Kubernetes Ingress : commandes de base avec exemples pratiques - guide d'implémentation

Introduction

Ingress expose des routes HTTP et HTTPS depuis l'extérieur du cluster vers des Services internes. Ce guide vous donne les Kubernetes Ingress commands les plus utiles, explique ce que fait chaque commande, quand l'utiliser, et fournit des exemples prêts à copier. Vous allez créer et vérifier un Ingress HTTP minimal, ajouter du TLS, puis dépanner en toute sécurité sans perturber la production.

Ce que vous allez faire :

• Confirmer votre Ingress controller et sa classe
• Créer un Ingress HTTP minimal
• Tester le routage en local via port-forward + curl
• Ajouter TLS pour HTTPS
• Dépanner avec les events et les logs

Sécurité d'abord :

• Travaillez dans un namespace dédié
• Utilisez dry-run et diff avant apply
• Changez une seule chose à la fois et vérifiez

Aperçu du workflow

1. Vérifier les prérequis

• Un Ingress controller est installé (exemple : NGINX Ingress).
• Vous avez un accès kubectl au cluster.

1. Préparer un Service de démonstration
2. Créer un Ingress minimal
3. Vérifier avec get/describe
4. Tester en local via port-forward et curl
5. Ajouter TLS et retester
6. Dépanner avec events/logs si nécessaire

Commandes de base à utiliser au quotidien

Inspection générale :

• Lister tous les Ingress dans tous les namespaces :

  kubectl get ingress -A

• Lister les classes d'Ingress disponibles :

  kubectl get ingressclass

• Décrire un Ingress pour voir règles, backends et events :

  kubectl describe ingress demo -n ingress-demo

Gestion du changement :

• Prévisualiser les changements sans les appliquer :

  kubectl diff -f ingress.yaml

• Appliquer des changements depuis un fichier :

  kubectl apply -f ingress.yaml

• Annoter ou labelliser un Ingress (remplacer si existant) :

  kubectl annotate ingress demo nginx.ingress.kubernetes.io/rewrite-target=/ --overwrite -n ingress-demo
  kubectl label ingress demo app=demo --overwrite -n ingress-demo

• Éditer sur place (à utiliser avec parcimonie) :

  kubectl edit ingress demo -n ingress-demo

• Patch ciblé et minimal :

  kubectl patch ingress demo -n ingress-demo \
    --type merge -p '{"metadata":{"annotations":{"nginx.ingress.kubernetes.io/ssl-redirect":"true"}}}'

• Supprimer une route si nécessaire :

  kubectl delete ingress demo -n ingress-demo

Contrôleur et vérifications système :

