CS Fundamentals Trainer · Guias

Internos do Git e pipelines de CI/CD

O Git como um armazenamento de objetos endereçado por conteúdo (hashes, packfiles, bisect, rebase), estratégias de branching, integração e entrega contínuas, e como as implantações canary, blue/green e graduais limitam o dano de uma versão ruim.

40 min de leitura

O Git parece um conjunto de comandos a decorar, e fica muito mais fácil depois que você sabe que ele é um pequeno banco de dados endereçado por conteúdo com um punhado de tipos de objeto, e que os branches são apenas nomes para objetos. O CI/CD (integração contínua e entrega contínua) é então a disciplina de pôr toda mudança pelo mesmo caminho automatizado, de um commit até rodar em produção, em passos pequenos que podem ser desfeitos. Este guia abre o repositório com os comandos reais e mede o que ele armazena, e depois cobre pipelines, estratégias de branching e as estratégias de implantação que limitam o dano de uma versão ruim. Tudo na metade do Git foi executado em um repositório real; o script está no apêndice.

Ele se encaixa com contêineres e Kubernetes (o que o pipeline implanta), observabilidade (como você sabe que uma versão está saudável) e segurança (segredos no histórico, cadeia de suprimentos).

1. O Git é um armazenamento de objetos endereçado por conteúdo

O Git guarda quatro tipos de objetos, cada um nomeado pelo hash do seu conteúdo (SHA-1 por padrão; SHA-256 em repositórios criados com --object-format=sha256, veja abaixo) (com um cabeçalho curto):

ObjetoGuardaAnalogia
blobos bytes de um arquivo (sem nome, sem permissões)conteúdo de arquivo
treeuma lista de nomes, modos e os ids de blobs e de outras treesum diretório
commito id de uma tree, os ids de seus commits pais, autor, committer, hora e mensagemum snapshot com histórico
tagum ponteiro nomeado, opcionalmente assinado, para um objetouma etiqueta

Verifiquei a regra de nomeação à mão. Para um arquivo contendo hello e uma quebra de linha, o git hash-object imprimiu ce013625030ba8dba906f756967f9e9ca394464a, e fazer o hash da string blob 6, um byte zero e hello com o simples sha1sum imprimiu o mesmo id. O nome do objeto é o seu conteúdo, o que tem três consequências:

Diagram: A commit points to a tree, and the tree to blobs; the branch is only a name

As duas trees apontam para um blob, porque o arquivo não mudou.

Branches, HEAD e o índice

Um branch é um arquivo em .git/refs/heads/ contendo um id de commit: no experimento, tinha exatamente 41 bytes, 40 caracteres hexadecimais e uma quebra de linha. Criar um branch grava 41 bytes, e é por isso que ramificar é barato no Git; e fazer um commit move o ponteiro do branch atual para o novo commit. O HEAD diz em qual branch (ou commit) você está. O índice (staging area) é a próxima tree proposta: git add grava blobs e atualiza o índice, e git commit transforma o índice em uma tree e um commit.

Os commits são snapshots, não diffs. As diferenças são calculadas quando necessário (e um commit mostrado por git show é uma diferença entre dois snapshots).

Packfiles: snapshots armazenados como deltas

Se cada versão fosse uma cópia completa, o histórico seria enorme. Os objetos novos são armazenados primeiro "soltos" (loose), um arquivo comprimido cada; o git gc (ou um push) os agrupa em um packfile, em que objetos parecidos são armazenados como deltas uns contra os outros. Criei um arquivo de 5 000 linhas (108 KB) e fiz commit de 200 pequenas edições nele:

ArmazenamentoTamanho
201 cópias completas, sem compressãocerca de 21 873 KB
depois de git gc --aggressive: um pack com 608 objetoscerca de 102 KB

Uma redução de mais de 200 vezes, porque cada edição mudou uma linha. É por isso que um repositório com longo histórico é menor do que se espera, e por que os arquivos binários grandes são a exceção: um vídeo ou uma imagem recodificados mudam quase todos os bytes, então os deltas não ajudam, e cada versão é mantida para sempre. Use o Git LFS ou um armazenamento de artefatos para eles.

O mesmo fato está por trás do maior erro com o Git: um arquivo que sofreu commit uma vez fica no histórico para sempre. Apagá-lo em um commit posterior o remove da tree, não dos commits antigos. Uma chave vazada precisa ser revogada primeiro (está comprometida no instante em que é enviada); reescrever o histórico para removê-la (git filter-repo) é limpeza, não correção. Veja o guia de segurança.

SHA-1 e SHA-256

O Git foi projetado com o SHA-1 para identidade, não para segurança. Depois que colisões práticas de SHA-1 foram demonstradas em 2017, o Git acrescentou detecção de colisões e suporta repositórios SHA-256 como transição. O ponto importante para o design é que o endereçamento por conteúdo, como nos logs de eventos e nos digests de imagens de contêiner, dá integridade e deduplicação ao mesmo tempo.

