Claude Code GitHub Actions : automatisation CI/CD propulsée par l'IA 2026

Table des matières

• →Que peut faire Claude Code en CI/CD ?
• →Premiers pas
• →Revue de code automatisée
• →Génération de description de PR
• →Tri des issues
• →Workflow de correction de bugs
• →Analyse de sécurité
• →Automatisation des tests
• →Articles connexes
• →Points clés à retenir

Que peut faire Claude Code en CI/CD ?

Premiers pas

Prérequis

1. →Dépôt GitHub
2. →Clé API Anthropic
3. →Application GitHub installée (optionnel, pour des fonctionnalités améliorées)

Installer l'application GitHub

La configuration la plus simple utilise l'application GitHub Claude :

> /install-github-app

Opening GitHub to install Claude Code App...

1. Select repositories to grant access
2. Confirm permissions
3. Copy the installation token

Installation complete. Your workflows can now use Claude Code.

Configuration manuelle

Pour un accès basé sur une clé API :

1. →

   Ajoutez votre clé API Anthropic aux secrets du dépôt :

   • →Allez dans Settings → Secrets → Actions
   • →Ajoutez ANTHROPIC_API_KEY
2. →

   Créez le fichier de workflow dans .github/workflows/

Structure de base du workflow

# .github/workflows/claude-code.yml
name: Claude Code

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Run Claude Code
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --print --dangerously-skip-permissions \
            -p "Review the changes in this PR and comment on issues"

Workflow de revue de code

Revue de code automatisée sur chaque pull request :

# .github/workflows/code-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize, reopened]

permissions:
  contents: read
  pull-requests: write

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Get changed files
        id: changed
        run: |
          echo "files=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | tr '\n' ' ')" >> $GITHUB_OUTPUT
      
      - name: Review code
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --print --dangerously-skip-permissions \
            -p "Review these changed files for:
                - Code quality issues
                - Potential bugs
                - Security vulnerabilities
                - Performance concerns
                - Style guide compliance
                
                Files: ${{ steps.changed.outputs.files }}
                
                Format your review as markdown with sections for each category.
                Include line numbers for specific issues." > review.md
      
      - name: Post review comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            
            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `## 🤖 AI Code Review\n\n${review}`
            });

Revue améliorée avec commentaires en ligne

- name: Review with inline comments
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  run: |
    claude --print --dangerously-skip-permissions \
      -p "Review this PR and for each issue found, output JSON:
          {\"file\": \"path/to/file\", \"line\": 42, \"comment\": \"Issue description\"}
          
          One JSON object per line." > issues.jsonl
    
    # Post inline comments
    while IFS= read -r line; do
      file=$(echo "$line" | jq -r '.file')
      line_num=$(echo "$line" | jq -r '.line')
      comment=$(echo "$line" | jq -r '.comment')
      
      gh pr comment ${{ github.event.pull_request.number }} \
        --body "**Line $line_num in $file**: $comment"
    done < issues.jsonl

Générateur de description de PR

Génération automatique de descriptions détaillées de PR :

# .github/workflows/pr-description.yml
name: Generate PR Description

on:
  pull_request:
    types: [opened]

permissions:
  pull-requests: write

jobs:
  describe:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Generate description
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          git diff origin/${{ github.base_ref }}...HEAD > changes.diff
          
          claude --print --dangerously-skip-permissions \
            -p "Based on this diff, generate a detailed PR description:
                
                $(cat changes.diff)
                
                Include:
                ## Summary
                Brief overview of changes
                
                ## Changes Made
                - Bullet points of specific changes
                
                ## Testing
                How to test these changes
                
                ## Screenshots
                (if UI changes, note what screenshots would be helpful)
                
                ## Related Issues
                Mention any issue numbers if apparent from code" > description.md
      
      - name: Update PR description
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const description = fs.readFileSync('description.md', 'utf8');
            
            github.rest.pulls.update({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
              body: description
            });

Bot de tri des issues

Catégorisation et assignation automatiques des issues :

# .github/workflows/issue-triage.yml
name: Issue Triage

on:
  issues:
    types: [opened]

permissions:
  issues: write

jobs:
  triage:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Analyze issue
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --print --dangerously-skip-permissions \
            -p "Analyze this GitHub issue and provide triage:
                
                Title: ${{ github.event.issue.title }}
                Body: ${{ github.event.issue.body }}
                
                Return JSON only:
                {
                  \"labels\": [\"bug\"|\"feature\"|\"documentation\"|\"question\"],
                  \"priority\": \"low\"|\"medium\"|\"high\"|\"critical\",
                  \"component\": \"frontend\"|\"backend\"|\"api\"|\"infra\"|\"other\",
                  \"summary\": \"One line summary\",
                  \"suggested_assignee\": \"team-area or null\"
                }" > triage.json
      
      - name: Apply triage
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const triage = JSON.parse(fs.readFileSync('triage.json', 'utf8'));
            
            // Add labels
            const labels = [...triage.labels, `priority:${triage.priority}`];
            await github.rest.issues.addLabels({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              labels: labels
            });
            
            // Add triage comment
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `🤖 **Automated Triage**\n\n` +
                    `**Summary:** ${triage.summary}\n` +
                    `**Component:** ${triage.component}\n` +
                    `**Priority:** ${triage.priority}`
            });

