Integracja CI/CD i automatyzacja

Claude Code przekształca się z narzędzia programistycznego w potężny silnik automatyzacji, gdy zostanie zintegrowany z potokami CI/CD. Wykorzystując GitHub Actions, tryb bezgłowy i SDK Claude Code, możesz zautomatyzować wszystko od przeglądów kodu po naprawy błędów, tworząc potok rozwoju wspomagany przez AI, który działa 24/7.

Integracja z GitHub Actions

Szybka konfiguracja z Claude

Najszybszy sposób na włączenie integracji z GitHub:

1. Uruchom polecenie instalatora

   claude> /install-github-app

2. Postępuj zgodnie z instrukcjami

   • Autoryzuj aplikację Claude GitHub
   • Udziel uprawnień do repozytorium
   • Klucz API jest konfigurowany automatycznie

3. Przetestuj integrację Utwórz komentarz do zgłoszenia:

   @claude zaimplementuj tę funkcję na podstawie opisu zgłoszenia

Wskazówka

Musisz być administratorem repozytorium, aby zainstalować aplikację GitHub. Dla użytkowników Bedrock/Vertex, zobacz ręczną konfigurację poniżej.

Ręczna konfiguracja GitHub Actions

Dla niestandardowych konfiguracji lub dostawców chmury:

Bezpośrednie API

.github/workflows/claude.yml

name: Claude Code Actions

on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]
  issues:
    types: [opened]

permissions:
  contents: write
  pull-requests: write
  issues: write

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

      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
          trigger_phrase: "@claude"
          max_turns: 30
          timeout_minutes: 60

AWS Bedrock

.github/workflows/claude-bedrock.yml

name: Claude via Bedrock

permissions:
  contents: write
  pull-requests: write
  issues: write
  id-token: write  # Dla OIDC

jobs:
  claude-pr:
    if: contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    env:
      AWS_REGION: us-west-2
    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
          aws-region: us-west-2

      - uses: anthropics/claude-code-action@v1
        with:
          use_bedrock: true
          model: "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
          github_token: ${{ secrets.GITHUB_TOKEN }}
          trigger_phrase: "@claude"

Google Vertex

.github/workflows/claude-vertex.yml

name: Claude via Vertex AI

permissions:
  contents: write
  pull-requests: write
  issues: write
  id-token: write # Dla workload identity

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

      - name: Authenticate to Google Cloud
        uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ secrets.GCP_WORKLOAD_IDENTITY_PROVIDER }}
          service_account: ${{ secrets.GCP_SERVICE_ACCOUNT }}

      - uses: anthropics/claude-code-action@v1
        with:
          use_vertex: true
          model: "claude-3-7-sonnet@20250219"
          github_token: ${{ secrets.GITHUB_TOKEN }}
          trigger_phrase: "@claude"
        env:
          CLOUD_ML_REGION: us-east5

Potężne przepływy pracy GitHub

Automatyzacja zgłoszenie → pull request

Przekształcaj zgłoszenia bezpośrednio w pull requesty:

.github/workflows/issue-to-pr.yml

name: Issue to PR

on:
  issues:
    types: [labeled]

jobs:
  implement-feature:
    if: github.event.label.name == 'implement-with-claude'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: anthropics/claude-code-action@v1
        with:
          prompt: |
            Zaimplementuj funkcję opisaną w zgłoszeniu #${{ github.event.issue.number }}:

            ${{ github.event.issue.title }}

            ${{ github.event.issue.body }}

            Postępuj zgodnie z naszymi standardami kodowania w CLAUDE.md.
            Utwórz kompleksowe testy.
            Zaktualizuj dokumentację w razie potrzeby.
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
          auto_pr: true
          pr_title: "feat: ${{ github.event.issue.title }}"

Automatyczne przeglądy kodu

Wzbogać przeglądy PR o analizę AI:

.github/workflows/claude-review.yml

name: AI 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 lepszej analizy

      - uses: anthropics/claude-code-action@v1
        with:
          prompt_file: .github/claude-review-prompt.md
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
          comment_on_pr: true

Szablon promptu do przeglądu:

.github/claude-review-prompt.md

Dokonaj przeglądu tego pull requesta skupiając się na:

1. **Luki bezpieczeństwa** - Uwierzytelnianie, autoryzacja, ataki injection
2. **Problemy wydajnościowe** - Algorytmy O(n²), niepotrzebne zapytania, wycieki pamięci
3. **Jakość kodu** - Naruszenia DRY, niejasne nazewnictwo, brakujące obsługiwanie błędów
4. **Pokrycie testami** - Brakujące przypadki skrajne, niewystarczające asercje
5. **Dokumentacja** - Nieaktualne komentarze, brakujące dokumentacje API

