Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Intégration CI/CD

Lektion 14 av 20 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Codex dans votre pipeline de livraison
  2. L’action GitHub officielle
  3. Automatiser la revue pour chaque PR
  4. Combler les tests manquants
  5. Réagir à un échec CI
  6. Appeler Codex depuis vos propres scripts
  7. Cartographier les points d’intégration
  8. Garder le contrôle de l’automatisation
  9. Viktiga punkter

Mis à jour le 3 novembre 2026 sur la base des pages Codex GitHub Action et Non-interactive mode de la documentation Codex : les entrées héritées task, criteria, scope, framework et api-key n’existent pas dans openai/codex-action@v1 (remplacées par openai-api-key, prompt/prompt-file, sandbox, output-file, etc.). L’action ne publie pas de commentaires d’elle-même. L’expression == failure sans guillemets ne fonctionnait pas. Le drapeau --apply est remplacé par codex exec --sandbox workspace-write. Sources : Codex GitHub Action · Non-interactive mode.

Codex dans votre pipeline de livraison

Codex ne se limite pas aux tâches lancées manuellement par un développeur. Il s’intègre à vos pipelines CI/CD pour automatiser les tâches de développement à chaque étape du cycle de livraison. Ce changement va au-delà du gain de temps : la revue de code, la génération de tests et la correction de bugs cessent de dépendre de la discipline individuelle pour devenir des étapes du pipeline déclenchées par des événements, et non par la bonne volonté du vendredi après-midi.

L’action GitHub officielle

OpenAI publie une action, openai/codex-action@v1, qui installe la CLI, démarre le proxy de l’API Responses lorsque vous fournissez une clé, et exécute codex exec avec les permissions que vous définissez. Ses principales entrées :

EntréeRôle
openai-api-keyLa clé, stockée en tant que secret GitHub (par exemple OPENAI_API_KEY)
prompt ou prompt-fileL’instruction en ligne ou un fichier dans le dépôt : l’un ou l’autre, pas les deux
sandboxread-only, workspace-write ou danger-full-access : choisissez le périmètre le plus restreint suffisant
model, effortLe modèle et l’effort de raisonnement ; si vides, les valeurs par défaut s’appliquent
output-fileEnregistre le message final de Codex pour les étapes suivantes
codex-argsOptions supplémentaires pour codex exec
safety-strategyPar défaut drop-sudo, qui supprime sudo avant l’exécution et protège les secrets en mémoire

L’action s’exécute sur des runners Linux ou macOS (sous Windows, vous avez besoin de safety-strategy: unsafe) après un actions/checkout du code. Elle ne publie rien d’elle-même : elle expose le dernier message de Codex dans la sortie final-message, qu’une étape ultérieure peut publier.

Automatiser la revue pour chaque PR

Le flux de travail ci-dessous suit la structure de l’exemple officiel : une première tâche exécute Codex en mode lecture seule, et une seconde, disposant des permissions d’écriture sur les PR, publie le résultat sous forme de commentaire. Vos critères vont dans le prompt.

# .github/workflows/codex-review.yml
name: Codex Review
on:
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  codex:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    outputs:
      final_message: ${{ steps.run_codex.outputs.final-message }}
    steps:
      - uses: actions/checkout@v5
        with:
          ref: refs/pull/${{ github.event.pull_request.number }}/merge
          fetch-depth: 0
          persist-credentials: false
      - name: Run Codex
        id: run_codex
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          sandbox: read-only
          prompt: |
            Review the changes in this pull request against the base branch.
            Priorities: security (injections, missing authentication), performance
            (N+1 queries), types (no any), tests (coverage of changes).
            Cite the files and lines involved.

  post_feedback:
    runs-on: ubuntu-latest
    needs: codex
    if: needs.codex.outputs.final_message != ''
    permissions:
      issues: write
      pull-requests: write
    steps:
      - uses: actions/github-script@v7
        with:
          github-token: ${{ github.token }}
          script: |
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.pull_request.number,
              body: process.env.CODEX_FINAL_MESSAGE,
            });
        env:
          CODEX_FINAL_MESSAGE: ${{ needs.codex.outputs.final_message }}

Le prompt mérite plus d’attention que le reste du fichier : il transforme une revue générique en une revue qui correspond à vos priorités. Vous pouvez le déplacer hors du YAML vers un fichier versionné, par exemple .github/codex/prompts/review.md, référencé par prompt-file. Pour une revue de PR simple, la revue automatique intégrée à GitHub (Leçon 11) évite d’écrire un flux de travail complet.

Combler les tests manquants

Un second flux de travail s’attaque au code livré sans tests. Codex doit ici écrire dans l’espace de travail (sandbox: workspace-write), mais le résultat reste une proposition : le flux de travail le transforme en un patch téléchargeable que le développeur examine et applique lui-même.

# .github/workflows/codex-tests.yml
name: Codex Generate Tests
on:
  pull_request:
    types: [opened]

