Konfiguracja pipeline

Continuous Integration i Continuous Deployment (CI/CD) wzmacniają prędkość developmentu. Gdy dodasz Claude Code do swoich pipeline’ów, odblokowujesz inteligentną automatyzację, która może naprawiać nieprzechodzące testy, aktualizować dokumentację, a nawet implementować funkcje - wszystko przy zachowaniu standardów jakości kodu.

CI/CD z AI: nowy paradygmat

Scenariusz: Twój zespół pushuje 50+ commitów dziennie w wielu repozytoriach. Ręczne przeglądy kodu to wąskie gardła, dokumentacja pozostaje w tyle, a naprawianie prostych awarii CI pochłania czas developerów. Co jeśli twój pipeline mógłby inteligentnie obsługiwać te zadania?

Claude Code przekształca CI/CD z bramy walidacyjnej w aktywnego uczestnika developmentu. Może analizować awarie, proponować poprawki, a nawet implementować funkcje na podstawie opisów problemów.

GitHub Actions: natywna integracja

GitHub Actions zapewnia najgładszą integrację Claude Code przez oficjalne actions i aplikację GitHub.

Konfiguracja aplikacji GitHub Claude Code

Instalacja przez CLI Claude’a
Okno terminala
```
claude
> /install-github-app
```
To przeprowadzi cię przez:
- Tworzenie aplikacji GitHub
- Ustawianie uprawnień repozytorium
- Konfigurację sekretów
Alternatywa konfiguracji ręcznej
- Utwórz aplikację GitHub z tymi uprawnieniami:
  - Repozytorium: Read/Write (contents, issues, pull requests)
  - Webhooks: Issue comments, PR comments
- Wygeneruj i zapisz klucz prywatny
- Zanotuj ID aplikacji

Konfiguruj sekrety repozytorium

ANTHROPIC_API_KEY: Twój klucz API Anthropic
APP_ID: ID aplikacji GitHub
APP_PRIVATE_KEY: Zawartość klucza prywatnego

Podstawowe workflow GitHub Actions

Automatyczny przegląd kodu

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Pełna historia dla lepszego kontekstu

      - uses: anthropics/claude-code-action@v1
        with:
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Przejrzyj ten PR skupiając się na:
            1. Lukach bezpieczeństwa
            2. Problemach wydajności
            3. Brakujących przypadkach brzegowych
            4. Problemach jakości kodu

            Bądź konkretny i praktyczny. Pomiń problemy stylistyczne.
            Odwołuj się do numerów linii gdy to możliwe.

Interaktywny asystent PR

name: Claude PR Assistant
on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]

jobs:
  assist:
    if: contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Generate GitHub App Token
        id: app-token
        uses: actions/create-github-app-token@v2
        with:
          app-id: ${{ secrets.APP_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}

      - uses: anthropics/claude-code-action@v1
        with:
          github-token: ${{ steps.app-token.outputs.token }}
          trigger-phrase: "@claude"
          timeout-minutes: 30

Teraz członkowie zespołu mogą komentować “@claude napraw nieprzechodzące testy” a Claude wypchnie poprawki.

name: Auto-Fix CI Failures
on:
  workflow_run:
    workflows: ["Tests"]
    types: [completed]

jobs:
  auto-fix:
    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.workflow_run.head_branch }}

      - name: Download failure logs
        uses: actions/download-artifact@v3
        with:
          name: test-results
          run-id: ${{ github.event.workflow_run.id }}

      - name: Claude fix attempt
        run: |
          claude -p "Przeanalizuj te awarie testów i je napraw:
          $(cat test-results.log)

          Napraw tylko rzeczywiste błędy, nie oczekiwania testów.
          Upewnij się, że poprawki nie psują innych testów." \
          --allowedTools Edit,Bash \
          --dangerously-skip-permissions

      - name: Verify fixes
        run: npm test

      - name: Create PR if fixed
        if: success()
        uses: peter-evans/create-pull-request@v5
        with:
          title: "fix: rozwiąż nieprzechodzące testy"
          body: "Automatyczna poprawka dla awarii testowych w ${{ github.event.workflow_run.head_branch }}"
          branch: fix/auto-test-repair

name: Sync Documentation
on:
  push:
    branches: [main]
    paths:
      - 'src/**/*.ts'
      - 'src/**/*.tsx'

jobs:
  update-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Generate documentation updates
        run: |
          claude -p "Zaktualizuj dokumentację na podstawie tych zmian w kodzie:
          $(git diff HEAD~1 HEAD -- 'src/**/*.ts' 'src/**/*.tsx')

          Zaktualizuj:
          - Dokumentację API jeśli endpointy się zmieniły
          - README jeśli dodano główne funkcje
          - Przewodnik migracji jeśli są breaking changes

          Zachowaj istniejącą strukturę dokumentów." \
          --allowedTools Edit,Write

      - name: Create PR
        uses: peter-evans/create-pull-request@v5
        with:
          title: "docs: synchronizuj ze zmianami w kodzie"
          commit-message: "docs: automatyczna aktualizacja dokumentacji"
          branch: docs/auto-update