• Consulter les logs du contrôleur (nom d'exemple pour NGINX Ingress) :

  kubectl -n ingress-nginx logs deploy/ingress-nginx-controller

• Regarder les events du namespace dans l'ordre temporel :

  kubectl -n ingress-demo get events --sort-by=.lastTimestamp

• Port-forward du Service du contrôleur pour tester en local (HTTP et HTTPS) :

  kubectl -n ingress-nginx port-forward svc/ingress-nginx-controller 8080:80 8443:443

Exemple pratique : Ingress HTTP minimal

Créez un namespace dédié et une petite application d'echo pour visualiser les en-têtes et chemins arrivant via l'Ingress.

1. Créer le namespace :

kubectl create namespace ingress-demo

1. Déployer une simple app d'echo et un Service :

# demo-app.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo
  namespace: ingress-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: demo
  template:
    metadata:
      labels:
        app: demo
    spec:
      containers:
      - name: http-echo
        image: hashicorp/http-echo:1.0.0
        args: ["-text=hello from demo"]
        ports:
        - containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
  name: demo-svc
  namespace: ingress-demo
spec:
  selector:
    app: demo
  ports:
  - name: http
    port: 80
    targetPort: 5678

Appliquer :

kubectl apply -f demo-app.yaml

1. Créer un Ingress minimal :

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

Appliquer et vérifier :

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

1. Tester en local via port-forward du Service du contrôleur :

# Dans un premier terminal
kubectl -n ingress-nginx port-forward svc/ingress-nginx-controller 8080:80

# Dans un autre terminal
curl -H "Host: app.example.local" http://127.0.0.1:8080/

Attendu : vous devez voir le texte d'echo ou une réponse HTTP 200.

Exemple pratique : ajouter TLS

Pour un test local rapide, utilisez un certificat auto-signé. À réserver aux environnements non production.

1. Créer une clé et un certificat TLS de test :

openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout tls.key -out tls.crt -subj "/CN=app.example.local/O=demo"

1. Créer un secret TLS Kubernetes dans le même namespace que l'Ingress :

kubectl -n ingress-demo create secret tls demo-tls --cert=tls.crt --key=tls.key

1. Ajouter TLS au spec de l'Ingress :

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

Appliquer et vérifier :

kubectl apply -f demo-ingress-tls.yaml
kubectl -n ingress-demo describe ingress demo

1. Tester HTTPS localement (port-forward 443) :

# Dans un premier terminal
kubectl -n ingress-nginx port-forward svc/ingress-nginx-controller 8443:443

# Dans un autre terminal (-k pour ignorer l'avertissement auto-signé)
curl -k -H "Host: app.example.local" https://127.0.0.1:8443/

Attendu : HTTP 200 sur HTTPS. En production, utilisez un certificat valide et évitez l'option -k.

Dépannage et opérations sûres

Vérifications rapides :

• Confirmer l'Ingress et sa classe :

  kubectl get ingress -A
  kubectl get ingressclass

• Chercher les erreurs et raisons dans la description et les events :

  kubectl -n ingress-demo describe ingress demo
  kubectl -n ingress-demo get events --sort-by=.lastTimestamp | tail -n 40

• S'assurer que des endpoints existent pour le Service :

  kubectl -n ingress-demo get endpoints demo-svc -o wide

• Examiner les logs du contrôleur pour les erreurs de routage ou TLS :

  kubectl -n ingress-nginx logs deploy/ingress-nginx-controller | tail -n 100

Changements plus sûrs :

• Prévisualiser avant d'appliquer :

  kubectl diff -f demo-ingress.yaml

• Faire des mises à jour ciblées :

  kubectl patch ingress demo -n ingress-demo \
    --type merge -p '{"metadata":{"annotations":{"nginx.ingress.kubernetes.io/proxy-body-size":"8m"}}}'

• Revenir en arrière en ré-appliquant un manifest validé ou en supprimant un changement à la fois.

Problèmes fréquents :

• 404 depuis le contrôleur : vérifiez l'en-tête Host dans curl, l'hôte de l'Ingress et la correspondance du path.
• 502/504 : confirmez l'alignement Service targetPort et containerPort du Pod ; vérifiez la readiness du Pod.
• Avertissements TLS : contrôlez que le secret est de type kubernetes.io/tls et que les hosts correspondent au CN/SAN du certificat.

Plan pilote local

Objectif : router un seul host et un seul path vers un Service, testé en local, avec un verdict clair.

Périmètre et configuration :

• Namespace : ingress-demo
• Host : app.example.local
• Paths : /
• Backends : un Service (demo-svc)
• Critères de succès : HTTP 200 pour les tests HTTP et HTTPS

Étapes :

1. Déployer l'echo app et le Service (demo-app.yaml)
2. Appliquer l'Ingress minimal (demo-ingress.yaml)
3. Port-forward du Service du contrôleur et curl avec l'en-tête Host
4. Ajouter le secret TLS et mettre à jour l'Ingress (demo-ingress-tls.yaml)
5. Re-tester en HTTPS en utilisant -k pour l'auto-signé
6. Documenter commandes et sorties pour réutilisation par l'équipe

Conditions de sortie :

• Réponses 200 vérifiées en HTTP et HTTPS
• Aucun event d'erreur dans le namespace
• Logs du contrôleur exempts d'erreurs récurrentes

Conclusion

Vous disposez désormais d'une méthode reproductible pour créer, vérifier, tester, sécuriser et dépanner un Kubernetes Ingress avec un petit ensemble de commandes fiables. Démarrez par un pilote local pour réduire les risques, puis étendez à plusieurs hosts et paths. Continuez d'utiliser diff, des patchs ciblés et des tests clairs pour éviter les régressions. Quand vous êtes prêts, standardisez ces manifests et ces commandes dans vos runbooks d'équipe pour des routes rapides, cohérentes et sûres - pensez-y comme un Kubernetes Ingress cheat sheet au quotidien pour vos Kubernetes Ingress operations.