Correction automatique de bugs

Créez des PR de correction pour les issues étiquetées :

# .github/workflows/auto-fix.yml
name: Auto Fix Bug

on:
  issues:
    types: [labeled]

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

jobs:
  fix:
    if: github.event.label.name == 'auto-fix'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Create fix branch
        run: |
          git checkout -b fix/issue-${{ github.event.issue.number }}
      
      - name: Analyze and fix
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --dangerously-skip-permissions \
            -p "Fix this issue:
                
                Title: ${{ github.event.issue.title }}
                Description: ${{ github.event.issue.body }}
                
                1. Find the relevant code
                2. Implement the fix
                3. Add or update tests
                4. Ensure code passes linting
                
                Make the minimal changes needed to fix the issue."
      
      - name: Commit and push
        run: |
          git config user.name "Claude Code Bot"
          git config user.email "claude@example.com"
          git add -A
          git commit -m "Fix: ${{ github.event.issue.title }}" || exit 0
          git push origin fix/issue-${{ github.event.issue.number }}
      
      - name: Create pull request
        uses: actions/github-script@v7
        with:
          script: |
            const pr = await github.rest.pulls.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: `Fix: ${{ github.event.issue.title }}`,
              body: `Automated fix for #${{ github.event.issue.number }}\n\nGenerated by Claude Code`,
              head: `fix/issue-${{ github.event.issue.number }}`,
              base: 'main'
            });
            
            // Link PR to issue
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `🤖 Created fix PR: #${pr.data.number}`
            });

Génération de tests

Générez des tests pour le nouveau code :

# .github/workflows/generate-tests.yml
name: Generate Tests

on:
  pull_request:
    types: [opened, synchronize]
    paths:
      - 'src/**/*.ts'
      - 'src/**/*.js'

permissions:
  contents: write
  pull-requests: write

jobs:
  generate-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
          fetch-depth: 0
      
      - name: Install dependencies
        run: npm install
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Get changed source files
        id: changed
        run: |
          files=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | grep -E 'src/.*\.(ts|js)$' | grep -v '\.test\.' | tr '\n' ' ')
          echo "files=$files" >> $GITHUB_OUTPUT
      
      - name: Generate tests
        if: steps.changed.outputs.files != ''
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --dangerously-skip-permissions \
            -p "Generate comprehensive tests for these changed files:
                ${{ steps.changed.outputs.files }}
                
                For each file:
                1. Create a corresponding .test.ts file if it doesn't exist
                2. Add tests for new functions/methods
                3. Include edge cases and error scenarios
                4. Follow existing test patterns in the codebase
                
                Run 'npm test' to verify tests pass."
      
      - name: Commit test files
        run: |
          git config user.name "Claude Code Bot"
          git config user.email "claude@example.com"
          git add -A '*.test.*'
          git commit -m "Add generated tests" || exit 0
          git push

