Configurer un Ingress Controller Kubernetes pas à pas : Nginx et Traefik

La formation configurer un ingress controller kubernetes pas à pas est essentielle pour tout ingénieur infrastructure formation LFS458 Administration Kubernetes. L'Ingress Controller expose vos services au trafic externe avec routage HTTP/HTTPS, terminaison TLS et load balancing. Traefik cumule 3,4 milliards de téléchargements, 58 000+ stars GitHub et 900+ contributeurs, tandis qu'Ingress NGINX reste le standard historique malgré son retrait annoncé pour mars 2026.

TL;DR : Nginx pour la simplicité et la maturité, Traefik pour les fonctionnalités avancées et la configuration dynamique. Les deux s'installent en moins de 5 minutes avec Helm.

Ces compétences sont au cœur de la formation LFS458 Administration Kubernetes.

Qu'est-ce qu'un Ingress Controller et pourquoi la formation configurer un ingress controller kubernetes pas à pas est-elle importante ?

Un Ingress Controller est un reverse proxy qui implémente la ressource Ingress de Kubernetes. Il lit les règles Ingress et configure automatiquement le routage vers vos services.

Composants de l'architecture Ingress

À retenir : L'Ingress Resource définit le "quoi" (routes), l'Ingress Controller implémente le "comment" (proxy).

L'administrateur système formation LFS458 Administration Kubernetes maîtrise ces concepts pour l'examen CKA. Selon la Linux Foundation, l'examen CKA dure 2 heures avec un score de passage de 66%.

Pour plus de tutoriels, consultez notre hub Tutoriels et guides pratiques Kubernetes.

Comment installer Ingress NGINX Controller ?

Prérequis

Vérifiez votre cluster :

kubectl cluster-info
kubectl get nodes

Installation avec Helm

# Ajouter le repository officiel
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Installer dans un namespace dédié
kubectl create namespace ingress-nginx

helm install ingress-nginx ingress-nginx/ingress-nginx \
  --namespace ingress-nginx \
  --set controller.replicaCount=2 \
  --set controller.metrics.enabled=true \
  --set controller.service.type=LoadBalancer

Vérifier l'installation

kubectl get pods -n ingress-nginx
kubectl get svc -n ingress-nginx

Résultat attendu :

NAME                                        READY   STATUS    RESTARTS   AGE
ingress-nginx-controller-5c8d66c76d-xxxxx   1/1     Running   0          2m
ingress-nginx-controller-5c8d66c76d-yyyyy   1/1     Running   0          2m

À retenir : Deux réplicas minimum en production pour la haute disponibilité. Un seul point de défaillance expose tout le trafic entrant.

Pour les commandes kubectl essentielles, consultez notre aide-mémoire kubectl.

Comment configurer un Ingress basique avec NGINX ?

Déployer une application de test

apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-app
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: demo
  template:
    metadata:
      labels:
        app: demo
    spec:
      containers:
      - name: nginx
        image: nginx:1.27-alpine
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: demo-service
  namespace: default
spec:
  selector:
    app: demo
  ports:
  - port: 80
    targetPort: 80

Créer la ressource Ingress

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: demo-ingress
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: demo.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: demo-service
            port:
              number: 80

Appliquez et testez :

kubectl apply -f demo-ingress.yaml
kubectl get ingress demo-ingress

# Test local
curl -H "Host: demo.example.com" http://<EXTERNAL-IP>/

Pour les erreurs courantes, consultez notre guide Résoudre les 10 erreurs de déploiement Kubernetes.

Comment installer Traefik Ingress Controller ?

Traefik offre une alternative moderne avec configuration dynamique et dashboard intégré.

Installation avec Helm

# Ajouter le repository Traefik
helm repo add traefik https://traefik.github.io/charts
helm repo update

# Créer le namespace
kubectl create namespace traefik

# Installer Traefik
helm install traefik traefik/traefik \
  --namespace traefik \
  --set deployment.replicas=2 \
  --set ingressRoute.dashboard.enabled=true \
  --set metrics.prometheus.enabled=true

Vérifier l'installation

kubectl get pods -n traefik
kubectl get svc -n traefik

Activer le dashboard Traefik

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: traefik-dashboard
  namespace: traefik
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`traefik.example.com`)
      kind: Rule
      services:
        - name: api@internal
          kind: TraefikService
  tls:
    certResolver: letsencrypt

À retenir : Le dashboard Traefik doit être sécurisé en production. Ne l'exposez jamais sans authentification.

Comment configurer la formation configurer un ingress controller kubernetes pas à pas avec TLS ?

