Exemple concret : exposer le Déploiement Nginx via un Service NodePort

Rendre notre Déploiement Nginx accessible

Dans les sections précédentes, nous avons créé avec succès un Déploiement nommé `nginx-deployment` qui gère trois réplicas de Pods Nginx. Ces Pods fonctionnent, mais ils sont pour l'instant isolés à l'intérieur du réseau du cluster. Notre objectif est maintenant de les rendre accessibles depuis l'extérieur, en particulier depuis notre machine locale si nous utilisons un cluster comme Minikube ou Kind.

Comme nous l'avons vu, le moyen le plus direct d'y parvenir dans un environnement de développement local est d'utiliser un Service de type `NodePort`. Ce type de Service exposera notre application Nginx sur un port spécifique de l'adresse IP du Noeud (ou des Noeuds) de notre cluster.

Nous allons donc créer un nouveau fichier manifeste YAML, cette fois pour définir notre Service. Appelons ce fichier `nginx-service.yaml`.

Construction du manifeste `nginx-service.yaml`

Ce manifeste décrira notre Service. Il doit contenir les informations suivantes :

• `apiVersion: v1` : Les Services font partie de l'API core de Kubernetes, donc nous utilisons `v1`.
• `kind: Service` : Nous spécifions que nous créons un objet Service.
• `metadata` : Nous donnons un nom à notre Service, par exemple `nginx-service`.
• `spec` : C'est ici que nous définissons le comportement du Service :
  • `type: NodePort` : Nous indiquons explicitement que nous voulons un Service de type NodePort.
  • `selector` : C'est le lien crucial avec notre Déploiement. Nous devons utiliser le même sélecteur de labels que celui utilisé pour les Pods gérés par notre `nginx-deployment`. Dans notre cas, c'était `app: nginx`. Le Service utilisera ce sélecteur pour trouver les Pods cibles.
  • `ports` : Nous définissons comment les ports sont mappés. C'est une liste, mais pour Nginx, nous n'avons besoin que d'une entrée :
    • `protocol: TCP` : Le protocole utilisé (le plus courant).
    • `port: 80` : C'est le port sur lequel le Service lui-même (son ClusterIP interne) écoutera. Choisir 80 est logique car c'est le port HTTP standard.
    • `targetPort: 80` : C'est le port sur lequel les conteneurs Nginx dans nos Pods cibles sont en train d'écouter. L'image Nginx standard écoute sur le port 80 par défaut.
    • `nodePort: 30080` : (Facultatif mais recommandé pour la prévisibilité) C'est le port statique (entre 30000 et 32767) qui sera ouvert sur l'adresse IP de chaque Noeud. Nous choisissons `30080` arbitrairement dans la plage autorisée. Si nous omettons ce champ, Kubernetes en choisira un au hasard.

Le manifeste YAML complet du Service

En combinant ces éléments, le fichier `nginx-service.yaml` se présente comme suit :

apiVersion: v1
kind: Service
metadata:
  name: nginx-service # Nom du Service
spec:
  type: NodePort      # Type d'exposition
  selector:
    app: nginx      # Doit correspondre aux labels des Pods du Déploiement
  ports:
    - protocol: TCP
      port: 80        # Port interne du Service (ClusterIP)
      targetPort: 80  # Port sur lequel le conteneur Nginx écoute dans les Pods
      nodePort: 30080 # Port exposé sur l'IP du Noeud (doit être dans la plage 30000-32767)

Ce manifeste indique clairement à Kubernetes : "Crée un Service nommé `nginx-service`, expose-le sur le port 30080 de chaque Noeud, et fais en sorte que le trafic arrivant sur le port 80 de ce Service soit dirigé vers le port 80 des Pods ayant le label `app: nginx`."

Appliquer le manifeste et accéder à Nginx

Appliquons maintenant ce manifeste pour créer le Service :

kubectl apply -f nginx-service.yaml

Vous devriez obtenir une sortie comme `service/nginx-service created`. Pour vérifier que le Service est correctement configuré, utilisez :

kubectl get service nginx-service

# Ou plus court : kubectl get svc nginx-service

# Sortie attendue :
# NAME            TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
# nginx-service   NodePort   10.103.97.123           80:30080/TCP   1m

Notez bien le type `NodePort` et la section `PORT(S)` qui montre `80:30080/TCP`. Cela confirme que le port interne 80 du Service est mappé au port externe 30080 sur les Noeuds.

Il nous faut maintenant l'adresse IP de notre Noeud Kubernetes local. Si vous utilisez Minikube, la commande est simple :

minikube ip

Cette commande retournera l'adresse IP de la machine virtuelle Minikube (par exemple, `192.168.49.2`). Si vous utilisez Kind ou une autre solution, la méthode pour obtenir l'IP du Noeud peut varier (consultez leur documentation, souvent cela implique une commande `docker inspect` ou l'utilisation de `localhost` si le port est mappé sur l'hôte).

Une fois que vous avez l'adresse IP du Noeud, vous pouvez accéder à votre serveur Nginx ! Ouvrez un navigateur web et allez à l'adresse `http://:30080` (en remplaçant `` par l'adresse obtenue). Vous devriez voir la page d'accueil par défaut de Nginx ("Welcome to nginx!"). Vous pouvez aussi utiliser `curl` depuis votre terminal :

curl http://:30080

Chaque requête que vous faites est acheminée vers l'un des trois Pods Nginx gérés par votre Déploiement, grâce au Service `nginx-service` qui agit comme point d'entrée et répartiteur de charge.

Pour nettoyer, vous pouvez supprimer le Service et le Déploiement :

kubectl delete -f nginx-service.yaml
kubectl delete -f nginx-deployment.yaml