Bądź zwięzły. Zgłaszaj tylko rzeczywiste problemy, nie preferencje stylistyczne.
Format: `[PRIORYTET: WYSOKI/ŚREDNI/NISKI] Opis problemu`

Naprawianie nieudanych buildów

Automatyczne próby naprawy błędów CI:

.github/workflows/fix-ci.yml

name: Auto-fix CI Failures

on:
  workflow_run:
    workflows: ['CI']
    types: [completed]

jobs:
  fix-failures:
    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: Get failure logs
        uses: actions/github-script@v7
        id: logs
        with:
          script: |
            const logs = await github.rest.actions.downloadJobLogsForWorkflowRun({
              owner: context.repo.owner,
              repo: context.repo.repo,
              job_id: ${{ github.event.workflow_run.id }}
            });
            return logs.data;

      - uses: anthropics/claude-code-action@v1
        with:
          prompt: |
            Build CI nie powiódł się z następującymi błędami:

            ${{ steps.logs.outputs.result }}

            Napraw problemy powodujące niepowodzenie buildu.
            Skup się na błędach testów, błędach lintingu i błędach typów.
          auto_commit: true
          commit_message: 'fix: rozwiąż błędy CI'

Tryb bezgłowy dla automatyzacji

Podstawowe użycie trybu bezgłowego

Uruchamiaj Claude Code programatycznie:

# Proste polecenie jednorazowe
claude -p "Zaktualizuj wszystkie nagłówki praw autorskich na 2025" --json

# Z określonymi uprawnieniami
claude -p "Napraw nieudany test w auth.test.js" \
  --allow-tools Edit,View,Bash \
  --output-format json

# Przekazuj dane przez pipe do przetwarzania
cat error.log | claude -p "Przeanalizuj te błędy i zasugeruj naprawy"

Zaawansowane wzorce automatyzacji

Wzorzec fan-out

Obsługuj migracje na dużą skalę:

migrate-components.sh

#!/bin/bash
# Generuj listę zadań
claude -p "Wylistuj wszystkie komponenty React class, które wymagają migracji do hooks" \
  --output-format json > tasks.json

# Przetwarzaj każdy komponent
jq -r '.files[]' tasks.json | while read file; do
  echo "Migrowanie $file..."
  claude -p "Przekonwertuj $file z komponentu klasowego na hooks. Zachowaj całą funkcjonalność." \
    --allow-tools Edit \
    --timeout 300
done

Integracja z potokiem

Integruj z istniejącymi narzędziami:

# Potok jakości kodu
npm run lint 2>&1 | \
  claude -p "Napraw wszystkie błędy lintingu" --allow-tools Edit | \
  claude -p "Teraz uruchom testy i napraw wszelkie błędy" --allow-tools Bash,Edit | \
  claude -p "Wygeneruj podsumowanie zmian" > changes.md

Przykłady integracji CI/CD

Pre-commit hooks

.git/hooks/pre-commit

#!/bin/bash
# Sprawdź komentarze TODO
if git diff --cached --name-only | xargs grep -l "TODO" > /dev/null; then
  echo "Znaleziono komentarze TODO. Proszę Claude o ich rozpatrzenie..."

  git diff --cached --name-only | xargs grep -l "TODO" | while read file; do
    claude -p "W $file, zaimplementuj wszelkie komentarze TODO lub przekonwertuj je na właściwe zgłoszenia" \
      --allow-tools Edit \
      --timeout 60
  done

  # Ponownie dodaj zmiany do stage
  git add -u
fi

Nocne aktualizacje dokumentacji

.github/workflows/update-docs.yml

name: Update Documentation

on:
  schedule:
    - cron: '0 2 * * *' # 2:00 codziennie
  workflow_dispatch:

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

      - name: Update API Documentation
        run: |
          claude -p "Zaktualizuj dokumentację API w docs/api.md na podstawie aktualnego kodu w src/api/" \
            --allow-tools Edit,View \
            --output-format json > result.json

      - name: Update README
        run: |
          claude -p "Zaktualizuj README.md: znaczniki, listę zależności i przykłady na podstawie package.json i ostatnich zmian" \
            --allow-tools Edit,View

      - name: Create PR if changes
        uses: peter-evans/create-pull-request@v5
        with:
          title: 'docs: automatyczne aktualizacje dokumentacji'
          commit-message: 'docs: zaktualizuj dokumentację API i README'
          branch: auto-update-docs

Wzorce CI/CD dla przedsiębiorstw

Koordynacja wielu usług

Organizuj zmiany w mikrousługach:

.github/workflows/coordinated-update.yml

name: Coordinated Service Update

