Kubernetes Basics · Aula

Solicitações e limites de recursos

Defina solicitações e limites de CPU e memória para os pods, garantindo uma alocação eficiente de recursos e evitando seu esgotamento.

Solicitações e limites de recursos é uma aula grátis de Kubernetes Basics no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kubernetes Basics, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kubernetes Basics inclui 4 aulas no total.

Necessidades de recursos no Kubernetes

Assim como qualquer aplicação, seus Pods precisam de recursos para funcionar. O Kubernetes ajuda a gerenciar esses recursos com eficiência usando solicitações de recursos e limites de recursos.

Essas configurações informam ao Kubernetes quanto de CPU e memória seus Pods precisam e quanto podem usar, garantindo uma distribuição justa dos recursos.

Solicitações de CPU: garantindo CPU

Uma solicitação de CPU informa ao Kubernetes a quantidade mínima de CPU de que seu Pod precisa para funcionar adequadamente. É uma garantia!

O Kubernetes usa as solicitações para agendar Pods em nós com recursos disponíveis suficientes.
Se um nó não tiver CPU suficiente para atender à solicitação, o Pod não será agendado nele.
Isso ajuda a evitar a falta de recursos para suas aplicações críticas.

Unidades de CPU e exemplo de solicitação

A CPU é medida em "núcleos" ou "milinúcleos" (m). 1000m equivale a 1 núcleo de CPU. Portanto, 500m corresponde à metade de um núcleo.

Veja como solicitar 0,5 núcleo de CPU na definição de um Pod:

apiVersion: v1
kind: Pod
metadata:
  name: cpu-request-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      requests:
        cpu: "500m"

Limites de CPU: evitando o uso excessivo

Um limite de CPU define a quantidade máxima de CPU que um Pod pode usar. É um teto.

Se um Pod tentar usar mais CPU do que o seu limite, o Kubernetes irá restringi-lo.
Isso significa que o uso de CPU do Pod será limitado, evitando que ele consuma excessivamente os recursos de outros Pods no mesmo nó.

Limite de CPU em ação

Veja um exemplo de configuração de um limite de CPU. Se esse Pod tentar usar mais de 1 núcleo de CPU, seu uso será restringido, o que limitará seu desempenho.

apiVersion: v1
kind: Pod
metadata:
  name: cpu-limit-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      limits:
        cpu: "1"

Solicitações de memória: garantindo RAM

Assim como a CPU, uma solicitação de memória especifica a quantidade mínima de RAM de que seu Pod precisa para funcionar.

O Kubernetes usa essa informação para encontrar um nó com memória livre suficiente para o seu Pod.
Se um nó ficar sem memória, os Pods sem solicitações geralmente são os primeiros a ser encerrados (expulsos) para liberar espaço.

Unidades de memória e exemplo de solicitação

A memória é medida em bytes. As unidades comuns são Mi (mebibytes) e Gi (gibibytes).

100Mi corresponde a 100 mebibytes. Veja como solicitar 256 MiB de memória:

apiVersion: v1
kind: Pod
metadata:
  name: mem-request-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      requests:
        memory: "256Mi"

Limites de memória: evitando OOM

Um limite de memória define a quantidade máxima de memória que um Pod pode consumir.

Se um Pod exceder seu limite de memória, ele será encerrado imediatamente pelo sistema operacional com um erro de "falta de memória" (OOM). Isso costuma aparecer como "OOMKilled".
Isso impede que um único Pod descontrolado consuma toda a memória do nó e faça o nó inteiro falhar.

Limite de memória em ação

Este Pod tem um limite de memória de 512 MiB. Se tentar usar mais, será encerrado (OOMKilled) para proteger as outras cargas de trabalho e o nó.

apiVersion: v1
kind: Pod
metadata:
  name: mem-limit-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      limits:
        memory: "512Mi"

Práticas recomendadas: solicitações e limites

É uma prática recomendada definir tanto solicitações quanto limites para todos os seus Pods. Isso proporciona estabilidade e previsibilidade ao seu cluster.

As solicitações garantem que seus Pods recebam os recursos mínimos necessários para o agendamento.
Os limites impedem a escassez de recursos para outros Pods e para o próprio nó.

Veja um exemplo completo:

apiVersion: v1
kind: Pod
metadata:
  name: full-resource-pod
spec:
  containers:
  - name: my-app
    image: my-registry/my-app:1.0
    resources:
      requests:
        cpu: "200m"
        memory: "128Mi"
      limits:
        cpu: "500m"
        memory: "256Mi"

Verificação de recursos

Você tem um Pod definido com uma solicitação de CPU de 200m e um limite de CPU de 1 (que corresponde a 1000m).

O que acontece se este Pod tentar usar 1.5 núcleos de CPU?

Recapitulação: gerenciamento de recursos

Nesta lição, aprendemos sobre solicitações de recursos e limites de recursos no Kubernetes.

As solicitações (CPU e memória) garantem os recursos mínimos para o agendamento do Pod.
Os limites (CPU e memória) restringem o uso máximo para evitar a disputa por recursos.
Exceder os limites de CPU causa limitação; exceder os limites de memória causa o encerramento (OOMKilled).
Defina sempre tanto as solicitações quanto os limites para obter um desempenho estável e previsível dos aplicativos!

Perguntas Frequentes

A aula “Solicitações e limites de recursos” é grátis?

Sim — o texto completo de “Solicitações e limites de recursos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kubernetes Basics, atualize para CoddyKit PRO. O curso de Kubernetes Basics inclui 4 aulas no total.

O que vou aprender em “Solicitações e limites de recursos”?

Defina solicitações e limites de CPU e memória para os pods, garantindo uma alocação eficiente de recursos e evitando seu esgotamento. Você pratica Kubernetes Basics com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kubernetes Basics?

Nenhuma experiência prévia é necessária. Kubernetes Basics no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Solicitações e limites de recursos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kubernetes Basics?

Sim. Cada aula de Kubernetes Basics inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kubernetes Basics