Einführung
Im vorherigen Lab haben wir uns auf Ressourcenanforderungen (Requests) und Limits innerhalb einzelner Pods und Deployments konzentriert. Eine ResourceQuota hebt dieses Konzept auf die Ebene des Namespaces. Sie ermöglicht es einem Team oder Plattformbetreiber, Grenzen festzulegen, beispielsweise wie viele Pods existieren dürfen, wie viel CPU angefordert werden kann und wie viel Arbeitsspeicher in einem Namespace limitiert werden darf.
In diesem Lab erstellen Sie eine Namespace-ResourceQuota, überprüfen deren harte Limits, beobachten, wie Kubernetes einen Pod ablehnt, der keine erforderlichen Ressourcen deklariert, und führen anschließend konforme Pods aus, bis der Namespace sein Kontingent für die Anzahl der Pods erreicht hat.
Einen Namespace für das Quota-Training vorbereiten
In diesem Schritt bereiten Sie einen sauberen Namespace für das Üben mit ResourceQuota vor.
Beginnen Sie im Verzeichnis /home/labex/project. Sie werden die Quota- und Pod-Manifeste in diesem Verzeichnis erstellen.
mkdir -p /home/labex/project
cd /home/labex/project
Überprüfen Sie, ob der Kubernetes API-Server erreichbar ist. Falls die VM gerade erst gestartet wurde und der Node noch nicht bereit ist, warten Sie einige Sekunden und führen Sie den Befehl erneut aus.
kubectl get nodes --request-timeout=5s
Die erwartete Ausgabe sieht in etwa so aus:
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Warten Sie, bis der Cluster-Networking-Pod bereit ist, bevor Sie Anwendungspods erstellen.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Erwartete Ausgabe:
pod/calico-node-... condition met
Erstellen Sie einen Namespace namens ckad-prep-quotas:
kubectl create namespace ckad-prep-quotas
Setzen Sie diesen Namespace als aktuellen Kontext-Namespace:
kubectl config set-context --current --namespace=ckad-prep-quotas
Bestätigen Sie den aktuellen Namespace:
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
Erwartete Ausgabe:
ckad-prep-quotas
Eine Namespace ResourceQuota erstellen
In diesem Schritt erstellen Sie eine ResourceQuota, die sowohl die Anzahl der Objekte als auch die gesamten angeforderten Ressourcen begrenzt.
Die pods-Quote begrenzt, wie viele Pods im Namespace existieren dürfen. Die requests.*- und limits.*-Quoten verfolgen die Summe der Ressourcenanforderungen und Limits, die von allen passenden Pods deklariert wurden. Wenn ein Namespace Quota-Einträge für CPU- und Speicheranforderungen oder -limits enthält, müssen neue Pods diese Felder deklarieren, damit Kubernetes sie erfassen kann.
Erstellen Sie 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
Wenden Sie die Quote an:
kubectl apply -f app-resource-quota.yaml
Erwartete Ausgabe:
resourcequota/app-resource-quota created
Überprüfen Sie die Quote. Da zu diesem Zeitpunkt keine Pods im Namespace laufen, sollten die genutzten Werte bei Null liegen.
kubectl describe resourcequota app-resource-quota
Die erwartete Ausgabe enthält:
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
Beobachten, wie ein Pod durch die Quote abgelehnt wird
In diesem Schritt versuchen Sie, einen Pod ohne Ressourcenanforderungen und Limits zu erstellen.
Dieser Pod ist absichtlich unvollständig. Da die Namespace-Quote CPU- und Speicheranforderungen sowie Limits verfolgt, kann Kubernetes keinen Pod zulassen, der diese Felder auslässt. Dies ist ein nützlicher Fehler, den man bei CKAD-Aufgaben erkennen sollte: Das Manifest mag zwar gültiges YAML sein, aber die Zulassungsprüfung (Admission) kann es aufgrund der Namespace-Richtlinie dennoch ablehnen.
Erstellen Sie 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
Versuchen Sie, das Manifest anzuwenden. Das || true am Ende sorgt dafür, dass Ihre Shell nach dem erwarteten Fehler fortfährt, damit Sie das Ergebnis untersuchen können.
kubectl apply -f no-resources-pod.yaml || true
Die erwartete Ausgabe enthält:
Error from server (Forbidden): error when creating "no-resources-pod.yaml": pods "no-resources" is forbidden: failed quota
Bestätigen Sie, dass der Pod nicht erstellt wurde:
kubectl get pod no-resources
Die erwartete Ausgabe enthält:
Error from server (NotFound): pods "no-resources" not found
Überprüfen Sie, dass die Quote immer noch anzeigt, dass null Pods verwendet werden:
kubectl get resourcequota app-resource-quota -o 'jsonpath={.status.used.pods}{"\n"}'
Erwartete Ausgabe:
0
Konforme Pods ausführen, bis die Quote voll ist
In diesem Schritt erstellen Sie Pods, die Ressourcenanforderungen und Limits enthalten, und beobachten dann, wie die Pod-Anzahl-Quote einen dritten Pod stoppt.
Jeder der folgenden gültigen Pods fordert 100m CPU und 64Mi Arbeitsspeicher an und limitiert sich selbst auf 200m CPU und 128Mi Arbeitsspeicher. Zwei solcher Pods passen innerhalb der Quote. Ein dritter Pod verfügt zwar über gültige Ressourcenfelder, aber der Namespace erlaubt nur zwei Pods.
Erstellen Sie 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
Wenden Sie das Manifest an und warten Sie auf beide Pods:
kubectl apply -f quota-workers.yaml
kubectl wait --for=condition=Ready pod/quota-worker-a pod/quota-worker-b --timeout=120s
Erwartete Ausgabe:
pod/quota-worker-a created
pod/quota-worker-b created
pod/quota-worker-a condition met
pod/quota-worker-b condition met
Überprüfen Sie die Quota-Auslastung:
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"}'
Erwartete Ausgabe:
2 200m 128Mi 400m 256Mi
Erstellen Sie einen dritten Pod mit gültigen Ressourcen:
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
Die erwartete Ausgabe enthält:
Error from server (Forbidden): error when creating "quota-worker-c.yaml": pods "quota-worker-c" is forbidden: exceeded quota
Zusammenfassung
Sie haben eine Namespace-ResourceQuota erstellt, deren harte Limits überprüft, beobachtet, wie Kubernetes einen Pod ablehnte, der erforderliche Ressourcenfelder ausließ, und konforme Pods ausgeführt, bis der Namespace sein Limit für die Anzahl der Pods erreichte. Dies verknüpft die Ressourceneinstellungen einzelner Container mit der Ressourcenverwaltung auf Namespace-Ebene.
