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):
| Objeto | Guarda | Analogia |
|---|---|---|
| blob | os bytes de um arquivo (sem nome, sem permissões) | conteúdo de arquivo |
| tree | uma lista de nomes, modos e os ids de blobs e de outras trees | um diretório |
| commit | o id de uma tree, os ids de seus commits pais, autor, committer, hora e mensagem | um snapshot com histórico |
| tag | um ponteiro nomeado, opcionalmente assinado, para um objeto | uma 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:
- Conteúdo idêntico é armazenado uma vez. Adicionei uma cópia do arquivo com outro nome: as duas entradas do índice apontaram para o mesmo id de blob, então o repositório não ganhou nenhum blob novo.
- Um objeto não pode mudar sem mudar de nome. O id de um commit cobre sua tree e seus pais, que cobrem tudo abaixo deles, de modo que o id de um commit verifica o histórico inteiro por trás dele (uma árvore de Merkle ou cadeia de hashes, como em replicação e blockchains). Adulterar um commit antigo muda todos os ids depois dele.
- Os objetos são imutáveis; "mudar" um commit significa criar um novo.
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:
| Armazenamento | Tamanho |
|---|---|
| 201 cópias completas, sem compressão | cerca de 21 873 KB |
depois de git gc --aggressive: um pack com 608 objetos | cerca 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-1 | Repositório SHA-256 | |
|---|---|---|
id do blob hello | ce013625030ba8dba906f756967f9e9ca394464a (40 caracteres hexadecimais) | 2cf8d83d9ee29543b34a87727421fdecb7e3f3a183d337639025de576db9ebb4 (64) |
| id do primeiro commit | bc31b899… | 58f1538c… (um id diferente para o mesmo conteúdo) |
git log --oneline | bc31b89 first | 58f1538 first (as abreviações continuam curtas) |
| configuração do repositório | core.repositoryformatversion = 0, sem extensão | core.repositoryformatversion = 1, extensions.objectformat = sha256 |
| regra de nomeação à mão | sha1("blob 6" + NUL + "hello\n") | sha256("blob 6" + NUL + "hello\n"), que calculei com sha256sum e obtive o id acima |
O que decorre disso:
- O formato faz parte da identidade do repositório. O mesmo conteúdo tem ids diferentes nos dois formatos, então ids, tags e assinaturas de um repositório não significam nada no outro. Um
git fetchde um repositório SHA-1 para um SHA-256 falhou na hora comfatal: mismatched algorithms: client sha256; server sha1. Não é possível converter um repositório no lugar com o Git que testei; migrar significa criar um repositório novo e importar o histórico (por exemplo, comgit fast-export/fast-import, que reescreve todos os ids e, com eles, todas as assinaturas e todas as referências a ids de commit em issues, configuração de CI e documentos). O projeto Git documenta um plano de transição com interoperabilidade entre os dois formatos, mas trate-o como um plano, não como algo de que depender. - O custo é pequeno. Em um histórico gerado com 300 commits e 6.600 objetos, o repositório empacotado tinha 12.500 KB com SHA-1 e 12.688 KB com SHA-256 (1,5% a mais, por causa dos ids mais longos);
git gc --aggressivelevou 33,2 s e 34,7 s egit log --stat, 1,17 s e 0,99 s, diferenças dentro do ruído de uma máquina compartilhada. O hash de dados brutos rodou a cerca de 1.494 MB/s (SHA-1) e 1.345 MB/s (SHA-256) em Python nesta CPU, que tem suporte de hardware para os dois; em uma CPU sem instruções SHA, o SHA-256 é mais lento, e nenhum dos dois é o gargalo dos comandos cotidianos do Git. - Por que mudar, afinal. Colisões de SHA-1 foram demonstradas em 2017 (o ataque SHAttered), e desde o Git 2.13 ele usa um SHA-1 com detecção de colisões que rejeita os padrões de ataque conhecidos. Para o uso comum o risco é baixo, mas um id de commit é a raiz de confiança de uma tag ou de um commit assinado, então um hash criptograficamente mais forte é a resposta sensata a longo prazo.
- O suporte do ecossistema é o verdadeiro obstáculo. Nas fontes que pude ler (uma prévia do Git 3.0 publicada em 2026; verifique o estado atual antes de decidir): o SHA-256 não é o padrão do Git e está planejado para o Git 3.0, que não tem data de lançamento; Forgejo e Dulwich o suportam, GitLab, go-git e libgit2 são experimentais, e GitHub e Bitbucket não suportavam repositórios SHA-256. Um repositório que o seu provedor de hospedagem não consegue hospedar não serve para uma equipe.
- O que fazer agora. Fique no SHA-1, a menos que tenha um requisito específico e toda a sua cadeia de ferramentas suporte SHA-256; assine commits e tags (a autenticidade não depende só do hash do objeto); e pare de fixar 40 no código: uma expressão regular
[0-9a-f]{40}, uma colunaCHAR(40), um formato de log de largura fixa ou uma ferramenta que analisa a saída dogit rev-parsevai quebrar com um id de 64 caracteres. Aceite os dois comprimentos, para que o dia da troca seja uma mudança de configuração.
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
- Um merge cria um commit com dois pais e mantém o histórico como realmente aconteceu. Os commits existentes não mudam.
- Um rebase pega seus commits e os reproduz em cima de outro commit, criando novos commits com novos pais. No experimento, um branch de feature de um commit tinha o id
dba6fbeantes dogit rebase maine0cae772depois: a mesma mudança, mas um objeto novo, já que seu pai faz parte da sua identidade. O resultado é uma linha reta, fácil de ler e de percorrer com bisect.
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 intervalo | Execuções de teste necessárias | Resultado |
|---|---|---|
| 100 | 7 | c77 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égia | Como funciona | Encaixa em |
|---|---|---|
| Trunk-based development | todos 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 flags | equipes que implantam continuamente; a prática que a pesquisa DORA associa a alto desempenho |
| GitHub flow | branches de feature de vida curta, um pull request com revisão e CI, merge na main, deploy a partir da main | a maioria das equipes web |
| Gitflow | branches develop e de release de vida longa, mais branches de feature e de hotfix | software entregue em versões que precisam ser mantidas em paralelo (produtos instalados, bibliotecas) |
| Branches de release | ramificar na release, fazer backport das correções | o 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
- Integração contínua (CI): toda mudança é integrada à linha principal com frequência (pelo menos uma vez por dia) e cada merge é compilado e testado automaticamente. O objetivo é achar problemas de integração em minutos, não no fim de uma release.
- Entrega contínua (continuous delivery): a linha principal está sempre pronta para lançamento; toda mudança que passa pelo pipeline pode ser implantada com o apertar de um botão.
- Implantação contínua (continuous deployment): toda mudança que passa é implantada em produção automaticamente, sem botão.
Diagram: A typical pipeline: fast checks first, one artifact promoted through environments
Princípios que tornam um pipeline confiável:
- Primeiro o feedback rápido. Execute primeiro as verificações mais baratas e mais informativas e falhe cedo (a ordem do CI deste repositório é verificação de tipos, lint, testes, build). Um pipeline que leva uma hora é ignorado ou contornado.
- Construa uma vez, implante o mesmo artefato em todo lugar. O binário ou a imagem testado em staging precisa ser, byte a byte, o mesmo de produção (identificado por seu digest ou id de commit), com diferenças apenas na configuração. Reconstruir por ambiente testa algo diferente do que é entregue (twelve-factor: build, release, run).
- Mantenha configuração e segredos fora do artefato e injete-os na hora do deploy.
- Uma pirâmide de testes: muitos testes unitários rápidos, menos testes de integração, poucos testes de ponta a ponta. Testes de ponta a ponta lentos e instáveis no topo são caros; um teste instável (flaky) repetido até ficar verde é pior que nenhum, porque ensina todo mundo a ignorar o vermelho.
- Mudanças de schema e de código são entregues separadamente, como passos aditivos (expandir, implantar, depois contrair), já que durante uma implantação as duas versões rodam contra um mesmo banco de dados; veja replicação e versionamento de eventos.
- Proteja o pipeline: ele pode implantar em produção, então suas credenciais são as chaves do sistema. Use credenciais de vida curta, privilégio mínimo, dependências e actions fixadas e artefatos assinados (veja a segurança da cadeia de suprimentos no guia de segurança).
- Meça-o com as quatro métricas DORA: frequência de implantação, lead time para mudanças, taxa de falha de mudanças e tempo para restaurar o serviço. Lançamentos pequenos e frequentes melhoram as quatro, porque uma mudança pequena é fácil de entender, testar e reverter.
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):
| Caso | Veredito da etapa de deploy |
|---|---|
build genuíno a partir da main | ACEITA: construído por ci-runner-1 a partir de 9f1c2ab0 na main |
| artefato trocado depois do build | REJEITA: o artefato não é o que foi construído |
| declaração editada para afirmar outro commit | REJEITA: a assinatura não verifica |
| assinado com uma chave em que a etapa de deploy não confia | REJEITA: a assinatura não verifica |
| build genuíno, mas de uma feature branch | REJEITA: 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 passo | App antigo (v1) | App novo (v2, tolera as duas colunas) |
|---|---|---|
início (name) | ok | FALHA (a coluna nova ainda não existe) |
| ingênuo: renomear em um único passo | FALHA | ok |
expandir: adicionar full_name | ok | ok |
preencher (backfill): copiar name para full_name | ok | ok |
contrair: remover name | FALHA | ok |
| contrair sem preencher | FALHA | FALHA (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:
- Reverter código é fácil; reverter dados não é. Uma migração "down" que remove uma coluna destrói o que a v2 escreveu nela. Prefira correções para frente e feature flags, deixe os passos destrutivos para o fim e faça um backup ou snapshot antes deles.
- Execute as migrações como uma etapa própria do pipeline, uma única vez (não a cada início de pod), com um lock, um timeout e logs, e torne-as idempotentes. Verifique quanto tempo levam em dados do tamanho da produção: algumas mudanças travam uma tabela enquanto duram (no PostgreSQL, adicionar uma coluna anulável é rápido e um índice deve ser criado com
CONCURRENTLY; veja a documentação do banco para a sua versão). - O rollback da aplicação é "refazer o deploy do artefato anterior pelo digest", o que só funciona se esse artefato ainda estiver armazenado e o schema ainda for compatível com ele. Retenha os artefatos e teste regularmente o caminho de rollback, como parte dos releases.
- Condicione a promoção a sinais de saúde (taxa de erros, latência) e deixe o pipeline reverter sozinho (seção 6 sobre estratégias de deploy, e observabilidade).
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égia | Como | Rollback | Custo e pegadinha |
|---|---|---|---|
| Recreate | pare a versão antiga, inicie a nova | reimplantar | indisponibilidade |
| Rolling | substitua as instâncias gradualmente (veja Kubernetes) | avançar ou voltar, devagar | as duas versões rodam juntas, então precisam ser compatíveis |
| Blue/green | execute um segundo ambiente completo, teste-o, depois troque o roteador | volte a troca (segundos) | o dobro da capacidade durante a release; o banco de dados é compartilhado, então mudanças de schema ainda exigem cuidado |
| Canary | envie uma pequena parte do tráfego real à nova versão, compare suas métricas, depois aumente | devolva a parte para 0 | exige boas métricas e um portão automatizado |
| Feature flag / dark launch | entregue o código desligado, ative por grupo de usuários | desligue a flag | dívida de flags: remova as antigas |
| Shadow (espelho) | copie o tráfego de produção para a nova versão e descarte suas respostas | desnecessá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:
- a parcela de tráfego for grande o bastante para detectar o problema: com 50 requisições, uma taxa de erro de 0,1% não se distingue de zero, então cada estágio precisa de requisições (ou tempo) suficientes para que a estatística signifique alguma coisa;
- o portão comparar os sinais certos: taxa de erros, percentis de latência, saturação e métricas de negócio, como a taxa de checkout, contra a versão antiga rodando ao mesmo tempo, e não contra ontem (observabilidade);
- o rollback for automático e testado. O pior momento para descobrir que o rollback não funciona é durante um incidente.
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
- Branches de vida longa e merges big-bang.
- Fazer rebase ou force-push de branches compartilhados.
- Fazer commit de segredos, arquivos
.envou binários grandes e depois "apagá-los" em um commit posterior. - Uma branch main vermelha sobre a qual as pessoas fazem merge; builds quebrados que não são consertados primeiro.
- Testes instáveis que são reexecutados até passar.
- Reconstruir o artefato para cada ambiente, ou implantar
latest. - Passos manuais no processo de release que "só a Ana conhece".
- Um rollback nunca testado, ou impossível porque uma migração não pode ser desfeita.
- Um canary sem portão de métricas, ou julgado com tráfego insuficiente.
- Credenciais do pipeline com acesso amplo e permanente à produção.
- Commits que misturam refatoração, formatação e uma mudança de comportamento, que não podem ser revisados, percorridos com bisect nem revertidos separadamente.
9. Coisas a mencionar em uma entrevista
- O Git armazena blobs, trees, commits e tags nomeados pelo hash do seu conteúdo; um branch é um ponteiro de 41 bytes; os commits são snapshots; os packfiles armazenam deltas.
- Por que arquivos idênticos são armazenados uma vez, por que o histórico evidencia adulteração e por que um segredo vazado nunca é removido por um novo commit.
- Merge contra rebase, a regra de ouro de não reescrever histórico compartilhado e o reflog para recuperação.
git bisect: busca binária, cerca de log2(n) passos.- Trunk-based development contra Gitflow, e feature flags para separar deploy de release.
- CI contra entrega contínua contra implantação contínua; construir uma vez, promover o artefato; pirâmide de testes; métricas DORA.
- Rolling, blue/green, canary, feature flags e tráfego shadow, e o que cada um exige (compatibilidade, capacidade, métricas).
- Mudanças de schema retrocompatíveis como expandir e contrair.
Resumo rápido
- O Git é um armazenamento endereçado por conteúdo: o nome de um objeto é o SHA-1 do seu conteúdo, então conteúdo idêntico é armazenado uma vez, o histórico evidencia adulteração e os objetos nunca mudam. O experimento confirmou o hash à mão, um branch de 41 bytes e uma economia de mais de 200 vezes com os deltas do packfile (de cerca de 21 873 KB para cerca de 102 KB).
- O rebase cria novos commits (novos ids); o merge mantém os antigos. Não reescreva histórico compartilhado; o reflog recupera erros locais.
- O bisect achou o commit ruim entre 100 em 7 execuções de teste.
- Branches de vida curta e feature flags mantêm a integração barata; o CI/CD dá feedback rápido, constrói uma vez e promove um artefato, e é medido pelas métricas DORA.
- As implantações canary, blue/green e graduais limitam o raio da explosão; no modelo, um canary de 5% transformou 80 falhas por 1 000 requisições em 4. Dependem de mudanças retrocompatíveis, métricas honestas e um rollback automático.
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
- Scott Chacon e Ben Straub, Pro Git, especialmente o capítulo 10, "Git Internals" (objetos, refs, packfiles), e os capítulos sobre branches, rebase e
git bisect. - Documentação do Git: gitformat-pack, git-hash-object, git-bisect, git-rebase, git-reflog e Git and hash function transition.
- Marc Stevens et al., The first collision for full SHA-1 (o ataque "SHAttered", 2017), e a documentação do Git sobre detecção de colisões SHA-1.
- Jez Humble e David Farley, Continuous Delivery (Addison-Wesley, 2010); Martin Fowler, Continuous Integration, Feature Toggles, BlueGreenDeployment e CanaryRelease.
- Nicole Forsgren, Jez Humble e Gene Kim, Accelerate (IT Revolution, 2018), e a pesquisa DORA sobre as quatro métricas-chave de entrega.
- Paul Hammant, Trunk Based Development.
- Google, Site Reliability Engineering (O'Reilly, 2016), capítulo 8 "Release Engineering", e The Site Reliability Workbook, capítulo 16 "Canarying Releases".
- O Twelve-Factor App, fatores V (build, release, run) e X (paridade dev/prod); o framework SLSA para a proveniência de builds.
- Documentação do Git: hash-function-transition,
git init --object-formate as notas de lançamento do Git 2.42; Marc Stevens et al., The first collision for full SHA-1 (2017). - SLSA (níveis da cadeia de suprimentos e o formato de proveniência), Sigstore (cosign) e a documentação da sua plataforma de CI sobre atestações de artefatos; o modo de verificação de hashes do pip.
- Martin Fowler, Parallel Change (expandir e contrair); documentação do PostgreSQL,
CREATE INDEX CONCURRENTLY.
Pratique este tema: DevOps & Cloud