Kubernetes LimitRange Ressourcenverwaltung

Einführung

In diesem Lab lernen Sie über Kubernetes LimitRange kennen, das dazu dient, Grenzen für den Ressourcenverbrauch in Kubernetes-Pods festzulegen. LimitRange ist ein Kubernetes-Feature, das Ihnen hilft, die den Pods zugewiesenen Ressourcen zu verwalten und Probleme mit Ressourcenkonflikten zu vermeiden.

Sie werden eine Reihe von schrittweisen Anweisungen durcharbeiten, um die verschiedenen Aspekte von LimitRange zu verstehen, beginnend mit einfachen Beispielen und allmählich zu komplexeren Szenarien übergehenden. Jeder Schritt wird Codebeispiele in Form von YAML-Manifesten enthalten, die Sie auf Ihren Kubernetes-Cluster anwenden können, um die Auswirkungen von LimitRange in Aktion zu sehen.

Starten Sie den Minikube-Cluster

Bevor Sie Ressourcen erstellen, benötigen Sie einen laufenden Kubernetes-Cluster. Minikube ist eine leichte Kubernetes-Umgebung, die auf Ihrem lokalen Rechner läuft.

Navigieren Sie in Ihr Arbeitsverzeichnis:

Öffnen Sie das Terminal und navigieren Sie in den Standard-Projektordner:
```
cd /home/labex/project
```
Starten Sie Minikube:

Starten Sie Minikube, um einen Kubernetes-Cluster zu initialisieren:
```
minikube start
```
- Dieser Befehl richtet einen Ein-Knoten-Kubernetes-Cluster auf Ihrem lokalen Rechner ein.
- Minikube kann je nach Leistung Ihres Systems einige Minuten dauern, um zu starten.
Überprüfen Sie, ob Minikube läuft:

Überprüfen Sie den Status des Minikube-Clusters:
```
minikube status
```
- Suchen Sie nach Komponenten wie kubelet und apiserver, die als Running aufgeführt sind.
- Wenn der Cluster nicht läuft, führen Sie minikube start erneut aus.

Wenn Sie Probleme beim Starten von Minikube haben, können Sie minikube delete verwenden, um die Umgebung bei Bedarf zurückzusetzen.

Erstellen einer einfachen LimitRange

In diesem Schritt erstellen Sie eine einfache LimitRange, die Grenzen für die CPU- und Speicherressourcen von Pods in einem Namespace festlegt. So können Sie es machen:

Erstellen Sie eine neue YAML-Datei namens limitrange.yaml mit folgendem Inhalt:

apiVersion: v1
kind: LimitRange
metadata:
  name: example-limitrange
spec:
  limits:
    - type: Container
      max:
        cpu: "1"
        memory: "1Gi"
      min:
        cpu: "100m"
        memory: "100Mi"
      default:
        cpu: "500m"
        memory: "500Mi"

Diese LimitRange legt folgende Grenzen fest:

Maximale CPU: 1 Kern
Maximaler Speicher: 1 GiB
Minimale CPU: 100 Millikerne (100m)
Minimaler Speicher: 100 MiB
Standard-CPU: 500 Millikerne (500m)
Standard-Speicher: 500 MiB

Wenden Sie die Datei limitrange.yaml auf Ihren Kubernetes-Cluster an, indem Sie den Befehl kubectl apply verwenden:

kubectl apply -f limitrange.yaml

Überprüfen Sie, ob die LimitRange erfolgreich erstellt wurde, indem Sie folgenden Befehl ausführen:

kubectl describe limitrange example-limitrange

Sie sollten die LimitRange example-limitrange mit den in der spec-Sektion angegebenen Grenzen aufgeführt sehen.

Anwenden von LimitRange auf Pods

In diesem Schritt erstellen Sie einen Pod, der der LimitRange unterliegt, die Sie in "Erstellen einer einfachen LimitRange" erstellt haben. So können Sie es machen:

Erstellen Sie eine neue YAML-Datei namens pod.yaml mit folgendem Inhalt:

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
spec:
  containers:
    - name: nginx
      image: nginx

Diese Pod-Definition erstellt einen einfachen Pod mit einem einzelnen Container, der das Nginx-Image ausführt.

