Skip to content

7. Service ou Ingress

Fiche construite à partir du blog de Stéphane Robert (Services, Ingress) et de la documentation officielle Kubernetes (Service, Ingress).

Service

Donne à un groupe de Pods une IP stable et un nom DNS, et répartit le trafic entre eux. Il travaille en couche 4 (TCP/UDP) : il ne connaît que des IP et des ports.

Ingress

Point d’entrée HTTP/HTTPS du cluster. Il route les requêtes selon le nom de domaine et le chemin, gère le TLS, puis envoie le trafic vers des Services. Il travaille en couche 7.

Service Ingress
Couche L4 (TCP/UDP) L7 (HTTP/HTTPS)
Routage IP et port Host, path
TLS Non Oui (port 443)
Protocoles Tous (TCP, UDP, SCTP) HTTP et HTTPS uniquement
Cible Des Pods (via selector) Des Services
Fonctionne seul Oui (kube-proxy) Non : il faut un Ingress Controller
Ressource v1 / Service networking.k8s.io/v1 / Ingress

Les Pods sont éphémères : à chaque recréation, ils changent d’IP. Le Service offre un point d’accès durable :

  • une IP stable (la ClusterIP)
  • un nom DNS interne
  • une répartition de charge entre les Pods
  • une découverte par nom : l’appelant n’a jamais besoin de connaître l’IP des Pods
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: ClusterIP # valeur par défaut
selector:
app: nginx # labels des Pods ciblés
ports:
- protocol: TCP
port: 80 # port exposé par le Service
targetPort: 80 # port d'écoute du conteneur

Ou en impératif :

Terminal window
kubectl expose deployment nginx --name=nginx-service --port=80 --target-port=80

Les types sont imbriqués : un NodePort crée aussi une ClusterIP, et un LoadBalancer crée aussi un NodePort.

Type Accès Usage
ClusterIP (défaut) Interne au cluster uniquement Microservices, bases de données, caches
NodePort <IP-du-nœud>:<nodePort> sur chaque nœud, port entre 30000 et 32767 Tests, labs, cluster sans load balancer
LoadBalancer IP externe fournie par le cloud (EXTERNAL-IP) Exposer un service en production sur un cloud
ExternalName Alias DNS (enregistrement CNAME), sans selector ni proxy Pointer vers un service externe (ex. base managée)
Headless (clusterIP: None) Le DNS renvoie directement les IP des Pods, sans load balancing StatefulSets, bases de données répliquées
  • Nom complet : <service>.<namespace>.svc.cluster.local
  • Dans le même namespace : nginx-service suffit
  • Depuis un autre namespace : nginx-service.production
  • Toujours utiliser le nom du Service, jamais son IP
  • Pas de routage HTTP (par domaine ou par chemin)
  • Pas de terminaison TLS
  • Pas de sécurité : n’importe quel Pod peut joindre n’importe quel Service. Seules les NetworkPolicies restreignent les flux.

Exposer chaque application avec son propre Service LoadBalancer, c’est une IP externe (et un load balancer payant) par application. L’Ingress offre un point d’entrée unique qui regroupe les règles de routage HTTP de plusieurs applications derrière une seule adresse.

Le contrôleur est un reverse proxy (Traefik, HAProxy, Contour, NGINX Ingress Controller de NGINX Inc.…) qui surveille les objets Ingress et met à jour sa configuration. Il est lui-même exposé par un Service LoadBalancer ou NodePort.

  1. Le client appelle https://webapp.example.com/api
  2. Le trafic arrive sur le Service du contrôleur (LoadBalancer ou NodePort)
  3. Le contrôleur lit les règles Ingress et choisit le Service selon le host et le path
  4. Le Service (souvent ClusterIP) répartit vers ses Pods
  5. Un Pod répond
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: webapp-ingress
spec:
ingressClassName: traefik # quel contrôleur traite cet Ingress
tls:
- hosts:
- webapp.example.com
secretName: webapp-tls # Secret avec tls.crt et tls.key, même namespace
rules:
- host: webapp.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: webapp-service # un Service, pas des Pods
port:
number: 80 # le port du Service

ingressClassName

Désigne le contrôleur qui traite l’Ingress. Doit correspondre exactement à une IngressClass existante (kubectl get ingressclass). À toujours déclarer.

rules

Une règle par host, puis une liste de paths, chacun envoyé vers un Service et un port.

tls

Terminaison TLS sur le port 443 uniquement. Le trafic vers le Service et les Pods est ensuite en clair. Les hosts du bloc tls doivent correspondre à ceux des rules.

annotations

Couvrent ce que la spec ne prévoit pas (redirection HTTPS, auth, timeouts). Propres à chaque contrôleur, et une annotation inconnue est ignorée sans erreur.

Le champ est obligatoire pour chaque path.

pathType Correspondance Exemple avec path: /foo/bar
Exact Le chemin exact, sensible à la casse /foo/bar uniquement
Prefix Préfixe découpé par /, élément par élément /foo/bar, /foo/bar/baz, mais pas /foo/barbaz
ImplementationSpecific Dépend du contrôleur Non portable

Si plusieurs paths correspondent, le plus long l’emporte ; à égalité, Exact passe avant Prefix.

Besoin Choix
Communication interne entre applications du cluster (API, base de données, cache) Service ClusterIP
Base de données répliquée, StatefulSet, accès direct à chaque Pod Service headless
Pointer vers un service hors du cluster par un nom interne Service ExternalName
Tester rapidement depuis l’extérieur, en lab, sans load balancer Service NodePort
Exposer un protocole non HTTP à l’extérieur (TCP/UDP : base de données, DNS, MQTT, jeu…) Service LoadBalancer (ou NodePort)
Exposer une seule application, sans besoin de routage HTTP Service LoadBalancer
Exposer plusieurs applications web derrière une seule IP Ingress
Router par nom de domaine (api.example.com, app.example.com) ou par chemin (/api, /admin) Ingress
Centraliser le HTTPS et les certificats (avec cert-manager) Ingress
Besoins avancés : gRPC, TCP, répartition pondérée du trafic, routage par header Gateway API

Ingress aujourd’hui : API gelée et Gateway API

Section titled “Ingress aujourd’hui : API gelée et Gateway API”
  • L’API Ingress est stable (GA) et Kubernetes ne prévoit pas de la supprimer, mais elle est gelée : plus aucune évolution.
  • Le projet Kubernetes recommande la Gateway API à la place, en particulier pour les nouveaux projets. Elle couvre ce qu’Ingress ne fait qu’avec des annotations propriétaires.
  • Ingress reste valable pour du routage HTTP simple.

Remonter la chaîne dans l’ordre : Ingress → Service → EndpointSlices → Pods → logs du contrôleur.

Terminal window
kubectl get ingress
kubectl describe ingress webapp-ingress
kubectl get svc webapp-service -o wide
kubectl get endpointslice -l kubernetes.io/service-name=webapp-service
kubectl get pods -l app=webapp --show-labels
Symptôme Cause probable
Service sans endpoint selector ne correspond à aucun label, ou Pods pas Ready
Ingress sans effet Pas d’Ingress Controller, ou ingressClassName absent ou faux
404 Aucune règle ne correspond (host, path, ingressClassName)
502 Service ou Pods injoignables (mauvais targetPort…)
503 Aucun Pod disponible, ou Service inexistant
Connection refused Contrôleur non exposé ou mauvais port