Ausführen von Containern in Pods

Einführung

In diesem Lab erfahren Sie, wie Sie Container in Kubernetes-Pods ausführen können. Pods sind die kleinste und einfachste Einheit in Kubernetes und können einen oder mehrere Container enthalten. Das Ausführen von Containern in Pods bietet viele Vorteile, darunter eine bessere Ressourcennutzung, einfachere Skalierung und effizientere Bereitstellung.

Starten des Minikube-Clusters

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

1. Navigieren Sie zu Ihrem Arbeitsverzeichnis:

   Öffnen Sie das Terminal und navigieren Sie zum Standard-Projektordner:

   cd /home/labex/project

2. 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.

3. Ü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 eines Pods mit einem einzelnen Container

Der erste Schritt besteht darin, einen Pod mit einem einzelnen Container zu erstellen. Dazu erstellen Sie eine YAML-Datei, die den Pod und seinen Container definiert.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-1
spec:
  containers:
    - name: my-container
      image: nginx

Speichern Sie den obigen Code in einer Datei mit dem Namen /home/labex/project/pod-single-container.yaml und führen Sie den folgenden Befehl aus:

kubectl apply -f /home/labex/project/pod-single-container.yaml

Dieser Befehl erstellt einen Pod namens my-pod-1 mit einem einzelnen Container namens my-container, der das Nginx-Image ausführt.

Erstellen eines Pods mit mehreren Containern

Der zweite Schritt besteht darin, einen Pod mit mehreren Containern zu erstellen. Dazu müssen Sie die vorherige YAML-Datei ändern, um einen weiteren Container hinzuzufügen.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-2
spec:
  containers:
    - name: my-container
      image: nginx
    - name: my-sidecar
      image: busybox
      command: ["sh", "-c", "echo Hello from the sidecar! && sleep 3600"]

Speichern Sie den obigen Code in einer Datei namens /home/labex/project/pod-multiple-containers.yaml und führen Sie den folgenden Befehl aus:

kubectl apply -f /home/labex/project/pod-multiple-containers.yaml

Dieser Befehl erstellt einen Pod namens my-pod-2 mit zwei Containern. Der erste Container führt das Nginx-Image aus, und der zweite Container führt das BusyBox-Image aus und gibt eine Nachricht auf der Konsole aus.

Erstellen eines Pods mit Umgebungsvariablen

Der dritte Schritt besteht darin, einen Pod mit Umgebungsvariablen zu erstellen. Dazu müssen Sie die YAML-Datei ändern, um dem Nginx-Container Umgebungsvariablen hinzuzufügen.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-3
spec:
  containers:
    - name: my-container
      image: nginx
      env:
        - name: MY_ENV_VAR
          value: "Hello World!"

Speichern Sie den obigen Code in einer Datei namens /home/labex/project/pod-env-vars.yaml und führen Sie den folgenden Befehl aus:

kubectl apply -f /home/labex/project/pod-env-vars.yaml

Dieser Befehl erstellt einen Pod namens my-pod-3 mit einem einzelnen Container namens my-container, der das Nginx-Image ausführt und eine Umgebungsvariable namens MY_ENV_VAR mit dem Wert Hello World! hat.

Erstellen eines Pods mit ConfigMaps

Der vierte Schritt besteht darin, einen Pod mit ConfigMaps zu erstellen. Eine ConfigMap ist eine Kubernetes-Ressource, die es Ihnen ermöglicht, Konfigurationsdaten (wie Umgebungsvariablen, Konfigurationsdateien) getrennt von Ihrem Anwendungs-Code zu speichern. Diese Trennung erleichtert es, die Konfiguration zu ändern, ohne Ihre Container neu zu erstellen.

Lassen Sie uns dies in einfache Schritte aufteilen:

1. Zunächst erstellen Sie eine ConfigMap:

   kubectl create configmap my-config --from-literal=MY_ENV_VAR=labex

   Dieser Befehl erstellt eine ConfigMap namens my-config, die ein einzelnes Schlüssel-Wert-Paar speichert:

   • Schlüssel: MY_ENV_VAR
   • Wert: labex

   Sie können überprüfen, ob die ConfigMap erstellt wurde, und deren Inhalt anzeigen, indem Sie Folgendes verwenden:

   kubectl get configmap my-config -o yaml

2. Als Nächstes erstellen Sie einen Pod, der diese ConfigMap verwendet:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-pod-4
   spec:
     containers:
       - name: my-container
         image: nginx
         envFrom:
           - configMapRef:
               name: my-config

   Speichern Sie diese YAML-Datei in /home/labex/project/pod-configmap.yaml und wenden Sie sie an:

   kubectl apply -f /home/labex/project/pod-configmap.yaml

Dadurch wird ein Pod erstellt, der auf den Konfigurationswert zugreifen kann, den wir in der ConfigMap gespeichert haben. Der Wert wird als Umgebungsvariable innerhalb des Containers verfügbar sein. Sie können dies überprüfen, indem Sie Folgendes ausführen:

kubectl exec -it my-pod-4 -- env | grep MY_ENV_VAR

Erstellen eines Pods mit Persistenten Volumes

Der fünfte Schritt besteht darin, einen Pod mit einem Persistenten Volume (PV, dauerhaftem Volume) und einem Persistent Volume Claim (PVC, Anspruch auf dauerhaftes Volume) zu erstellen. PVs und PVCs werden verwendet, um Daten dauerhaft zu speichern und auch nach einem Neustart des Pods darauf zugreifen zu können.

Um dies zu tun, erstellen Sie zunächst ein PV.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

Speichern Sie den obigen Code in einer Datei namens /home/labex/project/pv.yaml und führen Sie den folgenden Befehl aus:

kubectl apply -f /home/labex/project/pv.yaml

Dieser Befehl erstellt ein PV namens my-pv mit einer Kapazität von 1Gi und einem Host-Pfad von /mnt/data.

Als Nächstes erstellen Sie einen PVC, der 1Gi Speicherplatz vom PV anfordert.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Speichern Sie den obigen Code in einer Datei namens /home/labex/project/pvc.yaml und führen Sie den folgenden Befehl aus:

kubectl apply -f /home/labex/project/pvc.yaml

Dieser Befehl erstellt einen PVC namens my-pvc, der 1Gi Speicherplatz anfordert.

Schließlich ändern Sie die YAML-Datei, um ein Volume und eine Volume-Montage (Volume Mount) zum Nginx-Container hinzuzufügen.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-5
spec:
  containers:
    - name: my-container
      image: nginx
      volumeMounts:
        - name: my-volume
          mountPath: /mnt/data
  volumes:
    - name: my-volume
      persistentVolumeClaim:
        claimName: my-pvc

Speichern Sie den obigen Code in einer Datei namens /home/labex/project/pod-pv.yaml und führen Sie den folgenden Befehl aus:

kubectl apply -f /home/labex/project/pod-pv.yaml

Dieser Befehl erstellt einen Pod namens my-pod-5 mit einem einzelnen Container namens my-container, der das Nginx-Image ausführt und eine Volume-Montage bei /mnt/data hat, die durch den PVC namens my-pvc unterstützt wird.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben dieses Lab abgeschlossen und gelernt, wie man Container in Kubernetes-Pods ausführt. Sie haben auch gelernt, wie man Pods mit mehreren Containern, Umgebungsvariablen, ConfigMaps und Persistenten Volumes erstellt. Dies sind leistungsstarke Konzepte, die Ihnen helfen werden, robusterere und skalierbarere Anwendungen zu entwickeln.