Wenden Sie die Datei pod.yaml auf Ihren Kubernetes-Cluster an, indem Sie den Befehl kubectl apply verwenden:

kubectl apply -f pod.yaml

Überprüfen Sie, ob der Pod erfolgreich erstellt wurde, indem Sie folgenden Befehl ausführen:

kubectl get pods example-pod

Sie sollten den Pod example-pod mit dem Status Running aufgeführt sehen.

Prüfen Sie die auf den Pod angewendeten Ressourcenlimits, indem Sie folgenden Befehl ausführen:

kubectl describe pod example-pod

Sie sollten die definierten CPU- und Speicherlimits für den Pod sehen.

Testen der Durchsetzung von LimitRange

In diesem Schritt testen Sie die Durchsetzung der LimitRange, indem Sie versuchen, einen Pod zu erstellen, der die in der LimitRange definierten Ressourcenlimits überschreitet. So können Sie es machen:

Erstellen Sie eine neue YAML-Datei namens pod-exceeding-limits.yaml mit folgendem Inhalt:

apiVersion: v1
kind: Pod
metadata:
  name: example-pod-exceeding-limits
spec:
  containers:
    - name: nginx
      image: nginx
      resources:
        limits:
          cpu: "2"
          memory: "2Gi"

Diese Pod-Definition erstellt einen Pod mit einem Container, der Ressourcen anfordert, die die in der LimitRange festgelegten Grenzen überschreiten (CPU: 2 Kerne, Speicher: 2 GiB).

Wenden Sie die Datei pod-exceeding-limits.yaml auf Ihren Kubernetes-Cluster an, indem Sie den Befehl kubectl apply verwenden:

kubectl apply -f pod-exceeding-limits.yaml

Sie können sehen, dass der Vorgang zum Erstellen des Pods abgelehnt wird. Die Fehlermeldung lautet Error from server (Forbidden): error when creating "pod-exceeding-limits.yaml": pod "example-pod-exceeding-limits" Forbidden: [Maximum cpu usage per container is 1, but limited to 2, maximum memory usage per container is 1Gi, but limited to 2Gi].

Aktualisieren der LimitRange

In diesem Schritt aktualisieren Sie die in "Erstellen einer einfachen LimitRange" erstellte LimitRange, um die Ressourcenlimits zu ändern. So können Sie es machen:

Passen Sie die Datei limitrange.yaml an, um die Ressourcenlimits gemäß Ihren Anforderungen zu aktualisieren. Beispiel:

apiVersion: v1
kind: LimitRange
metadata:
  name: example-limitrange
spec:
  limits:
    - type: Container
      max:
        cpu: "2"
        memory: "2Gi"
      min:
        cpu: "200m"
        memory: "200Mi"
      default:
        cpu: "1"
        memory: "1Gi"

Diese aktualisierte LimitRange legt folgende Grenzen fest:

Maximale CPU: 2 Kerne
Maximaler Speicher: 2 GiB
Minimale CPU: 200 Millikerne (200m)
Minimaler Speicher: 200 MiB
Standard-CPU: 1 Kern
Standard-Speicher: 1 GiB

Wenden Sie die aktualisierte Datei limitrange.yaml auf Ihren Kubernetes-Cluster an, indem Sie den Befehl kubectl apply verwenden:

kubectl apply -f limitrange.yaml

Überprüfen Sie, ob die LimitRange erfolgreich aktualisiert wurde, indem Sie folgenden Befehl ausführen:

kubectl describe limitranges example-limitrange

Sie sollten die aktualisierten Ressourcenlimits in der Ausgabe sehen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Kubernetes LimitRange verwenden können, um Grenzen für den Ressourcenverbrauch in Pods festzulegen. Sie haben mit der Erstellung einer einfachen LimitRange begonnen, diese auf einen Pod angewendet, die Durchsetzung getestet und anschließend die LimitRange aktualisiert, um die Ressourcenlimits zu ändern. LimitRange ist ein leistungsstarkes Tool zur Ressourcenverwaltung in Kubernetes und zur Sicherstellung einer effizienten Ressourcennutzung in Ihrem Cluster.