Différences Fondamentales entre Service et Ingress
Dans l'écosystème Kubernetes, la gestion du trafic réseau repose sur plusieurs abstractions :
- Service : Opère au niveau de la couche 4 (TCP/UDP) du modèle OSI. Il permet d'exposer des applications de manière native sans nécessiter de composants additionnels.
- Ingress : Opère au niveau de la couche 7 (HTTP/HTTPS). Contrairement au Service, l'objet Ingress n'est qu'une déclaration de règles. Il nécesssite le déploiement d'un contrôleur d'Ingress (tel que Traefik) pour interpréter ces règles et router le trafic vers les Services appropriés.
Déploiement de Traefik via Helm
Traefik peut être déployé efficacement en tant que contrôleur d'Ingress à l'aide du gestionnaire de paquets Helm.
helm repo add traefik https://traefik.github.io/charts
helm repo update
Pour installer le contrôleur dans un espace de noms dédié :
helm install traefik-controller traefik/traefik --namespace traefik --create-namespace
Une fois le déploiement terminé, vérifiez les ressources créées :
kubectl get deployments,services,ingressclasses -n traefik
L'accès à l'adresse IP externe du Service traefik-controller devrait retourner une erreeur HTTP 404, indiquant que le routeur est actif mais qu'aucune route n'est encore configurée.
Configuration du Routage HTTP avec les Ressources Ingress Natives
Créons un environnement de test simulant plusieurs versions d'une API backend.
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-v1
spec:
replicas: 2
selector:
matchLabels:
app: api-v1
template:
metadata:
labels:
app: api-v1
spec:
containers:
- name: web
image: nginx:1.25-alpine
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: api-svc-v1
spec:
selector:
app: api-v1
ports:
- port: 80
targetPort: 80
Exposez cette application via une ressource Ingress standard en spécifiant la classe Traefik :
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: api-ingress
spec:
ingressClassName: traefik
rules:
- host: api.example.com
http:
paths:
- pathType: Prefix
path: /
backend:
service:
name: api-svc-v1
port:
number: 80
Le routage par chemin (URI) peut être configuré en ajoutant plusieurs blocs path sous la même règle host, dirigeant par exemple /v1 vers api-svc-v1 et /v2 vers api-svc-v2.
Sécurisation avec TLS
Pour activer le HTTPS, générez un certificat auto-signé et stockez-le dans un Secret Kubernetes :
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=secure.example.com"
kubectl create secret tls app-tls-secret --cert=tls.crt --key=tls.key
Intégrez ensuite ce secret dans la configuration de l'Ingress :
tls:
- hosts:
- secure.example.com
secretName: app-tls-secret
Activation du Tableau de Bord Traefik
Le tableau de bord de Traefik facilite la visualisation des routeurs et des middlewares. Pour l'exposer, modifiez le fichier values.yaml du chart Helm :
ingressRoute:
dashboard:
enabled: true
Appliquez la mise à jour via helm upgrade. Créez ensuite un Ingress dédié pour accéder à l'interface via un domaine spécifique comme traefik.example.com/dashboard/.
Architecture et Concepts Fondamentaux
Traefik fonctionne comme un routeur de périphérie (Edge Router) qui intercepte les requêtes et applique dynamiquement des règles de routage. Son architecture repose sur plusieurs composants :
- EntryPoints : Les ports d'entrée du réseau (ex: 80, 443) qui écoutent le trafic entrant.
- Routers (Règles) : Analysent les requêtes (Host, Path, Headers) et déterminent comment les traiter.
- Middlewares : Interceptent les requêtes pour les modifier avant qu'elles n'atteignent le service (authentification, limitation de débit, en-têtes).
- Services : Définissent comment atteindre les charges de travail backend réelles.
- Providers : Les sources de configuration (Kubernetes, Docker, Consul) que Traefik interroge pour découvrir dynamiquement les services.
Utilisation des CRDs IngressRoute
Les objets Ingress natifs de Kubernetes possèdent des limitations. Traefik introduit des définitions de ressources personnalisées (CRD) comme IngressRoute pour offrir des fonctionnalités avancées.
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: advanced-routing
spec:
entryPoints:
- web
routes:
- match: Host(`app.example.com`) && PathPrefix(`/api`)
kind: Rule
services:
- name: backend-service
port: 8080
Routage TCP avec IngressRouteTCP
Pour exposer des bases de données comme MySQL, il faut d'abord configurer un nouveau point d'entrée dans les values.yaml de Traefik :
ports:
mysql:
port: 3306
expose: true
exposedPort: 3306
protocol: TCP
Ensuite, déclarez la route TCP. Notez que pour les flux non-TLS, le Server Name Indication (SNI) doit utiliser le joker *.
apiVersion: traefik.io/v1alpha1
kind: IngressRouteTCP
metadata:
name: mysql-route
spec:
entryPoints:
- mysql
routes:
- match: HostSNI(`*`)
services:
- name: mysql-service
port: 3306
Routage UDP avec IngressRouteUDP
Le processus est similaire pour le protocole UDP (par exemple, pour des serveurs DNS ou des applications IoT). Ajoutez le port UDP dans la configuration Helm, puis appliquez la CRD :
apiVersion: traefik.io/v1alpha1
kind: IngressRouteUDP
metadata:
name: udp-app-route
spec:
entryPoints:
- udp-portal
routes:
- services:
- name: udp-backend-service
port: 8080
Note technique : Lors de l'exposition de multiples protocoles (TCP et UDP) sur le même contrôleur, il est parfois nécessaire d'utiliser un Service de type NodePort au lieu de LoadBalancer selon les implémentations du fournisseur Cloud, afin de garantir que les mappages de ports ne sont pas restreints.
Gestion du Trafic avec les Middlewares
Les middlewares s'attachent aux routes pour modifier le comportement des requêtes.
Restriction d'Accès (IPAllowList)
Pour protéger des interfaces sensibles (comme Prometheus ou le tableau de bord), configurez une liste blanche d'adresses IP :
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
name: internal-whitelist
spec:
ipAllowList:
sourceRange:
- 10.0.0.0/8
- 192.168.1.0/24
Authentification et Chaînage
Vous pouvez exiger une authentification basique et la combiner avec la restriction IP. Créez d'abord un Secret contenant les identifiants :
htpasswd -c auth admin
kubectl create secret generic basic-auth --from-file=auth
Déclarez le middleware d'authentification :
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
name: auth-middleware
spec:
basicAuth:
secret: basic-auth
Enfin, liez les deux middlewares à votre IngressRoute :
middlewares:
- name: internal-whitelist
- name: auth-middleware
Services Avancés : TraefikService
La ressource TraefikService permet de définir des topologies de routage complexes qui ne sont pas possibles avec les Services Kubernetes standard.
Déploiement Canari (Weighted Round Robin)
Répartissez le trafic entre deux versions d'un service en attribuant des poids spécifiques, idéal pour les tests de nouvelle version en production :
apiVersion: traefik.io/v1alpha1
kind: TraefikService
metadata:
name: canary-deployment
spec:
weighted:
services:
- name: api-stable
port: 80
weight: 90
kind: Service
- name: api-canary
port: 80
weight: 10
kind: Service
L'IngressRoute pointera alors vers ce TraefikService en spécifiant kind: TraefikService.
Miroir de Trafic (Traffic Mirroring)
La fonctionnalité de "mirroring" copie un pourcentage du trafic en direct vers un environnement de test ou d'analyse, sans impacter la réponse renvoyée au client final :
apiVersion: traefik.io/v1alpha1
kind: TraefikService
metadata:
name: shadow-traffic
spec:
mirroring:
kind: Service
name: api-production
port: 80
mirrors:
- name: api-staging
port: 80
percent: 15
Dans cet exemple, 100% des requêtes sont traitées par api-production, tandis qu'une copie asynchrone de 15% de ce trafic est simultanément envoyée à api-staging pour analyse de charge ou débogage.