Aller au contenu principal

Lab 8.1 - Configuration d'Ingress NGINX

Objectifs du Lab​

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

  • Installer un Ingress Controller NGINX.
  • Comprendre le rôle d'un Ingress Controller.
  • Créer une ressource Ingress de base.
  • Exposer une application via Ingress.
  • Tester l'accès à l'application via Ingress.

Durée Estimée​

45-60 minutes

Prérequis​

  • kubectl installé et configuré.
  • Cluster Kubernetes local fonctionnel (minikube ou kind).
  • Connaissances sur Ingress (Chapitre 8.1 et 8.2).

Partie 1: Installation de l'Ingress Controller NGINX​

Étape 1.1: Activer l'Ingress sur Minikube​

Si vous utilisez minikube, activez le plugin Ingress:

minikube addons enable ingress

Vérifiez que l'Ingress Controller est installé:

kubectl get pods -n ingress-nginx

Vous devriez voir des Pods de l'Ingress Controller NGINX.

Étape 1.2: Installation Manuelle (Alternative)​

Si vous n'utilisez pas minikube ou pour une installation manuelle, utilisez:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.8.1/deploy/static/provider/cloud/deploy.yaml

Attendez que les Pods soient prêts:

kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=90s

Partie 2: Déploiement d'une Application de Test​

Avant de configurer Ingress, déployons une application simple.

Étape 2.1: Créer un Deployment​

Créez un fichier app-deployment.yaml:

# app-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: nginx
        image: nginx:1.20
        ports:
        - containerPort: 80

Appliquez le Deployment:

kubectl apply -f app-deployment.yaml

Étape 2.2: Créer un Service​

Créez un fichier app-service.yaml:

# app-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  selector:
    app: web-app
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

Appliquez le Service:

kubectl apply -f app-service.yaml

Vérifiez que le Service est créé:

kubectl get svc web-app-service

Partie 3: Création d'une Ressource Ingress​

Étape 3.1: Créer l'Ingress​

Créez un fichier ingress-basic.yaml:

# ingress-basic.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-app-ingress
spec:
  ingressClassName: nginx # Spécifie l'Ingress Controller à utiliser
  rules:
  - host: webapp.local # Nom d'hôte (pour local, utilisez ce nom ou modifiez /etc/hosts)
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-app-service
            port:
              number: 80

Explication:

  • ingressClassName: nginx: Indique d'utiliser l'Ingress Controller NGINX.
  • host: webapp.local: Le nom d'hôte pour accéder à l'application.
  • path: /: Tous les chemins commençant par /.
  • backend: Le Service backend qui gère le trafic.

Appliquez l'Ingress:

kubectl apply -f ingress-basic.yaml

Étape 3.2: Vérifier l'Ingress​

Vérifiez que l'Ingress est créé:

kubectl get ingress

Vérifiez les détails:

kubectl describe ingress web-app-ingress

Vous devriez voir l'adresse IP de l'Ingress Controller (sur minikube, cela peut prendre quelques secondes).

Partie 4: Accès à l'Application​

Étape 4.1: Obtenir l'Adresse IP de l'Ingress​

Sur minikube, obtenez l'IP:

minikube ip

Ou vérifiez l'Ingress:

kubectl get ingress web-app-ingress

Étape 4.2: Configurer le Hostname (Local)​

Pour un cluster local, vous devez ajouter l'entrée dans /etc/hosts (Linux/Mac) ou C:\Windows\System32\drivers\etc\hosts (Windows):

# Sur Linux/Mac, éditez /etc/hosts
sudo nano /etc/hosts

# Ajoutez cette ligne (remplacez <INGRESS_IP> par l'IP de l'Ingress):
<INGRESS_IP> webapp.local

Sur Windows, éditez C:\Windows\System32\drivers\etc\hosts avec les permissions administrateur.

Étape 4.3: Tester l'Accès​

Testez l'accès à l'application:

curl http://webapp.local

Ou ouvrez http://webapp.local dans votre navigateur.

Vous devriez voir la page par défaut de NGINX.

Étape 4.4: Alternative avec Port-Forward (Sans Modifier /etc/hosts)​

Si vous ne voulez pas modifier /etc/hosts, utilisez port-forward vers l'Ingress Controller:

# Trouvez le nom du Pod de l'Ingress Controller
INGRESS_POD=$(kubectl get pods -n ingress-nginx -l app.kubernetes.io/component=controller -o jsonpath='{.items[0].metadata.name}')

# Port-forward
kubectl port-forward -n ingress-nginx $INGRESS_POD 8080:80

Puis testez:

curl -H "Host: webapp.local" http://localhost:8080

Partie 5: Vérification des Logs​

Vérifiez les logs de l'Ingress Controller pour voir les requêtes:

kubectl logs -n ingress-nginx -l app.kubernetes.io/component=controller --tail=20

Vous devriez voir les requêtes HTTP entrantes.

Partie 6: Nettoyage​

Supprimez les ressources créées:

kubectl delete ingress web-app-ingress
kubectl delete -f app-service.yaml
kubectl delete -f app-deployment.yaml

Pour désactiver l'Ingress sur minikube:

minikube addons disable ingress

Résumé du Lab​

Dans ce lab, vous avez installé et configuré un Ingress Controller NGINX, créé une ressource Ingress de base, et exposé une application via Ingress. Vous avez appris à accéder à l'application via le nom d'hôte configuré.

Prochaines Étapes​

Le prochain lab vous montrera comment configurer le routage basé sur les chemins (Path-based routing) pour diriger le trafic vers différentes applications.

Lab 8.2: Path-based Routing

Lab créé le: Décembre 2024