PHP Academy · Aula

CI/CD com GitHub Actions

Teste e implante PHP automaticamente a cada envio.

Aula 4 de 413 etapas

CI/CD com GitHub Actions é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Integração contínua e entrega contínua para PHP

Cada envio deve ser testado, verificado quanto a problemas de estilo, analisado estaticamente e — quando estiver aprovado no ramo principal — transformado em uma imagem e implantado. O GitHub Actions executa esse pipeline em executores gerenciados, acionado por eventos do repositório.

Você criará um fluxo de trabalho que executa o PHPUnit em um serviço MySQL real, armazena o Composer em cache, executa o PHPStan, compila uma imagem do Docker e faz a implantação.

Anatomia do fluxo de trabalho

Um fluxo de trabalho fica em .github/workflows/*.yml. Ele tem gatilhos on:, um ou mais jobs:, e cada tarefa tem steps:. As tarefas são executadas em executores isolados e em paralelo, a menos que estejam vinculadas por needs:.

name: CI
on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

Ação setup-php

shivammathur/setup-php é a forma padrão de instalar uma versão específica do PHP com as extensões e ferramentas escolhidas (Composer, PHPStan etc.) no executor — muito mais rápido do que compilar uma imagem apenas para testar.

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.3'
          extensions: pdo_mysql, intl, redis, zip
          coverage: pcov
          tools: composer:v2, phpstan

Armazenando o Composer em cache

Baixar novamente as dependências a cada execução desperdiça minutos. Armazene o diretório do Composer em cache usando como chave o hash de composer.lock, para que o cache só seja invalidado quando as dependências mudarem.

      - name: Get Composer cache dir
        id: composer-cache
        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT

      - uses: actions/cache@v4
        with:
          path: ${{ steps.composer-cache.outputs.dir }}
          key: composer-${{ hashFiles('**/composer.lock') }}
          restore-keys: composer-

      - run: composer install --prefer-dist --no-progress

Contêineres de serviço

As tarefas podem iniciar contêineres de serviço — um MySQL ou Redis real que o executor pode acessar em 127.0.0.1. Adicione uma verificação de integridade por meio de options para que as etapas não sejam executadas antes de o banco de dados estar pronto.

  test:
    runs-on: ubuntu-latest
    services:
      mysql:
        image: mysql:8.4
        env:
          MYSQL_DATABASE: app_test
          MYSQL_ROOT_PASSWORD: root
        ports: ['3306:3306']
        options: >-
          --health-cmd="mysqladmin ping -proot"
          --health-interval=5s --health-retries=10

Executando testes e cobertura

Com as dependências instaladas e o MySQL em execução, execute o PHPUnit. Aponte o DSN dos testes para 127.0.0.1:3306. Gere a cobertura e, opcionalmente, faça a compilação falhar se ela ficar abaixo de um limite.

      - name: Run PHPUnit
        env:
          DATABASE_URL: "mysql://root:root@127.0.0.1:3306/app_test"
        run: vendor/bin/phpunit --coverage-clover=coverage.xml

      - name: Static analysis
        run: phpstan analyse src --level=8 --no-progress

Compilações em matriz

As bibliotecas devem passar em várias versões do PHP. Uma strategy.matrix distribui a tarefa em execuções paralelas, uma por combinação, com ${{ matrix.php }} interpolado nas etapas.

  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        php: ['8.2', '8.3', '8.4']
    steps:
      - uses: actions/checkout@v4
      - uses: shivammathur/setup-php@v2
        with:
          php-version: ${{ matrix.php }}

Calculando o identificador da imagem

As implantações precisam de um identificador de imagem único e rastreável. O SHA do commit é a escolha convencional. Este trecho mostra a lógica de derivação do identificador que você expressaria no fluxo de trabalho — transformando uma referência e um SHA em um identificador de registro.

<?php
// Mirrors what the workflow computes for the image tag
$ref = 'refs/heads/main';
$sha = '9f41efadc0de1234567890abcdef0000deadbeef';

$branch = str_replace('refs/heads/', '', $ref);
$shortSha = substr($sha, 0, 7);
$tag = sprintf('registry.example.com/app:%s-%s', $branch, $shortSha);

echo $tag . PHP_EOL;          // registry.example.com/app:main-9f41efa
echo 'is_main: ' . ($branch === 'main' ? 'yes' : 'no') . PHP_EOL;
?>

Compilando e enviando a imagem

No ramo principal, compile a imagem do Docker com docker/build-push-action, usando o BuildKit e o cache do GitHub Actions. Primeiro, autentique-se no registro com um token secreto; nunca codifique credenciais diretamente.

  build:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - uses: docker/build-push-action@v6
        with:
          push: true
          target: runtime
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

Segredos e OIDC

Armazene as credenciais nos segredos do repositório ou do ambiente, referenciados como ${{ secrets.NAME }} — eles são ocultados nos registros. Para implantações na nuvem, prefira o OIDC: o executor obtém um token de curta duração da AWS/GCP por meio de permissions: id-token: write, para que nenhuma chave de longa duração fique no repositório.

  deploy:
    needs: build
    runs-on: ubuntu-latest
    permissions:
      id-token: write     # enables OIDC
      contents: read
    steps:
      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/deploy
          aws-region: eu-central-1

Etapa de implantação e ambientes

Condicione as implantações de produção a um environment do GitHub, opcionalmente com revisores obrigatórios. A etapa de implantação então aciona sua atualização — atualizando uma implantação do Kubernetes, um serviço do ECS ou conectando-se por SSH para baixar a nova imagem.

  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment:
      name: production       # can require manual approval
      url: https://app.example.com
    steps:
      - name: Roll out
        run: |
          kubectl set image deployment/app \
            app=ghcr.io/${{ github.repository }}:${{ github.sha }}
          kubectl rollout status deployment/app --timeout=120s

Verificação rápida

Qual é a principal vantagem de segurança do OIDC em relação às chaves de nuvem armazenadas no Actions?

Recapitulação

Você criou um pipeline de integração contínua e entrega contínua em GitHub Actions: acionado por envios/PR, setup-php com extensões, Composer armazenado em cache com chave baseada no arquivo de bloqueio, um contêiner de serviço MySQL com verificação de integridade, PHPUnit + PHPStan, uma matriz de versões e, em seguida, uma compilação e um envio apenas no ramo principal, com cache do GHA e uma implantação autenticada por OIDC e condicionada ao ambiente.

Princípios: use hashes do arquivo de bloqueio para o cache, controle os serviços prontos com verificações de integridade, identifique as imagens pelo SHA e prefira OIDC a chaves armazenadas.

Grátis para começar

Aprenda PHP com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
49
Aulas
195

Perguntas Frequentes

A aula “CI/CD com GitHub Actions” é grátis?

Sim — o texto completo de “CI/CD com GitHub Actions” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “CI/CD com GitHub Actions”?

Teste e implante PHP automaticamente a cada envio. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “CI/CD com GitHub Actions”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Conteinerizando uma aplicação PHP
  2. Compilações em múltiplas etapas e otimização
  3. Docker Compose para ambientes locais
  4. CI/CD com GitHub Actions
← Voltar para PHP Academy