Aller au contenu principal

Lab 8.2 - Path-based Routing

Objectifs du Lab​

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

  • Configurer le routage basé sur les chemins (path-based).
  • Router le trafic vers différentes applications selon le chemin.
  • Comprendre les différents pathTypes.
  • Tester le routage avec plusieurs chemins.

Durée Estimée​

45-60 minutes

Prérequis​

  • kubectl installé et configuré.
  • Cluster Kubernetes local fonctionnel avec Ingress Controller.
  • Connaissances sur Ingress (Lab 8.1).

Partie 1: Déploiement de Plusieurs Applications​

Nous allons déployer deux applications différentes pour tester le routage basé sur les chemins.

Étape 1.1: Déployer l'Application Frontend​

Créez frontend-deployment.yaml:

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

Étape 1.2: Déployer l'Application Backend​

Créez backend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: httpd
        image: httpd:2.4
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: backend-service
spec:
  selector:
    app: backend
  ports:
  - port: 80
    targetPort: 80

Appliquez les déploiements:

kubectl apply -f frontend-deployment.yaml
kubectl apply -f backend-deployment.yaml

Partie 2: Configuration de l'Ingress avec Path-based Routing​

Étape 2.1: Créer l'Ingress avec Plusieurs Chemins​

Créez ingress-path-based.yaml:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-based-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: app.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend-service
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: backend-service
            port:
              number: 80
      - path: /backend
        pathType: Prefix
        backend:
          service:
            name: backend-service
            port:
              number: 80

Explication:

  • /: Route vers le frontend (page d'accueil).
  • /api: Route vers le backend.
  • /backend: Route alternative vers le backend.

Appliquez l'Ingress:

kubectl apply -f ingress-path-based.yaml

Partie 3: Personnalisation des Applications pour le Test​

Pour mieux visualiser le routage, personnalisons les réponses des applications.

Étape 3.1: Personnaliser le Frontend​

Créez un ConfigMap pour le frontend:

apiVersion: v1
kind: ConfigMap
metadata:
  name: frontend-config
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Frontend Application</title></head>
    <body>
      <h1>Frontend Application</h1>
      <p>Vous êtes sur la page d'accueil (/)</p>
      <p><a href="/api">Accéder à l'API</a></p>
    </body>
    </html>

Appliquez et montez le ConfigMap dans le frontend (modifiez le Deployment si nécessaire).

Étape 3.2: Personnaliser le Backend​

Créez un ConfigMap pour le backend:

apiVersion: v1
kind: ConfigMap
metadata:
  name: backend-config
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Backend API</title></head>
    <body>
      <h1>Backend API</h1>
      <p>Vous êtes sur l'API (/api ou /backend)</p>
      <p>Ceci est le service backend</p>
    </body>
    </html>

Partie 4: Test du Routage​

Étape 4.1: Configurer le Hostname​

Ajoutez app.local à votre fichier /etc/hosts (ou équivalent Windows) pointant vers l'IP de l'Ingress Controller.

Étape 4.2: Tester les Différents Chemins​

Testez le routage:

# Page d'accueil (devrait aller au frontend)
curl http://app.local/

# API (devrait aller au backend)
curl http://app.local/api

# Backend alternatif (devrait aller au backend)
curl http://app.local/backend

Vous devriez voir différentes réponses selon le chemin.

Partie 5: Comprendre les pathTypes​

Les pathType déterminent comment les chemins sont comparés:

  • Exact: Correspondance exacte du chemin.
  • Prefix: Correspondance du préfixe (le plus courant).
  • ImplementationSpecific: Dépend de l'implémentation de l'Ingress Controller.

Exemple avec Exact​

- path: /api/v1
  pathType: Exact
  backend:
    service:
      name: api-v1-service
      port:
        number: 80

Partie 6: Nettoyage​

Supprimez les ressources:

kubectl delete ingress path-based-ingress
kubectl delete -f frontend-deployment.yaml
kubectl delete -f backend-deployment.yaml
kubectl delete configmap frontend-config backend-config

Résumé du Lab​

Dans ce lab, vous avez configuré le routage basé sur les chemins avec Ingress. Vous avez appris à router le trafic vers différentes applications selon le chemin de l'URL, à utiliser différents pathTypes, et à tester le routage.

Prochaines Étapes​

Le prochain lab vous montrera comment configurer TLS/SSL avec cert-manager pour sécuriser les communications HTTPS.

Lab 8.3: TLS/SSL avec Cert-Manager

Lab créé le: Décembre 2024