Kubernetes Port-Forwarding-Befehl

Einführung

In diesem Lab erfahren Sie, wie Sie den Kubernetes-Befehl port-forward verwenden können, um einen lokalen Port an einen Port auf einem Pod weiterzuleiten. Die Portweiterleitung ist ein wichtiges Debugging-Tool, das es Ihnen ermöglicht, auf Anwendungen zuzugreifen, die in Ihrem Cluster ausgeführt werden, ohne sie für das Internet zugänglich zu machen. Sie beginnen mit einfachen Beispielen und arbeiten sich schrittweise zu komplexeren Szenarien voran, einschließlich der Arbeit mit mehreren Ports, mehreren Containern und Services.

Skills Graph

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 Standardprojektordner:

   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.
   • Je nach Leistung Ihres Systems kann es einige Minuten dauern, bis Minikube gestartet ist.

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.

Erkundung des kubectl port-forward-Befehls

Der kubectl port-forward-Befehl ermöglicht es Ihnen, einen oder mehrere lokale Ports an einen Pod, eine Bereitstellung (Deployment) oder einen Service in Ihrem Kubernetes-Cluster weiterzuleiten. Er wird üblicherweise zum Testen und Debuggen von Services verwendet, ohne sie nach außen hin sichtbar zu machen.

Führen Sie den folgenden Befehl aus, um die verfügbaren Optionen für kubectl port-forward anzuzeigen:

kubectl port-forward -h

Sie werden die folgende Ausgabe sehen:

Forward one or more local ports to a pod.

Use resource type/name such as deployment/mydeployment to select a pod. Resource type defaults to 'pod' if omitted.

If there are multiple pods matching the criteria, a pod will be selected automatically. The forwarding session ends
when the selected pod terminates, and a rerun of the command is needed to resume forwarding.

Examples:
  ## Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
  kubectl port-forward pod/mypod 5000 6000

  ## Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in a pod selected by the deployment
  kubectl port-forward deployment/mydeployment 5000 6000

  ## Listen on port 8443 locally, forwarding to the targetPort of the service's port named "https" in a pod selected by the service
  kubectl port-forward service/myservice 8443:https

  ## Listen on port 8888 locally, forwarding to 5000 in the pod
  kubectl port-forward pod/mypod 8888:5000

  ## Listen on port 8888 on all addresses, forwarding to 5000 in the pod
  kubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000

  ## Listen on port 8888 on localhost and selected IP, forwarding to 5000 in the pod
  kubectl port-forward --address localhost,10.19.21.23 pod/mypod 8888:5000

  ## Listen on a random port locally, forwarding to 5000 in the pod
  kubectl port-forward pod/mypod :5000

Weiterleiten eines lokalen Ports an einen Pod

In diesem Schritt erfahren Sie, wie Sie einen lokalen Port an einen Port auf einem Pod weiterleiten können. Dies ist nützlich für das Debuggen von Anwendungen oder den Zugriff auf Services, die nicht außerhalb des Clusters zugänglich sind.

Hinweis zur Terminalverwaltung:

• Der kubectl port-forward-Befehl läuft im Terminal und blockiert es für andere Befehle.
• Sie müssen ein neues Terminalfenster öffnen, um zusätzliche Befehle auszuführen, während die Portweiterleitung aktiv ist.
• Um die Portweiterleitung jederzeit zu beenden, können Sie in dem Terminal, in dem der Befehl läuft, Strg+C drücken.

1. Erstellen Sie zunächst eine Bereitstellung (Deployment) mit einer Replik und einem Nginx-Container:

   kubectl create deployment nginx --image=nginx --replicas=1

   Dieser Befehl erstellt eine Bereitstellung, die das offizielle Nginx-Container-Image ausführt.

2. Warten Sie, bis der Pod bereit ist:

   kubectl wait --for=condition=Ready pod -l app=nginx

   Ermitteln Sie den Namen des Pods, den wir für die Portweiterleitung verwenden werden:

   kubectl get pod -l app=nginx

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   NAME                     READY   STATUS    RESTARTS   AGE
   nginx-66b6c48dd5-abcd1   1/1     Running   0          30s

3. Verwenden Sie den kubectl port-forward-Befehl, um einen lokalen Port an den Pod weiterzuleiten:

   Zunächst ermitteln Sie den Namen Ihres Pods:

   export POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')
   echo $POD_NAME

   Sie sollten eine Ausgabe wie die folgende sehen:

   nginx-748c667d99-pdhzs

   Verwenden Sie nun den Pod-Namen, um die Portweiterleitung einzurichten:

   kubectl port-forward $POD_NAME 19000:80

   Sie sollten eine Ausgabe wie die folgende sehen:

   Forwarding from 127.0.0.1:19000 -> 80
   Forwarding from [::1]:19000 -> 80

