Kubernetes (7/12) — Ingress & HTTPS

L’idée reçue

« Pour exposer mon appli, je change le type du Service en LoadBalancer et c’est réglé. »

Ça donne un accès brut, sans routage par nom de domaine ni HTTPS. La couche « porte d’entrée » professionnelle de Kubernetes, c’est l’Ingress : des règles de routage HTTP/HTTPS, appliquées par un Ingress Controller. En K3s, ce contrôleur est déjà là : Traefik.

Architecture cible, standard en production : Ingress → Service → Deployment → Pods. On remplace mondomaine.fr par ton domaine (DNS chez OVH, pointant vers l’IP publique de ton cluster).

À la fin de ce module, tu sauras…

Distinguer Ingress (les règles) et Ingress Controller (le moteur)
Confirmer que Traefik est bien le contrôleur de ton K3s
Créer un Ingress qui route un nom de domaine vers ton Service
Activer HTTPS automatique via ACME (Let’s Encrypt)

01Ingress vs Ingress Controller

Expérience 1

Confirmer le contrôleur de ton cluster

Manipule

kubectl get pods -n kube-system | grep traefik
kubectl get svc -n kube-system | grep traefik

Observe

traefik-6746955c79-r8qpt      1/1   Running   ...
traefik   LoadBalancer   10.43.x.x   &lt;EXTERNAL-IP&gt;   80:.../TCP,443:.../TCP

Le Pod traefik tourne dans kube-system : c’est l’Ingress Controller de K3s. Son Service expose les ports 80 et 443 — la porte d’entrée externe du cluster.

Comprends deux notions à ne pas confondre

Un Ingress est un objet Kubernetes où tu déclares des règles (« si l’hôte est demo.mondomaine.fr, envoie vers demo-service »). L’Ingress Controller est le composant qui applique ces règles — ici Traefik, qui lit l’API, surveille les Ingress, et route le trafic. Sans contrôleur, un Ingress ne fait rien. K3s installe Traefik par défaut : pratique.

02Le DNS vers le cluster

Expérience 2

Faire pointer un nom vers Traefik

Chez OVH, crée un enregistrement A pour demo.mondomaine.fr vers l’IP publique qui atteint ton cluster (l’EXTERNAL-IP de Traefik, exposée via ton réseau OPNsense de la Phase 2).

Manipule

dig +short demo.mondomaine.fr

Le nom renvoie ton IP publique. Le trafic HTTP pour ce nom arrivera à Traefik.

Comprends pourquoi le DNS d’abord

L’Ingress route par nom d’hôte : sans DNS correct, Traefik ne reçoit rien à router. Et pour le HTTPS via ACME (défi HTTP-01), Let’s Encrypt doit pouvoir joindre ton hôte publiquement sur le port 80. Le DNS est donc la première brique.

03Créer l’Ingress (HTTP d’abord)

Expérience 3

Router demo.mondomaine.fr → demo-service

Manipule

cat &lt;&lt;'EOF' | kubectl apply -f -
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: demo-ingress
namespace: lab-soria
annotations:
  traefik.ingress.kubernetes.io/router.entrypoints: web
spec:
rules:
- host: demo.mondomaine.fr
  http:
    paths:
    - path: /
      pathType: Prefix
      backend:
        service:
          name: demo-service
          port:
            number: 8092
EOF

Manipule

kubectl get ingress
curl -I http://demo.mondomaine.fr/

Observe

NAME           CLASS     HOSTS                  ADDRESS         PORTS
demo-ingress   traefik   demo.mondomaine.fr     &lt;IP publique&gt;   80

HTTP/1.1 200 OK

La chaîne complète fonctionne en HTTP : Navigateur → DNS → IP publique → Traefik (Ingress) → demo-service → Pods.

Comprends le YAML, ligne clé

host = le nom qui déclenche la règle. path: / + pathType: Prefix = tout le trafic. backend.service = vers quel Service (et quel port) router. L’annotation entrypoints: web dit à Traefik d’écouter sur l’entrée HTTP (port 80). L’Ingress n’est pas « un nginx de plus » : c’est la façon Kubernetes de décrire des règles de reverse proxy.

04Activer HTTPS via ACME (Traefik)

Expérience 4

Des certificats Let’s Encrypt automatiques