Repositórios SHA-256 na prática

Tudo o que está acima diz "SHA-1", mas um repositório Git pode usar SHA-256: git init --object-format=sha256 (Git 2.29 e posteriores; o projeto Git deixou de chamá-lo de experimental a partir da 2.42). O modelo de objetos é idêntico; só muda a função de hash e, portanto, todos os ids. Criei o mesmo repositório de um arquivo e um commit nos dois formatos (Git 2.43, com datas fixas para que a única diferença fosse o formato):

Repositório SHA-1Repositório SHA-256
id do blob helloce013625030ba8dba906f756967f9e9ca394464a (40 caracteres hexadecimais)2cf8d83d9ee29543b34a87727421fdecb7e3f3a183d337639025de576db9ebb4 (64)
id do primeiro commitbc31b899…58f1538c… (um id diferente para o mesmo conteúdo)
git log --onelinebc31b89 first58f1538 first (as abreviações continuam curtas)
configuração do repositóriocore.repositoryformatversion = 0, sem extensãocore.repositoryformatversion = 1, extensions.objectformat = sha256
regra de nomeação à mãosha1("blob 6" + NUL + "hello\n")sha256("blob 6" + NUL + "hello\n"), que calculei com sha256sum e obtive o id acima

O que decorre disso:

2. Merge, rebase e reescrita do histórico

Dois branches que divergiram podem ser combinados de duas maneiras:

Diagram: Merge keeps both lines of history; rebase replays one line on top of the other

A regra que decorre da imutabilidade: nunca reescreva commits sobre os quais outras pessoas já basearam trabalho (rebase ou amend de algo enviado a um branch compartilhado). As cópias delas ainda têm os ids antigos, e os dois históricos agora divergem, e é assim que uma equipe acaba com commits duplicados e merges dolorosos. Reescreva à vontade o seu próprio trabalho não publicado; quando precisar atualizar um branch que compartilha, avise e use --force-with-lease em vez de --force, para não sobrescrever o push de um colega.

Um squash merge transforma um branch em um único commit na linha principal. Dá um histórico limpo e uma ligação um-para-um entre pull request e commit, ao custo de perder os passos individuais (o que importa para o bisect dentro de uma mudança grande). Escolha uma política por repositório e faça-a valer.

Recuperando: o reflog

Os ponteiros de branch se movem, e os commits antigos permanecem no armazenamento de objetos até a coleta de lixo (por padrão, objetos inalcançáveis são mantidos por semanas). O reflog registra para onde o HEAD e cada branch apontaram ao longo do tempo, então, depois de um reset ou rebase ruim, o git reflog mostra o id antigo e git reset --hard <id> ou git branch rescue <id> o traz de volta. A maior parte do trabalho "perdido" não está perdida; o trabalho que nunca sofreu commit está.

3. Achando o commit que quebrou algo: bisect

O git bisect é uma busca binária no histórico (veja complexidade). Você marca um commit bom e um ruim; o Git faz checkout do meio, você (ou um script) diz bom ou ruim, e ele divide o intervalo ao meio. Fiz 100 commits em que um teste começa a falhar em c77 e executei git bisect run com um script que sai com 0 para bom e diferente de zero para ruim:

Commits no intervaloExecuções de teste necessáriasResultado
1007c77 apontado como o primeiro commit ruim

log2(100) é cerca de 6,6, então sete execuções; para 10 000 commits são 14 execuções. Funciona melhor com commits pequenos e compiláveis (para que todo commit possa ser testado) e um teste rápido e determinístico, o que é mais um argumento a favor das práticas de trunk-based abaixo.

4. Estratégias de branching

EstratégiaComo funcionaEncaixa em
Trunk-based developmenttodos integram em um branch principal pelo menos uma vez por dia; os branches vivem por horas, o trabalho incompleto fica escondido atrás de feature flagsequipes que implantam continuamente; a prática que a pesquisa DORA associa a alto desempenho
GitHub flowbranches de feature de vida curta, um pull request com revisão e CI, merge na main, deploy a partir da maina maioria das equipes web
Gitflowbranches develop e de release de vida longa, mais branches de feature e de hotfixsoftware entregue em versões que precisam ser mantidas em paralelo (produtos instalados, bibliotecas)
Branches de releaseramificar na release, fazer backport das correçõeso mesmo, de forma mais leve

O motivo de os branches curtos vencerem é o custo do merge: o custo de combinar duas linhas de trabalho cresce mais rápido que o seu tamanho, já que os conflitos crescem com o número de mudanças e com o quanto cada lado esqueceu o contexto do outro. Branches de vida longa adiam esse custo e o aumentam. As feature flags deixam você fazer merge de código inacabado com segurança e depois ligar uma funcionalidade para 1% dos usuários, o que separa implantar código de lançar uma funcionalidade.

5. Integração e entrega contínuas

Diagram: A typical pipeline: fast checks first, one artifact promoted through environments

Princípios que tornam um pipeline confiável:

