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

MecanismoO que limitaA mentira que conta
Namespaceso 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"
cgroupsquanto 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 camadasquais 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:

OndeProcessos visíveis
dentro do novo namespace de PID4, e o shell se vê como PID 1
no host71

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çãoIterações do laço por segundoTempo de CPU usado em 3 segundos
sem limite6,45 milhões2,94 s
cota de 20% de um núcleo1,30 milhão0,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:

CamadaConteúdo
inferior (somente leitura)a.txt = base (intocado)
superior (gravável)a.txt (a cópia alterada) e b.txt
visão mescladaa.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:

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

Os principais objetos

ObjetoO que é
Poda 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
Serviceum 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 / Gatewayroteamento HTTP de fora do cluster para os Services
ConfigMap, Secretconfiguraçã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
StatefulSetpods com identidades estáveis e seus próprios volumes persistentes, para bancos de dados e coisas semelhantes
Job, CronJobexecutam até terminar, uma vez ou em um agendamento
HorizontalPodAutoscalermuda 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íticaNós usadosCPU requisitada preenchida
first fit3198%
best fit3198%
spread (nó menos carregado primeiro)3295%

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.

CPUMemória
Requestusado pelo scheduler para posicionar o pod; vira um peso relativo (cpu.shares) que só importa quando há disputa por CPUusado pelo scheduler para posicionar o pod; nada é imposto em tempo de execução, mas decide quem é removido primeiro quando o nó fica sem recursos
Limitum 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 mortoum 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 CPUCPU realmente usadap50p99Períodos limitados
nenhum0,4955 ms194 ms
2,0 CPUs (sem efeito)0,4955 ms189 ms0 de 122
1,0 CPU0,4997 ms559 ms71 de 144 (49%)
0,6 CPU0,48306 ms1.834 ms151 de 184 (82%)
0,5 CPU0,47653 ms2.559 ms192 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óriaResultado
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égiaPassos até terminarMenos pods prontos durante a atualização
maxSurge 1, maxUnavailable 0124
maxSurge 2, maxUnavailable 163
maxSurge 0, maxUnavailable 1 (não precisa de capacidade extra)133
maxSurge 0, maxUnavailable 4 (como a estratégia Recreate)40

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

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

2. Pods Running, mas não Ready (readiness probes falhando)

3. Pods presos em Pending

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çãoResultado
um cluster de 16 CPUs, totalmente requisitado, maxUnavailable 0, nova versão saudáveltravou: 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 4terminou em 13 ticks (pods antigos são removidos para abrir espaço)
mais um nó (24 CPUs), maxUnavailable 0terminou em 12 ticks
as mesmas 16 CPUs, mas com requests reduzidos para que 20 pods caibamterminou em 12 ticks
24 CPUs, maxUnavailable 0, nova versão nunca passa na readinesstravou: 16 pods antigos ainda atendendo, 4 pods novos iniciando mas nunca prontos
24 CPUs, maxUnavailable 4, nova versão nunca passa na readinesstravou, 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

7. Erros comuns

8. Coisas a mencionar em uma entrevista

Resumo rápido

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

Pratique este tema: DevOps & Cloud

Mais guias