Pipeline de entrega

Do commit à produção sem susto: etapas do pipeline, artefatos versionados, ambientes, estratégias de deploy, rollback e feature flags.

Cerca de 15 min · Revisado em

Ao final, você vai conseguir

  • Diferenciar CI, entrega contínua e implantação contínua
  • Ordenar as etapas de um pipeline, do build até produção
  • Gerar um artefato versionado e separar o que é artefato do que é configuração de ambiente
  • Comparar deploys rolling, blue-green e canary e escolher um para um cenário
  • Fazer rollback para uma versão anterior e explicar quando usar uma feature flag

Sexta-feira, 18h, alguém publica uma versão nova do app de delivery e o botão de pagar some. Em uma empresa sem pipeline, começa a correria: quem publicou, o que mudou, como voltava mesmo? Em uma empresa com pipeline, alguém aperta “voltar para a versão anterior” e vai jantar. Esta aula é sobre construir o segundo cenário.

Conferir não é entregar

Na aula de CI você automatizou a conferência. CD é a parte da entrega e tem dois sentidos. Entrega contínua (*Continuous Delivery*): toda versão aprovada fica pronta para ir ao ar com um clique. Implantação contínua (*Continuous Deployment*): ela vai ao ar sozinha, sem clique.

Deploy (implantação) é colocar uma versão para rodar em um ambiente. Um pipeline de entrega é a sequência automática de etapas que leva um commit até esse deploy, parando no primeiro problema.

Na empresa de Júlia, todo merge no main roda os testes e gera uma versão pronta. Para ir à produção, alguém do time clica em “aprovar”. Isso é:

  • Entrega contínua
  • Implantação contínua
  • Só CI, sem CD

As etapas do caminho

Um pipeline é uma esteira. Cada etapa só começa se a anterior passou, e quanto mais perto da produção, mais caro é errar. Por isso as verificações baratas e rápidas vêm primeiro.

As etapas de um pipeline típico
EtapaO que fazSe falhar
BuildCompila e empacota o códigoNada é publicado; corrija o código
TestesRoda testes unitários e de integraçãoNada é publicado
ArtefatoGuarda o pacote pronto, com versãoSem artefato não há o que implantar
StagingImplanta num ambiente parecido com produçãoProdução não é tocada
ProduçãoImplanta para as pessoas usuáriasRollback para a versão anterior

Um pipeline em GitHub Actions com etapas encadeadas.

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t loja:${{ github.sha }} .
      - run: docker push registro.exemplo.com/loja:${{ github.sha }}

  staging:
    needs: build
    environment: staging
    runs-on: ubuntu-latest
    steps:
      - run: ./deploy.sh staging ${{ github.sha }}

  producao:
    needs: staging
    environment: producao
    runs-on: ubuntu-latest
    steps:
      - run: ./deploy.sh producao ${{ github.sha }}
  • Gatilho: Só o main gera versões que podem ir ao ar. Pull requests rodam a CI, mas não chegam aqui.
  • Artefato versionado: A imagem é marcada com o SHA do commit, o código único que o Git dá a cada commit. Assim, cada artefato aponta exatamente para o código que o gerou.
  • needs: needs cria a ordem: este job só começa se build terminou com sucesso. Sem ele, os jobs rodariam em paralelo.
  • environment: Um ambiente no GitHub: tem segredos próprios (a senha do banco de staging não é a de produção) e pode ter regras de proteção.
  • Aprovação: No ambiente producao dá para exigir que uma pessoa aprove antes de o job rodar. O pipeline pausa e espera o clique.
  • Mesmo artefato: Produção recebe a mesma imagem testada em staging. Nada é recompilado no caminho.

Coloque as etapas do pipeline na ordem em que acontecem.

  • Build: compilar e empacotar
  • Testes automatizados
  • Publicar o artefato com uma versão
  • Deploy em staging
  • Aprovação de uma pessoa do time
  • Deploy em produção

