<\> Casa do Dev
Notícias abrir
Ferramentas abrir
Vagas abrir
Aprender abrir
Comunidade abrir
Guia de Compras abrir

Pipeline de CI/CD com GitHub Actions: do commit ao deploy automático

DA

8 min

Pipeline de CI/CD com GitHub Actions: do commit ao deploy automático

Guia completo de CI/CD com GitHub Actions: lint, testes, build de imagem e deploy automático, com YAML comentado e erros comuns.

Neste artigo

CI/CD com GitHub Actions elimina o pior tipo de trabalho em tecnologia: o deploy manual que depende da memória de uma pessoa. Quando você conecta lint, testes e publicação a cada push, o erro aparece em minutos e não em produção. Este guia monta uma esteira completa, comentada linha a linha, do primeiro workflow ao deploy automático com aprovação manual.

Um workflow do GitHub Actions é um arquivo YAML em .github/workflows/ com gatilhos (on), etapas (jobs) e ações (steps). No mínimo, rode lint e testes a cada push; quando estiver estável, adicione build de imagem e deploy. Antes de sair automatizando, vale revisar os fundamentos de Git, porque o pipeline opera inteiro em cima do seu fluxo de branches e commits.

O que é um pipeline de CI/CD e por que ele importa

CI (integração contínua) é automatizar a checagem a cada mudança: rodar testes, linter e build assim que o código entra. CD (entrega contínua) é automatizar a publicação: levar a imagem ou o build aprovado até o ambiente de destino. As duas juntas transformam o deploy de evento raro e tenso em rotina previsível.

Sem isso, o cenário padrão é: alguém junta código de três pessoas numa sexta à tarde, descobre conflito, quebra a main e passa o fim de semana corrigindo. Com o pipeline, cada commit é validado isoladamente em minutos. O custo de corrigir cai porque o problema aparece perto de quem o criou, não dias depois num merge grande.

💡 Dica: comece só com CI (testes e lint). Adicione o deploy depois que o time confiar na esteira. Automatizar o deploy antes de ter testes criam um jeito mais rápido de publicar bug.

Como montar o primeiro workflow do GitHub Actions

Todo workflow vive em .github/workflows/ e precisa de três partes: o gatilho, um ou mais jobs e os steps que executam as ações. O exemplo abaixo roda testes de um projeto Node a cada push na branch principal.

# .github/workflows/ci.yml
name: CI

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

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

      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm

      - run: npm ci
      - run: npm run lint
      - run: npm test

O que cada linha faz: on dispara em push e pull request para a branch principal; runs-on escolhe a máquina; actions/checkout baixa o código; setup-node prepara a versão do Node com cache; e os três run executam instalação, lint e testes. Se qualquer passo falhar, o workflow falha e o commit aparece em vermelho.

Gatilhos que valem conhecer

Além do push e do pull_request, o on aceita outros gatilhos que resolvem casos comuns. O workflow_dispatch permite rodar manualmente pelo botão do GitHub, útil para deploy em ambiente que não deve ser automático. O schedule roda em cron, ideal para tarefas periódicas como verificação de dependências. E release dispara quando você publica uma versão, encaixando no fluxo de entrega de bibliotecas.

Como adicionar cache para acelerar o pipeline

O cache é o que separa uma esteira rápida de uma que baixa dependências a cada execução. No exemplo, cache: npm já liga o cache do npm. Em projetos maiores, você pode cachear diretórios inteiros com a ação actions/cache, economizando os minutos que se repetem em todo push.

Cache mal dimensionado é um problema silencioso: se a chave não muda quando as dependências mudam, o pipeline usa pacotes velhos e você persegue bug que não existe localmente. A regra prática é derivar a chave do arquivo de lock, para que uma mudança de dependência invalide o cache automaticamente.

Como transformar o CI em CD com build e deploy

Com o CI estável, o próximo passo é empacotar e publicar. Um fluxo comum para aplicações web é gerar uma imagem Docker, enviar para um registro e disparar o deploy. O trecho abaixo estende o workflow para construir a imagem apenas quando já passou nos testes.

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - run: npm test

  build-and-deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Build da imagem
        run: |
          docker build -t minha-app:${{ github.sha }} .

      - name: Publicar no registro
        run: |
          docker push minha-app:${{ github.sha }}

      - name: Disparar deploy
        run: |
          echo "deploy da versão ${{ github.sha }} acionado"