Créer un Secret TLS

# Générer un certificat auto-signé pour les tests
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout tls.key -out tls.crt \
  -subj "/CN=demo.example.com"

# Créer le secret Kubernetes
kubectl create secret tls demo-tls \
  --key tls.key \
  --cert tls.crt \
  -n default

Configurer l'Ingress avec TLS

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: demo-ingress-tls
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - demo.example.com
    secretName: demo-tls
  rules:
  - host: demo.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: demo-service
            port:
              number: 80

Intégration cert-manager

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@example.com
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
    - http01:
        ingress:
          class: nginx
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: demo-ingress-auto-tls
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - demo.example.com
    secretName: demo-tls-auto
  rules:
  - host: demo.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: demo-service
            port:
              number: 80

Pour les formations destinées aux ingénieurs sécurité, consultez notre page Tutoriels Kubernetes pour ingénieurs sécurité.

Comment comparer Nginx et Traefik ?

Quand choisir NGINX ?

• Équipe familière avec NGINX
• Configuration statique principalement
• Besoin de performances maximales

Quand choisir Traefik ?

• Configuration dynamique fréquente
• Besoin de middlewares avancés
• Préférence pour les CRDs

Pour les architectes évaluant Kubernetes, consultez notre guide Tutoriels pour architectes Cloud.

Comment configurer le routage avancé ?

Routage par path avec NGINX

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-path-ingress
  annotations:
    nginx.ingress.kubernetes.io/use-regex: "true"
spec:
  ingressClassName: nginx
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /v1/users
        pathType: Prefix
        backend:
          service:
            name: users-service
            port:
              number: 80
      - path: /v1/orders
        pathType: Prefix
        backend:
          service:
            name: orders-service
            port:
              number: 80
      - path: /v2/.*
        pathType: ImplementationSpecific
        backend:
          service:
            name: api-v2-service
            port:
              number: 80

Middlewares Traefik

apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: rate-limit
spec:
  rateLimit:
    average: 100
    burst: 50
---
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: compress
spec:
  compress: {}
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: api-route
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`api.example.com`)
      kind: Rule
      middlewares:
        - name: rate-limit
        - name: compress
      services:
        - name: api-service
          port: 80

À retenir : Les middlewares Traefik se chaînent déclarativement. NGINX utilise des annotations moins lisibles mais tout aussi puissantes.

Pour les engineering managers construisant des équipes cloud-native, consultez notre page Tutoriels pour Engineering Managers.

Comment monitorer votre Ingress Controller ?

Métriques NGINX

# values.yaml pour Helm
controller:
  metrics:
    enabled: true
    serviceMonitor:
      enabled: true
      namespace: monitoring

Métriques Traefik

metrics:
  prometheus:
    enabled: true
    entryPoint: metrics
    service:
      enabled: true

Dashboard Grafana

# Importer le dashboard NGINX Ingress Controller
# ID: 9614

# Importer le dashboard Traefik
# ID: 17346

Pour les responsables formation, consultez notre page Tutoriels pour responsables formation.

Comment migrer d'NGINX vers Traefik ?

Avec le retrait d'Ingress NGINX prévu pour mars 2026, planifiez votre migration.

Étapes de migration

1. Installer Traefik en parallèle de NGINX
2. Convertir les Ingress vers IngressRoute progressivement
3. Tester chaque route migrée
4. Basculer le DNS service par service
5. Désinstaller NGINX après validation complète

# Vérifier les Ingress existants
kubectl get ingress --all-namespaces

# Exporter pour conversion
kubectl get ingress demo-ingress -o yaml > demo-ingress-nginx.yaml

Pour les DRH utilisant la formation pour la stratégie talents, consultez notre page Tutoriels pour DRH.

Pour les ingénieurs DevOps découvrant Kubernetes, consultez notre guide Tutoriels pour ingénieurs DevOps.

Passez à l'action : maîtrisez les Ingress Controllers

La configuration des Ingress Controllers fait partie des compétences testées au CKA. Avec 82% des utilisateurs de conteneurs exécutant Kubernetes en production, cette expertise est incontournable.

Formez-vous avec SFEIR :

• La formation LFS458 Administration Kubernetes couvre les Ingress Controllers en détail sur 4 jours
• La formation Kubernetes les fondamentaux introduit les concepts de base en 1 jour
• La formation LFD459 pour développeurs aborde l'exposition des applications. Pour approfondir, consultez notre formation Déploiement et mise en production Kubernetes.

Contactez nos conseillers pour planifier votre formation et préparer votre certification CKA.