Construa uma vez, implante em todo lugar

Um artefato é o pacote pronto para rodar: uma imagem Docker, um .zip de site, um .jar. A regra de ouro é gerar o artefato uma vez e promover esse mesmo pacote de ambiente em ambiente. Se você recompila para produção, está implantando algo que nunca foi testado.

Então como o mesmo pacote fala com bancos diferentes? Pela configuração, que vem de fora: variáveis de ambiente e segredos de cada ambiente. O artefato é igual; o endereço do banco muda.

O que fica dentro do artefato e o que muda por ambiente?

Igual em todos (no artefato) · Muda por ambiente (configuração)

  • O código compilado da aplicação
  • O endereço do banco de dados
  • As bibliotecas nas versões travadas
  • A chave da API de pagamentos
  • O nível de detalhe dos logs
  • Os arquivos de CSS e imagens do site

Para saber o que está no ar, cada artefato precisa de uma versão. Uma convenção comum é o versionamento semântico: MAIOR.MENOR.CORREÇÃO, como 1.4.2. Correção sobe o último número; função nova, o do meio; mudança que quebra quem usa, o primeiro.

Gerando e registrando uma versão

Você vai empacotar a loja como imagem Docker com versão, enviá-la a um registro e marcar o commit no Git.

  1. Construa a imagem com o nome loja e a versão 1.4.0.

    docker build -t loja:1.4.0 .
    [+] Building 18.3s (10/10) FINISHED
     => [1/5] FROM docker.io/library/node:22-alpine
     => [5/5] RUN npm run build
     => exporting to image
     => => naming to docker.io/library/loja:1.4.0
  2. Dê à imagem o nome completo do registro da empresa, registro.exemplo.com/loja:1.4.0.

    docker tag loja:1.4.0 registro.exemplo.com/loja:1.4.0
  3. Envie a imagem para o registro.

    docker push registro.exemplo.com/loja:1.4.0
    The push refers to repository [registro.exemplo.com/loja]
    5f70bf18a086: Pushed
    1.4.0: digest: sha256:9b2c41e0d7a3 size: 1572
  4. Marque o commit atual no Git com a tag v1.4.0.

    git tag v1.4.0
  5. Envie a tag para o GitHub.

    git push origin v1.4.0
    To github.com:ana/loja.git
     * [new tag]         v1.4.0 -> v1.4.0

Trocando a versão sem derrubar ninguém

Colocar a versão nova no ar não precisa ser um “desliga tudo e liga de novo”. Existem estratégias para trocar com as pessoas usando, e para limitar o estrago se algo der errado.

Rolling

Troca aos poucos

Com 4 servidores, troca um de cada vez. Simples e sem custo extra, mas por um tempo as duas versões convivem.

Blue-green

Dois ambientes iguais

A versão nova sobe inteira ao lado da antiga e o tráfego é virado de uma vez. Voltar é virar de novo. Custa o dobro durante a troca.

Canary

Um grupo pequeno primeiro

A versão nova recebe 5% das pessoas. Se os erros não sobem, aumenta para 25%, 50%, 100%. Se sobem, só 5% sentiram.

Um deploy canary em ação

  1. Usuários → Balanceador: Pedidos chegando. O balanceador de carga recebe todos os pedidos e decide para qual servidor cada um vai.
  2. Balanceador → Versão 1.3: 95% do tráfego. A maioria continua na versão estável.
  3. Balanceador → Versão 1.4: 5% do tráfego. Um grupo pequeno recebe a versão nova. É o “canário na mina”: o primeiro sinal de perigo.
  4. Versão 1.4 → Versão 1.4: Erros sobem para 8%. O painel mostra que a versão nova falha muito mais que a antiga. Hora de agir.
  5. Balanceador → Versão 1.3: 100% volta para a 1.3. O tráfego é devolvido à versão estável. Só 5% das pessoas viram o problema, por poucos minutos.