Um pipeline concreto: proveniência, dependências fixadas, varredura de segredos, migrações e rollback

Os princípios acima viram verificações. Aqui está um pipeline, com a falha que cada etapa previne e uma demonstração executável das partes que podem ser mostradas sem um servidor de CI (os scripts estão no apêndice). A definição do pipeline no final é um esboço de como as peças se encaixam; os produtos de CI e os scanners que ela cita não são demonstrados aqui.

Diagram: A pipeline with supply-chain and rollback controls

1. Fixação de dependências. Uma faixa de versões significa que o mesmo commit compila código diferente em dias diferentes. Na demonstração, lib>=2.0 instala a 2.31.0 em janeiro e a 3.0.0 em junho. Um arquivo de lock com hashes (pip install --require-hashes, package-lock.json, go.sum) fixa tanto a versão quanto os bytes: um download cujo sha-256 difere do lock é recusado (REFUSED lib==2.31.0: hash 42c962426d1f… does not match the lock file's fec2012abbd8…). Faça commit do arquivo de lock, atualize-o deliberadamente (um bot abre o pull request, o pipeline o testa) e execute uma auditoria do conjunto fixado a cada build (pip-audit, npm audit, OSV-Scanner; os exemplos de varredura estão no guia de segurança). Fixe as actions de CI de terceiros em um id de commit completo, não em uma tag móvel.

2. Compile uma vez, de forma reproduzível, e registre de onde veio. Compilar a mesma fonte duas vezes com as configurações padrão gerou dois arquivos diferentes (75978fa7e9035769… e c9b605c62ba3ef43…), por causa de timestamps embutidos e da ordem dos arquivos. Normalizando-os (nomes ordenados, data de modificação e dono fixos), obtive o mesmo ea511b3da0f25700… nas duas vezes. Um build reproduzível permite que qualquer pessoa confira um artefato recompilando-o e torna o digest uma identidade estável. Depois, o job de build assina uma declaração de proveniência: o digest do artefato, o repositório e o commit, a branch, o construtor e as entradas. A etapa de deploy a verifica antes de executar qualquer coisa. Na demonstração (assinaturas Ed25519; uma chave confiável mantida pela etapa de deploy):

CasoVeredito da etapa de deploy
build genuíno a partir da mainACEITA: construído por ci-runner-1 a partir de 9f1c2ab0 na main
artefato trocado depois do buildREJEITA: o artefato não é o que foi construído
declaração editada para afirmar outro commitREJEITA: a assinatura não verifica
assinado com uma chave em que a etapa de deploy não confiaREJEITA: a assinatura não verifica
build genuíno, mas de uma feature branchREJEITA: não é uma branch protegida

Em pipelines reais você não escreve isso por conta própria: use as atestações de artefatos da plataforma ou o Sigstore/cosign, no formato de proveniência do SLSA, e verifique com as mesmas ferramentas na etapa de deploy ou em uma política de admissão do Kubernetes. O ponto é a política: só artefatos construídos pelo nosso pipeline a partir de uma branch protegida rodam em produção. Marque as imagens de contêiner pelo digest (image@sha256:…), não por uma tag mutável.

3. Varredura de segredos, antes e depois do fato. Montei um repositório em que um arquivo .env com uma chave de exemplo da AWS foi commitado e apagado no commit seguinte. Uma varredura dos arquivos que estão agora na árvore de trabalho encontrou 0 problemas. Uma varredura das linhas adicionadas em cada commit encontrou o id da chave de acesso e a chave secreta no commit "add config". git log --all -S AKIAIOSFODNN7EXAMPLE lista os dois commits, e o git show do antigo imprime o arquivo: apagar um segredo não o remove. Uma verificação pre-commit sobre as mudanças em stage bloqueou um commit que acrescentava TOKEN=ghp_…. Portanto: varra as mudanças em stage localmente (hook de pre-commit), varra o pull request e o histórico completo no CI (gitleaks, TruffleHog) e ative a proteção de push da plataforma de hospedagem onde ela existir. Quando algo vaza, a ordem é: revogue e rotacione primeiro, depois limpe o histórico se precisar, depois descubra se foi usado. Ajuste o scanner (limiares de entropia, listas de permissão para fixtures de teste, uma validade em cada supressão): na demonstração ele não sinalizou um id de commit do Git, um UUID nem uma senha de exemplo em um arquivo de anotações, e é isso que impede que as pessoas o ignorem.

4. Migrações de banco de dados e rollback. Durante um deploy gradual, as versões antiga e nova da aplicação rodam contra o mesmo banco, e um rollback executa a versão antiga de novo. Uma mudança de schema precisa, portanto, funcionar para as duas. Testei a renomeação de uma coluna (name para full_name) com SQLite e duas versões da aplicação:

Schema depois do passoApp antigo (v1)App novo (v2, tolera as duas colunas)
início (name)okFALHA (a coluna nova ainda não existe)
ingênuo: renomear em um único passoFALHAok
expandir: adicionar full_nameokok
preencher (backfill): copiar name para full_nameokok
contrair: remover nameFALHAok
contrair sem preencherFALHAFALHA (as linhas antigas não têm valor)

A renomeação ingênua quebra todo pod que ainda roda a v1 e quebra o rollback. A sequência segura é expandir (aditiva, roda antes do deploy), fazer o deploy da v2 (lê qualquer uma das colunas, escreve nas duas), preencher (em lotes pequenos) e, só depois que a v1 tiver sumido e a janela de rollback tiver fechado, um release posterior que contrai. Regras que acompanham:

Um esboço do pipeline como configuração (sintaxe do GitHub Actions; não executado aqui):

name: release
on: { push: { branches: [main] } }
permissions: { contents: read, id-token: write, attestations: write }       # least privilege; the signing identity comes from the platform
jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@<full-commit-sha>                            # pinned to a commit, not a tag
      - run: gitleaks detect --redact                                        # secrets in the history
      - run: pip install --require-hashes -r requirements.lock && pip-audit -r requirements.lock
      - run: python -m unittest discover                                     # unit and security regression tests
  build:
    needs: verify
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@<full-commit-sha>
      - run: docker build -t app:${{ github.sha }} . && docker push registry/app:${{ github.sha }}
      - uses: actions/attest-build-provenance@<full-commit-sha>              # signed provenance for the image digest
  deploy:
    needs: build
    environment: production                                                  # required reviewers, protected secrets
    steps:
      - run: ./migrate.sh expand                                             # additive schema changes only
      - run: cosign verify-attestation … && ./deploy.sh --digest "$DIGEST" --canary 10%
      - run: ./wait_for_health.sh --error-rate-below 1% || ./deploy.sh --rollback   # automatic rollback to the previous digest

6. Estratégias de implantação: limitando o raio da explosão

Toda release é um risco, e o que você controla é quantos usuários encontram um problema antes de você perceber.

EstratégiaComoRollbackCusto e pegadinha
Recreatepare a versão antiga, inicie a novareimplantarindisponibilidade
Rollingsubstitua as instâncias gradualmente (veja Kubernetes)avançar ou voltar, devagaras duas versões rodam juntas, então precisam ser compatíveis
Blue/greenexecute um segundo ambiente completo, teste-o, depois troque o roteadorvolte a troca (segundos)o dobro da capacidade durante a release; o banco de dados é compartilhado, então mudanças de schema ainda exigem cuidado
Canaryenvie uma pequena parte do tráfego real à nova versão, compare suas métricas, depois aumentedevolva a parte para 0exige boas métricas e um portão automatizado
Feature flag / dark launchentregue o código desligado, ative por grupo de usuáriosdesligue a flagdívida de flags: remova as antigas
Shadow (espelho)copie o tráfego de produção para a nova versão e descarte suas respostasdesnecessário (os usuários nunca a veem)dobra a carga; é preciso evitar efeitos colaterais

Uma release canary é uma implantação em estágios com um portão entre os estágios. Percorra uma com estágios de 5%, 25%, 50% e 100%, um limite de 1% de erros, e depois ative uma versão com um bug:

Interactive animation: canary release

No modelo, uma versão saudável passa pelos quatro estágios. A versão que falha em 8% das requisições é parada no primeiro estágio: afetou 4 de cada 1 000 requisições naquela janela (4 erros nas 50 requisições que recebeu) em vez de 80 de cada 1 000 se todos tivessem sido trocados de uma vez, uma redução de 20 vezes, que é exatamente a parcela que ela teve permissão para pegar (5%). Um canary só protege você se:

Seja qual for a estratégia, as versões antiga e nova rodam lado a lado por um tempo, então as mudanças de API e de banco de dados precisam ser retrocompatíveis por pelo menos uma versão (versionamento de REST, microsserviços).

7. Infraestrutura como código e GitOps

Ambientes construídos à mão se afastam uns dos outros e não podem ser reproduzidos. A infraestrutura como código descreve servidores, redes e clusters em arquivos que são revisados, versionados e aplicados por ferramentas. O GitOps aplica a mesma ideia à implantação: o repositório Git é o estado desejado do ambiente, e um agente no cluster compara continuamente a realidade com o repositório e corrige a diferença, o mesmo laço de reconciliação dos controladores do Kubernetes. Uma implantação é um commit, um rollback é um revert e o log de auditoria é o histórico do Git. Mantenha os segredos fora do repositório (use um gerenciador de segredos ou valores criptografados).

8. Erros comuns

9. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Um script de shell que precisa apenas de git e Python 3. Ele cria um repositório novo em um diretório novo, ignora a sua configuração global do Git e imprime cada resultado. Os ids de objeto e os timestamps diferem a cada execução (dependem da hora), mas a estrutura, o hash do blob hello (que é sempre ce013625030ba8dba906f756967f9e9ca394464a), os tamanhos e a contagem de passos do bisect são repetíveis. O tamanho do pack vem do git gc --aggressive em uma máquina e versão do Git, e será um pouco diferente em outras. Os números do canary são calculados pelo modelo da animação com valores esperados (sem aleatoriedade), não medidos em um serviço real.

git.sh: objetos, packs, bisect e rebase

#!/bin/bash
# Git internals experiments. Needs only git and python3.
set -eu
export GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null
export GIT_AUTHOR_NAME=a GIT_AUTHOR_EMAIL=a@x GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@x
rm -rf r && git init -q -b main r && cd r
echo "--- 1. a blob's name is the SHA-1 of 'blob <size>\\0<content>'"
printf 'hello\n' > a.txt
echo "git hash-object: $(git hash-object a.txt)"
echo "by hand (sha1):  $(printf 'blob 6\0hello\n' | sha1sum | cut -d' ' -f1)"
git add a.txt; git commit -qm one
echo "--- 2. the objects: commit -> tree -> blob"
git cat-file -p HEAD; git cat-file -p 'HEAD^{tree}'
echo "--- 3. the same content stored twice is one object"
cp a.txt b.txt; git add b.txt; git commit -qm two
git ls-files -s
echo "--- 4. a branch is a file holding one commit id (40 hex characters and a newline)"
cat .git/refs/heads/main; wc -c < .git/refs/heads/main
echo "--- 5. delta compression: a 5000-line file edited 200 times"
python3 - <<'PY'
import random
r=random.Random(1); open('big.txt','w').write(''.join(f"line {i} {r.random():.10f}\n" for i in range(5000)))
PY
git add big.txt; git commit -qm big
for i in $(seq 1 200); do sed -i "$((i*20))s/.*/edited $i/" big.txt; git commit -qam "edit $i"; done
size=$(wc -c < big.txt)
echo "file: $((size/1024)) KB; 201 full copies would be $((201*size/1024)) KB"
git gc -q --aggressive
git count-objects -vH | grep -E 'size-pack|in-pack'
echo "--- 6. bisect: 100 commits, the test starts failing at c77"
git checkout -q -b bisect-demo
for i in $(seq 1 100); do echo "$i" > counter.txt; [ "$i" -ge 77 ] && echo bug > broken.txt; git add -A; git commit -qm "c$i"; done
cat > test.sh <<'T'
#!/bin/sh
[ ! -f broken.txt ]
T
chmod +x test.sh; cp test.sh /tmp/gt.sh
first=$(git rev-list --max-parents=0 HEAD | tail -1)
git bisect start HEAD main >/dev/null
git bisect run /tmp/gt.sh | grep -E "is the first bad commit|running" | wc -l
git bisect log | grep -c '^git bisect \(good\|bad\)'
git bisect log | grep "first bad" || git show -s --format='first bad commit: %s' refs/bisect/bad
git bisect reset >/dev/null 2>&1
echo "--- 7. merge keeps commit ids; rebase rewrites them"
git checkout -q main; git checkout -q -b feature; echo f > f.txt; git add f.txt; git commit -qm feature
git checkout -q main; echo m > m.txt; git add m.txt; git commit -qm mainline
git checkout -q feature; echo "feature commit before rebase: $(git rev-parse --short HEAD)"
git rebase -q main; echo "feature commit after rebase:  $(git rev-parse --short HEAD)   (same change, new parent, new id)"

Repositórios SHA-1 e SHA-256 lado a lado

Um script de shell que precisa do git 2.29 ou mais novo, do bc e do Python 3. Ele cria repositórios descartáveis e os remove.

#!/bin/bash
# SHA-1 and SHA-256 repositories side by side: identifiers, size, speed, and what does not interoperate. Needs git 2.29 or newer.
set -e
W=$(mktemp -d); cd "$W"
export GIT_AUTHOR_DATE='2026-01-01T00:00:00Z' GIT_COMMITTER_DATE='2026-01-01T00:00:00Z' GIT_AUTHOR_NAME=t GIT_AUTHOR_EMAIL=t@t GIT_COMMITTER_NAME=t GIT_COMMITTER_EMAIL=t@t
for f in sha1 sha256; do
  git init -q --object-format=$f r_$f; cd r_$f
  printf 'hello\n' > a.txt; git add a.txt; git commit -q -m first
  echo "== $f: blob $(git hash-object a.txt)"
  echo "   commit $(git rev-parse HEAD) ($(git rev-parse HEAD | tr -d '\n' | wc -c) hex characters), git log --oneline shows: $(git log --oneline)"
  echo "   config: repositoryformatversion=$(git config core.repositoryformatversion) extensions.objectformat=$(git config extensions.objectformat || echo '(not set: SHA-1)')"
  cd ..
done
echo "== the naming rule by hand: sha256 of 'blob 6<NUL>hello<LF>' = $(printf 'blob 6\0hello\n' | sha256sum | cut -d' ' -f1)"
echo "== the same content gets a different commit id: the format is part of the identity, so ids from one repository mean nothing in the other"
echo "== fetch across formats:"; (cd r_sha256 && git fetch ../r_sha1 2>&1 | head -1) || true
# a history of 300 commits touching 20 files each, in both formats
for f in sha1 sha256; do
  git init -q --object-format=$f big_$f; cd big_$f
  python3 - <<'P'
import random, subprocess, os
r = random.Random(1)
for c in range(300):
    for k in range(20):
        open(f"f{(c*7+k) % 400}.txt", "w").write("".join(r.choice("abcdefgh \n") for _ in range(4000)))
    subprocess.run(["git", "add", "-A"], check=True); subprocess.run(["git", "commit", "-q", "-m", f"c{c}"], check=True)
P
  T0=$(date +%s.%N); git gc -q --aggressive; echo "   $f: git gc --aggressive took $(echo "$(date +%s.%N) - $T0" | bc) s"
  echo "   $f: objects $(git count-objects -v | awk '/in-pack/ {print $2}'), pack size $(du -sk .git/objects/pack | cut -f1) KB, total .git $(du -sk .git | cut -f1) KB"
  T0=$(date +%s.%N); git log --stat >/dev/null; echo "   $f: git log --stat over 300 commits took $(echo "$(date +%s.%N) - $T0" | bc) s"
  cd ..
done
rm -rf "$W"

Dependências fixadas, um build reproduzível e proveniência assinada

Python 3 com o pacote cryptography para as assinaturas Ed25519. Dados locais fazem o papel dos downloads de pacotes e de um runner de build.

"""Supply-chain basics for a pipeline: pinned and hash-checked dependencies, a reproducible build, and signed provenance that the deploy step verifies.
Standard library plus `cryptography` (Ed25519). Local files stand in for downloads and for a build runner."""
import gzip, hashlib, io, json, os, tarfile, time
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives import serialization
from cryptography.exceptions import InvalidSignature

sha = lambda b: hashlib.sha256(b).hexdigest()

# ------------------------------------------------------------------ 1. pinning with hashes
def pin_demo():
    print("1. Dependencies: a range changes under you, a pin with a hash cannot")
    index = {"2026-01-01": ["2.30.0", "2.31.0"], "2026-06-01": ["2.30.0", "2.31.0", "2.32.0", "3.0.0"]}   # versions available on two dates
    pick = lambda day, rule: max((v for v in index[day] if rule(v)), key=lambda v: tuple(map(int, v.split("."))))
    rule = lambda v: tuple(map(int, v.split("."))) >= (2, 0, 0)
    print(f"   'lib>=2.0' installs {pick('2026-01-01', rule)} in January and {pick('2026-06-01', rule)} in June: the same commit builds with different code")
    wheel = b"PK-not-really-a-wheel: lib 2.31.0 contents"                          # the file that was reviewed and locked
    lock = {"lib": ("2.31.0", sha(wheel))}
    def install(name, content):
        ver, want = lock[name]; got = sha(content)
        return f"installed {name}=={ver}" if got == want else f"REFUSED {name}=={ver}: hash {got[:12]}… does not match the lock file's {want[:12]}…"
    print("   lock file, genuine download:    ", install("lib", wheel))
    print("   lock file, tampered download:   ", install("lib", wheel + b" + a backdoor"))

# ------------------------------------------------------------------ 2. a reproducible build
def build_archive(files, deterministic, mtime_hint):
    raw = io.BytesIO()
    with tarfile.open(fileobj=raw, mode="w") as tar:
        for name in (sorted(files) if deterministic else list(files)):
            data = files[name]; info = tarfile.TarInfo(name); info.size = len(data)
            info.mtime = 0 if deterministic else mtime_hint; info.uid = info.gid = 0 if deterministic else 1000; info.mode = 0o644
            tar.addfile(info, io.BytesIO(data))
    out = io.BytesIO()
    with gzip.GzipFile(fileobj=out, mode="wb", mtime=0 if deterministic else int(mtime_hint)) as g: g.write(raw.getvalue())
    return out.getvalue()

def repro_demo():
    print("2. A build you can check: the same source twice")
    files = {"app/main.py": b"print('hello')\n", "app/util.py": b"X = 1\n", "VERSION": b"1.4.2\n"}
    a = build_archive(files, False, time.time()); time.sleep(1.1); b = build_archive(files, False, time.time())
    print(f"   default build, run twice:        {sha(a)[:16]}…  {sha(b)[:16]}…  identical: {a == b}")
    a = build_archive(files, True, 0); b = build_archive(dict(reversed(list(files.items()))), True, 0)
    print(f"   timestamps and order normalised: {sha(a)[:16]}…  {sha(b)[:16]}…  identical: {a == b}")
    return a

# ------------------------------------------------------------------ 3. signed provenance, verified before deploy
def provenance_demo(artifact):
    print("3. Provenance: who built these bytes, from which commit, and does the deploy step check?")
    ci_key = Ed25519PrivateKey.generate(); ci_pub = ci_key.public_key()                 # in real life the key never leaves the build system (or is keyless, as in Sigstore)
    other_key = Ed25519PrivateKey.generate()
    def attest(art, commit, branch, builder="ci-runner-1", key=ci_key):
        stmt = json.dumps({"subject": {"name": "app.tar.gz", "sha256": sha(art)}, "source": {"repo": "example/app", "commit": commit, "branch": branch},
                           "builder": builder, "materials": {"requirements.lock": "sha256:…"}}, sort_keys=True).encode()
        return stmt, key.sign(stmt)
    ALLOWED_BUILDERS, PROTECTED = {"ci-runner-1", "ci-runner-2"}, {"main"}
    def verify(art, stmt, sig):
        try: ci_pub.verify(sig, stmt)
        except InvalidSignature: return "REJECT: signature does not verify"
        p = json.loads(stmt)
        if p["subject"]["sha256"] != sha(art): return "REJECT: the artifact is not the one that was built"
        if p["builder"] not in ALLOWED_BUILDERS: return f"REJECT: builder {p['builder']} not allowed"
        if p["source"]["branch"] not in PROTECTED: return f"REJECT: built from branch {p['source']['branch']}, not a protected branch"
        return f"ACCEPT: built by {p['builder']} from {p['source']['commit'][:8]} on {p['source']['branch']}"
    s, sig = attest(artifact, "9f1c2ab07d", "main")
    print("   genuine build from main:                     ", verify(artifact, s, sig))
    print("   artifact swapped after the build:            ", verify(artifact + b"x", s, sig))
    print("   statement edited to claim another commit:    ", verify(artifact, s.replace(b"9f1c2ab07d", b"deadbeef00"), sig))
    s2, sig2 = attest(artifact, "9f1c2ab07d", "main", key=other_key)
    print("   signed with a key the deploy step does not trust:", verify(artifact, s2, sig2))
    s3, sig3 = attest(artifact, "77aa00bb11", "feature/x")
    print("   genuine build, but from a feature branch:    ", verify(artifact, s3, sig3))

if __name__ == "__main__":
    pin_demo(); art = repro_demo(); provenance_demo(art)

Um scanner de segredos mínimo sobre um repositório descartável

Python 3 e git. Os "segredos" são os valores de exemplo da documentação da AWS ou inventados. Scanners reais (gitleaks, TruffleHog) têm conjuntos de regras muito maiores.

"""A minimal secret scanner run over a throwaway git repository, to show what scanning the current files misses and what the history keeps.
All 'secrets' are the well-known example values from the AWS documentation or made up; the real tools (gitleaks, TruffleHog, platform push protection) have far larger rule sets."""
import math, os, re, shutil, subprocess, tempfile

RULES = {"AWS access key id": re.compile(r"\bAKIA[0-9A-Z]{16}\b"), "private key": re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),
         "generic secret assignment": re.compile(r"(?i)(?:secret|token|password|api[_-]?key)\w*\s*[:=]\s*['\"]?([A-Za-z0-9/+_\-]{16,})")}
