Sem limites, um pod pode consumir sozinho a CPU e a memória de um nó inteiro e derrubar serviços vizinhos por pressão de recursos — sem exploit, sem malware, apenas um manifesto sem restrição. Times que compartilham um cluster em plataforma interna ou em nuvem gerenciada são os mais expostos: uma carga mal dimensionada ou um contêiner comprometido usado para mineração transforma um namespace em prejuízo coletivo. A ação prioritária é nativa e barata: ativar ResourceQuota e LimitRange em todo namespace de workload, para que a decisão sobre consumo de recursos seja tomada na admissão, antes do agendamento.
O risco do pod sem limites
A documentação do Kubernetes resume o problema em uma frase: por padrão, contêineres executam com recursos de computação sem limite em um cluster. O efeito prático aparece em dois cenários. No primeiro, o acidente: um loop mal calibrado em um job consome núcleos e memória até o nó entrar em pressão, evictar pods vizinhos e degradar serviços que nada têm a ver com o incidente. No segundo, o ataque: um contêiner invadido que executa mineração de criptomoedas depende exatamente do que falta na defesa — um teto de consumo que torne o roubo de ciclos de CPU economicamente inútil.
O guia de segurança de contêineres do NIST estabelece o princípio que fundamenta essa defesa: nenhum contêiner deve conseguir interferir na operação de outro que compartilha o mesmo kernel. No Linux, essa garantia depende da alocação de recursos aplicada por control groups (cgroups), o mecanismo que o kubelet usa para transformar o campo limits de um manifesto em limite real do kernel. Sem esse campo preenchido, o mecanismo não tem o que aplicar — e o isolamento entre cargas fica na boa vontade de cada equipe.
Como o ResourceQuota funciona
O ResourceQuota é um objeto por namespace que limita o consumo agregado: a soma de requests e limits de CPU e memória, o armazenamento solicitado por claims persistentes e até a quantidade de objetos por tipo, como services e secrets. O ponto de aplicação é a admissão: quando a criação ou atualização de um recurso viola a cota, a criação do pod é rejeitada com HTTP 403 antes de entrar em fila de agendamento, com mensagem que explica qual restrição seria violada. O time descobre o problema no deploy, e não no incidente de nó sem recursos.
Há dois detalhes operacionais que evitam falsa sensação de segurança. Primeiro, a documentação avisa que nem contenção nem mudanças na cota afetam recursos já criados — um Deployment existente continua no ar mesmo quando o namespace passa do teto. Segundo, um Deployment cujos pods não cabem na cota é criado com sucesso, mas seus pods não sobem; o sinal aparece no status do objeto, com kubectl describe, e não em um erro de API. Quem monitora apenas o sucesso do apply enxerga silêncio onde há contenção.
Quando a cota cobre CPU ou memória, todo pod novo do namespace precisa declarar requests ou limits — caso contrário, a própria admissão pode ser rejeitada. É aqui que um time sem disciplina de manifesto quebra o pipeline. A saída oficial é complementar a cota com um LimitRange que injeta padrões automaticamente.
apiVersion: v1
kind: ResourceQuota
metadata:
name: cota-equipe-pedidos
spec:
hard:
requests.cpu: '4'
requests.memory: 8Gi
limits.cpu: '8'
limits.memory: 16Gi
pods: '20'
Os valores acima são ilustrativos. O critério de definição é o consumo observado por namespace com margem para picos — cota calculada no chute bloqueia tanto quanto a falta de cota.
LimitRange e a injeção de padrões
O LimitRange atua na mesma fronteira de admissão, mas no nível do objeto: define mínimo, máximo e razão entre request e limit por contêiner e, principalmente, estabelece padrões. Contêineres criados sem requisitos de recursos recebem automaticamente valores padrão de CPU e memória injetados na admissão, o que elimina a rejeição em massa de pods legados e fecha a brecha mais comum na adoção de cotas.
apiVersion: v1
kind: LimitRange
metadata:
name: padrao-cpu
spec:
limits:
- default:
cpu: 500m
defaultRequest:
cpu: 500m
max:
cpu: '1'
min:
cpu: 100m
type: Container
Dois avisos da documentação pesam na operação. O LimitRange não verifica a consistência dos padrões que aplica: um pod que declara request de 700m sem limit pode receber um padrão inferior ao próprio request e ficar não agendável, com erro que aponta request acima do limite. E a validação ocorre apenas na admissão — pods já em execução não são tocados quando a política é criada ou alterada. A correção vem de rollout e revisão de manifesto, não de ajuste mágico em produção.
| Camada | O que limita | Quando age | Limite conhecido |
|---|---|---|---|
| Nenhuma política | Nada | Nunca | Qualquer pod pode esgotar o nó |
| ResourceQuota | Soma de recursos e objetos por namespace | Admissão de novos objetos | Não afeta recursos já criados |
| LimitRange | Mínimo, máximo e padrões por contêiner | Admissão de pods novos | Não valida pods em execução |
Procedimento em quatro passos
- P1 — Auditoria. Liste os namespaces sem política com
kubectl get resourcequota -Aekubectl get limitrange -A. Namespace de workload sem nenhum dos dois é a fila de incidentes de amanhã. - P1 — Baseline. Meça o consumo real de cada namespace por pelo menos uma semana e defina as cotas a partir dele com margem para picos. Sem medição, cota vira chute — e chute derruba deploy legítimo.
- P1 — Padrões antes do teto. Aplique o LimitRange antes do ResourceQuota, para que pods sem requests recebam valores automáticos em vez de rejeição sumária na primeira cota ativa.
- P2 — Sistema e alerta. Proteja namespaces de sistema com cota por escopo de PriorityClass, como no exemplo oficial para o kube-system, e crie alerta para eventos de cota excedida em cada namespace.
Pontos cegos e sinais
Cotas resolvem esgotamento, não invasão. Um pod dentro dos limites ainda executa código malicioso — para isso existem as camadas de detecção de execução, que monitoram comportamento e não consumo. A cota também não impede que um contêiner comprometido tente roubar credenciais do nó, risco que começa na leitura do serviço de metadados e é tratado na prática no guia de IMDSv2. E antes de dimensionar qualquer política, o time precisa saber o que roda em cada namespace — uma tarefa de inventário de ativos, não de adivinhação.
Os sinais a monitorar são objetivos: eventos de cota excedida por namespace, pods rejeitados na admissão, Deployments com réplicas abaixo do desejado e consumo colado no teto definido. Quando o uso encosta no limite configurado, a resposta é revisar a cota com dados — não remover o freio que ainda segurou o nó.