Um banco digital vai mudar a tela de Pix. O time quer que, se der problema, o menor número possível de clientes seja afetado e que dê para comparar erros entre versões. Qual estratégia combina mais?

  • Canary
  • Blue-green
  • Desligar o sistema de madrugada e trocar tudo

Plano de volta, flags e aprovações

Rollback é voltar para a versão anterior que funcionava. Com artefatos versionados, é só implantar de novo o artefato antigo. A regra prática: na dúvida durante um problema, volte primeiro e investigue depois.

Voltando para a versão anterior

A versão v1.4.0 quebrou o pagamento. Use a CLI do GitHub para disparar o workflow de deploy com a versão anterior.

  1. Liste as versões publicadas para achar a anterior.

    gh release list
    TITLE   TYPE    TAG NAME  PUBLISHED
    v1.4.0  Latest  v1.4.0    about 20 minutes ago
    v1.3.2          v1.3.2    about 3 days ago
    v1.3.1          v1.3.1    about 1 week ago
  2. Dispare o workflow deploy.yml passando a entrada versao com o valor v1.3.2.

    gh workflow run deploy.yml -f versao=v1.3.2
    ✓ Created workflow_dispatch event for deploy.yml at main
  3. Acompanhe a execução até o fim.

    gh run watch
    ✓ main Deploy · 9127
    Triggered via workflow_dispatch about 1 minute ago
    
    JOBS
    ✓ producao in 52s (ID 3381)
      ✓ Deploy da imagem loja:1.3.2
      ✓ Health check
  4. Confira qual versão está respondendo em produção.

    curl https://loja.exemplo.com.br/versao
    {"versao":"1.3.2","commit":"b71d03f"}
A versão 1.4 apagou uma coluna do banco de dados. Você faz rollback para a 1.3. Por que isso pode não resolver?

Porque o rollback troca o código, não os dados. A 1.3 vai procurar uma coluna que não existe mais. Por isso mudanças de banco devem ser compatíveis com a versão anterior: primeiro adicione o novo, depois migre, e só remova o antigo numa versão futura.

Uma feature flag (chave de funcionalidade) é um “interruptor” no código: a função nova vai para produção desligada e é ligada por configuração, para todos ou para um grupo. Assim, deploy (código no ar) e lançamento (pessoas vendo) viram decisões separadas.

Uma feature flag no código

if (flags.estaLigada('novo-checkout', usuario)) {
  mostrarNovoCheckout();
} else {
  mostrarCheckoutAtual();
}

O time quer lançar um novo cardápio no app só para clientes de Recife primeiro, sem fazer um deploy separado. O que resolve?

  • Uma feature flag ligada para clientes de Recife
  • Um deploy canary de 10%
  • Um ambiente de staging só para Recife
  • Um rollback seletivo

Fechamento

  • CI confere cada mudança; CD leva a versão aprovada até um ambiente, com ou sem aprovação humana.
  • Um pipeline segue build, testes, artefato, staging e produção, parando na primeira falha.
  • O artefato é gerado uma vez, recebe uma versão e é promovido entre ambientes; o que muda é a configuração.
  • Rolling, blue-green e canary trocam a versão sem desligar tudo; canary limita quem é afetado.
  • Rollback reimplanta a versão anterior, feature flags separam deploy de lançamento e aprovações protegem produção.

Monte um pipeline com volta garantida

Use um projeto seu que já tenha CI. Você vai transformar a conferência em entrega com versão e provar que consegue voltar atrás.

  1. Faça a CI validar cada pull request e bloquear o merge se ela falhar
  2. No main, gere um artefato versionado (imagem Docker ou build do site) marcado com a versão ou o SHA do commit
  3. Crie um ambiente de produção com segredos próprios e permissões mínimas para o job de deploy
  4. Publique duas versões e depois faça rollback para a primeira, registrando os comandos usados
  5. Escreva no README como descobrir qual versão está no ar e como voltar para a anterior

Referências

Cursos relacionados