Projet · Phase 5.5

Kubernetes (5/12) — Exposer un Deployment : le Service

Les Pods changent d'IP et de nom sans cesse. Comment leur parler de façon stable ? Le Service : une porte d'entrée fixe qui route vers les bons Pods — non par leur nom, mais par leurs labels.

⏱ ~1 hNiveau intermédiairePrérequis : Kubernetes (4/12)Pratique · TP
L’idée reçue

« Je note l’IP de mon Pod et je m’y connecte. »

Mauvaise idée : les Pods sont des cibles instables. Leur nom change quand ils sont recréés, leur IP aussi, ils vont et viennent pendant les rollouts et le scaling. En Kubernetes, on ne se connecte jamais à un Pod directement pour du long terme. On passe par un Service : une porte d’entrée stable.

À la fin de ce module, tu sauras…

  • Expliquer pourquoi un Pod n’est pas une adresse fiable
  • Créer un Service qui expose un Deployment
  • Comprendre que le lien Service → Pods se fait par labels, pas par nom
  • Tester l’accès et diagnostiquer une erreur de port

01Pourquoi un Pod n’est pas une adresse fiable

Tes Pods sont gérés (recréés, scalés, mis à jour), mais chaque recréation change leur nom et leur IP. Se connecter à un Pod précis, c’est viser une cible qui bouge en permanence.
Comprends le besoin d’une couche stable

Pendant un rollout ou un scaling, les Pods apparaissent et disparaissent. Une adresse qui pointe sur un Pod donné devient fausse dès la prochaine réconciliation. Il faut une couche d’accès stable qui, elle, ne bouge pas — et qui sait toujours où sont les Pods du moment.

02Créer un Service

Expérience 1

Une porte d’entrée pour demo-deploy

Manipule
kubectl expose deployment demo-deploy --port=8092 --target-port=80 --name=demo-service
kubectl get svc
Observe
service/demo-service exposed

NAME           TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)    AGE
demo-service   ClusterIP   10.43.51.65   <none>        8092/TCP   64s
Le Service existe, avec une identité stable : un nom (demo-service), une IP de cluster fixe, et un port d’entrée (ici 8092). Cette adresse ne changera pas, même si les Pods derrière changent.
Comprends port vs target-port, et ClusterIP

–port=8092 est le port d’entrée du Service ; –target-port=80 est le port des Pods (nginx écoute sur 80). Le type ClusterIP signifie « accessible à l’intérieur du cluster » — parfait pour les communications entre services. L’exposition vers l’extérieur (Internet) viendra avec l’Ingress.

03Le point clé : Service → labels → Pods

Voici le concept le plus important : un Service ne se connecte PAS au Deployment par son nom. Il sélectionne des Pods via un selector (des labels).
Comprends pourquoi le lien par labels est génial

Le Deployment crée des Pods portant certains labels. Le Service sélectionne les Pods qui correspondent à ces labels, et route le trafic vers eux. La relation est label-based, pas name-based. C’est pourquoi le Service reste stable quand les Pods sont recréés, changent d’IP, ou pendant rollouts et scaling : il vise « les bons Pods », jamais des noms précis.

04Tester l’accès (et un échec instructif)

Expérience 2

curl depuis l’intérieur du cluster

Entre dans un Pod et interroge le Service par son nom :

Manipule
kubectl exec -it demo-deploy-59d8c7f2a-aaaaa -- /bin/sh
curl http://demo-service
Observe
curl: (28) Failed to connect to demo-service port 80 ...
Échec — mais très instructif. Le nom demo-service se résout bien (sinon l’erreur serait différente) ; le problème est le port : curl a visé 80 par défaut, alors que notre Service écoute sur 8092.
Manipule
curl http://demo-service:8092
Cette fois, la page nginx répond. Le bon test correspond à la configuration du Service.
Comprends ce que l’échec prouve

Que le nom se résolve prouve qu’il existe un DNS interne dans le cluster (on l’explore au module suivant). L’erreur de port rappelle que –port définit précisément par où entrer. Un « échec » bien lu enseigne souvent plus qu’un succès.

Ce que tu retiens

Un Service est la porte d’entrée stable devant un groupe de Pods : un nom et une IP fixes, un routage automatique. Le lien Service → Pods se fait par labels/selector, jamais par nom de Pod — c’est ce qui le rend insensible aux recréations, rollouts et scaling. Un ClusterIP est accessible à l’intérieur du cluster.

Mini-projet

Une porte stable devant tes Pods

À faire

  1. Expose demo-deploy avec un Service (port d’entrée de ton choix, target-port 80).
  2. Vérifie son ClusterIP et son port avec kubectl get svc.
  3. Depuis un Pod, teste l’accès par le nom du Service et le bon port.
  4. Supprime un Pod, laisse-le se recréer, et prouve que le Service répond toujours.
  5. Documente dans BookStack : pourquoi le lien par labels rend le Service stable.
Fil rouge — Le Service marche, mais « par magie » pour l’instant : comment sait-il exactement quels Pods viser, et comment répartit-il le trafic ? Au module suivant, on ouvre le capot : selector, endpoints, DNS et load-balancing.

?Auto-évaluation

1. Pourquoi ne se connecte-t-on pas directement à un Pod sur le long terme ?

Parce que son nom et son IP changent à chaque recréation, pendant les rollouts et le scaling. Le Service offre une adresse stable.

2. Comment un Service sait-il quels Pods viser ?

Par un selector de labels : il route vers tous les Pods dont les labels correspondent, pas vers des noms de Pods.

3. Que signifie le type ClusterIP ?

Le Service est accessible à l’intérieur du cluster. L’exposition vers l’extérieur se fait via un Ingress (à venir).

Connecte-toi pour enregistrer ta progression.

Suite → Kubernetes (6/12) — Networking : selector, endpoints, DNS