Carregando
0x30Lição 4 de 16

Pipelines de integração contínua

Construa e teste cada mudança automaticamente com um pipeline rápido: estágios, ordem que falha rápido, a pirâmide de testes e como lidar com testes instáveis.

28 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Projetar um pipeline de CI que constrói e testa cada mudança
  • Ordenar e paralelizar os jobs para que o pipeline falhe rápido e termine rápido
  • Equilibrar a pirâmide de testes e lidar com testes instáveis

A Byte Bakery agora faz merge na main todo dia. Sem automação, isso é assustador: quem confere se cada merge ainda compila e passa nos testes? Um pipeline de CI confere - a cada push e a cada pull request:

  1. baixa o código numa máquina limpa;
  2. instala as dependências;
  3. roda as checagens rápidas: formatação, lint, checagem de tipos;
  4. roda os testes unitários e depois os testes de integração, mais lentos;
  5. constrói o artefato pronto para deploy (um pacote ou uma imagem de contêiner) e o guarda.

O pipeline é definido como código, no repositório, então é versionado e revisado como todo o resto. Entre as ferramentas estão GitHub Actions, GitLab CI, Jenkins, CircleCI, Buildkite e Azure Pipelines - as ideias valem para todas.

.gitlab-ci.yml
1stages: [check, test, build]
2
3lint:
4  stage: check
5  image: python:3.12-slim
6  script:
7    - pip install ruff
8    - ruff check .
9
10unit-tests:
11  stage: test
12  image: python:3.12-slim
13  script:
14    - pip install -r requirements.txt
15    - pytest tests/unit --junitxml=report.xml
16  artifacts:
17    reports:
18      junit: report.xml
19
20build-image:
21  stage: build
22  image: docker:27
23  services: [docker:27-dind]
24  script:
25    - docker build -t registry.example.com/byte-bakery/shop:$CI_COMMIT_SHORT_SHA .
26    - docker push registry.example.com/byte-bakery/shop:$CI_COMMIT_SHORT_SHA
27  rules:
28    - if: $CI_COMMIT_BRANCH == "main"

Feedback rápido

Um pipeline só é útil se as pessoas esperarem por ele. Mire em menos de 10 minutos:

  • Falhe rápido: rode primeiro as checagens mais baratas que pegam mais problemas. Uma falha de lint de 20 segundos não deveria esperar uma suíte de testes de 15 minutos.
  • Paralelize os jobs independentes e divida as suítes de testes grandes entre várias máquinas.
  • Faça cache das dependências (próxima lição) e só reconstrua o que mudou.
  • Pare a linha: quando a main fica vermelha, consertá-la (ou reverter) é a prioridade número um de todo mundo. Um pipeline sempre vermelho ensina as pessoas a ignorá-lo.

Experimente

Até 15 XP

Rode o pipeline da Byte Bakery

Aqui está o pipeline como um grafo de jobs numa linha do tempo.

  • Qual cadeia de jobs define o tempo total? Esse é o caminho crítico (critical path) - acelerar qualquer outra coisa não ajuda.
  • Faça unit-tests falhar. Quais jobs são pulados? O que ainda roda?
  • Faça deploy-staging falhar. Quando o rollback roda?
Workflow concluído com sucesso em 12 min
  1. ✓ sucesso0-1 min
  2. ✓ sucesso0-2 min
  3. ✓ sucesso2-6 min
  4. ✓ sucesso2-8 min
  5. ✓ sucesso6-9 min
  6. ✓ sucesso9-11 min
  7. ⊘ ignorado
  8. ✓ sucesso11-12 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.

A pirâmide de testes

Nem todos os testes são iguais. A pirâmide de testes sugere muitos testes unitários rápidos na base, menos testes de integração (com um banco de dados ou serviço de verdade) no meio e um punhado de testes ponta a ponta lentos (um navegador clicando pelo checkout) no topo. Uma pirâmide invertida - com a maioria dos testes ponta a ponta - dá um pipeline lento e instável.

Um teste instável (flaky) passa e falha com o mesmo código - por causa de tempo, ordem dos testes, estado compartilhado ou rede. Testes instáveis são veneno: as pessoas aprendem a clicar em “tentar de novo” e param de confiar nos builds vermelhos. Detecte-os (mesmo commit, resultados diferentes), coloque-os em quarentena para não bloquearem os merges e corrija-os ou apague-os rápido.

Principais conclusões

  • Um pipeline de CI constrói e testa cada mudança numa máquina limpa, definido como código no repositório.

  • Mantenha-o rápido: falhe rápido, paralelize, use cache - e o caminho crítico define o tempo total.

  • Muitos testes unitários, menos testes de integração, poucos testes ponta a ponta.

  • Pare a linha quando a main quebrar, e coloque em quarentena e corrija os testes instáveis.

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.

Exercício 1

Encontre o caminho crítico

+25 XP

Cada linha da entrada é um job: name minutes needs... (os jobs pelos quais ele espera, talvez nenhum). Os jobs começam assim que todas as suas dependências terminam; os jobs independentes rodam em paralelo.

Imprima cada job na ordem da entrada como unit-tests: 2-6 (minuto de início e de fim), depois total: 11 min e o caminho crítico, critical path: install -> unit-tests -> build-image -> deploy-staging: comece pelo job que termina por último e vá passando repetidamente para a dependência que terminou por último (a primeira listada, em caso de empate).

  • Pipeline da Byte Bakery
  • Fora de ordem
main.py
Carregando editor…

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.

Exercício 2

Cace os testes instáveis

+25 XP

Cada linha da entrada é um resultado de teste do CI: commit test pass|fail, do mais antigo para o mais novo. Classifique cada teste (em ordem alfabética):

  • flaky (mixed results on 2 commits) -> quarantine se ele passou e falhou em pelo menos um commit (conte esses commits);
  • senão, failing -> fix now se todas as execuções no commit mais novo (o commit da última linha) falharam;
  • senão, stable.

Termine com quarantine: test_a, test_b (ou quarantine: none).

  • Uma semana de CI
  • Tudo verde
main.py
Carregando editor…

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…