jobs:
  generate-tests:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Generate missing tests
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          sandbox: workspace-write
          prompt: |
            For every file modified in this pull request that lacks a test,
            write the missing tests using Vitest, then run them.
      - name: Save the proposed tests as a patch
        run: git diff > codex-tests.patch
      - uses: actions/upload-artifact@v4
        with:
          name: codex-tests
          path: codex-tests.patch

Le développeur garde le contrôle de bout en bout : il récupère le patch, l’adapte ou le rejette. La documentation de l’action recommande d’exécuter Codex en dernier dans une tâche afin que les étapes suivantes n’héritent pas de changements inattendus ; ici, la seule étape suivante se contente de lire le diff.

Réagir à un échec CI

Le troisième flux de travail s’accroche au résultat d’un autre flux de travail. Lorsque la CI échoue, Codex rejoue les tests sur le commit concerné, traque la cause et produit un diagnostic sans rien pousser :

# .github/workflows/codex-diagnose.yml
name: Codex Diagnose CI
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]

jobs:
  diagnose:
    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v5
        with:
          ref: ${{ github.event.workflow_run.head_sha }}
          persist-credentials: false
      - name: Analyze the CI failure
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          sandbox: workspace-write
          output-file: codex-diagnostic.md
          prompt: |
            CI failed on this commit. Run the tests, identify the cause of the failure,
            and propose a fix without modifying the test logic.
      - uses: actions/upload-artifact@v4
        with:
          name: codex-diagnostic
          path: codex-diagnostic.md

Celui-ci exige le plus de prudence. Un test qui échoue signale parfois un défaut de conception, et une correction automatique plausible peut le faire disparaître de l’écran sans le résoudre : la CI redevient verte, mais le problème persiste. D’où le choix d’un diagnostic à examiner plutôt que d’un commit poussé automatiquement.

Appeler Codex depuis vos propres scripts

En dehors de GitHub Actions, codex exec s’intègre dans n’importe quel script. Par défaut, il s’exécute dans un bac à sable en lecture seule ; donnez-lui la permission d’écriture avec --sandbox workspace-write lorsque la tâche l’exige. Le hook pre-commit ci-dessous signale les fichiers TypeScript sans tests et en génère un à la volée :

#!/bin/bash
# Pre-commit hook script

# Check that modified files have tests
CHANGED=$(git diff --cached --name-only --diff-filter=ACM | grep '\.ts$' | grep -v '\.test\.ts$')
for file in $CHANGED; do
  test_file="${file%.ts}.test.ts"
  if [ ! -f "$test_file" ]; then
    echo "⚠️ File without test: $file"
    codex exec --sandbox workspace-write "Write tests for $file in $test_file"
    git add "$test_file"
  fi
done

En CI, codex exec réutilise par défaut l’authentification sauvegardée ; fournissez plutôt explicitement les identifiants en utilisant une clé API dédiée.

Cartographier les points d’intégration

Une fois ces briques de base en place, pensez en termes d’événements du cycle de livraison plutôt que de fichiers YAML. Les cinq scénarios ci-dessous couvrent les cas les plus courants :

Étape CI/CDTâche CodexDéclencheur
PR ouverteRevue automatiquepull_request opened
PR ouverteGénération de testspull_request opened
Échec CIAnalyse et correctionworkflow_run failure
ReleaseChangelog automatiquetag push
Mise à jour de dépendanceVérification de compatibilitéDependabot PR

Garder le contrôle de l’automatisation

Une intégration CI/CD s’exécute sans surveillance, ce qui appelle quelques précautions de base. Limitez qui peut déclencher les flux de travail : par défaut, seuls les utilisateurs disposant de permissions d’écriture peuvent exécuter l’action (utilisez allow-users, allow-bots pour élargir explicitement cela). Assainissez les entrées provenant des PR, des messages de commit ou des issues avant de les transmettre à Codex : du texte caché peut contenir une injection de prompt. Utilisez une clé API dédiée aux permissions minimales plutôt que la clé personnelle d’un développeur, qu’il emportera avec lui en quittant l’entreprise, brisant ainsi vos pipelines. Ne fusionnez jamais automatiquement une correction produite par Codex : la revue humaine reste la porte d’entrée vers la branche principale. Définissez des limites explicites sur le nombre de tâches par jour et le coût maximal afin qu’une boucle de correction mal configurée ne consume pas votre budget mensuel overnight. Enfin, conservez un historique des tâches Codex exécutées en CI : le jour où un comportement inattendu apparaît en production, ces journaux seront votre seule piste solide.

Viktiga punkter

  • Codex s’intègre à GitHub Actions et à d’autres systèmes CI/CD
  • La revue automatique sur les PR est le cas d’usage le plus courant
  • Codex peut corriger automatiquement les échecs CI
  • La CLI permet l’intégration dans des scripts personnalisés
  • Gardez toujours un humain dans la boucle pour valider les corrections