Mise en réseau avec Ingress sur Kubernetes

Introduction

Dans ce laboratoire, vous apprendrez à utiliser Ingress pour acheminer le trafic externe vers les services exécutés dans un cluster Kubernetes.

Kubernetes Ingress est un outil puissant pour gérer l'accès externe aux services dans un cluster Kubernetes. Ingress agit comme un équilibreur de charge de couche 7, vous permettant d'acheminer le trafic vers différents services en fonction du chemin d'URL ou du nom d'hôte entrant.

Dans ce laboratoire, nous allons créer une application exemple et la rendre accessible au monde extérieur à l'aide d'ingress. Nous utiliserons nginx-ingress comme contrôleur Ingress, qui est une solution populaire et largement utilisée pour Kubernetes Ingress.

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

Accédez à votre répertoire de travail :

Ouvrez le terminal et accédez au dossier de projet par défaut :
```
cd /home/labex/project
```
Démarrez Minikube :

Démarrez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes mono - nœud sur votre machine locale.
- Minikube peut prendre quelques minutes à démarrer en fonction des performances de votre système.
Vérifiez que Minikube est en cours d'exécution :

Vérifiez l'état du cluster Minikube :
```
minikube status
```
- Recherchez des composants tels que kubelet et apiserver listés comme Running (en cours d'exécution).
- Si le cluster n'est pas en cours d'exécution, relancez la commande minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Installer le contrôleur Ingress Nginx

Tout d'abord, nous devons installer le contrôleur nginx-ingress dans notre cluster. Nous pouvons le faire en créant un déploiement (Deployment) et un service (Service) qui seront chargés d'exécuter le contrôleur Ingress.

Créez un espace de noms (namespace) pour le contrôleur Ingress :

kubectl create namespace ingress-nginx

Installez le chart ingress-nginx à l'aide de kubectl :

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

Vérifiez que les pods du contrôleur ingress-nginx sont en cours d'exécution :

kubectl get pods -n ingress-nginx

NAME                                        READY   STATUS              RESTARTS   AGE
ingress-nginx-admission-create-zjfqx        0/1     ContainerCreating   0          2s
ingress-nginx-admission-patch-8rvzw         0/1     ContainerCreating   0          2s
ingress-nginx-controller-6bdb654777-qz8fb   0/1     ContainerCreating   0          2s

Créer une application exemple

Ensuite, nous allons créer une application exemple que nous allons exposer à l'aide d'ingress.

Créez un déploiement (Deployment) pour une application exemple :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: sample-app
  template:
    metadata:
      labels:
        app: sample-app
    spec:
      containers:
      - name: sample-app
        image: nginx
        ports:
        - containerPort: 80

Le fichier YAML s'appelle sample-app.yaml. Appliquez le déploiement à votre cluster avec la commande suivante :

kubectl apply -f sample-app.yaml

Créez un service (Service) pour l'application exemple :

apiVersion: v1
kind: Service
metadata:
  name: sample-app
spec:
  selector:
    app: sample-app
  ports:
  - name: http
    port: 80
    targetPort: 80

Le fichier YAML s'appelle service-sample-app.yaml. Appliquez le déploiement à votre cluster avec la commande suivante :

kubectl apply -f service-sample-app.yaml

Créer une ressource Ingress

Maintenant que nous avons configuré le contrôleur Ingress et que nous avons un service backend en cours d'exécution, nous pouvons créer les règles pour la ressource Ingress.

Dans cet exemple, nous allons créer une règle simple pour acheminer le trafic du domaine test.local vers notre service backend :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: test.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: sample-app
            port:
              name: http

Le fichier YAML s'appelle ingress.yaml. Appliquez la ressource Ingress au cluster :

kubectl apply -f ingress.yaml

Tester la ressource Ingress

Enfin, nous pouvons tester la ressource Ingress pour nous assurer que tout fonctionne correctement.

Tout d'abord, déterminez l'adresse IP du nœud :

kubectl get node -o wide

NAME       STATUS   ROLES           AGE   VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION      CONTAINER-RUNTIME
minikube   Ready    control-plane   93s   v1.26.1   192.168.49.2   <none>        Ubuntu 20.04.5 LTS   5.15.0-56-generic   docker://20.10.23

Cette commande récupérera l'adresse du nœud Kubernetes. L'adresse IP étiquetée comme INTERNAL-IP.

Ensuite, ajoutez une entrée à votre fichier /etc/hosts pour mapper le domaine test.local à l'adresse IP du nœud :

echo "<IP_ADDRESS> test.local" | sudo tee -a /etc/hosts

Remplacez <IP_ADDRESS> par l'adresse IP interne du nœud. Par exemple :

echo "192.168.49.2 test.local" | sudo tee -a /etc/hosts

Ensuite, obtenez le port du nœud (NodePort) du service ingress-nginx.

kubectl get services -n ingress-nginx

Cette commande affichera une liste des services dans l'espace de noms (namespace) ingress-nginx. Recherchez le service nginx-ingress-controller et notez son NodePort.

NAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.104.99.158   <pending>     80:32518/TCP,443:31620/TCP   2m45s
ingress-nginx-controller-admission   ClusterIP      10.100.46.109   <none>        443/TCP                      2m45s

Enfin, utilisez curl pour effectuer une requête HTTP vers le point d'accès Ingress :

curl test.local:NodePort

Par exemple :

curl test.local:32518

Remplacez <NodePort> par le NodePort du service nginx-ingress-controller.

Si tout est configuré correctement, vous devriez voir la page d'accueil Nginx.

Vous pouvez également tester l'ingress en utilisant un navigateur web pour visiter test.local:<NodePort>/nginx.

Félicitations, vous avez correctement configuré une ressource Ingress dans Kubernetes et l'avez testée pour vous assurer qu'elle fonctionne correctement.

Résumé

Dans ce laboratoire, nous avons parcouru le processus de configuration et de paramétrage d'un contrôleur Ingress Nginx dans Kubernetes. Nous avons également créé une application exemple et utilisé Ingress pour acheminer le trafic externe vers notre service Nginx. Ce n'est que le début de ce que vous pouvez faire avec la mise en réseau Kubernetes, et nous vous encourageons à explorer davantage.