Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Integrazione CI/CD

Lezione 14 di 20 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Codex nella tua pipeline di rilascio
  2. L’Action ufficiale per GitHub
  3. Automatizza la revisione per ogni PR
  4. Colma i test mancanti
  5. Reagisci a un fallimento della CI
  6. Chiama Codex dai tuoi script
  7. Mappa i punti di integrazione
  8. Mantieni il controllo sull’automazione
  9. Punti chiave

Aggiornato il 3 novembre 2026 sulla base delle pagine Codex GitHub Action e Modalità non interattiva della documentazione di Codex: gli input legacy task, criteria, scope, framework e api-key non esistono in openai/codex-action@v1 (sostituiti da openai-api-key, prompt/prompt-file, sandbox, output-file, ecc.). L’action non pubblica commenti autonomamente. L’espressione == failure senza virgolette non funzionava. Il flag --apply è sostituito da codex exec --sandbox workspace-write. Fonti: Codex GitHub Action · Modalità non interattiva.

Codex nella tua pipeline di rilascio

Codex non si limita ai compiti avviati manualmente da uno sviluppatore. Si integra nelle tue pipeline CI/CD per automatizzare le attività di sviluppo in ogni fase del ciclo di rilascio. Questo cambiamento va oltre il risparmio di tempo: la revisione del codice, la generazione di test e la correzione dei bug smettono di dipendere dalla disciplina individuale e diventano passaggi della pipeline attivati da eventi, non dalla buona volontà del venerdì pomeriggio.

L’Action ufficiale per GitHub

OpenAI pubblica un’action, openai/codex-action@v1, che installa la CLI, avvia il proxy delle API Responses quando fornisci una chiave ed esegue codex exec con i permessi che imposti. I suoi input principali:

InputRuolo
openai-api-keyLa chiave, archiviata come segreto GitHub (ad esempio OPENAI_API_KEY)
prompt o prompt-fileL’istruzione inline o un file nel repository: uno o l’altro, non entrambi
sandboxread-only, workspace-write o danger-full-access: scegli l’ambito più ristretto sufficiente
model, effortIl modello e lo sforzo di ragionamento; se vuoti, si applicano i valori predefiniti
output-fileSalva il messaggio finale di Codex per i passaggi successivi
codex-argsOpzioni aggiuntive per codex exec
safety-strategyPredefinito su drop-sudo, che rimuove sudo prima dell’esecuzione e protegge i segreti in memoria

L’action viene eseguita su runner Linux o macOS (su Windows, hai bisogno di safety-strategy: unsafe) dopo un actions/checkout del codice. Non pubblica nulla autonomamente: espone l’ultimo messaggio di Codex nell’output final-message, che un passaggio successivo può pubblicare.

Automatizza la revisione per ogni PR

Il flusso di lavoro seguente segue la struttura dell’esempio ufficiale: un primo job esegue Codex in modalità sola lettura e un secondo, con permessi di scrittura sulle PR, pubblica il risultato come commento. I tuoi criteri vanno nel 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 }}

Il prompt merita più attenzione del resto del file: trasforma una revisione generica in una che corrisponde alle tue priorità. Puoi spostarlo fuori dallo YAML in un file versionato, ad esempio .github/codex/prompts/review.md, referenziato da prompt-file. Per una semplice revisione di PR, la revisione automatica integrata in GitHub (Lezione 11) evita del tutto la scrittura di un flusso di lavoro.

Colma i test mancanti

Un secondo flusso di lavoro affronta il codice consegnato senza test. Qui Codex deve scrivere nello spazio di lavoro (sandbox: workspace-write), ma il risultato rimane una proposta: il flusso di lavoro lo trasforma in una patch scaricabile che lo sviluppatore esamina e applica personalmente.

# .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

Lo sviluppatore mantiene il controllo dall’inizio alla fine: scarica la patch, la adatta o la rifiuta. La documentazione dell’action consiglia di eseguire Codex per ultimo in un job, così i passaggi successivi non ereditano modifiche impreviste; qui, l’unico passaggio successivo si limita a leggere il diff.

Reagisci a un fallimento della CI

Il terzo flusso di lavoro si aggancia al risultato di un altro flusso di lavoro. Quando la CI fallisce, Codex riesegue i test sul commit pertinente, individua la causa e produce una diagnosi senza spingere nulla:

# .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

Questo richiede la massima cautela. Un test fallito a volte segnala un difetto di progettazione e una correzione automatica plausibile può farlo scomparire dallo schermo senza risolverlo: la CI torna verde, ma il problema rimane. Da qui la scelta di una diagnosi da revisionare piuttosto che di un commit spinto automaticamente.

Chiama Codex dai tuoi script

Al di fuori di GitHub Actions, codex exec si inserisce in qualsiasi script. Per impostazione predefinita, viene eseguito in una sandbox sola lettura; dagli il permesso di scrittura con --sandbox workspace-write quando il compito lo richiede. L’hook pre-commit seguente segnala i file TypeScript senza test e ne genera uno al volo:

#!/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

In CI, codex exec riutilizza l’autenticazione salvata per impostazione predefinita; invece, fornisci le credenziali esplicitamente usando una chiave API dedicata.

Mappa i punti di integrazione

Una volta messi in piedi questi mattoni, pensa in termini di eventi del ciclo di rilascio piuttosto che di file YAML. I cinque scenari seguenti coprono i casi più comuni:

Fase CI/CDCompito di CodexTrigger
PR apertaRevisione automaticapull_request opened
PR apertaGenerazione testpull_request opened
Fallimento CIAnalisi e correzioneworkflow_run failure
ReleaseChangelog automaticotag push
Aggiornamento dipendenzeControllo compatibilitàDependabot PR

Mantieni il controllo sull’automazione

Un’integrazione CI/CD viene eseguita senza supervisione, il che richiede alcune precauzioni di base. Limita chi può attivare i flussi di lavoro: per impostazione predefinita, solo gli utenti con permessi di scrittura possono eseguire l’action (usa allow-users, allow-bots per ampliarlo esplicitamente). Sanifica l’input proveniente da PR, messaggi di commit o issue prima di passarlo a Codex: il testo nascosto può contenere un’iniezione di prompt. Usa una chiave API dedicata con permessi minimi invece della chiave personale di uno sviluppatore, che porterà con sé quando lascerà l’azienda, rompendo le tue pipeline. Non unire mai automaticamente una correzione prodotta da Codex: la revisione umana rimane il cancello verso il ramo principale. Imposta limiti espliciti sul numero di compiti al giorno e sul costo massimo, così un ciclo di correzione mal configurato non brucia il tuo budget mensile durante la notte. Infine, mantieni una cronologia dei compiti di Codex eseguiti in CI: il giorno in cui appare un comportamento imprevisto in produzione, questi log saranno la tua unica pista solida.

Punti chiave

  • Codex si integra in GitHub Actions e altri sistemi CI/CD
  • La revisione automatica sulle PR è il caso d’uso più comune
  • Codex può correggere automaticamente i fallimenti della CI
  • La CLI consente l’integrazione in script personalizzati
  • Mantieni sempre un essere umano nel ciclo per validare le correzioni