def entropy(s): return -sum(s.count(c) / len(s) * math.log2(s.count(c) / len(s)) for c in set(s))

def scan_text(text, min_entropy=3.5):
    hits = []
    for line in text.splitlines():
        for name, rx in RULES.items():
            m = rx.search(line)
            if m and (name != "generic secret assignment" or entropy(m.group(1)) >= min_entropy): hits.append((name, line.strip()[:70]))
    return hits

def git(*a, cwd): return subprocess.run(["git", *a], cwd=cwd, capture_output=True, text=True, check=True).stdout

def main():
    d = tempfile.mkdtemp(); g = lambda *a: git(*a, cwd=d)
    g("init", "-q"); g("config", "user.email", "t@t"); g("config", "user.name", "t")
    open(f"{d}/app.py", "w").write("print('hello')\n"); g("add", "."); g("commit", "-qm", "first")
    open(f"{d}/.env", "w").write("DB_HOST=db\nAWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE\nAWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\n")
    g("add", "-A"); g("commit", "-qm", "add config")                                     # the mistake
    os.remove(f"{d}/.env"); g("add", "-A"); g("commit", "-qm", "remove .env (oops)")      # the 'fix'
    open(f"{d}/notes.md", "w").write("build id: 3f786850e387550fdab836ed7e6dc881de23001b\napi_key = changeme-changeme-changeme\nrequest id 123e4567-e89b-12d3-a456-426614174000\n")
    g("add", "-A"); g("commit", "-qm", "notes")
    print("1. scanning only the files in the working tree now:")
    found = [h for f in os.listdir(d) if os.path.isfile(f"{d}/{f}") for h in scan_text(open(f"{d}/{f}").read())]
    print(f"   {len(found)} findings" + "".join(f"\n      {n}: {l}" for n, l in found))
    print("2. scanning every commit's added lines (what a history scan does):")
    seen = set()
    for c in g("rev-list", "--reverse", "HEAD").split():
        for n, l in scan_text("\n".join(x[1:] for x in g("show", "-U0", "--format=", c).splitlines() if x.startswith("+") and not x.startswith("+++"))):
            if (n, l) not in seen: seen.add((n, l)); print(f"   commit {c[:8]} ({g('log', '-1', '--format=%s', c).strip()}): {n}: {l}")
    print("3. the file is gone from HEAD, but still in the repository:")
    print("   git log --all --oneline -S AKIAIOSFODNN7EXAMPLE ->", g("log", "--all", "--oneline", "-S", "AKIAIOSFODNN7EXAMPLE").strip().replace("\n", " | "))
    first = g("log", "--all", "--format=%h", "-S", "AKIAIOSFODNN7EXAMPLE").split()[-1]
    print(f"   git show {first}:.env contains the key: {'AKIAIOSFODNN7EXAMPLE' in g('show', f'{first}:.env')}")
    print("4. a pre-commit check on the staged changes:")
    open(f"{d}/deploy.sh", "w").write("export TOKEN=ghp_16C7e42F292c6912E7710c838347Ae178B4a\n"); g("add", "."); staged = g("diff", "--cached", "-U0")
    hits = scan_text("\n".join(x[1:] for x in staged.splitlines() if x.startswith("+") and not x.startswith("+++")))
    print("   staged diff:", f"BLOCK the commit: {hits[0][0]} in {hits[0][1]!r}" if hits else "clean")
    shutil.rmtree(d)