Integracja GitLab CI

GitLab CI oferuje potężne funkcje pipeline, które dobrze współpracują z możliwościami Claude Code.

Podstawowa konfiguracja GitLab

variables:
  ANTHROPIC_API_KEY: $ANTHROPIC_API_KEY

stages:
  - review
  - fix
  - deploy

claude-review:
  stage: review
  image: node:20
  only:
    - merge_requests
  script:
    - npm install -g @anthropic-ai/claude-code
    - |
      claude -p "Przejrzyj zmiany w tym MR:
      $(git diff origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME...HEAD)

      Skup się tylko na krytycznych problemach.
      Wynik jako komentarze sformatowane dla GitLab." \
      --output-format json > review.json
    - |
      # Opublikuj komentarze w MR
      jq -r '.comments[]' review.json | while read -r comment; do
        curl -X POST \
          -H "PRIVATE-TOKEN: $CI_JOB_TOKEN" \
          "$CI_API_V4_URL/projects/$CI_PROJECT_ID/merge_requests/$CI_MERGE_REQUEST_IID/notes" \
          -d "body=$comment"
      done

auto-fix-lint:
  stage: fix
  image: node:20
  rules:
    - if: '$CI_PIPELINE_SOURCE == "schedule"'
  script:
    - npm install -g @anthropic-ai/claude-code
    - npm ci
    - |
      if npm run lint 2>&1 | tee lint-output.txt | grep -q "error"; then
        claude -p "Napraw te błędy lintingu:
        $(cat lint-output.txt)

        Dokonaj minimalnych zmian żeby naprawić problemy." \
        --allowedTools Edit \
        --dangerously-skip-permissions

        git add -A
        git commit -m "fix: rozwiąż problemy lintingu [skip ci]"
        git push origin HEAD:fix/auto-lint-$CI_PIPELINE_ID

        # Utwórz MR przez API
        curl -X POST \
          -H "PRIVATE-TOKEN: $GITLAB_TOKEN" \
          "$CI_API_V4_URL/projects/$CI_PROJECT_ID/merge_requests" \
          -d "source_branch=fix/auto-lint-$CI_PIPELINE_ID" \
          -d "target_branch=$CI_DEFAULT_BRANCH" \
          -d "title=fix: automatyczne poprawki lint"
      fi

Zaawansowane wzorce GitLab

Dynamiczne tworzenie środowisk

provision-review-app:
  stage: deploy
  environment:
    name: review/$CI_COMMIT_REF_NAME
    url: https://$CI_ENVIRONMENT_SLUG.example.com
  script:
    - |
      claude -p "Wygeneruj manifesty Kubernetes dla środowiska review:
      - App: $CI_PROJECT_NAME
      - Branch: $CI_COMMIT_REF_NAME
      - Image: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

      Uwzględnij:
      - Deployment z 1 repliką
      - Service
      - Ingress z subdomeną opartą na branchu
      - Limity zasobów odpowiednie do testowania" \
      --output-format yaml > k8s-review.yaml

    - kubectl apply -f k8s-review.yaml

Integracja Jenkins

Pipeline Jenkins mogą wykorzystywać Claude Code przez kroki shell lub niestandardowe pluginy.

Jenkinsfile z Claude Code

pipeline {
    agent any

    environment {
        ANTHROPIC_API_KEY = credentials('anthropic-api-key')
    }

    stages {
        stage('Code Analysis') {
            steps {
                script {
                    def analysis = sh(
                        script: '''
                            claude -p "Przeanalizuj tę bazę kodu pod kątem:
                            - Luk bezpieczeństwa
                            - Wąskich gardeł wydajności
                            - Problemów architektonicznych

                            Wynik jako JSON z poziomami ważności" \
                            --output-format json
                        ''',
                        returnStdout: true
                    )

                    def issues = readJSON text: analysis
                    if (issues.critical.size() > 0) {
                        error "Znaleziono krytyczne problemy: ${issues.critical}"
                    }
                }
            }
        }

        stage('Generate Tests') {
            when {
                changeRequest()
            }
            steps {
                sh '''
                    # Znajdź zmodyfikowane pliki
                    CHANGED_FILES=$(git diff --name-only origin/main...HEAD | grep -E '\\.(js|ts)x?$' | grep -v test)

                    for file in $CHANGED_FILES; do
                        claude -p "Wygeneruj kompleksowe testy dla $file
                        Uwzględnij przypadki brzegowe i scenariusze błędów
                        Użyj naszych istniejących wzorców testowych" \
                        --allowedTools Write
                    done
                '''
            }
        }

        stage('Deploy Documentation') {
            when {
                branch 'main'
            }
            steps {
                sh '''
                    claude -p "Wygeneruj dokumentację API z naszej bazy kodu
                    Wynik specyfikacji OpenAPI 3.0
                    Uwzględnij przykłady dla każdego endpointu" > openapi.yaml

                    # Wdróż na stronę dokumentacji
                    npm run deploy-docs
                '''
            }
        }
    }

    post {
        failure {
            script {
                // Auto-twórz PR poprawek dla niektórych awarii
                if (currentBuild.rawBuild.getLog(100).contains('TypeError')) {
                    sh '''
                        claude -p "Napraw TypeError w tym buildzie:
                        ${BUILD_URL}console

                        Utwórz minimalną poprawkę" \
                        --allowedTools Edit,Bash

                        git checkout -b fix/build-${BUILD_NUMBER}
                        git add -A
                        git commit -m "fix: rozwiąż TypeError w buildzie ${BUILD_NUMBER}"
                        git push origin fix/build-${BUILD_NUMBER}
                    '''
                }
            }
        }
    }
}

