Carregando
0x40Lição 5 de 16

Artefatos, versões e cache

Construa uma vez e promova o mesmo artefato para todos os ambientes, versione-o de forma rastreável, mantenha os builds reprodutíveis e acelere-os com cache.

26 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Explicar o “construa uma vez, implante muitas” e por que os artefatos são promovidos, e não reconstruídos
  • Versionar os artefatos para que todo build em execução leve de volta a um commit
  • Tornar os builds reprodutíveis com lockfiles, e rápidos com chaves de cache

Na Noite do Release, a equipe de operações reconstruía a aplicação a partir do código-fonte no servidor de produção. Duas vezes, ela baixou uma versão de biblioteca mais nova que a testada, e os drones começaram a entregar no hemisfério errado.

Construa uma vez, implante muitas. O pipeline constrói um artefato - um wheel, um JAR, uma imagem de contêiner - exatamente uma vez, guarda-o num repositório de artefatos (um registry de pacotes ou de contêineres, como Artifactory, Nexus, GitHub Packages ou um registry na nuvem) e então promove exatamente o mesmo artefato por dev, staging e produção. O que você testou é, byte a byte, o que você entrega. Só a configuração muda entre os ambientes.

Versões que você consegue rastrear

Todo artefato precisa de uma versão única e imutável que leve de volta à sua origem:

  • Versionamento semântico (MAJOR.MINOR.PATCH) para coisas de que outros dependem: bibliotecas e APIs.
  • Acrescente o SHA do commit como metadado de build - 1.4.0+3f2a9c1 - ou use o SHA como tag da imagem, para que “o que está rodando?” tenha uma resposta exata.
  • Nunca sobrescreva uma versão publicada. Se a 1.4.0 estava errada, publique a 1.4.1.

Builds reprodutíveis

Um build é reprodutível se o mesmo código-fonte sempre gera o mesmo resultado. Fixe as versões das dependências com um lockfile (poetry.lock, package-lock.json, requirements.txt com versões exatas e hashes), fixe as versões das ferramentas e das imagens base, e evite baixar qualquer coisa “latest” durante o build.

Cache

Instalar as dependências do zero a cada execução é lento. Um cache de CI guarda um diretório (como o cache de downloads do pip) sob uma chave e o restaura nas execuções seguintes. A chave deve mudar exatamente quando o conteúdo em cache mudaria: calcule o hash do lockfile.

  • Acerto exato: mesmo lockfile, tudo restaurado - a instalação leva segundos.
  • Acerto parcial: o lockfile mudou; restaure o cache mais recente com o mesmo prefixo (uma restore key) para que a maioria dos pacotes já esteja lá, e depois salve um cache novo.
  • Erro: comece do zero.
cache_key.py
1import hashlib
2
3def cache_key(os_name, lockfile_text):
4    digest = hashlib.sha256(lockfile_text.encode()).hexdigest()[:12]
5    return f"deps-{os_name}-{digest}"
6
7print(cache_key("linux", "flask==3.0.3\nrequests==2.32.3\n"))
8print(cache_key("linux", "flask==3.0.3\nrequests==2.32.3\n"))
9print(cache_key("linux", "flask==3.1.0\nrequests==2.32.3\n"))
Saída
deps-linux-bec5158eea64
deps-linux-bec5158eea64
deps-linux-0b76931b637a

Experimente

Até 15 XP

Cache ou artefato?

Caches são acelerações descartáveis; artefatos são as saídas que você guarda, testa e entrega. Classifique cada item.

0 de 6 classificadosPontuação 0/0
  • “O diretório de downloads do pip”

  • “A imagem de contêiner enviada ao registry e implantada em produção”

  • “O node_modules da última execução”

  • “O relatório de testes JUnit da execução”

  • “O wheel construído `byte_bakery-1.4.0-py3-none-any.whl`”

  • “O cache de camadas do Docker do build anterior”

Principais conclusões

  • Construa um artefato uma vez, guarde-o num repositório e promova o mesmo artefato por todos os ambientes.

  • Dê a todo artefato uma versão imutável que leve a um commit, como 1.4.0+3f2a9c1.

  • Fixe as dependências com lockfiles para ter builds reprodutíveis.

  • Use como chave do cache um hash do lockfile, com um prefixo como alternativa para acertos parciais.

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

Simule um cache de CI

+25 XP

A primeira linha da entrada é o prefixo da chave de cache, como deps-linux-. Cada linha seguinte é uma execução de CI: run_id lockfile_hash. A chave de uma execução é o prefixo mais o hash do lockfile dela.

Para cada execução: se existir um cache com exatamente essa chave, imprima run 1: hit. Senão, se existir algum cache, restaure o salvo mais recentemente (run 2: partial (restored deps-linux-ab12)); caso contrário, run 1: miss. Depois de um acerto parcial ou de um erro, a execução salva um cache com a própria chave. Termine com exact hit rate: 40%.

  • Uma semana de execuções
  • Lockfile mudando sem parar
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

Promova artefatos com segurança

+25 XP

Os ambientes são dev, staging e prod, nessa ordem. Cada linha da entrada é um evento:

  • build VERSION - constrói o artefato e o implanta em dev: imprima build 1.4.0: deployed to dev.
  • test VERSION ENV pass|fail - registra um resultado de teste, só se VERSION estiver implantada em ENV naquele momento: imprima test 1.4.0 dev: pass, ou test 1.4.0 staging: ignored (not deployed there).
  • promote VERSION ENV - implanta VERSION em ENV se ela foi construída e o resultado de teste mais recente dela no ambiente anterior é um pass. Imprima promote 1.4.0 staging: ok, ou rejected (unknown artifact), rejected (not tested in dev) ou rejected (tests failed in dev).

Termine com dev: 1.5.0, staging: 1.4.0, prod: none.

  • Dois releases
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…