if __name__ == "__main__": main()

Renomeando uma coluna ao longo de um deploy gradual

Python 3 com sqlite3.

"""Database migrations and rollback: which versions of the application work with which schema step. SQLite; the 'application' versions are two small classes.
Goal: rename a column (name -> full_name) while old and new code run together during a rolling deploy, and keep rollback possible."""
import sqlite3

class V1:                                   # the version in production: knows only `name`
    label = "v1 (reads/writes name)"
    def write(self, db, i, n): db.execute("insert into users(id, name) values (?, ?)", (i, n))
    def read(self, db, i): return db.execute("select name from users where id=?", (i,)).fetchone()[0]
class V2:                                   # the new version: writes both columns when it can, reads full_name with a fallback to name
    label = "v2 (reads/writes full_name, tolerates both)"
    def write(self, db, i, n):
        cols = {r[1] for r in db.execute("pragma table_info(users)")}
        if "name" in cols and "full_name" in cols: db.execute("insert into users(id, name, full_name) values (?, ?, ?)", (i, n, n))
        elif "full_name" in cols: db.execute("insert into users(id, full_name) values (?, ?)", (i, n))
        else: db.execute("insert into users(id, full_name) values (?, ?)", (i, n))        # the column is not there yet: this will fail
    def read(self, db, i):
        cols = {r[1] for r in db.execute("pragma table_info(users)")}
        sel = "coalesce(full_name, name)" if {"name", "full_name"} <= cols else "full_name"
        return db.execute(f"select {sel} from users where id=?", (i,)).fetchone()[0]

