CS Fundamentals Trainer · Guias
Contêineres e Kubernetes
O que um contêiner realmente é (namespaces, cgroups e camadas de imagem, medidos) e como o Kubernetes mantém o estado desejado: o plano de controle, o agendamento por requests, atualizações graduais e probes, e o autoscaling.
42 min de leitura
"Um contêiner é uma máquina virtual leve" é a descrição mais comum e a menos precisa. Um contêiner é um processo Linux comum ao qual o kernel foi instruído a mentir de três maneiras: sobre o que ele pode ver (namespaces), sobre o quanto ele pode usar (control groups, ou cgroups) e sobre quais arquivos ele tem (um sistema de arquivos raiz em camadas). O Kubernetes então executa milhares desses processos em muitas máquinas, e todo o seu design é uma ideia repetida: você declara o estado que quer, e controladores continuam trabalhando até a realidade coincidir.
Este guia constrói um contêiner à mão com as ferramentas do próprio kernel e mede o que os limites fazem, e depois sobe para o Kubernetes: suas partes, seu scheduler, atualizações graduais, probes e autoscaling. Tudo na primeira metade foi executado em um sandbox Linux como root; os scripts estão no apêndice. Ele dá continuidade a sistemas operacionais, e seus tópicos de implantação se conectam a Git e CI/CD e microsserviços.
1. Um contêiner é um processo com três disfarces
| Mecanismo | O que limita | A mentira que conta |
|---|---|---|
| Namespaces | o que o processo pode ver | "você é o processo 1 em uma máquina chamada web-7f9, com só estes processos, dispositivos de rede e montagens" |
| cgroups | quanto ele pode usar | "você tem 50 MB de memória e um quinto de uma CPU" (imposto, não apenas anunciado) |
| Sistema de arquivos em camadas | quais arquivos ele tem | "este é o seu diretório raiz" (montado a partir de camadas da imagem mais uma camada gravável) |
Diagram: Containers share the host's kernel; virtual machines each bring one
Como há apenas um kernel, um contêiner inicia em milissegundos e tem quase nenhuma sobrecarga, e uma vulnerabilidade no kernel é compartilhada por todos no host; essa é a principal diferença na força do isolamento em relação a uma máquina virtual.
Namespaces: o que o processo vê
Um namespace dá a um processo a sua própria visão de um tipo de recurso: ids de processo (PID), interfaces de rede, pontos de montagem, nome do host (UTS), usuários, comunicação entre processos e cgroups. Iniciei um shell em um novo namespace de PID com unshare:
| Onde | Processos visíveis |
|---|---|
| dentro do novo namespace de PID | 4, e o shell se vê como PID 1 |
| no host | 71 |
O processo é o mesmo objeto do kernel que o host vê sob outro número; ele simplesmente não consegue ver o resto. Um novo namespace UTS me deixou mudar o nome do host para demo por dentro enquanto o nome da máquina continuou vm. Um runtime de contêineres cria um conjunto completo de uma vez.
cgroups: quanto ele pode usar
Os control groups contabilizam e limitam os recursos de um conjunto de processos. São o que transforma "um contêiner" de uma visão em um orçamento. Coloquei um programa Python em um cgroup com um limite de memória de 50 MB e fiz com que alocasse e tocasse 10 MB por vez:
allocated 10 MB
allocated 20 MB
allocated 30 MB
allocated 40 MB
Killed exit status: 137
No quinto bloco, o OOM killer do kernel encerrou o processo com SIGKILL, e o shell relatou o status de saída 137, que é 128 + 9 (sinal 9). É isso que você vê no Kubernetes como OOMKilled com código de saída 137. Repare no que não aconteceu: não houve nenhuma exceção que o programa pudesse capturar. A memória é um limite rígido, e o processo morre. O cache de páginas, a memória de processos filhos e os sistemas de arquivos em memória também contam para o limite.
A CPU funciona de outro jeito: é uma taxa, então excedê-la significa ser limitado (throttled) (pausado), não morto. Dei a um laço ocupado uma cota de 20 ms de tempo de CPU por período de 100 ms:
| Configuração | Iterações do laço por segundo | Tempo de CPU usado em 3 segundos |
|---|---|---|
| sem limite | 6,45 milhões | 2,94 s |
| cota de 20% de um núcleo | 1,30 milhão | 0,62 s |
O processo limitado recebeu 21% do tempo e rodou a 20% da velocidade. Para um serviço web, isso aparece como latência: uma requisição que precisa de 50 ms de CPU pode levar 50 ms ou, se a cota se esgotar nesse período, espera pelo próximo. O throttling de CPU é uma causa clássica de misteriosos picos de latência p99 em contêineres cujo uso médio de CPU parece baixo.
Duas consequências para o runtime decorrem disso. Primeiro, os programas precisam ler o limite: uma JVM ou um runtime Go que dimensiona seu heap e seus pools de threads pela memória e pelos núcleos do host, e não pelos do contêiner, será morto ou limitado (os runtimes modernos leem os limites do cgroup; confira o seu, veja coleta de lixo). Segundo, defina o limite de memória acima do pico real (incluindo a sobrecarga do runtime) e monitore o quanto você se aproxima.
Camadas de imagem: quais arquivos ele tem
Uma imagem de contêiner é uma pilha de camadas somente leitura, cada uma um conjunto de mudanças em arquivos (o resultado de um passo do build), mais uma fina camada gravável por cima. O sistema de arquivos overlay do kernel as mescla. Fiz uma camada inferior com a.txt contendo "base", depois mudei a.txt e adicionei b.txt na visão mesclada:
| Camada | Conteúdo |
|---|---|
| inferior (somente leitura) | a.txt = base (intocado) |
| superior (gravável) | a.txt (a cópia alterada) e b.txt |
| visão mesclada | a.txt = alterado, b.txt = novo |
Isso é copy-on-write de novo (como no fork do guia de sistemas operacionais): a primeira escrita em um arquivo o copia para a camada superior. Explica por que muitos contêineres podem compartilhar uma imagem em disco, por que iniciar um contêiner é rápido e por que os dados gravados dentro de um contêiner se perdem quando ele é removido, a menos que estejam em um volume montado. Consequências práticas para construir imagens:
- Ordene os passos do que muda menos para o que muda mais, para que o cache de camadas seja reaproveitado: instale as dependências (copiadas do arquivo de lock) antes de copiar seu código-fonte.
- Use builds em vários estágios (multi-stage): compile em uma imagem de build grande e copie apenas o resultado para uma imagem de runtime pequena. Imagens menores são baixadas mais rápido, iniciam mais rápido e expõem menos a ataques.
- Um arquivo apagado continua na camada inferior, então um segredo adicionado em um passo e removido no seguinte ainda está na imagem (como em um histórico do git; veja o guia de segurança).
- Fixe as imagens base por digest para builds reproduzíveis e reconstrua regularmente para receber correções de segurança.
- Rode como usuário não root, com um sistema de arquivos raiz somente leitura sempre que possível.
O Docker é uma forma de construir e executar tudo isso; as imagens seguem o padrão OCI e rodam também no containerd ou no CRI-O, que é o que o Kubernetes usa.
2. Kubernetes: declare o estado que você quer
Um host pode executar contêineres à mão. Para executar centenas em dezenas de máquinas, com reinicializações, atualizações, escalonamento e rede, você precisa de um orquestrador. O Kubernetes é construído sobre o estado desejado: você submete objetos que descrevem o que quer ("quatro réplicas desta imagem, acessíveis por este nome"), e controladores executam um laço para sempre: observar o estado real, compará-lo com o estado desejado e agir para fechar a diferença.
Diagram: The parts of a Kubernetes cluster
- O API server é a porta de entrada e o único componente que fala com o armazenamento. Todo o resto o observa.
- O etcd é o banco de dados do cluster. Ele usa o Raft (consenso), e é por isso que um plano de controle tem 3 ou 5 membros e que perder sua maioria congela as mudanças (os pods em execução continuam rodando).
- O scheduler escolhe um nó para cada pod que ainda não tem um.
- Os controladores fazem a realidade corresponder à especificação: o controlador de Deployment mantém ReplicaSets, que mantêm o número certo de pods.
- O kubelet em cada nó garante que os contêineres de seus pods estejam rodando e saudáveis e reporta de volta. O kube-proxy (ou equivalente) programa a rede do nó para que os Services funcionem.
Os principais objetos
| Objeto | O que é |
|---|---|
| Pod | a menor unidade: um ou mais contêineres que compartilham um endereço de rede e volumes, agendados juntos |
| Deployment (e ReplicaSet) | mantém N pods idênticos rodando e executa atualizações graduais |
| Service | um nome estável e um IP virtual que balanceia a carga entre os pods saudáveis que casam com um seletor de labels (balanceamento de carga, DNS) |
| Ingress / Gateway | roteamento HTTP de fora do cluster para os Services |
| ConfigMap, Secret | configuração e credenciais injetadas como variáveis de ambiente ou arquivos (gerenciamento de segredos). Um Secret é só base64, então ative a criptografia em repouso e restrinja o acesso |
| StatefulSet | pods com identidades estáveis e seus próprios volumes persistentes, para bancos de dados e coisas semelhantes |
| Job, CronJob | executam até terminar, uma vez ou em um agendamento |
| HorizontalPodAutoscaler | muda o número de réplicas a partir de uma métrica |
| PersistentVolume(Claim) | armazenamento que sobrevive a um pod |
Os pods são gado, não animais de estimação (cattle, not pets): são criados, mortos e reagendados a qualquer momento e seus endereços IP mudam, então nada deve depender de um pod específico. Você endereça o Service e guarda o estado em volumes ou armazenamentos externos.
3. Agendamento: os requests decidem, o uso não
Cada contêiner declara requests (o que o scheduler deve reservar) e limits (o que o cgroup impõe). O scheduler só coloca um pod em um nó com capacidade não requisitada suficiente e depois pontua os candidatos (distribuição, afinidade e assim por diante). Ele trabalha a partir dos requests, não do uso real.
Empacotei 200 pods com requests de CPU aleatórios (244 CPUs no total) em nós de 8 CPUs:
| Política | Nós usados | CPU requisitada preenchida |
|---|---|---|
| first fit | 31 | 98% |
| best fit | 31 | 98% |
| spread (nó menos carregado primeiro) | 32 | 95% |
O mínimo teórico é 30,5, então as três políticas empacotam bem; espalhar custa um nó e compra resiliência, porque um nó que falha leva consigo menos pods do mesmo serviço. Os mesmos pods usaram de fato cerca de 90 CPUs, 37% do que requisitaram. Essa diferença é o problema de custo usual: requests altos demais desperdiçam dinheiro (os nós parecem cheios e estão ociosos), e requests baixos demais deixam o scheduler empacotar nós em excesso, que então limitam ou despejam pods sob carga. Meça o uso real e defina os requests perto do valor típico e os limits com folga. A classe de qualidade de serviço decorre disso: pods cujos requests são iguais aos limits são Guaranteed e são despejados por último; pods com alguns requests são Burstable; pods sem nenhum são BestEffort e são os primeiros a sair quando um nó fica sem recursos.
3.1 Requests e limits: o que cada um realmente faz
Os dois números são fáceis de confundir e cumprem funções diferentes em momentos diferentes. Medi-os em cgroups reais (Linux, cgroups v1, como root; scripts no apêndice) e o restante vem da documentação do Kubernetes.
| CPU | Memória | |
|---|---|---|
| Request | usado pelo scheduler para posicionar o pod; vira um peso relativo (cpu.shares) que só importa quando há disputa por CPU | usado pelo scheduler para posicionar o pod; nada é imposto em tempo de execução, mas decide quem é removido primeiro quando o nó fica sem recursos |
| Limit | um teto rígido (cfs_quota_us por cfs_period_us, um período de 100 ms por padrão); o contêiner é limitado (throttled), nunca morto | um teto rígido (memory.limit_in_bytes); além dele, o OOM killer do kernel mata o processo (OOMKilled, código de saída 137) |
O Kubernetes também deriva uma classe de QoS desses números (documentação): requests iguais aos limits em todos os contêineres dão Guaranteed; alguns requests ou limits dão Burstable; nenhum dá BestEffort. Sob pressão no nó, os pods BestEffort são removidos primeiro, depois os Burstable que usam mais que os seus requests, e os Guaranteed por último.
Um request de CPU é um peso, não um teto. Dois processos girando em uma CPU, com shares de 1024 e 256 (uma razão de 4:1 nos requests), receberam 78% e 20% da CPU. O que tinha o share pequeno, rodando sozinho, recebeu 99%: um request reserva um direito e nada mais quando ninguém mais quer a CPU.
Um limit de CPU é um teto, mesmo em uma máquina ociosa. Um processo sozinho em uma CPU ociosa, com um limit de 0,2 CPU (20 ms a cada 100 ms), obteve 21% e foi limitado (throttled) em todos os 41 períodos do teste.
O throttling aparece como latência, enquanto a CPU média parece normal. O quadro habitual é um serviço cujos dashboards mostram 40 a 50% de CPU. Rodei um serviço com dois processos worker e tráfego em rajadas (carregamentos de página de três requisições de uma vez; cada requisição com 50 ms de CPU; cerca de 0,49 CPU em média) em uma máquina de dois núcleos, sob diferentes limits:
| Limit de CPU | CPU realmente usada | p50 | p99 | Períodos limitados |
|---|---|---|---|---|
| nenhum | 0,49 | 55 ms | 194 ms | |
| 2,0 CPUs (sem efeito) | 0,49 | 55 ms | 189 ms | 0 de 122 |
| 1,0 CPU | 0,49 | 97 ms | 559 ms | 71 de 144 (49%) |
| 0,6 CPU | 0,48 | 306 ms | 1.834 ms | 151 de 184 (82%) |
| 0,5 CPU | 0,47 | 653 ms | 2.559 ms | 192 de 205 (94%) |
O uso médio é o mesmo em todas as linhas. Um limit de 1,0 CPU é o dobro da média e ainda assim triplicou o p99: uma rajada de três requisições precisa de 150 ms de CPU, a cota permite 100 ms por período, então o restante espera o período seguinte. Com um limit próximo da média, a fila nunca se esvazia. Esse é o padrão "a CPU média parece boa, o p99 é terrível": olhe as métricas de throttling (container_cpu_cfs_throttled_periods_total sobre container_cpu_cfs_periods_total no cAdvisor/Prometheus), não a utilização média. Um pod limitado também falha nos seus próprios health probes por lentidão: um readiness probe com timeout de 1 segundo teria oscilado nas linhas de 0,6 e 0,5.
Opções quando um serviço sofre throttling: elevar o limit bem acima da rajada de que você precisa; definir um request de CPU que corresponda ao uso real e deixar o limit de CPU alto ou sem definição (muitas equipes fazem isso para serviços sensíveis à latência, aceitando que um vizinho barulhento possa então levar mais que a sua parte quando o nó está ocupado; outras mantêm limits por justiça em clusters compartilhados, então isso é uma decisão de política); e fazer os pools de threads da aplicação corresponderem à CPU que ela realmente terá (um runtime que enxerga todos os núcleos do host vai iniciar threads demais).
Um limit de memória definido a partir da média mata no pico. Rodei um programa com um conjunto de trabalho estável de 40 MB e um pico de 50 MB mantido por 0,2 s a cada 0,6 s (média de cerca de 57 MB):
| Limit de memória | Resultado |
|---|---|
| 64 MB (logo acima da média) | morto por SIGKILL (código de saída 137 em um shell) no primeiro pico; 0 de 6 picos sobreviveram; o limit foi atingido 36 vezes antes da morte |
| 128 MB (acima do pico de 90 MB) | os 6 picos sobreviveram; uso máximo de 90 MB; o limit nunca foi atingido |
A memória não é compressível como a CPU: não existe um "throttling" que, em vez disso, deixe o processo mais lento; no limite, o kernel primeiro tenta recuperar memória (descartando o cache de páginas, o que deixa a E/S de arquivos mais lenta) e, quando não consegue, mata. Defina o limit de memória a partir do pico, com folga, e defina o request igual ao limit, para um posicionamento previsível e para a classe Guaranteed no lado da memória. Os runtimes gerenciados precisam das próprias configurações, porque o heap deles é separado do limit do contêiner: por exemplo, -XX:MaxRAMPercentage para a JVM e GOMEMLIMIT para Go, deixando espaço para pilhas, memória nativa e o próprio runtime (coleta de lixo).
Pressão de memória antes da morte. Entre "tudo bem" e "morto", uma carga de trabalho fica mais lenta: o cache de páginas de arquivos é descartado (bancos de dados e serviços que servem arquivos perdem os dados em cache e voltam a ler do disco), os coletores de lixo rodam com mais frequência e, com swap ativado, páginas vão para o disco. No kernel, a informação de pressão (pressure stall information) (/proc/pressure/memory, cpu e io) diz que fração do tempo as tarefas esperaram pelo recurso. Não consegui reproduzir o efeito do cache de páginas no meu sandbox (ler um arquivo de 300 MB sob um limit de 100 MB teve a mesma velocidade que sob um limit de 600 MB, então o sandbox evidentemente não cobra o cache de arquivos do limit); trate este parágrafo como documentação, não como uma medição. A pressão no nível do nó é diferente de um contêiner chegar ao próprio limit: quando o nó fica sem recursos, o kubelet remove (evicts) pods (status Evicted, mensagem "The node was low on resource: memory"), escolhidos pela ordem de QoS acima; um pod morto por exceder o próprio limit mostra OOMKilled.
4. Atualizações graduais (rolling updates)
Um Deployment substitui os pods gradualmente, sob duas regras que valem a cada instante: existem no máximo replicas + maxSurge pods e pelo menos replicas - maxUnavailable pods estão prontos. Percorra uma atualização de quatro pods com maxSurge: 1 e maxUnavailable: 0, e depois veja o que acontece quando a nova versão está quebrada:
Interactive animation: rolling update
No modelo, uma atualização com maxSurge 1 e maxUnavailable 0 levou 12 passos e nunca teve menos de 4 pods prontos: a capacidade nunca é reduzida, ao preço de um pod extra e de uma implantação mais lenta. Outras configurações trocam velocidade por capacidade:
| Estratégia | Passos até terminar | Menos pods prontos durante a atualização |
|---|---|---|
| maxSurge 1, maxUnavailable 0 | 12 | 4 |
| maxSurge 2, maxUnavailable 1 | 6 | 3 |
| maxSurge 0, maxUnavailable 1 (não precisa de capacidade extra) | 13 | 3 |
maxSurge 0, maxUnavailable 4 (como a estratégia Recreate) | 4 | 0 |
O caso que prova o design é a versão quebrada: quando os novos pods nunca passam em sua verificação de readiness, uma implantação com maxUnavailable 0 para (stalls) com todos os quatro pods antigos ainda atendendo tráfego e um novo pod preso. Com maxUnavailable 1, três pods antigos continuam atendendo e dois novos ficam presos. Os usuários não veem nada de errado, e a implantação em si continua em andamento até alguém notar (então alerte sobre uma implantação que exceda seu progressDeadlineSeconds) e executar kubectl rollout undo. Isso só funciona se a readiness probe realmente testar a aplicação.
Probes
- Readiness: "posso receber tráfego?" Um pod que falha é removido dos endpoints do Service, mas não é reiniciado. Use-a para aquecimento, uma dependência fora do ar ou sobrecarga.
- Liveness: "estou travado?" O contêiner de um pod que falha é reiniciado. Mantenha-a barata e independente de dependências, ou uma queda do banco de dados reiniciará sua frota inteira em um laço.
- Startup: dá tempo a uma aplicação de início lento antes de a liveness começar.
Combine-as com um desligamento gracioso (graceful shutdown): ao encerrar, o Kubernetes envia SIGTERM e espera (terminationGracePeriodSeconds) antes do SIGKILL; a aplicação deve parar de aceitar trabalho novo, concluir as requisições em andamento e sair. Sem isso, todo deploy derruba requisições (padrões de resiliência). Um PodDisruptionBudget limita quantos pods de um serviço podem estar fora do ar ao mesmo tempo durante a manutenção de nós.
Passo a passo de diagnóstico: OOMKilled, probes falhando, pods Pending e rollouts travados
Quando um release dá errado, o hábito útil é sempre o mesmo: status, depois eventos, depois logs, depois métricas. Os comandos e as mensagens abaixo vêm da documentação do Kubernetes e são típicos; eu não tinha um cluster no sandbox, então não os capturei de um, e a redação exata varia entre versões. As duas coisas que consegui testar, o comportamento dos cgroups e as regras de rollout, estão medidas acima e abaixo.
kubectl get pods -o wide # STATUS, READY (0/1?), RESTARTS, which node
kubectl describe pod <pod> # Events at the bottom; Last State; Conditions; Requests/Limits
kubectl logs <pod> --previous # logs of the container that just died, not the new one
kubectl get events --sort-by=.lastTimestamp # what the cluster did, in order
kubectl top pod <pod> --containers # current CPU and memory (needs metrics-server)
kubectl rollout status deployment/<name> # waits; reports why it is stuck
kubectl rollout undo deployment/<name> # go back to the previous revision
1. OOMKilled e CrashLoopBackOff
- Sintoma: RESTARTS não para de subir; o
describemostraLast State: Terminated,Reason: OOMKilled,Exit Code: 137(128 + sinal 9). - Confirme que é o limit do próprio contêiner: compare o limit da especificação com o uso de memória antes da morte (
kubectl top, ou o pico do gráfico de memória). Um pod comStatus: Failed, Reason: Evictedé o outro caso, pressão no nó, e a correção é diferente (requests, tamanho do nó, quem mais está no nó). - Por que acontece: o limit está abaixo do pico (meu experimento: um limit de 64 MB em um programa que tem média de 57 MB e pico de 90 MB morreu no primeiro pico), um vazamento, um runtime que dimensiona o heap a partir da memória do host, ou uma rajada, como uma requisição grande ou uma exportação mantida em memória.
- Correção: descubra se é um vazamento (o uso cresce sem limite ao longo das reinicializações) ou um pico (o gráfico faz dentes de serra e um único pico cruza o limit). Para um pico, eleve o limit com folga ou achate o pico (faça streaming em vez de carregar tudo, limite o tamanho e a concorrência das requisições). Defina os limites de heap do runtime abaixo do limit do contêiner. Não se limite a remover o limit: um pod pode então esgotar o nó.
- Um
CrashLoopBackOffnão é uma causa por si só; ele apenas diz que o contêiner continua saindo e que o kubelet espera mais entre as reinicializações. Leia os logs com--previouse o código de saída.
2. Pods Running, mas não Ready (readiness probes falhando)
- Sintoma:
READY 0/1, o Service não tem endpoints para aquele pod (kubectl get endpoints <service>), o tráfego vai para os outros ou para lugar nenhum; os eventos dodescribedizemReadiness probe failed, seguido do código de status, do timeout ou de conexão recusada. - Causas, em ordem de frequência: um caminho ou uma porta errados; a aplicação precisa de mais tempo para iniciar do que o probe permite (use um startup probe em vez de um atraso inicial enorme); o probe verifica uma dependência e a dependência está fora (isso tira todos os pods de uma vez: mantenha a readiness em "esta instância consegue atender" e trate a dependência com timeouts e alternativas); o timeout do probe é menor que a resposta da aplicação sob carga ou throttling (um probe com
timeoutSeconds: 1falha sempre que o pod sofre throttling como mostrou a linha de 0,6 CPU); ou a aplicação está realmente quebrada. - Teste você mesmo:
kubectl exec <pod> -- curl -s localhost:<porta>/readyoukubectl port-forward; verifique o log da aplicação no momento da falha. - Um probe de liveness que falha reinicia o contêiner, então um liveness estrito demais, somado a throttling ou a uma dependência lenta, transforma uma lentidão em um laço de reinicializações. Mantenha o liveness barato e independente das dependências.
3. Pods presos em Pending
- Sintoma: o pod existe e não tem nó. Os eventos do
describedizemFailedSchedulingcom um motivo como0/3 nodes are available: 3 Insufficient cpu,node(s) had untolerated taint,node(s) didn't match Pod's node affinity/selectoroupod has unbound immediate PersistentVolumeClaims. Insufficient cpuoumemory: o scheduler trabalha com os requests, não com o uso. Okubectl describe nodemostraAllocated resources: um nó pode estar 90% requisitado e 20% usado. A correção é mais nós (o cluster autoscaler os adiciona para pods Pending que cabem em um nó novo) ou requests menores, com base no uso medido. Requests superdimensionados são a causa habitual.- Erros de restrição: um taint sem toleration, uma afinidade ou um seletor que não corresponde a nenhum nó, um volume preso a uma zona sem capacidade nessa zona, ou um
ResourceQuota(então o pod pode nem ser criado: olhe os eventos do ReplicaSet em busca deexceeded quota). - Verifique também: as configurações de prioridade e preempção, e se um
PodDisruptionBudgetou um nó isolado (cordoned) está reduzindo a capacidade utilizável.
4. Um rollout que não termina
O kubectl rollout status continua esperando e o Deployment aparece como Progressing até passar o progressDeadlineSeconds (600 por padrão); depois informa ProgressDeadlineExceeded. O Kubernetes não faz rollback sozinho; ele para de avançar e deixa a mistura de pods antigos e novos como está, então o kubectl rollout undo (ou o rollback do seu pipeline) é um passo deliberado. Três problemas diferentes parecem iguais vistos de fora, e eu os simulei com as regras da atualização gradual (16 réplicas, cada uma pedindo 1 CPU, maxSurge 4):
| Situação | Resultado |
|---|---|
um cluster de 16 CPUs, totalmente requisitado, maxUnavailable 0, nova versão saudável | travou: 16 pods antigos prontos, 4 pods novos Pending; não há capacidade para um pod de surge, e nenhum pod antigo pode ser removido antes |
o mesmo cluster, maxUnavailable 4 | terminou em 13 ticks (pods antigos são removidos para abrir espaço) |
mais um nó (24 CPUs), maxUnavailable 0 | terminou em 12 ticks |
| as mesmas 16 CPUs, mas com requests reduzidos para que 20 pods caibam | terminou em 12 ticks |
24 CPUs, maxUnavailable 0, nova versão nunca passa na readiness | travou: 16 pods antigos ainda atendendo, 4 pods novos iniciando mas nunca prontos |
24 CPUs, maxUnavailable 4, nova versão nunca passa na readiness | travou, mas com apenas 12 pods antigos prontos e 8 pods novos não prontos: capacidade já reduzida |
Como distingui-los: pods novos Pending indicam um problema de capacidade ou de escalonamento (seção 3 acima); pods novos Running mas não Ready indicam um problema de probe ou de aplicação (item 2); ImagePullBackOff ou ErrImagePull indica um nome de imagem, uma tag ou credenciais de registry errados; CrashLoopBackOff indica que a nova versão cai (item 1). Previna os travamentos que não são bugs: deixe capacidade sobrando para o surge (ou use um maxUnavailable pequeno), defina os requests a partir de medições, condicione o rollout a um readiness probe que teste a nova versão, use minReadySeconds para que um pod que fica pronto por um segundo e depois falha não conte como saudável, e faça o pipeline falhar e reverter em ProgressDeadlineExceeded, em vez de esperar por uma pessoa.
5. Autoscaling e capacidade
O Horizontal Pod Autoscaler calcula o número de réplicas a partir de uma métrica, pela regra:
desiredReplicas = ceil( currentReplicas × currentMetric / targetMetric )
Por exemplo, 4 pods com 90% de CPU média e uma meta de 60% dão ceil(4 × 90 / 60) = 6 pods. Ele age sobre a CPU relativa aos requests, então requests errados significam escalonamento errado, e precisa de tempo para reagir (atraso das métricas, inicialização do pod, pull da imagem), então não absorve um pico repentino por si só; mantenha folga e escale por um sinal melhor (profundidade da fila, requisições por segundo) onde a CPU é um mau indicador. O cluster autoscaler adiciona nós quando os pods não podem ser agendados. O escalonamento vertical (o VPA) ajusta os requests em vez da quantidade. Veja balanceamento de carga e os argumentos de filas em padrões de resiliência para entender por que operar perto de 100% de utilização é perigoso.
6. Cargas com estado, rede e segurança em resumo
- Estado: o sistema de arquivos de um contêiner é descartável. Os bancos de dados no Kubernetes usam StatefulSets, volumes persistentes e um operador que entende backup, failover e atualizações; muitas equipes preferem um banco de dados gerenciado.
- Rede: cada pod recebe seu próprio IP e pode alcançar todos os outros pods (uma rede plana fornecida por um plugin CNI); os Services dão nomes estáveis por meio do DNS do cluster. As NetworkPolicies restringem quais pods podem se falar e vêm desativadas por padrão (tudo pode falar com tudo) até você escrevê-las.
- Segurança: rode como não root com um sistema de arquivos somente leitura e capabilities removidas; não use contêineres privilegiados nem monte o socket do Docker; use imagens mínimas; restrinja bem as permissões de RBAC (o token da service account de um pod é uma credencial); escaneie as imagens; e lembre que todos os contêineres de um nó compartilham um kernel.
7. Erros comuns
- Tratar um contêiner como uma máquina virtual: entrar nele por SSH, corrigi-lo à mão, guardar estado nele.
- Nenhum limite de memória (um pod pode deixar um nó sem recursos) ou um limite igual à média (mortes por OOM em todo pico).
- Limites de CPU tão baixos que a aplicação é limitada e a latência p99 sofre enquanto a CPU média parece boa.
- Requests muito acima do uso real, ou nenhum.
- Uma readiness probe que sempre diz sim, ou uma liveness probe que depende do banco de dados.
- Nenhum desligamento gracioso: conexões derrubadas a cada deploy.
- Usar a tag
latest, de modo que ninguém sabe o que está rodando. - Segredos embutidos em imagens ou commitados em manifestos.
- Uma réplica de algo que importa, e todas as réplicas em um nó ou zona.
- Tratar o Kubernetes como um objetivo: para um sistema pequeno, um serviço gerenciado de contêineres ou uma única VM podem ser mais simples e suficientes.
8. Coisas a mencionar em uma entrevista
- Um contêiner é um processo com namespaces (visão), cgroups (orçamento) e um sistema de arquivos em camadas; compartilha o kernel do host, ao contrário de uma máquina virtual.
- Limites de memória matam (saída 137, OOMKilled); limites de CPU limitam (latência). Os runtimes precisam ler os limites.
- Camadas de imagem, o cache de camadas, builds multi-stage e por que um segredo apagado continua na imagem.
- O plano de controle (API server, etcd com Raft, scheduler, controladores) e os agentes dos nós (kubelet, kube-proxy); estado desejado e reconciliação.
- Requests contra limits, e como o scheduler coloca pods usando requests.
- Atualizações graduais com surge e indisponibilidade, readiness e o que significa uma implantação parada; probes e desligamento gracioso.
- A fórmula do HPA e seus limites.
Resumo rápido
- Um contêiner é um processo Linux com namespaces, cgroups e um sistema de arquivos raiz em camadas: no experimento, 4 processos visíveis em vez de 71, um limite de 50 MB que matou o processo (saída 137), uma cota de CPU de 20% que deu 21% do tempo e camadas overlay com copy-on-write.
- O Kubernetes mantém o estado desejado que você declara usando controladores, com um API server, etcd (Raft), um scheduler e agentes de nó.
- O scheduler posiciona por requests, que no teste foram 2,7 vezes o que os pods realmente usaram; defina requests e limits a partir de medições.
- As atualizações graduais mantêm a capacidade quando
maxUnavailableé 0, e uma versão quebrada para em vez de derrubar o serviço, desde que a readiness probe seja honesta. - Acrescente desligamento gracioso, orçamentos de disrupção, autoscaling sensato e uma postura de segurança de privilégio mínimo; e use o Kubernetes apenas quando precisar do que ele oferece.
Apêndice: o código dos experimentos
Quatro arquivos. containers.sh é um script de shell que deve rodar como root em um Linux com cgroups versão 1 (na versão 2 os arquivos de controle são memory.max e cpu.max em /sys/fs/cgroup); ele mostra os namespaces de PID e de nome de host, os limites de memória e de CPU e uma montagem overlay, e usa hog.py e spin.py. k8s.py usa apenas a biblioteca padrão do Python e simula o posicionamento first-fit, best-fit e spread e as regras de implantação do Deployment. As contagens de processos, o status de saída 137 e os números de CPU são medições reais de um pequeno sandbox e variam entre máquinas; os resultados de agendamento e de implantação são simulações das regras documentadas com tamanhos de pod aleatórios, não uma execução de um cluster Kubernetes real.
Namespaces, cgroups e camadas de imagem à mão (shell)
#!/bin/bash
# Run as root on Linux with cgroups v1 (as in my sandbox); on cgroups v2 the file names differ (memory.max, cpu.max).
set -u
echo "--- 1. a new PID namespace: the process believes it is the only one"
unshare -p -f --mount-proc -- sh -c 'echo "inside: my pid is $$, processes visible: $(ps -e | wc -l)"'
echo "on the host: processes visible: $(ps -e | wc -l)"
echo "--- 2. a new UTS namespace: its own host name"
unshare -u sh -c 'hostname demo; echo "inside: $(hostname)"'; echo "outside: $(hostname)"
echo "--- 3. a memory limit of 50 MB (hog.py joins the cgroup and allocates 10 MB at a time)"
mkdir -p /sys/fs/cgroup/memory/t1 && echo 52428800 > /sys/fs/cgroup/memory/t1/memory.limit_in_bytes
python3 hog.py; echo "exit status: $? (137 = 128 + 9, killed by SIGKILL)"
echo "limit hits (failcnt): $(cat /sys/fs/cgroup/memory/t1/memory.failcnt)"
echo "--- 4. a CPU quota of 20 ms per 100 ms period = 20% of one core"
mkdir -p /sys/fs/cgroup/cpu/t2
echo 20000 > /sys/fs/cgroup/cpu/t2/cpu.cfs_quota_us; echo 100000 > /sys/fs/cgroup/cpu/t2/cpu.cfs_period_us
python3 spin.py # no limit
python3 spin.py t2 # inside the cgroup with the quota
echo "--- 5. image layers: a read-only lower layer and a writable upper layer"
mkdir -p ov/{lower,upper,work,merged}; echo base > ov/lower/a.txt
mount -t overlay overlay -o lowerdir=ov/lower,upperdir=ov/upper,workdir=ov/work ov/merged
echo changed > ov/merged/a.txt; echo new > ov/merged/b.txt
echo "lower a.txt: $(cat ov/lower/a.txt); upper layer holds: $(ls ov/upper | tr '\n' ' '); merged view of a.txt: $(cat ov/merged/a.txt)"
umount ov/merged; rmdir /sys/fs/cgroup/memory/t1 /sys/fs/cgroup/cpu/t2
hog.py: alocar memória até o limite matar o processo
import os, sys, time
open("/sys/fs/cgroup/memory/t1/cgroup.procs","w").write(str(os.getpid()))
blocks = []
try:
for i in range(40):
blocks.append(bytearray(10*1024*1024));
for j in range(0, len(blocks[-1]), 4096): blocks[-1][j] = 1
print(f"allocated {10*(i+1)} MB", flush=True)
except MemoryError: print("MemoryError")
spin.py: medir a CPU que um processo realmente recebe
import os, sys, time
if len(sys.argv) > 1: open(f"/sys/fs/cgroup/cpu/{sys.argv[1]}/cgroup.procs","w").write(str(os.getpid()))
n = 0; t = time.perf_counter(); user0 = os.times()
while time.perf_counter() - t < 3: n += 1
print(f"{sys.argv[1] if len(sys.argv)>1 else 'no limit':>8}: {n/3/1e6:6.2f} million loop iterations per second, cpu time used {os.times().user - user0.user:.2f} s of 3 s wall")
Simulações de agendamento e de atualização gradual
import random
# ---- 1. scheduling: pods with CPU requests onto nodes of 8 CPUs
def pack(requests, capacity, policy, rnd):
nodes = [] # remaining capacity per node
for r in requests:
fits = [i for i, free in enumerate(nodes) if free >= r]
if policy == "first-fit": i = fits[0] if fits else None
elif policy == "spread": i = max(fits, key=lambda i: nodes[i]) if fits else None # least loaded node first (the default Kubernetes scoring leans this way)
elif policy == "best-fit": i = min(fits, key=lambda i: nodes[i]) if fits else None
if i is None: nodes.append(capacity); i = len(nodes) - 1
nodes[i] -= r
used = sum(requests) / (len(nodes) * capacity)
return len(nodes), used
rnd = random.Random(4)
reqs = [rnd.choice([0.25, 0.5, 1, 1.5, 2, 3]) for _ in range(200)]
print(f"200 pods requesting {sum(reqs):.0f} CPUs in total on 8-CPU nodes (never fewer than {sum(reqs)/8:.1f} nodes):")
for policy in ("first-fit", "best-fit", "spread"):
n, u = pack(reqs, 8, policy, rnd); print(f" {policy:>9}: {n} nodes, {u*100:.0f}% of requested CPU filled")
n, u = pack(sorted(reqs, reverse=True), 8, "best-fit", rnd); print(f" best-fit, largest pods first: {n} nodes, {u*100:.0f}%")
# requests vs real use
use = [r * rnd.uniform(0.1, 0.6) for r in reqs]
print(f"the same pods actually use {sum(use):.0f} CPUs ({sum(use)/sum(reqs)*100:.0f}% of what they requested): requests decide placement, not use")
# ---- 2. rolling update of N replicas, following the Deployment controller's rules:
# total pods <= N + maxSurge, and ready pods >= N - maxUnavailable at every moment
def rolling(n=4, surge=1, unavailable=0, ready_after=2, new_works=True, max_ticks=60):
pods = [{"v": "v1", "age": 99, "ready": True} for _ in range(n)]; min_ready = n; t = 0
while t < max_ticks:
t += 1
for p in pods:
if p["v"] == "v2" and not p["ready"]:
p["age"] += 1; p["ready"] = new_works and p["age"] >= ready_after
# scale up: create new pods while the total stays within N + maxSurge
while len(pods) < n + surge and sum(p["v"] == "v2" for p in pods) < n: pods.append({"v": "v2", "age": 0, "ready": False})
# scale down: delete old pods while the ready count stays at or above N - maxUnavailable
for p in [p for p in pods if p["v"] == "v1"]:
ready = sum(q["ready"] for q in pods)
if ready - (1 if p["ready"] else 0) >= n - unavailable: pods.remove(p)
min_ready = min(min_ready, sum(q["ready"] for q in pods))
if len(pods) == n and all(p["v"] == "v2" and p["ready"] for p in pods): return dict(done=True, ticks=t, min_ready=min_ready, old=0, stuck_new=0)
return dict(done=False, ticks=t, min_ready=min_ready, old=sum(p["v"] == "v1" for p in pods), stuck_new=sum(p["v"] == "v2" and not p["ready"] for p in pods))
for name, kw in (("maxSurge 1, maxUnavailable 0", dict(surge=1, unavailable=0)), ("maxSurge 2, maxUnavailable 1", dict(surge=2, unavailable=1)), ("maxSurge 0, maxUnavailable 1", dict(surge=0, unavailable=1)), ("maxSurge 0, maxUnavailable 4 (recreate-like)", dict(surge=0, unavailable=4))):
r = rolling(**kw); print(f"rolling update of 4 pods, {name}: finished={r['done']} in {r['ticks']} ticks, never fewer than {r['min_ready']} ready pods")
for name, kw in (("maxSurge 1, maxUnavailable 0", dict(surge=1, unavailable=0)), ("maxSurge 1, maxUnavailable 1", dict(surge=1, unavailable=1))):
r = rolling(new_works=False, **kw); print(f"new version never becomes ready, {name}: finished={r['done']}, after {r['ticks']} ticks {r['old']} old pods still serving, {r['stuck_new']} new pods not ready, never fewer than {r['min_ready']} ready pods")
# ---- 3. health checks: liveness vs readiness
print("readiness removes a pod from the load balancer without restarting it; liveness restarts the container; a slow-starting app needs a startup probe")
Requests e limits de CPU em cgroups reais: shares, cota e latência com throttling
Python 3, executado como root em Linux com cgroups v1 (como o script de shell acima). Ele precisa do pequeno auxiliar abaixo, salvo como cg.py; ele cria e remove os próprios grupos.
"""CPU requests and limits on real cgroups (v1, run as root). Requests become cpu.shares: a relative weight that matters only when the CPU is contended.
Limits become a quota (cfs_quota_us per cfs_period_us): a hard cap that applies even when the CPU is idle, and that shows up as latency."""
import multiprocessing as mp, random, subprocess, sys, time
from cg import Group
def spinner(group):
p = subprocess.Popen([sys.executable, "-c", "while True: pass"]); group.add(p.pid); return p
def measure(groups_procs, seconds=4):
t0 = {g.name: g.cpu_seconds() for g, _ in groups_procs}; time.sleep(seconds)
out = {g.name: (g.cpu_seconds() - t0[g.name]) / seconds for g, _ in groups_procs}
for _, p in groups_procs: p.kill(); p.wait()
return out
def part1():
print("1. Requests (shares) and limits (quota) with spinning processes")
a = Group("expA", cpu_shares=1024, cpuset="0"); b = Group("expB", cpu_shares=256, cpuset="0")
res = measure([(a, spinner(a)), (b, spinner(b))])
print(f" two processes on one CPU, shares 1024 and 256 (a request ratio of 4:1): {res['expA']*100:3.0f}% and {res['expB']*100:3.0f}% of the CPU")
res = measure([(b, spinner(b))]); print(f" the process with the small share, alone on the CPU: {res['expB']*100:3.0f}% (a request is not a cap)")
a.remove(); b.remove()
c = Group("expC", quota_us=20_000, cpuset="0"); res = measure([(c, spinner(c))])
print(f" one process alone, limit 0.2 CPU (20 ms per 100 ms), the CPU otherwise idle: {res['expC']*100:3.0f}% (a limit is a cap, even when idle)")
n, th, t = c.throttle(); print(f" throttled in {th} of {n} periods ({100*th/n:.0f}%), {t:.1f} s paused in total"); c.remove()
def worker(conn, ms):
while True:
if conn.recv() is None: return
t0 = time.thread_time()
while time.thread_time() - t0 < ms / 1000: pass
conn.send(1)
def bursty(group, seconds=20, bursts_per_s=3, per_burst=3, ms=25, seed=1):
"""A service with two worker processes; a request is 25 ms of CPU in each worker (50 ms CPU, 25 ms of time on an idle two-core machine).
Page loads arrive as bursts of 3 requests; average load: 3 bursts/s x 3 requests x 50 ms = 0.45 CPU."""
rnd = random.Random(seed); pipes = []; procs = []
for _ in range(2):
parent, child = mp.Pipe(); p = mp.Process(target=worker, args=(child, ms)); p.start(); pipes.append(parent); procs.append(p)
if group:
for p in procs: group.add(p.pid)
arrivals = []; t = 0.0
while t < seconds: t += rnd.expovariate(bursts_per_s); arrivals += [t] * per_burst
cpu0 = group.cpu_seconds() if group else 0; n0 = group.throttle() if group else (0, 0, 0)
start = time.perf_counter(); lat = []
for at in arrivals:
now = time.perf_counter() - start
if at > now: time.sleep(at - now)
for c in pipes: c.send(1)
for c in pipes: c.recv()
lat.append((time.perf_counter() - start - at) * 1000)
wall = time.perf_counter() - start
for c in pipes: c.send(None)
for p in procs: p.join()
used = ((group.cpu_seconds() - cpu0) / wall) if group else float("nan"); n1 = group.throttle() if group else (0, 0, 0)
lat.sort(); q = lambda x: lat[min(len(lat) - 1, int(len(lat) * x))]
return dict(used=used, p50=q(.5), p99=q(.99), worst=lat[-1], periods=n1[0] - n0[0], throttled=n1[1] - n0[1], paused=n1[2] - n0[2])
def part2():
print("\n2. The same bursty service under different CPU limits (average use about 0.45 of a CPU; two cores in this machine)")
print(f" {'limit':<22}{'CPU used':>9}{'p50':>9}{'p99':>9}{'worst':>9} periods throttled")
for label, quota in (("none", None), ("2.0 CPUs", 200_000), ("1.0 CPU", 100_000), ("0.6 CPU", 60_000), ("0.5 CPU", 50_000)):
g = Group("expL", quota_us=quota); r = bursty(g); g.remove()
thr = f"{r['throttled']}/{r['periods']} ({100*r['throttled']/max(1,r['periods']):.0f}%), {r['paused']:.1f} s paused" if quota and r["periods"] else "-"
print(f" {label:<22}{r['used']:>8.2f} {r['p50']:>7.0f} ms{r['p99']:>7.0f} ms{r['worst']:>7.0f} ms {thr}")
if __name__ == "__main__":
part1(); part2()
O auxiliar de cgroups usado pelos scripts de CPU e de memória (cg.py)
"""Tiny helpers for cgroups v1 (run as root). Each experiment creates its own groups under /sys/fs/cgroup/<controller>/<name> and removes them afterwards."""
import os, time
R = "/sys/fs/cgroup"
def w(path, value): open(path, "w").write(str(value))
def r(path): return open(path).read().strip()
class Group:
def __init__(self, name, cpu_shares=None, quota_us=None, period_us=100_000, mem_limit=None, cpuset=None):
self.name = name
for c in ("cpu", "cpuacct", "memory", "cpuset"):
os.makedirs(f"{R}/{c}/{name}", exist_ok=True)
w(f"{R}/cpuset/{name}/cpuset.mems", r(f"{R}/cpuset/cpuset.mems"))
w(f"{R}/cpuset/{name}/cpuset.cpus", cpuset if cpuset is not None else r(f"{R}/cpuset/cpuset.cpus"))
if cpu_shares: w(f"{R}/cpu/{name}/cpu.shares", cpu_shares)
w(f"{R}/cpu/{name}/cpu.cfs_period_us", period_us)
w(f"{R}/cpu/{name}/cpu.cfs_quota_us", quota_us if quota_us else -1)
if mem_limit: w(f"{R}/memory/{name}/memory.limit_in_bytes", mem_limit)
def add(self, pid):
for c in ("cpu", "cpuacct", "memory", "cpuset"): w(f"{R}/{c}/{self.name}/cgroup.procs", pid)
def cpu_seconds(self): return int(r(f"{R}/cpuacct/{self.name}/cpuacct.usage")) / 1e9
def throttle(self):
d = dict(l.split() for l in open(f"{R}/cpu/{self.name}/cpu.stat")); return int(d["nr_periods"]), int(d["nr_throttled"]), int(d["throttled_time"]) / 1e9
def mem(self, f): return int(r(f"{R}/memory/{self.name}/{f}"))
def stat(self): return {k: int(v) for k, v in (l.split() for l in open(f"{R}/memory/{self.name}/memory.stat"))}
def remove(self):
for c in ("cpu", "cpuacct", "memory", "cpuset"):
try: os.rmdir(f"{R}/{c}/{self.name}")
except OSError: pass
Limits de memória: um limit definido a partir da média e um teste de cache de páginas que não mostrou efeito aqui
Os mesmos requisitos. O segundo teste está incluído por completude: no meu sandbox ele não mostrou diferença entre os dois limits, então o seu resultado não é usado no texto.
"""Memory limits on real cgroups (v1, run as root): a limit set from the average use, and page-cache pressure below the working set."""
import os, subprocess, sys, time
from cg import Group, w, r
MB = 1 << 20
SPIKY = r'''
import os, sys, time
open("/sys/fs/cgroup/memory/%s/cgroup.procs" % sys.argv[1], "w").write(str(os.getpid()))
base = bytearray(40 * 1024 * 1024)
for i in range(0, len(base), 4096): base[i] = 1 # a steady 40 MB working set
for n in range(6):
time.sleep(0.4)
spike = bytearray(50 * 1024 * 1024) # a 50 MB peak (a big request, a report, a batch) held for 0.2 s
for i in range(0, len(spike), 4096): spike[i] = 1
print("peak", n + 1, "survived", flush=True); time.sleep(0.2); del spike
'''
def part1():
print("1. A memory limit set from the average, and one set above the peak (40 MB steady, a 50 MB peak for 0.2 s every 0.6 s; average use about 57 MB)")
for label, limit in (("limit 64 MB (close to the average)", 64 * MB), ("limit 128 MB (above the peak)", 128 * MB)):
g = Group("expM", mem_limit=limit)
p = subprocess.run([sys.executable, "-c", SPIKY, "expM"], capture_output=True, text=True)
peaks = p.stdout.count("survived")
print(f" {label:<36} exit status {p.returncode:>4}{' (128 + 9: killed with SIGKILL, OOMKilled in Kubernetes)' if p.returncode == -9 else '':<60} peaks survived {peaks}/6, highest use {g.mem('memory.max_usage_in_bytes')/MB:.0f} MB, limit hits {g.mem('memory.failcnt')}")
g.remove()
def part2(file_mb=300, passes=3):
print(f"\n2. Page cache counts against the limit: reading a {file_mb} MB file {passes} times in a container")
path = "/var/tmp/cachefile.bin"
if not os.path.exists(path) or os.path.getsize(path) != file_mb * MB:
with open(path, "wb") as f:
for _ in range(file_mb): f.write(os.urandom(MB))
reader = r'''
import os, sys, time
open("/sys/fs/cgroup/memory/%s/cgroup.procs" % sys.argv[1], "w").write(str(os.getpid()))
for n in range(int(sys.argv[3])):
t = time.perf_counter(); size = 0
with open(sys.argv[2], "rb", buffering=0) as f:
while chunk := f.read(1 << 20): size += len(chunk)
print(f"{size / (1 << 20) / (time.perf_counter() - t):.0f}", flush=True)
'''
for label, limit in (("limit 100 MB (less than the file)", 100 * MB), ("limit 600 MB (more than the file)", 600 * MB)):
w("/proc/sys/vm/drop_caches", 3)
g = Group("expP", mem_limit=limit)
p = subprocess.run([sys.executable, "-c", reader, "expP", path, str(passes)], capture_output=True, text=True)
st = g.stat()
print(f" {label:<36} MB/s per pass: {' -> '.join(p.stdout.split())}; cache kept at the end {st['cache']/MB:.0f} MB, major page faults {st.get('total_pgmajfault', 0)}, limit hits {g.mem('memory.failcnt')}")
g.remove()
if __name__ == "__main__":
part1(); part2()
Rollouts que travam: pods de surge pendentes e readiness que nunca passa
Python 3, apenas biblioteca padrão.
"""Why a rollout stalls: a Deployment update with and without spare capacity, and with a new version that never becomes ready.
The same rules as the rolling-update model above, plus a cluster that can only schedule as many pods as their requests allow."""
def rollout(replicas, capacity, surge, unavailable, new_works=True, ready_after=2, max_ticks=80):
"""capacity = how many of these pods the cluster can schedule at once (free CPU by request / the pod's request)."""
pods = [dict(v="v1", state="ready", age=0) for _ in range(replicas)]
for t in range(1, max_ticks + 1):
for p in pods: # new pods become ready after their start-up (if the new version works)
if p["v"] == "v2" and p["state"] == "starting":
p["age"] += 1
if new_works and p["age"] >= ready_after: p["state"] = "ready"
scheduled = sum(p["state"] != "pending" for p in pods)
for p in pods: # the scheduler places a Pending pod only if requests fit
if p["state"] == "pending" and scheduled < capacity: p["state"] = "starting"; scheduled += 1
while len(pods) < replicas + surge and sum(p["v"] == "v2" for p in pods) < replicas:
pods.append(dict(v="v2", state="starting" if scheduled < capacity else "pending", age=0)); scheduled += pods[-1]["state"] != "pending"
for p in [p for p in pods if p["v"] == "v1"]: # the controller removes an old pod only if enough pods stay ready
ready = sum(q["state"] == "ready" for q in pods)
if ready - 1 >= replicas - unavailable: pods.remove(p)
if len(pods) == replicas and all(p["v"] == "v2" and p["state"] == "ready" for p in pods):
return f"finished in {t} ticks"
c = lambda v, s: sum(p["v"] == v and p["state"] == s for p in pods)
return f"STALLED after {max_ticks} ticks: {c('v1','ready')} old pods ready, {c('v2','ready')} new ready, {c('v2','starting')} new starting but never ready, {c('v2','pending')} new Pending"
if __name__ == "__main__":
print("16 replicas of a pod requesting 1 CPU; maxSurge 4 (25%)")
cases = [
("cluster of 16 CPUs (100% requested), maxUnavailable 0, healthy new version", dict(capacity=16, surge=4, unavailable=0)),
("same cluster, maxUnavailable 4", dict(capacity=16, surge=4, unavailable=4)),
("same cluster plus one more node (24 CPUs), maxUnavailable 0", dict(capacity=24, surge=4, unavailable=0)),
("same cluster with requests lowered so that 20 pods fit, maxUnavailable 0", dict(capacity=20, surge=4, unavailable=0)),
("24 CPUs, maxUnavailable 0, but the new version never passes its readiness probe", dict(capacity=24, surge=4, unavailable=0, new_works=False)),
("24 CPUs, maxUnavailable 4, the new version never passes its readiness probe", dict(capacity=24, surge=4, unavailable=4, new_works=False)),
]
for label, kw in cases: print(f" {label}:\n {rollout(16, **kw)}")
Fontes
- Páginas de manual do Linux: namespaces(7), cgroups(7), unshare(1).
- Documentação do kernel Linux: Overlay Filesystem e o guia de administração do cgroup v2, incluindo o controle de largura de banda de CPU.
- Documentação do Kubernetes: Cluster architecture, Deployments (atualização gradual, maxSurge e maxUnavailable), Resource management for pods and containers, Configure liveness, readiness and startup probes e Horizontal Pod Autoscaling.
- Open Container Initiative, Image and runtime specifications.
- Brendan Burns, Brian Grant, David Oppenheimer, Eric Brewer e John Wilkes, Borg, Omega, and Kubernetes, ACM Queue (2016).
- Documentação do Docker, Best practices for writing Dockerfiles e multi-stage builds.
- Documentação do Kubernetes: Resource Management for Pods and Containers, Pod Quality of Service Classes, Node-pressure Eviction, Debug Pods e Deployments (prazo de progresso, rollback).
- Documentação do kernel Linux: CFS Bandwidth Control (cota, período, estatísticas de throttling) e Pressure Stall Information.
Pratique este tema: DevOps & Cloud