Connecter des Pods avec des Services Kubernetes

Introduction

Dans Kubernetes, les Pods sont éphémères et peuvent être terminés puis recréés à tout moment. Cela pose un défi en matière de mise en réseau, car il est difficile de se connecter directement à un Pod. Pour résoudre ce problème, Kubernetes propose une abstraction de haut niveau appelée Service. Un Service fournit une adresse IP stable et un nom DNS pour un ensemble de Pods, permettant aux autres composants de s'y connecter facilement. Dans ce laboratoire, vous apprendrez à mettre en réseau des Pods à l'aide de Services dans Kubernetes.

Démarrer le cluster Minikube

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

Accédez à votre répertoire de travail :

Ouvrez le terminal et accédez au dossier de projet par défaut :
```
cd /home/labex/project
```
Démarrez Minikube :

Lancez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes à nœud unique sur votre machine locale.
- Le démarrage de Minikube peut prendre quelques minutes selon les performances de votre système.
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 indiqués comme Running.
- Si le cluster n'est pas en cours d'exécution, relancez 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.

Créer un Pod

La première étape consiste à créer un Pod simple. Créez un fichier nommé /home/labex/project/myapp-pod.yaml avec le contenu suivant :

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

Enregistrez le fichier et créez le Pod en exécutant la commande suivante :

minikube kubectl -- apply -f /home/labex/project/myapp-pod.yaml

Cela créera un Pod nommé my-pod-1 avec un seul conteneur exécutant l'image Nginx.

Créer un Service

La deuxième étape consiste à créer un Service qui cible le Pod que vous avez créé à l'étape précédente. Créez un fichier nommé /home/labex/project/service.yaml avec le contenu suivant :

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: nginx
  ports:
    - name: http
      port: 80
      targetPort: 80

Enregistrez le fichier et créez le Service en exécutant la commande suivante :

minikube kubectl -- apply -f /home/labex/project/service.yaml

Cela créera un Service nommé my-service qui cible les Pods avec le label app=nginx et expose le port 80.

Tester le Service

La troisième étape consiste à tester le Service en y accédant depuis un autre Pod. Créez un fichier nommé /home/labex/project/test-pod-1.yaml avec le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: test-pod-1
spec:
  containers:
    - name: my-container
      image: busybox
      command:
        - sleep
        - "3600"

Enregistrez le fichier et créez le Pod de test en exécutant la commande suivante :

minikube kubectl -- apply -f /home/labex/project/test-pod-1.yaml

Cela créera un Pod nommé test-pod-1 avec un seul conteneur exécutant l'image Busybox.

Ensuite, accédez au Service depuis le Pod Busybox avec wget :

minikube kubectl -- exec test-pod-1 -- wget -qO- http://my-service

Cette commande renvoie la page Nginx par défaut, indiquant que le Service fonctionne correctement.

Mettre à jour le Service

La quatrième étape consiste à mettre à jour le Service pour cibler un ensemble différent de Pods. Mettez à jour le champ selector dans le fichier /home/labex/project/service.yaml comme suit :

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: busybox
  ports:
    - name: http
      port: 80
      targetPort: 80

Enregistrez le fichier et mettez à jour le Service en exécutant la commande suivante :

minikube kubectl -- apply -f /home/labex/project/service.yaml

Cela mettra à jour le Service pour cibler les Pods avec le label app=busybox. À ce stade, le Service n'a aucun point de terminaison (endpoints) car aucun des Pods existants n'utilise encore ce label.

Tester le Service mis à jour

La cinquième étape consiste à tester le Service mis à jour en y accédant depuis un autre Pod. Créez un nouveau Pod de test avec la commande suivante :

minikube kubectl -- run my-pod-2 --image=busybox --restart=Never -- sleep 3600

Cela créera un nouveau Pod nommé my-pod-2 avec un seul conteneur exécutant l'image Busybox.

Avant de modifier les labels, confirmez que le Service n'a aucun point de terminaison correspondant :

minikube kubectl -- get endpoints my-service

La sortie devrait afficher <none> car aucun Pod ne possède actuellement le label app=busybox.

Cela se produit parce que le sélecteur du Service recherche désormais app=busybox, mais votre Pod serveur Nginx est toujours étiqueté app=nginx. Pour corriger cela, modifiez le label du Pod serveur d'origine afin que le Service pointe à nouveau vers le conteneur Nginx.

Exécutez la commande suivante pour mettre à jour le label du Pod serveur :

minikube kubectl -- label pod my-pod-1 app=busybox --overwrite

Cela met à jour le label sur my-pod-1 afin qu'il corresponde au sélecteur du Service.

Testez maintenant à nouveau le Service depuis my-pod-2 :

minikube kubectl -- exec my-pod-2 -- wget -qO- http://my-service

Cette commande devrait renvoyer la page Nginx par défaut, indiquant que le Service fonctionne à nouveau correctement.

Résumé

Dans ce laboratoire, vous avez appris à mettre en réseau des Pods avec des Services dans Kubernetes. Vous avez créé un Pod Nginx, l'avez exposé avec un Service et avez testé ce Service depuis des Pods clients Busybox. Vous avez également mis à jour le sélecteur du Service et modifié le label du Pod Nginx d'origine afin que le Service cible à nouveau un serveur web fonctionnel. Les Services sont un composant essentiel de la mise en réseau dans Kubernetes et vous permettent de vous connecter aux Pods de manière fiable et évolutive.