STEPS = {
    "S0 start: column name":                        lambda db: None,
    "S1 NAIVE: rename name -> full_name":          lambda db: db.execute("alter table users rename column name to full_name"),
    "S2 expand: add full_name (nullable)":         lambda db: db.execute("alter table users add column full_name text"),
    "S3 backfill: copy name into full_name":       lambda db: db.execute("update users set full_name = name where full_name is null"),
    "S4 contract: drop name":                      lambda db: db.execute("alter table users drop column name"),
}
def fresh():
    db = sqlite3.connect(":memory:"); db.execute("create table users(id integer primary key, name text not null)"); db.execute("insert into users values (1, 'Ada')"); return db

def works(app, steps):
    db = fresh()
    for s in steps: STEPS[s](db)
    try:
        app.write(db, 2, "Grace")
        return "ok" if (app.read(db, 1), app.read(db, 2)) == ("Ada", "Grace") else "FAIL"      # the old row and the new row must both read correctly
    except (sqlite3.Error, TypeError): return "FAIL"

if __name__ == "__main__":
    names = list(STEPS)
    def run(path, title):
        print(title)
        print(f"   {'schema after step':<44}{'v1':>6}{'v2':>6}")
        applied = []
        for s in path:
            applied.append(s); print(f"   {s:<44}{works(V1(), applied):>6}{works(V2(), applied):>6}")
    run([names[0], names[1]], "Naive: rename in one step")
    run([names[0], names[2], names[3], names[4]], "\nExpand, backfill, contract")
    run([names[0], names[2], names[4]], "\nExpand and contract, but the backfill was forgotten")
    print("\nReading it: v1 must keep working until the last v1 pod is gone AND the rollback window has closed, so 'contract' (S4) is its own later release.")
    print("A row written by v2 at S4 has no `name`; after the column is dropped, rolling back to v1 cannot work: the data and the code must be rolled back together, or not at all.")

Fontes

Pratique este tema: DevOps & Cloud

Mais guias