Commandes kubectl de base pour Kubernetes Ingress avec exemples pratiques

Introduction

Ingress expose des routes HTTP (HyperText Transfer Protocol) et HTTPS (HyperText Transfer Protocol Secure) depuis l'extérieur du cluster vers des Services internes. Ce guide vous donne les commandes kubectl Ingress les plus utiles, explique ce que chacune fait, quand l'utiliser et fournit des exemples prêts à copier. Vous créerez et vérifierez un Ingress HTTP minimal, ajouterez TLS (Transport Layer Security) pour le chiffrement, et dépannerez en toute sécurité sans perturber la production.

Ce que vous allez faire :

• Confirmer votre contrôleur Ingress et sa classe
• Créer un Ingress HTTP minimal
• Tester le routage localement avec port-forward + curl
• Ajouter TLS pour HTTPS
• Dépanner avec les événements et les journaux

Sécurité avant tout :

• Travaillez dans un espace de noms dédié (ex. ingress-demo) pour isoler les changements
• Utilisez --dry-run=client et kubectl diff avant d'appliquer
• Changez une seule chose à la fois et vérifiez

Vue d'ensemble du workflow

1. Vérifier les prérequis

• Un contrôleur Ingress est installé (ex. 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 localement via port-forward et curl
5. Ajouter TLS et retester
6. Dépanner avec événements/journaux si nécessaire

Commandes de base que vous utiliserez au quotidien

Inspection générale

• Lister tous les Ingress dans tous les espaces de noms :

kubectl get ingress -A

• Lister les classes Ingress disponibles :

kubectl get ingressclass

• Décrire un Ingress spécifique pour voir les règles, backends et événements :

kubectl describe ingress demo -n ingress-demo

Gestion des changements

• Prévisualiser les changements sans les appliquer :

kubectl diff -f ingress.yaml

• Appliquer les changements depuis un fichier :

kubectl apply -f ingress.yaml

• Annoter ou étiqueter un Ingress (écraser s'il existe déjà) :

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 avec un changement ciblé :

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

• Supprimer si vous devez retirer la route :

kubectl delete ingress demo -n ingress-demo

Vérifications du contrôleur et du système

• Consulter les journaux du contrôleur (exemple pour NGINX Ingress) :

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

• Surveiller les événements de l'espace de noms dans l'ordre chronologique :

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

• Port-forward le service du contrôleur pour tester localement (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 espace de noms dédié et une petite application echo pour voir les en-têtes et les chemins passer par l'Ingress.

1. Créer l'espace de noms :

kubectl create namespace ingress-demo

1. Déployer une application echo simple et son 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
a        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

Appliquez :

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

Appliquez et vérifiez :

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

1. Tester localement en port-forward le service du contrôleur :

# Dans un 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 devriez voir le texte echo ou une réponse HTTP 200.

Exemple pratique : ajouter TLS

Pour un test local rapide, utilisez un certificat auto-signé. Cela ne convient qu'aux tests non productifs.

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

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

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

1. Ajouter TLS à la 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

Appliquez et vérifiez :

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

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

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

# Dans un autre terminal (-k pour ignorer les avertissements de certificat auto-signé)
curl -k -H "Host: app.example.local" https://127.0.0.1:8443/

Attendu : HTTP 200 via HTTPS. En production, utilisez un certificat valide et n'utilisez pas -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 erreurs et raisons dans la description de l'Ingress et les événements :

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

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

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

• Examiner les journaux du contrôleur pour 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 manifeste connu bon ou en retirant un changement à la fois.

Problèmes courants

• 404 du contrôleur : vérifier l'en-tête Host dans curl, l'hôte de l'Ingress et la correspondance du chemin.
• 502/504 : confirmer que le targetPort du Service et le containerPort du Pod correspondent ; vérifier la readiness du Pod.
• Avertissements TLS : vérifier que le secret est de type kubernetes.io/tls et que les hôtes correspondent au CN/SAN du certificat.
• Mauvaise correspondance de chemin : s'assurer que pathType (Prefix/Exact) correspond aux attentes de routage de l'application.

Plan pilote local

Objectif : Router un seul hôte et un seul chemin vers un Service, testé localement, avec critères de réussite clairs.

Périmètre et configuration :

• Espace de noms : ingress-demo
• Hôte : app.example.local
• Chemins : /
• Backends : un Service (demo-svc)
• Critères de succès : réponse HTTP 200 pour les tests HTTP et HTTPS

Étapes :

1. Déployer l'application echo et le Service (demo-app.yaml)
2. Appliquer l'Ingress minimal (demo-ingress.yaml)
3. Port-forward le 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. Retester avec HTTPS en utilisant -k pour l'auto-signé
6. Documenter les commandes et sorties pour réutilisation par l'équipe

Conditions de sortie :

• Réponses 200 vérifiées en HTTP et HTTPS
• Aucun événement d'erreur dans l'espace de noms
• Journaux du contrôleur exempts d'erreurs récurrentes

Conclusion

Vous disposez maintenant d'une méthode reproductible pour créer, vérifier, tester, sécuriser et dépanner Kubernetes Ingress avec un petit ensemble de commandes fiables. Commencez par le pilote local pour réduire les risques, puis étendez à plusieurs hôtes et chemins. Continuez d'utiliser diff, les patches ciblés et des tests clairs pour éviter les régressions. Lorsque vous êtes prêt, standardisez ces manifests et commandes dans les runbooks de votre équipe afin que de nouvelles routes soient rapides, cohérentes et sûres.