Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Integração CI/CD

Aula 14 de 20 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. O Codex no Seu Pipeline de Entrega
  2. A Ação Oficial do GitHub
  3. Automatizar a Revisão para Cada PR
  4. Preencher Testes em Falta
  5. Reagir a uma Falha de CI
  6. Chamar o Codex a Partir dos Seus Próprios Scripts
  7. Mapear Pontos de Integração
  8. Manter o Controlo da Automação
  9. Pontos-chave

Atualizado a 3 de novembro de 2026 com base nas páginas Codex GitHub Action e Non-interactive mode da documentação do Codex: os inputs legados task, criteria, scope, framework e api-key não existem em openai/codex-action@v1 (substituídos por openai-api-key, prompt/prompt-file, sandbox, output-file, etc.). A ação não publica comentários por si só. A expressão == failure sem aspas não funcionava. A flag --apply foi substituída por codex exec --sandbox workspace-write. Fontes: Codex GitHub Action · Non-interactive mode.

O Codex no Seu Pipeline de Entrega

O Codex não se limita a tarefas lançadas manualmente por um programador. Integra-se nos seus pipelines de CI/CD para automatizar tarefas de desenvolvimento em todas as fases do ciclo de entrega. Esta mudança vai além da poupança de tempo: a revisão de código, a geração de testes e a correção de bugs deixam de depender da disciplina individual para se tornarem etapas do pipeline, acionadas por eventos e não pela boa vontade de uma sexta-feira à tarde.

A Ação Oficial do GitHub

A OpenAI publica uma ação, openai/codex-action@v1, que instala a CLI, inicia o proxy da Responses API quando fornece uma chave e executa codex exec com as permissões que definir. Os seus principais inputs:

InputFunção
openai-api-keyA chave, armazenada como um segredo do GitHub (por exemplo OPENAI_API_KEY)
prompt ou prompt-fileA instrução em linha ou um ficheiro no repositório—um ou outro, não ambos
sandboxread-only, workspace-write ou danger-full-access: escolha o âmbito mais restrito que seja suficiente
model, effortO modelo e o esforço de raciocínio; se vazios, aplicam-se os valores padrão
output-fileGuarda a mensagem final do Codex para etapas subsequentes
codex-argsOpções adicionais para codex exec
safety-strategyO padrão é drop-sudo, que remove o sudo antes da execução e protege segredos na memória

A ação executa em runners Linux ou macOS (no Windows, precisa de safety-strategy: unsafe) após um actions/checkout do código. Não publica nada por si só: expõe a última mensagem do Codex no output final-message, que uma etapa subsequente pode publicar.

Automatizar a Revisão para Cada PR

O fluxo de trabalho abaixo segue a estrutura do exemplo oficial: um primeiro job executa o Codex em modo apenas leitura e um segundo, com permissões de escrita em PRs, publica o resultado como um comentário. Os seus critérios vão para o 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 }}

O prompt merece mais atenção do que o resto do ficheiro: transforma uma revisão genérica numa revisão que corresponde às suas prioridades. Pode movê-lo do YAML para um ficheiro versionado, por exemplo .github/codex/prompts/review.md, referenciado por prompt-file. Para uma revisão simples de PR, a revisão automática integrada no GitHub (Lição 11) evita a escrita de um workflow.

Preencher Testes em Falta

Um segundo fluxo de trabalho aborda código entregue sem testes. Aqui, o Codex precisa de escrever no workspace (sandbox: workspace-write), mas o resultado permanece uma proposta: o workflow transforma-o num patch transferível que o programador revê e aplica ele próprio.

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

O programador mantém o controlo de ponta a ponta: obtém o patch, adapta-o ou rejeita-o. A documentação da ação recomenda executar o Codex por último num job para que as etapas seguintes não herdem alterações inesperadas—aqui, a única etapa seguinte apenas lê o diff.

Reagir a uma Falha de CI

O terceiro fluxo de trabalho liga-se ao resultado de outro workflow. Quando a CI falha, o Codex repete os testes no commit relevante, identifica a causa e gera um diagnóstico sem fazer push de nada:

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

Este exige o máximo de cautela. Um teste falhado sinaliza por vezes uma falha de conceção, e uma correção automática plausível pode fazê-lo desaparecer do ecrã sem o resolver: a CI fica verde novamente, mas o problema permanece. Daí a escolha de um diagnóstico para revisão em vez de um commit com push automático.

Chamar o Codex a Partir dos Seus Próprios Scripts

Fora das GitHub Actions, o codex exec encaixa em qualquer script. Por padrão, executa numa sandbox apenas leitura; dê-lhe permissão de escrita com --sandbox workspace-write quando a tarefa o exigir. O hook de pre-commit abaixo sinaliza ficheiros TypeScript sem testes e gera um no momento:

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

Na CI, o codex exec reutiliza a autenticação guardada por padrão; em vez disso, forneça credenciais explicitamente usando uma chave de API dedicada.

Mapear Pontos de Integração

Uma vez estes blocos de construção no lugar, pense em termos de eventos do ciclo de entrega e não de ficheiros YAML. Os cinco cenários abaixo cobrem os casos mais comuns:

Fase CI/CDTarefa do CodexGatilho
PR abertoRevisão automáticapull_request opened
PR abertoGeração de testespull_request opened
Falha de CIAnálise e correçãoworkflow_run failure
ReleaseChangelog automáticotag push
Atualização de dependênciasVerificação de compatibilidadeDependabot PR

Manter o Controlo da Automação

Uma integração CI/CD executa sem supervisão, o que exige algumas precauções básicas. Limite quem pode acionar workflows—por padrão, apenas utilizadores com permissões de escrita podem executar a ação (use allow-users, allow-bots para alargar isto explicitamente). Sanitize inputs de PRs, mensagens de commit ou issues antes de os entregar ao Codex: texto oculto pode conter uma injeção de prompt. Use uma chave de API dedicada com permissões mínimas em vez da chave pessoal de um programador, que ele levará consigo ao sair da empresa, quebrando os seus pipelines. Nunca faça merge automático de uma correção produzida pelo Codex: a revisão humana permanece o portão para o ramo principal. Defina limites explícitos no número de tarefas por dia e no custo máximo para que um loop de correção mal configurado não queime o seu orçamento mensal durante a noite. Por fim, mantenha um histórico das tarefas do Codex executadas na CI: no dia em que surgir um comportamento inesperado em produção, estes registos serão a sua única pista sólida.

Pontos-chave

  • O Codex integra-se em GitHub Actions e outros sistemas de CI/CD
  • A revisão automática em PRs é o caso de uso mais comum
  • O Codex pode corrigir falhas de CI automaticamente
  • A CLI permite a integração em scripts personalizados
  • Mantenha sempre um humano no loop para validar correções