Introducción
El laboratorio anterior se centró en las solicitudes (requests) y límites (limits) de recursos dentro de Pods y Deployments individuales. Un ResourceQuota traslada ese concepto al nivel del namespace. Permite que un equipo o el administrador de la plataforma establezca límites, como cuántos Pods pueden existir, cuánta CPU se puede solicitar y cuánta memoria se puede limitar en un solo namespace.
En este laboratorio, creará un ResourceQuota para un namespace, inspeccionará sus límites estrictos, observará cómo Kubernetes rechaza un Pod que no declara los recursos requeridos y, finalmente, ejecutará Pods compatibles hasta que el namespace alcance su cuota de cantidad de Pods.
Preparar un namespace para practicar cuotas
En este paso, preparará un namespace limpio para practicar con ResourceQuota.
Comience en /home/labex/project. Escribirá los manifiestos de cuota y de Pod en este directorio.
mkdir -p /home/labex/project
cd /home/labex/project
Verifique que el servidor de API de Kubernetes sea accesible. Si la máquina virtual acaba de iniciarse y el nodo aún no está listo, espere unos segundos y vuelva a ejecutar el comando.
kubectl get nodes --request-timeout=5s
La salida esperada incluye:
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Espere hasta que el Pod de red del clúster esté en estado Ready antes de crear los Pods de la aplicación.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Salida esperada:
pod/calico-node-... condition met
Cree un namespace llamado ckad-prep-quotas:
kubectl create namespace ckad-prep-quotas
Establezca este namespace como el namespace del contexto actual:
kubectl config set-context --current --namespace=ckad-prep-quotas
Confirme el namespace actual:
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
Salida esperada:
ckad-prep-quotas
Crear un ResourceQuota de Namespace
En este paso, creará un ResourceQuota que limita tanto el recuento de objetos como el total de recursos solicitados.
La cuota pods limita cuántos Pods pueden existir en el namespace. Las cuotas requests.* y limits.* rastrean la suma de las solicitudes y límites de recursos declarados por todos los Pods coincidentes. Cuando un namespace tiene entradas de cuota para solicitudes o límites de CPU y memoria, los nuevos Pods deben declarar esos campos para que Kubernetes pueda contabilizarlos.
Cree 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 la cuota:
kubectl apply -f app-resource-quota.yaml
Salida esperada:
resourcequota/app-resource-quota created
Inspeccione la cuota. En este punto, no hay Pods ejecutándose en el namespace, por lo que los valores utilizados deberían ser cero.
kubectl describe resourcequota app-resource-quota
La salida esperada incluye:
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 un Pod rechazado por la cuota
En este paso, intentará crear un Pod sin solicitudes ni límites de recursos.
Este Pod está incompleto a propósito. Debido a que la cuota del namespace rastrea las solicitudes y límites de CPU y memoria, Kubernetes no puede admitir un Pod que omita esos campos. Este es un error útil de reconocer en las tareas de CKAD: el manifiesto puede ser un YAML válido, pero la admisión puede rechazarlo debido a la política del namespace.
Cree 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
Intente aplicar el manifiesto. El || true al final permite que su shell continúe después del error esperado para que pueda inspeccionar el resultado.
kubectl apply -f no-resources-pod.yaml || true
La salida esperada incluye:
Error from server (Forbidden): error when creating "no-resources-pod.yaml": pods "no-resources" is forbidden: failed quota
Confirme que el Pod no fue creado:
kubectl get pod no-resources
La salida esperada incluye:
Error from server (NotFound): pods "no-resources" not found
Verifique que la cuota todavía muestre cero Pods en uso:
kubectl get resourcequota app-resource-quota -o 'jsonpath={.status.used.pods}{"\n"}'
Salida esperada:
0
Ejecutar Pods compatibles hasta llenar la cuota
En este paso, creará Pods que incluyen solicitudes y límites de recursos, y luego observará cómo la cuota de cantidad de Pods detiene un tercer Pod.
Cada Pod válido a continuación solicita 100m de CPU y 64Mi de memoria, y se limita a 200m de CPU y 128Mi de memoria. Dos de estos Pods caben dentro de la cuota. Un tercer Pod tiene campos de recursos válidos, pero el namespace solo permite dos Pods.
Cree 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 el manifiesto y espere a que ambos Pods estén listos:
kubectl apply -f quota-workers.yaml
kubectl wait --for=condition=Ready pod/quota-worker-a pod/quota-worker-b --timeout=120s
Salida esperada:
pod/quota-worker-a created
pod/quota-worker-b created
pod/quota-worker-a condition met
pod/quota-worker-b condition met
Inspeccione el uso de la cuota:
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"}'
Salida esperada:
2 200m 128Mi 400m 256Mi
Cree un tercer Pod con 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
La salida esperada incluye:
Error from server (Forbidden): error when creating "quota-worker-c.yaml": pods "quota-worker-c" is forbidden: exceeded quota
Resumen
Ha creado un ResourceQuota de namespace, inspeccionado sus límites estrictos, observado cómo Kubernetes rechaza un Pod que omitía los campos de recursos requeridos y ejecutado Pods compatibles hasta que el namespace alcanzó su límite de cantidad de Pods. Esto conecta la configuración de recursos de contenedores individuales con la gobernanza de recursos a nivel de namespace.