on:
  workflow_dispatch:
    inputs:
      change_description:
        description: 'Opisz zmianę do wdrożenia'
        required: true

jobs:
  plan:
    runs-on: ubuntu-latest
    outputs:
      plan: ${{ steps.create-plan.outputs.plan }}
    steps:
      - uses: actions/checkout@v4

      - id: create-plan
        run: |
          PLAN=$(claude -p "Utwórz plan implementacji dla: ${{ github.event.inputs.change_description }}. Wylistuj dotknięte usługi i kolejność aktualizacji." --json)
          echo "plan=$PLAN" >> $GITHUB_OUTPUT

  update-services:
    needs: plan
    strategy:
      matrix:
        service: ${{ fromJson(needs.plan.outputs.plan).services }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          repository: myorg/${{ matrix.service }}

      - uses: anthropics/claude-code-action@v1
        with:
          prompt: |
            Zaimplementuj tę zmianę: ${{ github.event.inputs.change_description }}
            To jest usługa: ${{ matrix.service }}
            Pełny plan: ${{ needs.plan.outputs.plan }}

            Zapewnij wsteczną kompatybilność.
          auto_pr: true

Automatyzacja bezpieczeństwa i zgodności

.github/workflows/security-scan.yml

name: Security Analysis

on:
  pull_request:
    branches: [main]

jobs:
  security-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Security Scan
        run: |
          npm audit --json > audit.json
          bandit -r . -f json -o bandit.json || true

      - name: Analyze and Fix
        run: |
          claude -p "Przeanalizuj raporty bezpieczeństwa i napraw krytyczne problemy:
            NPM Audit: $(cat audit.json)
            Bandit: $(cat bandit.json)

            Napraw tylko problemy o priorytecie KRYTYCZNY i WYSOKI.
            Udokumentuj wszelkie problemy wymagające ręcznego przeglądu." \
            --allow-tools Edit,View \
            --timeout 600

      - name: Generate Security Report
        run: |
          claude -p "Wygeneruj raport oceny bezpieczeństwa na podstawie wprowadzonych zmian" \
            > security-report.md

      - name: Comment on PR
        uses: actions/github-script@v7
        with:
          script: |
            const report = require('fs').readFileSync('security-report.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report
            });

Optymalizacja kosztów w CI/CD

Inteligentne wyzwalanie

Uruchamiaj Claude tylko przy istotnych zmianach:

name: Smart Claude Trigger

on:
  pull_request:
    paths:
      - '**.ts'
      - '**.tsx'
      - '**.js'
      - '**.jsx'

jobs:
  analyze-complexity:
    runs-on: ubuntu-latest
    outputs:
      should-run-claude: ${{ steps.check.outputs.result }}
    steps:
      - uses: actions/checkout@v4

      - id: check
        run: |
          # Uruchom Claude tylko dla znaczących zmian
          LINES_CHANGED=$(git diff --numstat origin/main..HEAD | awk '{sum+=$1+$2} END {print sum}')
          if [ $LINES_CHANGED -gt 50 ]; then
            echo "result=true" >> $GITHUB_OUTPUT
          else
            echo "result=false" >> $GITHUB_OUTPUT
          fi

  claude-review:
    needs: analyze-complexity
    if: needs.analyze-complexity.outputs.should-run-claude == 'true'
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        # ... reszta konfiguracji

Strategie cachowania

Redukuj redundantne wywołania API:

- name: Cache Claude Analysis
  uses: actions/cache@v3
  with:
    path: .claude-cache
    key: claude-${{ hashFiles('**/*.ts', '**/*.tsx') }}

- name: Run Claude Analysis
  run: |
    if [ -f .claude-cache/analysis.json ]; then
      echo "Używanie analizy z cache"
    else
      claude -p "Przeanalizuj bazę kodu pod kątem potencjalnych ulepszeń" \
        --output-format json > .claude-cache/analysis.json
    fi

Monitorowanie i obserwowalność

Śledzenie użycia Claude w CI

- name: Report Usage Metrics
  if: always()
  run: |
    claude -p "Podsumuj pracę wykonaną w tym uruchomieniu CI" --json > usage.json

    # Wyślij do serwisu monitorowania
    curl -X POST https://metrics.company.com/claude-usage \
      -H "Content-Type: application/json" \
      -d @usage.json

Monitorowanie wydajności

claude-metrics.js

const { execSync } = require('child_process');

