Introdução
O laboratório anterior focou em solicitações (requests) e limites (limits) de recursos dentro de Pods e Deployments individuais. Um ResourceQuota eleva esse conceito ao nível do namespace. Ele permite que uma equipe ou proprietário de plataforma defina limites, como quantos Pods podem existir, quanto de CPU pode ser solicitado e quanto de memória pode ser limitado em um único namespace.
Neste laboratório, você criará um ResourceQuota de namespace, inspecionará seus limites rígidos, observará o Kubernetes rejeitar um Pod que não declara os recursos necessários e, em seguida, executará Pods em conformidade até que o namespace atinja sua cota de contagem de Pods.
Preparar um Namespace para Prática de Cotas
Nesta etapa, você preparará um namespace limpo para praticar o ResourceQuota.
Comece em /home/labex/project. Você escreverá os manifestos de cota e de Pod neste diretório.
mkdir -p /home/labex/project
cd /home/labex/project
Verifique se o servidor da API do Kubernetes está acessível. Se a VM acabou de iniciar e o nó ainda não está pronto, aguarde alguns segundos e execute o comando novamente.
kubectl get nodes --request-timeout=5s
A saída esperada inclui:
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Aguarde até que o Pod de rede do cluster esteja pronto (Ready) antes de criar os Pods da aplicação.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Saída esperada:
pod/calico-node-... condition met
Crie um namespace chamado ckad-prep-quotas:
kubectl create namespace ckad-prep-quotas
Defina este namespace como o namespace do contexto atual:
kubectl config set-context --current --namespace=ckad-prep-quotas
Confirme o namespace atual:
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
Saída esperada:
ckad-prep-quotas
Criar um ResourceQuota de Namespace
Nesta etapa, você criará um ResourceQuota que limita tanto a contagem de objetos quanto o total de recursos solicitados.
A cota pods limita quantos Pods podem existir no namespace. As cotas requests.* e limits.* rastreiam a soma das solicitações e limites de recursos declarados por todos os Pods correspondentes. Quando um namespace possui entradas de cota para solicitações ou limites de CPU e memória, os novos Pods devem declarar esses campos para que o Kubernetes possa contabilizá-los.
Crie o arquivo app-resource-quota.yaml:
cat > app-resource-quota.yaml <<'EOF'
apiVersion: v1
kind: ResourceQuota
metadata:
name: app-resource-quota
spec:
hard:
pods: "2"
requests.cpu: "400m"
requests.memory: 256Mi
limits.cpu: "800m"
limits.memory: 512Mi
EOF
Aplique a cota:
kubectl apply -f app-resource-quota.yaml
Saída esperada:
resourcequota/app-resource-quota created
Inspecione a cota. Neste ponto, nenhum Pod está em execução no namespace, portanto, os valores utilizados devem ser zero.
kubectl describe resourcequota app-resource-quota
A saída esperada inclui:
Name: app-resource-quota
Resource Used Hard
limits.cpu 0 800m
limits.memory 0 512Mi
pods 0 2
requests.cpu 0 400m
requests.memory 0 256Mi
Observar um Pod Rejeitado pela Cota
Nesta etapa, você tentará criar um Pod sem solicitações e limites de recursos.
Este Pod está intencionalmente incompleto. Como a cota do namespace rastreia as solicitações e limites de CPU e memória, o Kubernetes não pode admitir um Pod que omita esses campos. Esta é uma falha útil de reconhecer em tarefas do CKAD: o manifesto pode ser um YAML válido, mas a admissão ainda pode rejeitá-lo devido à política do namespace.
Crie o arquivo no-resources-pod.yaml:
cat > no-resources-pod.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: no-resources
labels:
app: no-resources
spec:
terminationGracePeriodSeconds: 0
containers:
- name: app
image: busybox:1.36
command:
- /bin/sh
- -c
- 'sleep 3600'
EOF
Tente aplicar o manifesto. O || true no final permite que seu shell continue após o erro esperado, para que você possa inspecionar o resultado.
kubectl apply -f no-resources-pod.yaml || true
A saída esperada inclui:
Error from server (Forbidden): error when creating "no-resources-pod.yaml": pods "no-resources" is forbidden: failed quota
Confirme que o Pod não foi criado:
kubectl get pod no-resources
A saída esperada inclui:
Error from server (NotFound): pods "no-resources" not found
Verifique se a cota ainda mostra zero Pods em uso:
kubectl get resourcequota app-resource-quota -o 'jsonpath={.status.used.pods}{"\n"}'
Saída esperada:
0
Executar Pods em Conformidade até que a Cota esteja Cheia
Nesta etapa, você criará Pods que incluem solicitações e limites de recursos e, em seguida, observará a cota de contagem de Pods impedir um terceiro Pod.
Cada Pod válido abaixo solicita 100m de CPU e 64Mi de memória, e limita-se a 200m de CPU e 128Mi de memória. Dois desses Pods cabem dentro da cota. Um terceiro Pod possui campos de recursos válidos, mas o namespace permite apenas dois Pods.
Crie o arquivo quota-workers.yaml:
cat > quota-workers.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: quota-worker-a
labels:
app: quota-worker
spec:
terminationGracePeriodSeconds: 0
containers:
- name: app
image: busybox:1.36
command: ["/bin/sh", "-c", "echo worker-a-ready; sleep 3600"]
resources:
requests:
cpu: 100m
memory: 64Mi
limits:
cpu: 200m
memory: 128Mi
---
apiVersion: v1
kind: Pod
metadata:
name: quota-worker-b
labels:
app: quota-worker
spec:
terminationGracePeriodSeconds: 0
containers:
- name: app
image: busybox:1.36
command: ["/bin/sh", "-c", "echo worker-b-ready; sleep 3600"]
resources:
requests:
cpu: 100m
memory: 64Mi
limits:
cpu: 200m
memory: 128Mi
EOF
Aplique o manifesto e aguarde por ambos os Pods:
kubectl apply -f quota-workers.yaml
kubectl wait --for=condition=Ready pod/quota-worker-a pod/quota-worker-b --timeout=120s
Saída esperada:
pod/quota-worker-a created
pod/quota-worker-b created
pod/quota-worker-a condition met
pod/quota-worker-b condition met
Inspecione o uso da cota:
kubectl get resourcequota app-resource-quota -o 'jsonpath={.status.used.pods}{" "}{.status.used.requests\.cpu}{" "}{.status.used.requests\.memory}{" "}{.status.used.limits\.cpu}{" "}{.status.used.limits\.memory}{"\n"}'
Saída esperada:
2 200m 128Mi 400m 256Mi
Crie um terceiro Pod com recursos válidos:
cat > quota-worker-c.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: quota-worker-c
labels:
app: quota-worker
spec:
terminationGracePeriodSeconds: 0
containers:
- name: app
image: busybox:1.36
command: ["/bin/sh", "-c", "sleep 3600"]
resources:
requests:
cpu: 100m
memory: 64Mi
limits:
cpu: 200m
memory: 128Mi
EOF
kubectl apply -f quota-worker-c.yaml || true
A saída esperada inclui:
Error from server (Forbidden): error when creating "quota-worker-c.yaml": pods "quota-worker-c" is forbidden: exceeded quota
Resumo
Você criou um ResourceQuota de namespace, inspecionou seus limites rígidos, observou o Kubernetes rejeitar um Pod que omitiu campos de recursos obrigatórios e executou Pods em conformidade até que o namespace atingisse seu limite de contagem de Pods. Isso conecta as configurações de recursos de contêineres individuais com a governança de recursos em nível de namespace.
