CI/CD com GitHub Actions
Teste e implante PHP automaticamente a cada envio.
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@v4Açã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, phpstanArmazenando 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-progressContê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=10Executando 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-progressCompilaçõ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=maxSegredos 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-1Etapa 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=120sVerificaçã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.
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
- Conteinerizando uma aplicação PHP
- Compilações em múltiplas etapas e otimização
- Docker Compose para ambientes locais
- CI/CD com GitHub Actions