Projeto final: aposente a Noite do Release
Junte tudo para a Byte Bakery: passe os commits pelo pipeline de entrega completo, controle os releases para produção e informe as métricas DORA semana a semana.
- Modelar um pipeline de entrega completo, do commit até a produção
- Combinar checagens de pipeline, segurança, confiabilidade e horário num portão de release
- Informar o desempenho da entrega ao longo do tempo para mostrar a evolução
Seis meses depois de você chegar, a Byte Bakery faz a sua última Noite do Release - como festa, com pizza e sem notebooks. Toda mudança agora passa por um único pipeline: build, testes, varredura, deploy em staging, smoke test, deploy em produção. A infraestrutura vive no Terraform, o estado da produção no Git, os alertas seguem os SLOs e os incidentes terminam com postmortems sem culpados.
Neste projeto final, você vai construir as três ferramentas que mantêm tudo isso honesto:
- O executor de pipeline - passa cada commit pelos estágios, para na primeira falha e só faz deploy a partir da
main. - O portão de release - decide se um release pode ir para produção agora, a partir do pipeline, das vulnerabilidades, dos incidentes, do error budget, da janela de deploy e das datas de congelamento.
- O painel de entrega - transforma um log de deploys em métricas DORA semanais com tendências, para a equipe se ver melhorando.
Experimente
Até 15 XPO pipeline completo
Este é o pipeline da Byte Bakery hoje, do commit até a produção.
- Qual é o caminho crítico? Que job você aceleraria primeiro?
- Faça smoke-staging falhar. Alguma coisa chega à produção?
- Faça deploy-production falhar. O que acontece em seguida?
- ✓ sucesso0-1 min
- ✓ sucesso0-4 min
- ✓ sucesso0-1 min
- ✓ sucesso4-7 min
- ✓ sucesso7-9 min
- ✓ sucesso9-11 min
- ✓ sucesso11-13 min
- ✓ sucesso13-16 min
- ⊘ ignorado
- ✓ sucesso16-17 min
Clique em um job para fazê-lo falhar (clique de novo para corrigir). As barras mostram quando cada job é executado; jobs sem dependência entre si rodam ao mesmo tempo.
1name: Deliver
2on:
3 push:
4 branches: [main]
5
6permissions:
7 contents: read
8 id-token: write # OIDC: short-lived cloud credentials, no stored keys
9
10jobs:
11 build:
12 runs-on: ubuntu-latest
13 outputs:
14 image: ${{ steps.push.outputs.image }}
15 steps:
16 - uses: actions/checkout@v4
17 - run: pip install -r requirements.txt && ruff check . && pytest
18 - id: push
19 run: |
20 image=registry.example.com/byte-bakery/shop:${{ github.sha }}
21 docker build -t "$image" . && docker push "$image"
22 echo "image=$image" >> "$GITHUB_OUTPUT"
23 - run: trivy image --exit-code 1 --severity CRITICAL,HIGH registry.example.com/byte-bakery/shop:${{ github.sha }}
24
25 promote:
26 needs: build
27 runs-on: ubuntu-latest
28 environment: production # protection rules and the release gate live here
29 steps:
30 - uses: actions/checkout@v4
31 with:
32 repository: byte-bakery/deployments
33 - run: |
34 yq -i '.image = "${{ needs.build.outputs.image }}"' environments/production/shop/values.yaml
35 git commit -am "Deploy shop ${{ github.sha }}" && git push # GitOps: Argo CD does the restRepare como as peças da trilha se encaixam: o CI constrói um único artefato com o SHA do commit como tag e o varre, e a promoção é um commit no repositório de GitOps - o Argo CD faz a distribuição, os alertas acompanham o burn rate e um release ruim está a um git revert de distância.
1checks = [
2 ("pipeline is green", True, "block"),
3 ("no open SEV1 or SEV2 incidents", True, "block"),
4 ("error budget above 25%", False, "warn"),
5]
6failed = [(name, kind) for name, passed, kind in checks if not passed]
7blockers = sum(1 for _, kind in failed if kind == "block")
8print("NO GO" if blockers else f"GO WITH CAUTION ({len(failed)} warning)" if failed else "GO")GO WITH CAUTION (1 warning)
Para onde ir agora
Você percorreu a jornada do DevOps de ponta a ponta. Para continuar:
- Monte um pipeline de verdade para um projeto pessoal: GitHub Actions ou GitLab CI, uma imagem de contêiner e um deploy num plano gratuito.
- Escreva Terraform para uma pequena estrutura na nuvem, rode os planos nos pull requests e provoque um desvio de propósito.
- Leia The Phoenix Project (um romance!), The DevOps Handbook, Accelerate e os livros gratuitos do Google sobre Site Reliability Engineering.
- Experimente as trilhas de GitHub, Docker, Kubernetes, Microsserviços e Sistemas Distribuídos para se aprofundar nas ferramentas.
Principais conclusões
Um único pipeline: construir uma vez, testar, varrer, implantar em staging, verificar e promover para produção.
Os portões de release combinam a saúde do pipeline, segurança, incidentes, error budgets e horário.
Meça a entrega ao longo do tempo com as métricas DORA e use as tendências para melhorar.
O objetivo são deploys entediantes: pequenos, automatizados, observáveis e fáceis de desfazer.
Quiz da aula
7 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: automatize tarefas de DevOps com Python
Escreva as pequenas ferramentas em Python que times de DevOps realmente criam, como executores de pipeline, verificadores de plano, calculadoras de métricas e scanners, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contas na nuvem.
Passe os commits pelo pipeline
A primeira linha da entrada lista os estágios em ordem, como lint test build scan deploy-staging smoke deploy-prod. Cada linha seguinte é um commit: sha branch seguido dos resultados de estágio que não são aprovações, como test=fail.
Rode os estágios de cada commit em ordem, parando na primeira falha. O primeiro estágio cujo nome começa com deploy, e todos os estágios depois dele, só rodam na main; nos outros branches, o pipeline termina logo antes dele. Imprima a1b2c3 (main): lint:ok test:ok build:ok scan:ok deploy-staging:ok smoke:ok deploy-prod:ok -> released, com stage:FAIL -> failed at test para uma falha (acrescentando , roll back quando um estágio de deploy falhou), ou -> ready to merge para os outros branches.
Termine com released 2 of 5 commits; main is green - a main está verde se o último commit na main foi lançado (ou se não houve nenhum).
- Uma manhã movimentada
- Deploys ruins
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Construa o portão de release
Cada linha da entrada é key value, com as chaves date (YYYY-MM-DD), weekday (Mon a Sun), time (HH:MM), pipeline (green/red), blocking_vulnerabilities, open_sev1_sev2, error_budget_left (uma porcentagem), freeze (datas START..END, ou none) e hotfix (yes/no). Rode estas checagens em ordem, imprimindo cada uma como o nível dela completado até 5 caracteres, um espaço e a mensagem - ok pipeline is green, WARN ... ou BLOCK ...:
pipeline is green/ BLOCKpipeline is redno blocking vulnerabilities/ BLOCK3 blocking vulnerabilitiesno open SEV1/SEV2 incidents/ BLOCK1 open SEV1/SEV2 incident(s): finish the incident first- error budget:
error budget 40% left(ok a partir de 25%); WARNerror budget 12% left: ship small changes behind a canary; com 0 ou menos, BLOCKerror budget exhausted: reliability fixes only- a menos que seja um hotfix, o que o torna um WARN. - janela de deploy: ok
inside the deploy windowde Mon a Fri, das 09:00 até (sem incluir) as 16:00; caso contrário, WARNoutside the deploy window: make sure someone is around to watch. - congelamento: ok
no change freeze; dentro das datas de congelamento (inclusive), BLOCKchange freeze until 2027-01-02, ou WARNchange freeze until 2027-01-02 (hotfix allowed)para um hotfix.
Termine com decision: GO, decision: GO WITH CAUTION (2 warnings) ou decision: NO GO (1 blocker) (no singular ou no plural, conforme o caso).
- Terça de manhã
- Sexta à tarde
- Congelamento de fim de ano
- Hotfix no congelamento
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Construa o painel de entrega
Cada linha da entrada é um deploy: week team lead_time_hours ok|failed. Para cada equipe (em ordem alfabética), imprima o nome da equipe e depois cada uma das semanas dela, em ordem, como week 1: 3 deploys, median lead 6.0 h, 33% failed.
A partir da segunda semana, compare com a semana anterior da equipe: acrescente (up), (down) ou (same) depois do número de deploys, (faster), (slower) ou (same) depois do lead time, e (better), (worse) ou (same) depois da taxa de falhas - como week 2: 5 deploys (up), median lead 4.0 h (faster), 20% failed (better). Compare os números arredondados, do jeito que são impressos.
- Seis semanas depois
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…