Commande de redirection de ports Kubernetes

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser la commande Kubernetes port-forward pour rediriger un port local vers un port sur un pod. La redirection de ports est un outil de débogage essentiel qui vous permet d'accéder en toute sécurité aux applications exécutées dans votre cluster sans les exposer à Internet. Vous commencerez par des exemples simples et progresserez progressivement vers des scénarios plus complexes, y compris le travail avec plusieurs ports, plusieurs conteneurs et services.

Skills Graph

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

1. Accédez à votre répertoire de travail :

   Ouvrez le terminal et accédez au dossier de projet par défaut :

   cd /home/labex/project

2. Démarrez Minikube :

   Démarrez Minikube pour initialiser un cluster Kubernetes :

   minikube start

   • Cette commande configure un cluster Kubernetes mono - nœud sur votre machine locale.
   • Minikube peut prendre quelques minutes à démarrer en fonction des performances de votre système.

3. Vérifiez que Minikube est en cours d'exécution :

   Vérifiez l'état du cluster Minikube :

   minikube status

   • Recherchez des composants tels que kubelet et apiserver listés comme Running (en cours d'exécution).
   • Si le cluster n'est pas en cours d'exécution, relancez la commande minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Explorer la commande kubectl port-forward

La commande kubectl port-forward vous permet de rediriger un ou plusieurs ports locaux vers un pod, un déploiement (deployment) ou un service dans votre cluster Kubernetes. Elle est couramment utilisée pour tester et déboguer des services sans les exposer à l'extérieur.

Exécutez la commande suivante pour afficher les options disponibles pour kubectl port-forward :

kubectl port-forward -h

Vous verrez la sortie suivante :

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

Redirection d'un port local vers un pod

Dans cette étape, vous apprendrez à rediriger un port local vers un port sur un pod. Cela est utile pour déboguer des applications ou accéder à des services qui ne sont pas exposés en dehors du cluster.

Note concernant la gestion des terminaux :

• La commande kubectl port-forward continuera de s'exécuter dans votre terminal et le bloquera pour d'autres utilisations.
• Vous devrez ouvrir une nouvelle fenêtre de terminal pour exécuter des commandes supplémentaires pendant que la redirection de ports est active.
• Pour arrêter la redirection de ports à tout moment, vous pouvez appuyer sur Ctrl+C dans le terminal où elle s'exécute.

1. Commencez par créer un déploiement (deployment) avec une seule réplique et un conteneur Nginx :

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

   Cette commande crée un déploiement exécutant l'image de conteneur officielle Nginx.

2. Attendez que le pod soit prêt :

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

   Obtenez le nom du pod que nous utiliserons pour la redirection de ports :

   kubectl get pod -l app=nginx

   Vous devriez voir une sortie similaire à :

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

3. Utilisez la commande kubectl port-forward pour rediriger un port local vers le pod :

   Tout d'abord, obtenez le nom de votre pod :

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

   Vous devriez voir une sortie comme :

   nginx-748c667d99-pdhzs

   Maintenant, utilisez le nom du pod pour configurer la redirection de ports :

   kubectl port-forward $POD_NAME 19000:80

   Vous devriez voir une sortie comme :

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

4. Ouvrez une nouvelle fenêtre de terminal (car la redirection de ports continue de s'exécuter dans le terminal actuel) et vérifiez la redirection de ports :

   curl http://localhost:19000

   Vous devriez voir le contenu HTML de la page d'accueil Nginx.

   Vous pouvez également ouvrir un navigateur web et visiter http://localhost:19000 pour voir la page rendue.

Redirection de plusieurs ports locaux vers un pod

Avant de commencer cette étape, vous devez :

1. Arrêter la redirection de ports de l'Étape 1. Revenez dans le terminal correspondant et appuyez sur Ctrl+C.

Dans cette étape, vous apprendrez à rediriger plusieurs ports locaux vers un pod. Nous allons rediriger deux ports locaux différents vers le même port de conteneur, ce qui est utile lorsque vous souhaitez fournir différents points d'accès au même service.

1. Utilisez les commandes suivantes pour configurer la redirection de ports :

   Tout d'abord, obtenez le nom de votre pod si vous ne l'avez pas déjà fait :

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

   Vous devriez voir une sortie similaire à :

   nginx-748c667d99-pdhzs

   Maintenant, configurez la redirection de ports pour mapper deux ports locaux (19080 et 19081) sur le port 80 du conteneur :

   ## 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

   Vous devriez voir une sortie similaire à :

   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

   Cette commande redirige :

   • Le port local 19080 vers le port 80 du conteneur
   • Le port local 19081 vers le port 80 du conteneur

   Les deux ports locaux sont mappés sur le même port 80 du conteneur Nginx, vous permettant d'accéder au même serveur web via différents ports locaux.

2. Vérifiez la redirection de ports en vérifiant les ports d'écoute :

   ss -tulnp | grep 1908

   Vous devriez voir une sortie similaire à ceci :

   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. Maintenant, vous pouvez accéder à la page d'accueil Nginx via l'un ou l'autre des ports :

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

   curl http://localhost:19080

   curl http://localhost:19081

Les deux URL afficheront la même page d'accueil Nginx car elles sont toutes deux redirigées vers le même port de conteneur.

Redirection d'un port local vers un pod avec plusieurs conteneurs

Avant de commencer cette étape :

1. Si vous avez des commandes de redirection de ports en cours d'exécution depuis les étapes précédentes, accédez aux terminaux correspondants et appuyez sur Ctrl+C pour les arrêter.
2. Nous allons commencer à zéro avec une nouvelle configuration de pod multi - conteneurs.

Dans cette étape, vous apprendrez à rediriger un port local vers un conteneur spécifique dans un pod avec plusieurs conteneurs. C'est un scénario courant dans les architectures de microservices où des sidecars sont utilisés.

1. Tout d'abord, nettoyons les ressources précédentes :

   kubectl delete deployment nginx

2. Créez un pod avec deux conteneurs : Nginx et 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. Attendez que le pod soit prêt :

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

4. Vérifiez que les deux conteneurs sont en cours d'exécution :

   kubectl get pod nginx-busybox -o wide

   Vous devriez voir 2/2 dans la colonne READY.

5. Utilisez la commande kubectl port-forward pour rediriger un port local vers le conteneur Nginx :

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

6. Dans un nouveau terminal, vérifiez la connexion :

   curl http://localhost:19001

   Vous devriez voir le contenu HTML de la page d'accueil Nginx.

Utilisation de la redirection de ports avec les services Kubernetes

Avant de commencer cette étape :

1. Si vous avez une commande de redirection de ports en cours d'exécution depuis l'Étape 3, accédez au terminal correspondant et appuyez sur Ctrl+C pour l'arrêter.
2. Gardez à l'esprit que nous allons créer un nouveau déploiement (deployment) et un nouveau service dans cette étape, mais vous n'avez pas besoin de supprimer le pod précédent car il n'interférera pas avec nos nouvelles ressources.

Dans cette étape, vous apprendrez à utiliser la commande kubectl port-forward avec les services Kubernetes. La redirection de ports vers un service est différente de la redirection de ports vers un pod car elle vous permet d'accéder à n'importe quel pod vers lequel le service pointe.

1. Tout d'abord, créez un nouveau déploiement avec plusieurs répliques :

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

2. Attendez que tous les pods soient prêts :

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

3. Créez un service pour le déploiement :

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

4. Vérifiez que le service est créé :

   kubectl get service nginx-service

   Vous devriez voir une sortie similaire à :

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

5. Utilisez la commande kubectl port-forward pour rediriger un port local vers le service :

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

6. Dans un nouveau terminal, testez la connexion :

   curl http://localhost:20000

   Vous devriez voir le contenu HTML de la page d'accueil Nginx. Essayez d'exécuter cette commande plusieurs fois - vous pourriez remarquer que les réponses proviennent de différents pods derrière le service.

Résumé

Dans ce laboratoire, vous avez appris à utiliser efficacement la commande de redirection de ports (port-forward) Kubernetes dans diverses situations. Vous avez pratiqué :

1. La redirection d'un seul port local vers un pod
2. La redirection de plusieurs ports locaux vers le même port de conteneur
3. La manipulation de pods multi - conteneurs et la redirection de ports
4. La redirection de ports vers des services Kubernetes

Ces compétences sont essentielles pour le débogage et les tests d'applications dans un cluster Kubernetes. La redirection de ports offre un moyen sécurisé d'accéder à vos applications pendant le développement et la résolution de problèmes sans les exposer à Internet.

Voici quelques points clés à retenir :

• La redirection de ports est une connexion temporaire qui dure aussi longtemps que la commande kubectl port-forward est en cours d'exécution.
• Vous pouvez rediriger plusieurs ports locaux vers le même port de conteneur.
• La redirection de ports fonctionne avec les pods et les services.
• Lors de la redirection de ports vers un service, les requêtes peuvent être réparties sur plusieurs pods.

N'oubliez pas que la redirection de ports est principalement un outil de débogage et ne devrait pas être utilisée pour l'accès en production aux applications. Pour les scénarios de production, vous devriez utiliser les types de services Kubernetes appropriés (LoadBalancer, NodePort) ou des contrôleurs Ingress.