function trackClaudePerformance(command, context) {
  const start = Date.now();
  try {
    const result = execSync(`claude -p "${command}" --json`, {
      encoding: 'utf8',
      maxBuffer: 10 * 1024 * 1024,
    });

    const duration = Date.now() - start;
    const parsed = JSON.parse(result);

    // Wyślij do monitorowania
    sendMetrics({
      command,
      context,
      duration,
      tokensUsed: parsed.usage?.total_tokens,
      success: true,
    });

    return parsed;
  } catch (error) {
    sendMetrics({
      command,
      context,
      duration: Date.now() - start,
      success: false,
      error: error.message,
    });
    throw error;
  }
}

Najlepsze praktyki

Używaj plików CLAUDE.md

Konfiguruj wytyczne specyficzne dla projektu dla spójnego zachowania CI

Ustaw odpowiednie timeouty

Zapobiegaj niekontrolowanym kosztom z rozsądnymi limitami czasu

Przeglądaj przed merge

Zawsze miej przegląd ludzki dla zmian generowanych przez Claude

Monitoruj koszty

Śledź użycie API i optymalizuj wyzwalacze

Względy bezpieczeństwa

Uwaga

• Nigdy nie ujawniaj kluczy API w logach lub artefaktach
• Używaj GitHub Secrets lub zarządzania sekretami dostawcy chmury
• Ogranicz uprawnienia Claude do minimum wymaganego
• Przeglądaj wszystkie automatyczne zmiany przed wdrożeniem
• Rozważ używanie oddzielnych kluczy API dla CI z limitami wydatków

Rozwiązywanie typowych problemów

Claude nie odpowiada

Symptomy: Wzmianki @claude są ignorowane

Rozwiązania:

1. Zweryfikuj instalację aplikacji GitHub
2. Sprawdź uprawnienia przepływu pracy
3. Upewnij się, że warunki wyzwalacza się zgadzają
4. Zweryfikuj, czy klucz API jest ustawiony poprawnie
5. Sprawdź logi GitHub Actions

Błędy uwierzytelniania

Symptomy: Błędy 401/403 w logach

Rozwiązania:

1. Regeneruj klucz API
2. Sprawdź, czy nazwy sekretów się zgadzają
3. Zweryfikuj poświadczenia dostawcy chmury
4. Upewnij się o właściwe role IAM (Bedrock/Vertex)
5. Sprawdź uprawnienia klucza API

Problemy z timeout

Symptomy: Zadania anulowane po timeout

Rozwiązania:

1. Zwiększ timeout_minutes
2. Podziel duże zadania na mniejsze kroki
3. Używaj bardziej konkretnych promptów
4. Cachuj wyniki pośrednie
5. Używaj równoległych zadań gdzie to możliwe

Zaawansowana automatyzacja CLI

Dla niestandardowych integracji poza GitHub Actions:

claude-automation.ts

import { exec } from 'child_process';
import { promisify } from 'util';
import * as fs from 'fs/promises';

const execAsync = promisify(exec);

async function automateCodeReview(prNumber: number) {
  // Przygotuj prompt do przeglądu
  const prompt = `Dokonaj przeglądu pull requesta #${prNumber} pod kątem:
    - Luk bezpieczeństwa
    - Problemów wydajnościowych
    - Naruszeń stylu kodu
    - Brakujących testów

    Użyj pliku CLAUDE.md dla kontekstu projektu i
    .github/review-guide.md dla wytycznych przeglądu.`;

  // Zapisz prompt do pliku dla złożonych promptów wieloliniowych
  await fs.writeFile('/tmp/review-prompt.txt', prompt);

  try {
    // Wykonaj Claude Code CLI z promptem przeglądu
    const { stdout } = await execAsync(
      `claude --file /tmp/review-prompt.txt --json`,
      {
        cwd: process.cwd(),
        env: { ...process.env }
      }
    );

    return JSON.parse(stdout);
  } catch (error) {
    console.error('Przegląd Claude Code nie powiódł się:', error);
    throw error;
  }
}

// Alternatywa: Strumieniowanie wyjścia dla przetwarzania w czasie rzeczywistym
import { spawn } from 'child_process';

function streamCodeReview(prNumber: number): Promise<string[]> {
  return new Promise((resolve, reject) => {
    const messages: string[] = [];

    const claude = spawn('claude', [
      `Przejrzyj PR #${prNumber} pod kątem bezpieczeństwa i wydajności`,
      '--json'
    ]);

    claude.stdout.on('data', (data) => {
      messages.push(data.toString());
    });

    claude.on('close', (code) => {
      if (code === 0) {
        resolve(messages);
      } else {
        reject(new Error(`Claude Code zakończył się z kodem ${code}`));
      }
    });
  });
}

Następne kroki

Przepływy zespołowe

Skaluj wzorce CI/CD w całej organizacji

Zarządzanie kosztami

Optymalizuj koszty i użycie CI/CD

Wzorce bezpieczeństwa

Implementuj bezpieczne praktyki CI/CD