Carregando
0x80Lição 9 de 14

Pipelines de integração contínua

Teste cada mudança automaticamente com grafos de jobs, matrizes, cache e artefatos, e exija verificações verdes antes do merge.

32 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Construir um pipeline de CI: jobs de lint, teste e build conectados com needs
  • Testar em várias versões e plataformas com uma matriz, e acelerar as coisas com cache
  • Passar arquivos entre jobs com artefatos e proteger a main com verificações de status obrigatórias

Integração contínua (CI) significa que cada mudança é compilada e testada automaticamente assim que recebe push, então os problemas aparecem em minutos, e não na hora da release. Um pipeline típico tem vários jobs:

  • Os jobs rodam em paralelo por padrão, em runners separados.
  • needs: [lint, test] faz um job esperar outros - e ser pulado se algum deles falhar.
  • Condições if: mudam isso: if: always() roda de qualquer jeito, if: failure() roda só quando algo antes falhou (ótimo para notificações e rollbacks).
.github/workflows/ci.yml
1name: CI
2on: [push, pull_request]
3
4jobs:
5  lint:
6    runs-on: ubuntu-latest
7    steps:
8      - uses: actions/checkout@v4
9      - run: pipx run ruff check .
10
11  test:
12    runs-on: ${{ matrix.os }}
13    strategy:
14      matrix:
15        os: [ubuntu-latest, windows-latest]
16        python: ["3.11", "3.12"]
17    steps:
18      - uses: actions/checkout@v4
19      - uses: actions/setup-python@v5
20        with:
21          python-version: ${{ matrix.python }}
22          cache: pip                      # reuse downloaded packages between runs
23      - run: pip install -r requirements.txt
24      - run: pytest
25
26  build:
27    needs: [lint, test]
28    runs-on: ubuntu-latest
29    steps:
30      - uses: actions/checkout@v4
31      - run: python -m build
32      - uses: actions/upload-artifact@v4  # keep the built game for later jobs and downloads
33        with:
34          name: dungeon-dash-dist
35          path: dist/
36
37  notify:
38    needs: build
39    if: always()
40    runs-on: ubuntu-latest
41    steps:
42      - run: echo "Build finished with status ${{ needs.build.result }}"

Experimente

Até 15 XP

Rode o pipeline

Este é o pipeline completo do Dungeon Dash numa linha do tempo. Repare em quais jobs rodam lado a lado e quanto tempo a execução inteira leva.

  • Faça o test falhar. Quais jobs são pulados? Quais ainda rodam, e por quê?
  • Agora faça o deploy falhar. Quando o rollback roda?
  • Que job, se ficasse mais rápido, encurtaria a execução inteira? (A cadeia mais longa de needs é o caminho crítico.)
Workflow concluído com sucesso em 12 min
  1. ✓ sucesso0-1 min
  2. ✓ sucesso0-6 min
  3. ✓ sucesso0-3 min
  4. ✓ sucesso6-9 min
  5. ✓ sucesso9-11 min
  6. ⊘ ignorado
  7. ✓ 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.

Matrizes, cache e artefatos

  • Uma matriz roda o mesmo job para cada combinação de valores. O job test acima roda 2 sistemas operacionais × 2 versões de Python = 4 jobs em paralelo. exclude remove combinações; include acrescenta outras. Cada cópia lê os seus valores de ${{ matrix.os }} e ${{ matrix.python }}.
  • O cache (actions/cache, ou cache: pip nas actions de setup) guarda as dependências entre execuções, então a instalação de 2 minutos vira 10 segundos.
  • Os artefatos (upload-artifact / download-artifact) passam arquivos entre jobs - cada job começa numa máquina nova - e deixam as saídas do build disponíveis para download na página da execução.
matrix.py
1from itertools import product
2
3matrix = {"os": ["ubuntu", "windows", "macos"], "python": ["3.11", "3.12"]}
4exclude = [{"os": "macos", "python": "3.11"}]
5
6jobs = [dict(zip(matrix, values)) for values in product(*matrix.values())]
7jobs = [job for job in jobs if not any(all(job[key] == value for key, value in rule.items()) for rule in exclude)]
8print(len(jobs), "jobs")
9for job in jobs:
10    print(f"test ({job['os']}, {job['python']})")
Saída
5 jobs
test (ubuntu, 3.11)
test (ubuntu, 3.12)
test (windows, 3.11)
test (windows, 3.12)
test (macos, 3.12)

Verificações obrigatórias

A CI só protege a main se as verificações que falham realmente bloquearem o merge. Em Settings → Branches (ou Rules → Rulesets), proteja a main e exija:

  • que as verificações de status passem - escolha os jobs de CI que precisam estar verdes,
  • revisões de pull request antes do merge (e, opcionalmente, a aprovação de um code owner),
  • que as branches estejam atualizadas com a main, para os testes terem rodado no código mais recente,
  • e bloqueie force pushes e exclusões.

Agora nada chega à main sem passar nos testes e numa revisão - a rede de segurança que faltava ao Dungeon Dash.

Principais conclusões

  • A CI compila e testa cada mudança; os jobs rodam em paralelo, a menos que estejam conectados com needs.

  • Um job é pulado quando um job de que ele precisa falha - a menos que o if: dele diga always() ou failure().

  • As matrizes multiplicam os jobs entre versões e plataformas; cache e artefatos poupam tempo e passam arquivos.

  • Proteja a main com verificações de status e revisões obrigatórias, senão a CI é só uma sugestão.

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 do GitHub com Python

O trabalho real no GitHub envolve muita automação pequena: conferir CODEOWNERS, expandir matrizes de build, atualizar versões, ler a API. Escreva esses utilitários em Python e execute-os com entradas de exemplo, localmente no navegador e sem precisar de conta no GitHub.

Exercício 1

Expanda uma matriz de build

+25 XP

A entrada é um objeto JSON {"matrix": {...}, "exclude": [...], "include": [...]}. Expanda a matriz em todas as combinações (chaves na ordem dada, com a primeira chave variando mais devagar), descarte toda combinação que case com uma entrada de exclude (todas as chaves da entrada iguais) e depois acrescente cada entrada de include como uma combinação extra. Imprima N jobs e depois cada job como os=ubuntu, python=3.12.

(O GitHub de verdade também pode mesclar um include em combinações existentes; este exercício mantém a regra mais simples.)

  • Exclude e include
  • Três dimensões
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

Encontre o caminho crítico

+25 XP

Cada linha de entrada é um job: name minutes seguido dos jobs de que ele precisa, como build 3 lint test. Os jobs começam assim que tudo de que precisam terminou. Imprima o início e o fim de cada job (build: 6-9) na ordem da entrada, depois o tempo total e o caminho crítico - a cadeia de jobs que o determina, do primeiro ao último, unida por ->. Quando dois jobs necessários terminarem ao mesmo tempo, siga o que foi listado primeiro.

  • Pipeline do Dungeon Dash
  • Um empate
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…