Wzorce CI niezależne od platformy

Uniwersalny skrypt CI

Utwórz skrypt wielokrotnego użytku działający na różnych platformach CI:

#!/bin/bash
# ci-claude.sh - Uniwersalny helper Claude CI

set -e

# Wykryj środowisko CI
if [ -n "$GITHUB_ACTIONS" ]; then
    CI_PLATFORM="github"
    BRANCH=$GITHUB_REF_NAME
    COMMIT=$GITHUB_SHA
elif [ -n "$GITLAB_CI" ]; then
    CI_PLATFORM="gitlab"
    BRANCH=$CI_COMMIT_REF_NAME
    COMMIT=$CI_COMMIT_SHA
elif [ -n "$JENKINS_HOME" ]; then
    CI_PLATFORM="jenkins"
    BRANCH=$GIT_BRANCH
    COMMIT=$GIT_COMMIT
else
    CI_PLATFORM="local"
    BRANCH=$(git branch --show-current)
    COMMIT=$(git rev-parse HEAD)
fi

# Wspólne operacje Claude'a
case "$1" in
    "review")
        claude -p "Przejrzyj zmiany kodu w $BRANCH
        Platforma: $CI_PLATFORM
        Skup się na istotnych problemach" \
        --output-format json
        ;;

    "fix-tests")
        claude -p "Napraw nieprzechodzące testy na podstawie wyników CI
        Upewnij się, że poprawki są minimalne i prawidłowe" \
        --allowedTools Edit,Bash
        ;;

    "update-deps")
        claude -p "Zaktualizuj zależności i napraw breaking changes
        Utwórz szczegółowe notatki aktualizacji" \
        --allowedTools Edit,Write,Bash
        ;;

    *)
        echo "Użycie: $0 {review|fix-tests|update-deps}"
        exit 1
        ;;
esac

Konfiguracja wieloplatformowa

CircleCI
Azure DevOps

version: 2.1

orbs:
  claude: anthropic/claude-code@1.0.0

jobs:
  smart-review:
    docker:
      - image: cimg/node:20.0
    steps:
      - checkout
      - claude/install
      - run:
          name: Claude Review
          command: |
            claude -p "Przejrzyj ten commit: $CIRCLE_SHA1
            Sprawdź luki bezpieczeństwa i błędy
            Pomiń komentarze stylistyczne" > review.md
      - store_artifacts:
          path: review.md

workflows:
  review-and-fix:
    jobs:
      - smart-review:
          context: anthropic-api

trigger:
  - main
  - develop

pool:
  vmImage: 'ubuntu-latest'

variables:
  - group: claude-credentials

stages:
  - stage: Analysis
    jobs:
      - job: CodeReview
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '20.x'

          - script: |
              npm install -g @anthropic-ai/claude-code
            displayName: 'Install Claude Code'

          - script: |
              claude -p "Przeanalizuj $(Build.SourceBranch) pod kątem:
              - Wzorców specyficznych dla Azure
              - Problemów bezpieczeństwa
              - Problemów wydajności" \
              --output-format json > analysis.json
            displayName: 'Run Analysis'
            env:
              ANTHROPIC_API_KEY: $(ANTHROPIC_API_KEY)

          - task: PublishBuildArtifacts@1
            inputs:
              pathToPublish: 'analysis.json'
              artifactName: 'code-analysis'

Bezpieczeństwo i najlepsze praktyki

Bezpieczne zarządzanie poświadczeniami

Optymalizacja zasobów