4. Öffnen Sie ein neues Terminalfenster (da die Portweiterleitung im aktuellen Terminal weiterhin läuft) und überprüfen Sie die Portweiterleitung:

   curl http://localhost:19000

   Sie sollten den HTML-Inhalt der Nginx-Willkommensseite sehen.

   Sie können auch einen Webbrowser öffnen und http://localhost:19000 besuchen, um die gerenderte Seite zu sehen.

Weiterleiten mehrerer lokaler Ports an einen Pod

Bevor Sie mit diesem Schritt beginnen, müssen Sie Folgendes tun:

1. Beenden Sie die Portweiterleitung aus Schritt 1. Gehen Sie zurück zu dem Terminal und drücken Sie Strg+C.

In diesem Schritt erfahren Sie, wie Sie mehrere lokale Ports an einen Pod weiterleiten können. Wir werden zwei verschiedene lokale Ports an denselben Container-Port weiterleiten, was nützlich ist, wenn Sie verschiedenen Zugangspunkte zu demselben Service bereitstellen möchten.

1. Verwenden Sie die folgenden Befehle, um die Portweiterleitung einzurichten:

   Zunächst ermitteln Sie den Namen Ihres Pods, falls Sie ihn noch nicht haben:

   export POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')
   echo $POD_NAME

   Sie sollten eine Ausgabe wie die folgende sehen:

   nginx-748c667d99-pdhzs

   Richten Sie nun die Portweiterleitung ein, um zwei lokale Ports (19080 und 19081) an den Container-Port 80 zuzuordnen:

   ## The correct format is: kubectl port-forward POD_NAME LOCAL_PORT:CONTAINER_PORT [LOCAL_PORT:CONTAINER_PORT...]
   kubectl port-forward pod/$POD_NAME 19080:80 19081:80

   Sie sollten eine Ausgabe wie die folgende sehen:

   Forwarding from 127.0.0.1:19080 -> 80
   Forwarding from [::1]:19080 -> 80
   Forwarding from 127.0.0.1:19081 -> 80
   Forwarding from [::1]:19081 -> 80

   Dieser Befehl leitet weiter:

   • Lokalen Port 19080 an Container-Port 80
   • Lokalen Port 19081 an Container-Port 80

   Beide lokalen Ports werden an denselben Nginx-Container-Port 80 zugeordnet, sodass Sie über verschiedene lokale Ports auf denselben Webserver zugreifen können.

2. Überprüfen Sie die Portweiterleitung, indem Sie die lauschenden Ports prüfen:

   ss -tulnp | grep 1908

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   tcp   LISTEN  0       4096         0.0.0.0:19080     0.0.0.0:*
   tcp   LISTEN  0       4096         0.0.0.0:19081     0.0.0.0:*

3. Jetzt können Sie die Nginx-Willkommensseite über beide Ports zugreifen:

   • http://localhost:19080
   • http://localhost:19081

   curl http://localhost:19080

   curl http://localhost:19081

Beide URLs zeigen dieselbe Nginx-Willkommensseite, da sie beide an denselben Container-Port weitergeleitet werden.

Weiterleiten eines lokalen Ports an einen Pod mit mehreren Containern

Bevor Sie mit diesem Schritt beginnen:

1. Wenn Sie noch Portweiterleitungsbefehle aus vorherigen Schritten laufen haben, gehen Sie zu den entsprechenden Terminals und drücken Sie Strg+C, um sie zu beenden.
2. Wir beginnen von vorne mit einer neuen Einrichtung eines Pods mit mehreren Containern.

In diesem Schritt erfahren Sie, wie Sie einen lokalen Port an einen bestimmten Container in einem Pod mit mehreren Containern weiterleiten können. Dies ist ein häufiges Szenario in Microservices-Architekturen, in denen Sidecar-Container verwendet werden.

1. Zunächst bereinigen wir die vorherigen Ressourcen:

   kubectl delete deployment nginx

2. Erstellen Sie einen Pod mit zwei Containern: Nginx und BusyBox:

   cat << EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx-busybox
     labels:
       app: nginx-multi
   spec:
     containers:
     - name: nginx
       image: nginx
       ports:
       - containerPort: 80
     - name: busybox
       image: busybox
       command: ['sh', '-c', 'while true; do sleep 3600; done']
   EOF