Mises à jour de documentation

Gardez la documentation synchronisée avec le code :

# .github/workflows/update-docs.yml
name: Update Documentation

on:
  push:
    branches: [main]
    paths:
      - 'src/api/**'

permissions:
  contents: write

jobs:
  update-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Update API docs
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --dangerously-skip-permissions \
            -p "Update the API documentation in docs/API.md:
                
                1. Scan all files in src/api/
                2. Extract endpoint definitions
                3. Document request/response formats
                4. Include example usage
                5. Note any breaking changes
                
                Keep the existing documentation structure."
      
      - name: Commit doc updates
        run: |
          git config user.name "Claude Code Bot"
          git config user.email "claude@example.com"
          git add docs/
          git commit -m "Update API documentation" || exit 0
          git push

Analyse de sécurité

Revue de sécurité propulsée par l'IA :

# .github/workflows/security-scan.yml
name: Security Scan

on:
  pull_request:
    types: [opened, synchronize]

permissions:
  pull-requests: write
  security-events: write

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Security analysis
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          git diff origin/${{ github.base_ref }}...HEAD > changes.diff
          
          claude --print --dangerously-skip-permissions \
            -p "Perform a security review of these changes:
                
                $(cat changes.diff)
                
                Check for:
                1. SQL injection vulnerabilities
                2. XSS vulnerabilities
                3. Exposed secrets or credentials
                4. Insecure dependencies
                5. Authentication/authorization issues
                6. Data validation problems
                7. CSRF vulnerabilities
                8. Path traversal risks
                
                Format as:
                ## Security Review
                
                ### Critical Issues
                (blocking issues)
                
                ### Warnings
                (should fix)
                
                ### Notes
                (informational)
                
                ### Verdict
                PASS / FAIL" > security.md
      
      - name: Post security review
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('security.md', 'utf8');
            
            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `## 🔒 Security Review\n\n${review}`
            });
      
      - name: Check for failures
        run: |
          if grep -q "### Verdict" security.md && grep -q "FAIL" security.md; then
            echo "Security review failed"
            exit 1
          fi

Tâches planifiées

Exécutez Claude Code selon un calendrier :

# .github/workflows/weekly-audit.yml
name: Weekly Code Audit

on:
  schedule:
    - cron: '0 9 * * 1'  # Monday 9 AM
  workflow_dispatch:

permissions:
  issues: write

jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Run audit
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --print --dangerously-skip-permissions \
            -p "Perform a comprehensive code audit:
                
                1. Check for TODO/FIXME comments that are stale
                2. Identify unused exports and dead code
                3. Find potential performance issues
                4. Check for outdated dependencies
                5. Review error handling completeness
                6. Identify code duplication
                
                Provide a summary report with actionable items." > audit.md
      
      - name: Create audit issue
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const audit = fs.readFileSync('audit.md', 'utf8');
            
            github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: `Weekly Code Audit - ${new Date().toISOString().split('T')[0]}`,
              body: audit,
              labels: ['audit', 'automated']
            });

Astuces pour les workflows

Mise en cache pour la vitesse

- name: Cache Claude Code
  uses: actions/cache@v4
  with:
    path: ~/.npm
    key: claude-code-${{ runner.os }}

- name: Install Claude Code
  run: npm install -g @anthropic-ai/claude-code

Rate limiting

Empêchez une utilisation excessive de l'API :

jobs:
  review:
    # Only run on real PRs, not drafts
    if: github.event.pull_request.draft == false
    
    # Concurrency prevents parallel runs
    concurrency:
      group: claude-${{ github.ref }}
      cancel-in-progress: true

Variables d'environnement

Transmettez du contexte à Claude :