En K3s, Traefik est déployé via une ressource HelmChart. On y ajoute un « resolver » ACME (appelé le) qui gère l’émission et le renouvellement des certificats. Crée traefik-acme.yaml :

Manipule

apiVersion: helm.cattle.io/v1
kind: HelmChartConfig
metadata:
name: traefik
namespace: kube-system
spec:
valuesContent: |-
  certificatesResolvers:
    le:
      acme:
        email: admin@mondomaine.fr
        storage: /data/acme.json
        httpChallenge:
          entryPoint: web
  persistence:
    enabled: true
    size: 1Gi
    path: /data

Manipule

kubectl apply -f traefik-acme.yaml
kubectl -n kube-system rollout restart deploy/traefik
kubectl -n kube-system rollout status deploy/traefik

Comprends pourquoi cette approche

On configure ACME une fois au niveau de Traefik, puis chaque Ingress peut le réutiliser. C’est le pattern DevOps : config d’infra dans des manifestes, reproductible et versionnable. Le storage: /data/acme.json avec persistance est crucial : sans lui, Traefik redemanderait des certificats à chaque redémarrage et se ferait bloquer par Let’s Encrypt.

05Basculer l’Ingress en HTTPS

Expérience 5

Référencer le resolver dans l’Ingress

Manipule

kubectl annotate ingress demo-ingress -n lab-soria \
traefik.ingress.kubernetes.io/router.entrypoints=websecure \
traefik.ingress.kubernetes.io/router.tls=true \
traefik.ingress.kubernetes.io/router.tls.certresolver=le --overwrite

Attends l’émission du certificat (quelques secondes à une minute), puis teste :

Manipule

curl -I https://demo.mondomaine.fr/

Observe

HTTP/2 200
# certificat valide, cadenas vert dans le navigateur

SORIA Web (ou nginx de démo) est désormais servi en HTTPS, avec un certificat de confiance publique, renouvelé automatiquement.

Comprends web vs websecure

web est l’entrée HTTP (port 80), websecure l’entrée HTTPS (port 443). En pointant l’Ingress sur websecure + tls.certresolver=le, Traefik présente le certificat ACME et sert le trafic chiffré. Le même resolver le peut servir tous tes futurs Ingress — configuré une fois, réutilisé partout.

→Le mapping avec ce que tu connais déjà

Kubernetes	Équivalent (Phases précédentes)
Ingress (règles)	les ACL/conditions HAProxy (Phase 4)
Ingress Controller (Traefik)	le reverse proxy HAProxy lui-même
ACME resolver de Traefik	os-acme-client sur OPNsense (Phase 4)

✓Ce que tu retiens

L’Ingress déclare des règles de routage par nom d’hôte ; l’Ingress Controller (Traefik, intégré à K3s) les applique. Après un DNS correct, on route en HTTP, puis on active le HTTPS automatique via ACME (resolver configuré une fois au niveau de Traefik, réutilisable). La chaîne standard Ingress → Service → Deployment → Pods est maintenant complète, et sécurisée.

Mini-projet

SORIA Web sur Internet, en HTTPS

À faire

Confirme Traefik comme contrôleur et repère son EXTERNAL-IP.
Crée l’enregistrement DNS pour ton hôte.
Crée un Ingress HTTP vers ton Service, teste avec curl.
Configure le resolver ACME au niveau de Traefik (avec persistance).
Bascule l’Ingress en HTTPS et prouve le certificat valide.
Documente dans BookStack la chaîne Ingress → Service → Pods et le rôle d’ACME.

Fil rouge — Ton appli est en ligne… mais elle tourne encore avec une image publique (nginx). Pour déployer ta image depuis Harbor (privé), le cluster doit s’authentifier auprès du registre. Au module suivant : Secrets & imagePullSecret — et la connexion cluster ↔ Harbor.

?Auto-évaluation

1. Quelle est la différence entre un Ingress et un Ingress Controller ?

L’Ingress déclare les règles de routage ; le contrôleur (Traefik) est le moteur qui les applique réellement. Sans contrôleur, l’Ingress ne route rien.

2. Pourquoi la persistance de acme.json est-elle importante ?

Sans elle, Traefik redemande des certificats à chaque redémarrage et risque d’être bloqué par les limites de Let’s Encrypt.

3. Quel est l’avantage de configurer ACME au niveau de Traefik ?

Une seule configuration sert tous les Ingress : émission et renouvellement automatiques, réutilisables pour chaque nouveau service.