Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Intégration CI/CD

Paskaita 14 iš 20 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Codex dans ton 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 tes propres scripts
  7. Cartographier les points d’intégration
  8. Garde le contrôle de l’automatisation
  9. Svarbiausi punktai

Mise à jour du 3 novembre 2026 basée sur les 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 ton pipeline de livraison

Codex ne se limite pas aux tâches qu’un développeur lance manuellement. Il s’intègre à tes 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 les corrections de bugs ne dépendent plus de la discipline individuelle, mais deviennent 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 tu fournis une clé, et exécute codex exec avec les permissions que tu définis. 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 : choisis 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 (sur Windows, tu as 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 : un premier job exécute Codex en mode lecture seule, et un second, disposant de permissions d’écriture sur les PR, publie le résultat sous forme de commentaire. Tes 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 à tes priorités. Tu peux 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 un job pour 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 tes 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 ; donne-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 ; fournis 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, pense 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

Garde le contrôle de l’automatisation

Une intégration CI/CD s’exécute sans surveillance, ce qui appelle quelques précautions de base. Limite qui peut déclencher les flux de travail : par défaut, seuls les utilisateurs disposant de permissions d’écriture peuvent exécuter l’action (utilise allow-users, allow-bots pour élargir explicitement cela). Assainis 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. Utilise 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, cassant ainsi tes pipelines. Ne fusionne jamais automatiquement une correction produite par Codex : la revue humaine reste la porte d’entrée vers la branche principale. Fixe des limites explicites sur le nombre de tâches par jour et le coût maximal pour qu’une boucle de correction mal configurée ne consume pas ton budget mensuel overnight. Enfin, conserve un historique des tâches Codex exécutées en CI : le jour où un comportement inattendu apparaît en production, ces journaux seront ta seule piste solide.

Svarbiausi punktai

  • Codex s’intègre dans 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 les échecs CI automatiquement
  • La CLI permet l’intégration dans des scripts personnalisés
  • Garde toujours un humain dans la boucle pour valider les corrections