- name: Run with context
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
    PR_TITLE: ${{ github.event.pull_request.title }}
    PR_AUTHOR: ${{ github.event.pull_request.user.login }}
    BASE_BRANCH: ${{ github.base_ref }}
  run: |
    claude --print --dangerously-skip-permissions \
      -p "Review this PR titled '$PR_TITLE' by $PR_AUTHOR..."

Exécution conditionnelle

- name: Review only large PRs
  if: github.event.pull_request.additions > 100
  run: claude ...

- name: Skip bot PRs
  if: "!contains(github.event.pull_request.user.login, 'bot')"
  run: claude ...

Considérations de sécurité

Protection des clés API

# Use GitHub Secrets
env:
  ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

# Never echo keys
- run: echo "Key length: ${#ANTHROPIC_API_KEY}"  # OK
- run: echo "$ANTHROPIC_API_KEY"  # NEVER DO THIS

Portée des permissions

# Minimal permissions
permissions:
  contents: read
  pull-requests: write
  
# Not this
permissions: write-all

Exécution sandboxée

# Claude runs with --dangerously-skip-permissions
# Ensure workflows can't escape their scope

- name: Run in isolated directory
  run: |
    mkdir -p /tmp/workspace
    cp -r . /tmp/workspace
    cd /tmp/workspace
    claude --dangerously-skip-permissions ...

Revue du code généré

Exigez toujours une approbation humaine pour les changements générés :

# Create PR instead of direct push
- name: Create PR
  run: |
    gh pr create --title "AI Generated Changes" \
      --body "⚠️ Review required - generated by Claude Code"

Intégration avec d'autres fonctionnalités

Utiliser MCP dans les Actions

- name: Setup MCP
  run: |
    claude mcp add github --transport http https://api.github.com/mcp/
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Voir Model Context Protocol (MCP) pour Claude Code : guide complet.

Utiliser les commandes personnalisées

- name: Run custom command
  run: |
    claude --dangerously-skip-permissions -p "/review"

Voir Commandes slash personnalisées dans Claude Code : créez les vôtres.

Utilisation headless avec le SDK

Pour les workflows complexes, utilisez le SDK :

- name: Run SDK script
  run: node scripts/claude-workflow.js

Voir Claude Code headless et programmatique : SDK et automatisation.

Articles connexes

Approfondissez vos connaissances en CI/CD avec Claude Code :

• →Guide d'installation et de configuration de Claude Code — Commencez avec la configuration de Claude Code
• →Mode headless du SDK Claude Code — Patterns d'automatisation programmatique
• →Sous-agents Claude Code — Orchestrez plusieurs agents IA
• →Comparaison des éditeurs de code IA 2026 — Claude Code vs Cursor vs Copilot
• →Claude Code vs Copilot vs Cursor 2026 — Comparaison détaillée des fonctionnalités

Points clés à retenir

1. →

   Automatisez les revues : laissez l'IA détecter les problèmes avant la revue humaine.

2. →

   Générez du contenu : descriptions de PR, documentation, tests — tout automatisé.

3. →

   Triez à grande échelle : gérez les issues automatiquement.

4. →

   Sécurité d'abord : utilisez des permissions minimales, protégez les clés API.

5. →

   L'humain dans la boucle : l'IA crée les PR ; les humains les approuvent.

Maîtrisez l'automatisation propulsée par l'IA

GitHub Actions avec Claude Code n'est que le début de l'automatisation IA. Apprenez à construire des workflows autonomes complets.

Dans notre Module 6 — Agents autonomes, vous apprendrez :

• →La conception de workflows IA fiables
• →La gestion des erreurs et la récupération
• →Les patterns d'intervention humaine
• →La mise à l'échelle de l'automatisation IA

→ Explorer le Module 6 : Agents autonomes

Dernière mise à jour : janvier 2026. Couvre l'intégration de Claude Code GitHub Actions avec Claude Sonnet 4.5 et les dernières fonctionnalités du runner GitHub Actions.