A peça-chave aqui é needs: test: o job de build só roda depois que os testes passam. Isso garante que código quebrado nunca chega ao deploy, mesmo que alguém force um push direto na main.

Deploy com aprovação manual e ambientes

Para produção, o GitHub Actions tem o conceito de environment. Você declarando environment: production ganha duas coisas: secretes separados por ambiente e, quando configurado, aprovação manual antes do job rodar. É o controle que evita o push acidental direto para produção, sem abrir mão da automação no resto do fluxo.

Como guardar segredos sem vazar credencial

Token de deploy, chave de registro e senha de banco nunca entram no YAML. Armazene como secrets do repositório e leia via ${{ secrets.NOME }}. Isso mantém a credencial fora do histórico do Git e fora do diff, que é onde acontece a maioria dos vazamentos em repositórios privados que viram públicos.

⚠️ Atenção: não escreva segredos em echo dentro do log. Os logs de workflow ficam retidos e podem vazar para integrantes do time. Use máscaras do próprio Actions ou mantenha o valor em variável de ambiente do runner.

Erros comuns que travam quem está começando

O erro número um é o YAML mal indentado: dois espaços fazem diferença e o parser não perdoa. O segundo é esquecer o checkout e o workflow rodar sem o código. O terceiro é disparar deploy sem needs, publicando antes do teste. Revise esses três antes de culpar a ferramenta.

ErroSintomaCorreção
Indentação errada no YAMLFalha de parse antes de rodarUsar dois espaços consistentes
Faltou checkoutArquivo não encontradoIncluir actions/checkout como primeiro step
Deploy sem needsPublicação antes dos testesEncadear jobs com needs
Segredo no YAMLCredencial exposta no diffMover para repository secrets

Como o CI/CD encaixa na sua carreira

Saber montar esteira é diferencial real em vagas de backend e DevOps, e aparece com frequência em entrevistas de pleno. O recrutador não pergunta se você já fez deploy manual; pergunta se você sabe encadear teste, build e publicação sem intervenção. É o tipo de habilidade que se prova em minutos mostrando um repositório com workflow funcionando e log verde.

O salto de valor acontece quando você para de só usar e passa a desenhar o fluxo: decidir o que roda no push, o que espera aprovação e o que é liberado em deploy. Essa capacidade de planejar uma esteira de entrega é o que separa o desenvolvedor que executa tarefas do que assume responsabilidade por como o time coloca código no ar.

O conceito aqui é vizinho do que se vê em orquestração e nuvem: se você domina pipeline e quer ir além, o guia de governança de IA na nuvem mostra como arquitetos pensam automação em escala, e o guia completo de AWS cobre o ambiente onde a maioria dessas esteiras termina.

Perguntas frequentes

GitHub Actions é gratuito?

Repositórios públicos têm minutos gratuitos, e privados têm uma cota mensal. Para a maioria dos projetos pessoais e times pequenos, a camada gratuita dá conta do uso diário.

Qual a diferença entre CI e CD?

CI é a checagem automática a cada mudança, com testes e lint. CD é a publicação automática do que passou. CI sem CD ainda vale muito; CD sem CI é que publica bug rápido.

Preciso usar Docker para ter um pipeline?

Não. Você pode publicar código direto em um serviço de hospedagem sem container. Docker entra quando você quer empacotar o ambiente e o build de forma reproduzível em qualquer lugar.

Como disparo o workflow manualmente?

Adicione workflow_dispatch ao gatilho on. Isso cria um botão de execução manual na interface do GitHub, útil para deploy em ambiente que você não quer que rode sozinho a cada push.

Como regulo quem pode aprovar o deploy de produção?

Use environment: production no job e configure aprovação e regras de proteção no repositório. Só quem tem a permissão autoriza o passo, e os segredos ficam separados por ambiente.

Consigo testar o workflow antes de dar push?

Sim. A ferramenta act simula a execução localmente, útil para pegar erro de YAML antes de subir. Em repositórios privados, o próprio log do Actions já resolve a maioria dos problemas.

O que você achou deste artigo?

Responda a Pergunta do Dia Teste seu conhecimento e mantenha sua streak. Crie seu Dev Card público Perfil dev compartilhável em um único link.

Depois dessa formação...

Veja vagas de cloud e DevOps →

Vagas relacionadas

Ver todas as vagas →
DA

Escrito por

Dagmar

Atualizado em 06/10/2026 •

Ver perfil do autor

COMPARTILHAR