# Optymalizuj użycie Claude'a w CI
claude-efficient:
  script: |
    # Cache odpowiedzi Claude'a dla identycznych wejść
    CACHE_KEY=$(echo "$GIT_DIFF" | sha256sum | cut -d' ' -f1)
    CACHE_FILE="/tmp/claude-cache-$CACHE_KEY"

    if [ -f "$CACHE_FILE" ]; then
      cat "$CACHE_FILE"
    else
      claude -p "Przejrzyj te zmiany: $GIT_DIFF" | tee "$CACHE_FILE"
    fi

    # Ustaw rozsądne timeouty
    timeout 300 claude -p "Złożone zadanie analizy" || echo "Analiza przekroczyła czas"

    # Ogranicz równoległe instancje Claude'a
    sem -j 2 claude -p "Zadanie 1" &
    sem -j 2 claude -p "Zadanie 2" &
    wait

Monitoring i metryki

Śledź wpływ Claude’a na swoje CI/CD:

# Śledź metryki w CI
claude -p "Przeanalizuj wydajność CI:
- Wskaźnik sukcesu przed/po integracji Claude'a
- Czas zaoszczędzony na popularnych zadaniach
- Problemy wychwycone przez przegląd Claude'a
- Wyniki satysfakcji developerów

Wynik jako raport markdown" > ci-metrics.md

# Wyślij do systemu monitoringu
curl -X POST https://metrics.example.com/api/v1/claude \
  -H "Content-Type: application/json" \
  -d @<(jq -R -s '{
    timestamp: now,
    pipeline: env.CI_PIPELINE_ID,
    claude_operations: 5,
    time_saved_minutes: 45,
    issues_caught: 3
  }' < /dev/null)

Scenariusze CI/CD z prawdziwego świata

Scenariusz: Inteligentna automatyzacja wydań

Utwórz workflow wydań

name: Intelligent Release
on:
  workflow_dispatch:
    inputs:
      version:
        description: 'Wersja wydania'
        required: true

jobs:
  prepare-release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Generate release
        run: |
          claude -p "Przygotuj wydanie ${{ inputs.version }}:
          1. Zaktualizuj wersję w package.json
          2. Wygeneruj CHANGELOG z commitów od ostatniego tagu
          3. Zaktualizuj README z nową wersją
          4. Utwórz przewodnik migracji jeśli są breaking changes
          5. Wygeneruj notatki wydania

          Bądź dokładny ale zwięzły" \
          --allowedTools Edit,Write

      - name: Create PR
        uses: peter-evans/create-pull-request@v5
        with:
          title: "release: v${{ inputs.version }}"
          body: "Automatyczne przygotowanie wydania"

Dodaj zadania po wydaniu

- name: Post-release tasks
  if: github.event.pull_request.merged == true
  run: |
    claude -p "Zadania po wydaniu:
    1. Zaktualizuj stronę dokumentacji
    2. Powiadom zespoły o breaking changes
    3. Utwórz szablony problemów dla pomocy migracji
    4. Wygeneruj ogłoszenia mediów społecznościowych"

Scenariusz: Walidacja wdrożenia progresywnego

validate-canary:
  runs-on: ubuntu-latest
  steps:
    - name: Deploy canary
      run: |
        kubectl set image deployment/app app=myapp:${{ github.sha }} -n canary

    - name: Wait for stability
      run: sleep 300

    - name: Analyze canary metrics
      run: |
        claude -p "Przeanalizuj kondycję wdrożenia canary:
        Metryki: $(curl -s http://prometheus/api/v1/query?query=up)
        Logi: $(kubectl logs -n canary -l app=myapp --tail=1000)

        Określ czy bezpiecznie można awansować do produkcji.
        Rozważ: wskaźniki błędów, opóźnienie, użycie zasobów" \
        --output-format json > canary-analysis.json

    - name: Auto-promote or rollback
      run: |
        if jq -e '.recommendation == "promote"' canary-analysis.json; then
          kubectl set image deployment/app app=myapp:${{ github.sha }} -n production
        else
          kubectl rollout undo deployment/app -n canary
          exit 1
        fi

Następne kroki

Integracja CI/CD z Claude Code to podróż od prostej automatyzacji do inteligentnych pipeline’ów. Zacznij od podstawowych przeglądów kodu, następnie stopniowo dodawaj bardziej wyrafinowane workflow, gdy twój zespół zyskuje pewność.

Kluczem jest identyfikacja powtarzalnych zadań CI/CD pochłaniających czas developerów i systematyczna ich automatyzacja z wykorzystaniem inteligencji Claude’a. Każda automatyzacja uwalnia twój zespół do skupienia się na kreatywnym rozwiązywaniu problemów zamiast mechanicznych poprawek.

Gotowy do skalowania bazy kodu z inteligentnymi decyzjami architektonicznymi? Przejdź do Architektura, żeby nauczyć się jak Claude Code może pomóc projektować i rozwijać architektury systemów.