Erstellen eines einfachen YAML-Manifests
Bevor Sie Ihr erstes YAML-Manifest erstellen, ist es wichtig, die wichtigsten Kubernetes-Objekte zu verstehen, mit denen Sie arbeiten werden. Diese Objekte sind die Bausteine für die Verwaltung und Orchestrierung Ihrer Anwendungen innerhalb von Kubernetes.
Verständnis von Kubernetes-Objekten
- Pod: Die grundlegendste Einheit in Kubernetes. Ein Pod ist wie eine Box, die einen oder mehrere Container enthalten kann. Diese Container innerhalb eines Pods teilen sich dasselbe Netzwerk und denselben Speicher. Betrachten Sie einen Pod als eine einzelne Instanz Ihrer Anwendung.
- Deployment: Deployments werden zur Verwaltung von Pods verwendet. Sie stellen sicher, dass jederzeit eine gewünschte Anzahl von Pod-Replikaten läuft. Wenn ein Pod ausfällt, ersetzt ein Deployment ihn automatisch. Deployments kümmern sich auch auf kontrollierte Weise um Updates Ihrer Anwendung, wie z. B. Rolling Updates.
- Service: Services bieten eine stabile Möglichkeit, auf Ihre in Pods laufende Anwendung zuzugreifen. Da Pods erstellt und zerstört werden können, können sich ihre IP-Adressen ändern. Ein Service bietet eine feste IP-Adresse und einen DNS-Namen, der immer auf die von ihm verwalteten Pods verweist. Dies ermöglicht es anderen Teilen Ihrer Anwendung oder externen Benutzern, zuverlässig auf Ihre Anwendung zuzugreifen, ohne einzelne Pod-IPs verfolgen zu müssen.
Hier ist ein Diagramm, das die Beziehungen zwischen diesen Objekten veranschaulicht:
graph TD;
A[Deployment] -->|Manages| B[Pods]
B -->|Contains| C[Containers]
B -->|Communicates via| D[Services]
D -->|Exposes| E[External Clients]
Das Verständnis dieser Objekte ist entscheidend, da Sie deren gewünschten Zustand und Konfiguration mithilfe von YAML-Manifesten definieren werden.
YAML-Manifest-Übersicht
Ein YAML-Manifest in Kubernetes ist eine Datei im YAML-Format, die die Kubernetes-Objekte beschreibt, die Sie erstellen oder verwalten möchten. YAML ist eine menschenlesbare Sprache zur Daten serialisierung. Die Verwendung von YAML für Kubernetes-Manifeste bietet mehrere Vorteile:
- Deklarative Verwaltung: Sie beschreiben den gewünschten Zustand Ihrer Ressourcen in der YAML-Datei (z. B. "Ich möchte, dass 3 Replikate meiner Anwendung laufen"). Kubernetes arbeitet dann daran, den tatsächlichen Zustand mit Ihrem gewünschten Zustand abzugleichen. Dies wird als deklarative Verwaltung bezeichnet.
- Versionskontrolle: YAML-Dateien sind textbasiert und können einfach in Versionskontrollsystemen wie Git gespeichert werden. Dies ermöglicht es Ihnen, Änderungen an Ihren Kubernetes-Konfigurationen im Laufe der Zeit zu verfolgen, zu früheren Konfigurationen zurückzukehren und mit anderen zusammenzuarbeiten.
- Wiederverwendbarkeit und Portabilität: Sie können YAML-Manifeste in verschiedenen Umgebungen (Entwicklung, Test, Produktion) mit minimalen Änderungen wiederverwenden. Dies macht Ihre Deployments konsistenter und reproduzierbarer.
Nachdem Sie die Grundlagen von Kubernetes-Objekten und YAML-Manifesten verstanden haben, sind Sie bereit, Ihr erstes Manifest zu erstellen.
Erstellen eines YAML-Manifests
Navigieren Sie zuerst zu Ihrem Projektverzeichnis. Es wird davon ausgegangen, dass Sie ein Verzeichnis project in Ihrem Home-Verzeichnis (~) haben. Wenn Sie es nicht haben, erstellen Sie es jetzt mit mkdir project. Ändern Sie dann Ihr aktuelles Verzeichnis zu project mit cd project:
cd ~/project
Erstellen Sie als Nächstes ein neues Verzeichnis, um Ihre Kubernetes-Manifeste zu speichern. Nennen wir es k8s-manifests. Verwenden Sie den Befehl mkdir, um das Verzeichnis zu erstellen, und dann cd, um hineinzuwechseln:
mkdir -p k8s-manifests
cd k8s-manifests
Nun erstellen Sie Ihre erste YAML-Manifestdatei. Beginnen wir mit einem einfachen Manifest für einen NGINX-Pod. NGINX ist ein beliebter Webserver. Wir erstellen einen Pod, der einen einzelnen NGINX-Container ausführt. Verwenden Sie den Texteditor nano, um eine Datei namens nginx-pod.yaml zu erstellen:
nano nginx-pod.yaml
nano ist ein einfacher Texteditor, der in Ihrem Terminal läuft. Sobald nano geöffnet ist, fügen Sie den folgenden Inhalt in die Datei ein:
apiVersion: v1
kind: Pod
metadata:
name: nginx-pod
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80
Lassen Sie uns jeden Teil dieses YAML-Manifests verstehen:
apiVersion: v1: Gibt die Kubernetes-API-Version an, die für die Erstellung dieses Objekts verwendet werden soll. v1 ist die Kern-API-Gruppe und wird für grundlegende Objekte wie Pods, Services und Namespaces verwendet.kind: Pod: Zeigt an, dass Sie eine Pod-Ressource definieren.metadata:: Enthält Daten über den Pod, wie z. B. seinen Namen und seine Labels.
name: nginx-pod: Setzt den Namen des Pods auf nginx-pod. Dies ist, wie Sie diesen Pod innerhalb von Kubernetes referenzieren werden.labels:: Labels sind Schlüssel-Wert-Paare, die Objekten zugeordnet sind. Sie werden verwendet, um Objektmengen zu organisieren und auszuwählen. Hier fügen wir diesem Pod ein Label app: nginx hinzu.
spec:: Beschreibt den gewünschten Zustand des Pods.
containers:: Eine Liste von Containern, die innerhalb des Pods ausgeführt werden sollen. In diesem Fall haben wir nur einen Container.
- name: nginx: Setzt den Namen des Containers auf nginx.image: nginx:latest: Gibt das zu verwendende Container-Image an. nginx:latest bezieht sich auf die neueste Version des NGINX Docker-Images von Docker Hub.ports:: Eine Liste von Ports, die dieser Container verfügbar machen wird.
- containerPort: 80: Gibt an, dass der Container Port 80 verfügbar machen wird. Port 80 ist der Standard-HTTP-Port.
Nachdem Sie den Inhalt eingefügt haben, speichern Sie die Datei und beenden Sie nano. Tun Sie dies, indem Sie Ctrl+X (Beenden) drücken, dann Y (Ja zum Speichern) eingeben und schließlich Enter drücken, um den Dateinamen zu bestätigen und zu speichern.
Nachdem Sie Ihre nginx-pod.yaml-Datei erstellt haben, müssen Sie sie auf Ihren Kubernetes-Cluster anwenden, um den Pod zu erstellen. Verwenden Sie den Befehl kubectl apply mit dem Flag -f, das die Datei mit dem Manifest angibt:
kubectl apply -f nginx-pod.yaml
Dieser Befehl sendet das Manifest an Ihren Kubernetes-Cluster, und Kubernetes erstellt den Pod wie definiert. Sie sollten eine Ausgabe sehen, die dieser ähnelt:
pod/nginx-pod created
Um zu überprüfen, ob der Pod erstellt wurde und läuft, verwenden Sie den Befehl kubectl get pods. Dieser listet alle Pods im Standard-Namespace auf. Sie können auch kubectl describe pod nginx-pod verwenden, um detaillierte Informationen über den nginx-pod zu erhalten. Führen Sie diese Befehle aus:
kubectl get pods
kubectl describe pod nginx-pod
Beispielausgabe für kubectl get pods:
NAME READY STATUS RESTARTS AGE
nginx-pod 1/1 Running 0 1m
Diese Ausgabe zeigt, dass der nginx-pod READY (1 von 1 Container ist bereit) ist und sein STATUS Running ist. Das bedeutet, dass Ihr NGINX-Pod erfolgreich erstellt wurde und läuft.
Erstellen wir nun ein Manifest für eine komplexere Ressource: ein Deployment. Ein Deployment verwaltet eine Reihe von Pods und stellt sicher, dass die gewünschte Anzahl von Replikaten läuft. Erstellen Sie eine neue Datei namens nginx-deployment.yaml mit nano:
nano nginx-deployment.yaml
Fügen Sie den folgenden Inhalt in nginx-deployment.yaml ein:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
labels:
app: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80
Heben wir die wichtigsten Unterschiede und neuen Teile im Vergleich zum nginx-pod.yaml-Manifest hervor:
apiVersion: apps/v1: Für Deployments verwenden Sie die API-Version apps/v1, die Teil der API-Gruppe apps ist und übergeordnete Anwendungsmanagement-Ressourcen behandelt.kind: Deployment: Zeigt an, dass Sie eine Deployment-Ressource definieren.spec:: Der spec-Abschnitt für ein Deployment ist komplexer, da er definiert, wie das Deployment Pods verwalten soll.
replicas: 3: Dies ist neu. Es gibt an, dass Sie 3 Replikate (Kopien) Ihres Pods laufen lassen möchten. Das Deployment stellt sicher, dass immer 3 Pods vorhanden sind, die den in der template definierten Kriterien entsprechen.selector:: Ein Selektor wird vom Deployment verwendet, um zu identifizieren, welche Pods es verwalten soll.
matchLabels:: Definiert die Labels, die Pods haben müssen, um von diesem Deployment ausgewählt zu werden. Hier werden Pods mit dem Label app: nginx ausgewählt.
template:: Die template definiert die Pod-Spezifikation, die das Deployment zum Erstellen neuer Pods verwendet. Es ist im Wesentlichen dieselbe Pod-Definition wie in unserem nginx-pod.yaml-Beispiel, einschließlich metadata.labels und spec.containers. Wichtig: Die hier in template.metadata.labels definierten Labels müssen mit den selector.matchLabels übereinstimmen, damit das Deployment diese Pods verwalten kann.
Speichern und beenden Sie nano (Ctrl+X, Y, Enter).
Wenden Sie nun dieses Deployment-Manifest auf Ihren Cluster an:
kubectl apply -f nginx-deployment.yaml
Sie sollten eine Ausgabe wie diese sehen:
deployment.apps/nginx-deployment created
Überprüfen Sie das Deployment und die von ihm erstellten Pods. Verwenden Sie kubectl get deployments, um den Status des Deployments zu überprüfen, und kubectl get pods, um die Pods anzuzeigen.
kubectl get deployments
kubectl get pods
Beispielausgabe:
NAME READY UP-TO-DATE AVAILABLE AGE
nginx-deployment 3/3 3 3 1m
NAME READY STATUS RESTARTS AGE
nginx-deployment-xxx-yyy 1/1 Running 0 1m
nginx-deployment-xxx-zzz 1/1 Running 0 1m
nginx-deployment-xxx-www 1/1 Running 0 1m
kubectl get deployments zeigt, dass das nginx-deployment READY 3/3, UP-TO-DATE 3 und AVAILABLE 3 hat. Das bedeutet, dass das Deployment erfolgreich 3 Pods erstellt hat und diese verwaltet, und alle sind bereit und verfügbar.kubectl get pods listet nun drei Pods auf, deren Namen mit nginx-deployment- beginnen. Dies sind die von Ihrem nginx-deployment erstellten und verwalteten Pods.