3. Warten Sie, bis der Pod bereit ist:

   kubectl wait --for=condition=Ready pod/nginx-busybox

4. Überprüfen Sie, ob beide Container laufen:

   kubectl get pod nginx-busybox -o wide

   Sie sollten unter der Spalte READY 2/2 sehen.

5. Verwenden Sie den kubectl port-forward-Befehl, um einen lokalen Port an den Nginx-Container weiterzuleiten:

   kubectl port-forward pod/nginx-busybox 19001:80

6. In einem neuen Terminal überprüfen Sie die Verbindung:

   curl http://localhost:19001

   Sie sollten den HTML-Inhalt der Nginx-Willkommensseite sehen.

Verwenden von Port-Forwarding mit Kubernetes-Services

Bevor Sie mit diesem Schritt beginnen:

1. Wenn Sie noch Port-Forwarding-Befehle aus Schritt 3 laufen haben, gehen Sie zu dem entsprechenden Terminal und drücken Sie Strg+C, um sie zu beenden.
2. Beachten Sie, dass wir in diesem Schritt eine neue Bereitstellung (Deployment) und einen neuen Service erstellen werden. Sie müssen den vorherigen Pod jedoch nicht löschen, da er nicht mit unseren neuen Ressourcen interferieren wird.

In diesem Schritt erfahren Sie, wie Sie den kubectl port-forward-Befehl mit Kubernetes-Services verwenden können. Das Port-Forwarding an einen Service unterscheidet sich vom Port-Forwarding an einen Pod, da es Ihnen ermöglicht, auf jeden Pod zuzugreifen, auf den der Service zeigt.

1. Zunächst erstellen Sie eine neue Bereitstellung mit mehreren Replikas:

   kubectl create deployment nginx-service --image=nginx --replicas=3

2. Warten Sie, bis alle Pods bereit sind:

   kubectl wait --for=condition=Ready pod -l app=nginx-service

3. Erstellen Sie einen Service für die Bereitstellung:

   kubectl expose deployment nginx-service --port=80 --type=ClusterIP --name=nginx-service

4. Überprüfen Sie, ob der Service erstellt wurde:

   kubectl get service nginx-service

   Sie sollten eine Ausgabe wie die folgende sehen:

   NAME           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
   nginx-service  ClusterIP   10.96.123.456   <none>        80/TCP    10s

5. Verwenden Sie den kubectl port-forward-Befehl, um einen lokalen Port an den Service weiterzuleiten:

   kubectl port-forward service/nginx-service 20000:80

6. In einem neuen Terminal testen Sie die Verbindung:

   curl http://localhost:20000

   Sie sollten den HTML-Inhalt der Nginx-Willkommensseite sehen. Versuchen Sie, diesen Befehl mehrmals auszuführen - Sie könnten bemerken, dass die Antworten von verschiedenen Pods hinter dem Service stammen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den Kubernetes-Port-Forwarding-Befehl in verschiedenen Szenarien effektiv nutzen können. Sie haben geübt:

1. Das Weiterleiten eines einzelnen lokalen Ports an einen Pod
2. Das Weiterleiten mehrerer lokaler Ports an denselben Container-Port
3. Das Arbeiten mit Pods mit mehreren Containern und Port-Forwarding
4. Das Port-Forwarding an Kubernetes-Services

Diese Fähigkeiten sind für das Debuggen und Testen von Anwendungen in einem Kubernetes-Cluster unerlässlich. Port-Forwarding bietet eine sichere Möglichkeit, auf Ihre Anwendungen während der Entwicklung und beim Troubleshooting zuzugreifen, ohne sie für das öffentliche Internet zugänglich zu machen.

Einige wichtige Erkenntnisse:

• Port-Forwarding ist eine temporäre Verbindung, die nur so lange besteht, wie der kubectl port-forward-Befehl läuft.
• Sie können mehrere lokale Ports an denselben Container-Port weiterleiten.
• Port-Forwarding funktioniert sowohl mit Pods als auch mit Services.
• Beim Port-Forwarding an einen Service können Anfragen auf mehrere Pods verteilt werden.

Denken Sie daran, dass Port-Forwarding in erster Linie ein Debugging-Tool ist und nicht für den produktiven Zugriff auf Anwendungen verwendet werden sollte. Für Produktionsszenarien sollten Sie die richtigen Kubernetes-Service-Typen (LoadBalancer, NodePort) oder Ingress-Controller verwenden.