Aller au contenu principal

Chapitre 8.3 - Routage et TLS

Objectifs d'Apprentissage​

À la fin de ce chapitre, vous serez capable de:

  • Configurer le routage par hostname
  • Implémenter le routage par chemin (path-based)
  • Configurer TLS/SSL avec des certificats
  • Utiliser cert-manager pour la gestion automatique des certificats
  • Comprendre les path types
  • Gérer les rewrites et redirects

Introduction​

Le routage Ingress permet de diriger le trafic vers différents services selon le hostname ou le chemin. La configuration TLS permet de sécuriser les communications avec HTTPS.

Routage par Hostname​

Routage basé sur le nom de domaine:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-host-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: app1.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app1-service
            port:
              number: 80
  - host: app2.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app2-service
            port:
              number: 80
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 80

Résultat:

  • app1.example.com → app1-service
  • app2.example.com → app2-service
  • api.example.com → api-service

Routage par Chemin (Path-Based)​

Routage basé sur le chemin de l'URL:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-based-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 80
      - path: /web
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
      - path: /admin
        pathType: Prefix
        backend:
          service:
            name: admin-service
            port:
              number: 80
      - path: /
        pathType: Prefix
        backend:
          service:
            name: default-service
            port:
              number: 80

Résultat:

  • example.com/api → api-service
  • example.com/web → web-service
  • example.com/admin → admin-service
  • example.com/ → default-service

Path Types​

Prefix​

Le chemin doit commencer par le préfixe spécifié:

- path: /api
  pathType: Prefix

Correspond à:

  • /api
  • /api/v1
  • /api/users
  • /api/v1/users

Exact​

Le chemin doit correspondre exactement:

- path: /api
  pathType: Exact

Correspond à:

  • /api seulement

Ne correspond pas à:

  • /api/v1
  • /api/users

ImplementationSpecific​

Dépend de l'implémentation de l'Ingress Controller:

- path: /api
  pathType: ImplementationSpecific

Configuration TLS​

Créer un Secret TLS​

# Générer un certificat (exemple avec openssl)
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout tls.key -out tls.crt \
  -subj "/CN=example.com/O=example.com"

# Créer le Secret
kubectl create secret tls example-tls \
  --cert=tls.crt \
  --key=tls.key

Utiliser dans Ingress​

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tls-ingress
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    - www.example.com
    secretName: example-tls
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
  - host: www.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

Résultat: HTTPS activé pour example.com et www.example.com.

Cert-Manager pour Certificats Automatiques​

cert-manager gère automatiquement les certificats TLS avec Let's Encrypt.

Installation​

# Helm
helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --set installCRDs=true

ClusterIssuer (Let's Encrypt)​

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

Utilisation dans Ingress​

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: cert-ingress
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    secretName: example-tls  # Créé automatiquement par cert-manager
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

Résultat: Certificat TLS automatiquement obtenu et renouvelé par cert-manager.

Rewrites et Redirects​

Rewrite (NGINX)​

Réécrire l'URL avant de la transmettre au backend:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: rewrite-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /api(/|$)(.*)
        pathType: ImplementationSpecific
        backend:
          service:
            name: api-service
            port:
              number: 80

Résultat: example.com/api/users → api-service/users

Redirect​

Rediriger vers une autre URL:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: redirect-ingress
  annotations:
    nginx.ingress.kubernetes.io/permanent-redirect: "https://www.example.com"
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

Exemple Complet: Application Multi-Tiers​

Architecture​

Configuration​

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    secretName: example-tls
  rules:
  - host: example.com
    http:
      paths:
      # Web frontend
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
      # API backend
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      # Admin panel
      - path: /admin
        pathType: Prefix
        backend:
          service:
            name: admin-service
            port:
              number: 8080

Commandes Utiles​

Vérification​

# Voir les Ingress
kubectl get ingress

# Détails
kubectl describe ingress app-ingress

# Voir les certificats
kubectl get certificates
kubectl describe certificate example-tls

# Voir les secrets TLS
kubectl get secrets | grep tls

Test​

# Test HTTP
curl -H "Host: example.com" http://<ingress-ip>/

# Test HTTPS
curl -k https://example.com/

# Test avec path
curl -H "Host: example.com" http://<ingress-ip>/api/health

Bonnes Pratiques​

1. TLS Partout​

Utiliser HTTPS pour toutes les communications externes.

2. Cert-Manager​

Utiliser cert-manager pour la gestion automatique des certificats.

3. Path Types​

Choisir le bon path type (Prefix pour la plupart des cas).

4. Annotations​

Utiliser les annotations pour les fonctionnalités avancées (rewrites, redirects).

5. Monitoring​

Surveiller les certificats et leur expiration.

Résumé​

Dans ce chapitre, vous avez appris:

Routage par hostname: Plusieurs domaines avec un seul Ingress
Routage par chemin: Path-based routing vers différents services
Path types: Prefix, Exact, ImplementationSpecific
TLS: Configuration avec secrets Kubernetes
cert-manager: Gestion automatique des certificats Let's Encrypt
Rewrites: Réécriture d'URLs avec annotations
Redirects: Redirections permanentes ou temporaires
Bonnes pratiques: TLS partout, cert-manager, monitoring

Prochaines Étapes​

Module 9: Sécurité et RBAC
Lab 8.2: Configuration d'Ingress pour une Application
Lab 8.3: Certificats TLS avec Cert-Manager

Chapitre créé le: Décembre 2024