Exposer des applications Kubernetes

Introduction

Dans ce laboratoire (lab), vous apprendrez à exposer des applications Kubernetes en utilisant diverses techniques, notamment en créant des services internes et externes, en utilisant les étiquettes (labels) et en explorant les bases de l'Ingress. Vous commencerez par configurer un cluster Kubernetes local à l'aide de Minikube, puis déployerez une application NGINX exemple et l'exposerez à la fois en interne et en externe. Vous explorerez également l'utilisation des étiquettes pour organiser et sélectionner des ressources, et enfin, vous apprendrez à propos de l'Ingress et verrez un exemple simple de fichier YAML pour l'Ingress.

Démarrer le cluster Kubernetes

Dans cette étape, vous apprendrez à démarrer et à vérifier un cluster Kubernetes local en utilisant Minikube. C'est une étape essentielle pour développer et tester des applications Kubernetes sur votre machine locale.

Tout d'abord, démarrez le cluster Minikube :

minikube start

Exemple de sortie :

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23...
🚀  Launching Kubernetes...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Vérifiez l'état du cluster en utilisant plusieurs commandes :

minikube status
kubectl get nodes

Exemple de sortie pour minikube status :

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Exemple de sortie pour kubectl get nodes :

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Ces commandes confirment que :

Minikube est en cours d'exécution avec succès.
Un cluster Kubernetes local a été créé.
Le cluster est prêt à être utilisé.
Vous disposez d'un cluster mono - noeud avec des capacités de plan de contrôle.

Déployer une application exemple

Dans cette étape, vous apprendrez à créer et à déployer une application Kubernetes en utilisant un manifeste YAML. Nous allons créer un déploiement simple d'un serveur web NGINX pour démontrer le processus de définition et d'application de ressources Kubernetes.

Tout d'abord, créez un répertoire pour vos manifestes Kubernetes :

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Créez un fichier YAML pour un déploiement NGINX :

nano nginx-deployment.yaml

Ajoutez le manifeste de déploiement suivant :

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

Enregistrez le fichier (Ctrl+X, puis Y, puis Entrée).

Appliquez le déploiement au cluster Kubernetes :

kubectl apply -f nginx-deployment.yaml

Exemple de sortie :

deployment.apps/nginx-deployment created

Vérifiez le déploiement et les pods :

kubectl get deployments
kubectl get pods

Exemple de sortie pour kubectl get deployments :

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           1m

Exemple de sortie pour kubectl get pods :

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

Attendez que les pods soient dans l'état "Running" avant de continuer.

Analysons le manifeste YAML :

apiVersion : Spécifie la version de l'API Kubernetes.
kind : Définit le type de ressource (Déploiement).
metadata : Fournit le nom et les étiquettes (labels) pour le déploiement.
spec.replicas : Définit le nombre de replicas de pods.
selector : Aide le déploiement à gérer les bons pods.
template : Définit la spécification du pod.
containers : Spécifie l'image du conteneur et le port.

Ce déploiement crée trois pods NGINX identiques, démontrant ainsi comment Kubernetes gère les applications conteneurisées.

Créer un service via YAML pour exposer l'application en interne ou en externe

Dans cette étape, vous apprendrez à créer des services Kubernetes pour exposer votre déploiement NGINX en interne et en externe. Nous allons démontrer deux types de services courants : ClusterIP et NodePort.

Tout d'abord, accédez à votre répertoire de projet :

cd ~/project/k8s-manifests

Créez un fichier YAML pour le service ClusterIP :

nano nginx-clusterip-service.yaml

Ajoutez le manifeste de service suivant :

apiVersion: v1
kind: Service
metadata:
  name: nginx-clusterip-service
spec:
  selector:
    app: nginx
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 80

Maintenant, créez un fichier YAML pour le service NodePort :

nano nginx-nodeport-service.yaml

Ajoutez le manifeste de service suivant :

apiVersion: v1
kind: Service
metadata:
  name: nginx-nodeport-service
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080

Appliquez les deux configurations de service :

kubectl apply -f nginx-clusterip-service.yaml
kubectl apply -f nginx-nodeport-service.yaml

Exemple de sortie :

service/nginx-clusterip-service created
service/nginx-nodeport-service created

Vérifiez les services :

kubectl get services

Exemple de sortie :

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        30m
nginx-clusterip-service     ClusterIP   10.104.xxx.xxx   <none>        80/TCP         1m
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   1m

Pour accéder au service NodePort, obtenez l'adresse IP de Minikube :

minikube ip

Exemple de sortie :

192.168.49.2

Principales différences entre les types de services :

ClusterIP : Accès interne au cluster uniquement.
NodePort : Expose le service sur un port statique de l'adresse IP de chaque nœud.
Plage de ports NodePort : 30000 - 32767.

Vérifier la configuration du service

Dans cette étape, vous apprendrez à utiliser la commande kubectl describe service pour inspecter la configuration détaillée des services Kubernetes et comprendre leurs propriétés réseau.

Tout d'abord, assurez-vous d'être dans le répertoire du projet :

cd ~/project/k8s-manifests

Décrivons en détail le service ClusterIP :

kubectl describe service nginx-clusterip-service

Exemple de sortie :

Name:              nginx-clusterip-service
Namespace:         default
Labels:            <none>
Annotations:       <none>
Selector:          app=nginx
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.104.xxx.xxx
IPs:               10.104.xxx.xxx
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.0.7:80,10.244.0.8:80,10.244.0.9:80
Session Affinity:  None
Events:            <none>

Maintenant, décrivons le service NodePort :

kubectl describe service nginx-nodeport-service

Exemple de sortie :

Name:                     nginx-nodeport-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.108.yyy.yyy
IPs:                      10.108.yyy.yyy
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  30080/TCP
Endpoints:                10.244.0.7:80,10.244.0.8:80,10.244.0.9:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Inspectez les points d'accès (endpoints) du service pour vérifier la connectivité réseau :

kubectl get endpoints

Exemple de sortie :

NAME                        ENDPOINTS                               AGE
kubernetes                  192.168.49.2:8443                       45m
nginx-clusterip-service     10.244.0.7:80,10.244.0.8:80,10.244.0.9:80   15m
nginx-nodeport-service      10.244.0.7:80,10.244.0.8:80,10.244.0.9:80   15m

Informations clés à comprendre à partir de la description du service :

Sélecteur (Selector) : Montre quels pods font partie du service.
Adresse IP (IP) : Adresse IP interne au cluster du service.
Points d'accès (Endpoints) : Liste des adresses IP et des ports des pods qui servent le service.
Port et Port cible (Port et TargetPort) : Définissent comment le trafic est acheminé.
Port du nœud (NodePort) : Port externe pour le type de service NodePort.

Utiliser les étiquettes (labels) pour organiser et sélectionner les ressources

Dans cette étape, vous apprendrez à utiliser les étiquettes (labels) dans Kubernetes pour organiser et sélectionner efficacement des ressources. Les étiquettes sont des paires clé - valeur qui vous aident à gérer et à organiser les objets Kubernetes.

Tout d'abord, vérifiez les étiquettes actuelles de vos pods :

kubectl get pods --show-labels

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE   LABELS
nginx-deployment-xxx-yyy            1/1     Running   0          30m   app=nginx,pod-template-hash=xxx
nginx-deployment-xxx-zzz            1/1     Running   0          30m   app=nginx,pod-template-hash=yyy
nginx-deployment-xxx-www            1/1     Running   0          30m   app=nginx,pod-template-hash=zzz

Sélectionnez des pods en utilisant des étiquettes spécifiques :

kubectl get pods -l app=nginx

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Ajoutons une étiquette personnalisée à l'un des pods :

kubectl label pods nginx-deployment-xxx-yyy environment=development

Remplacez nginx-deployment-xxx-yyy par le nom d'un de vos pods.

Exemple de sortie :

pod/nginx-deployment-xxx-yyy labeled

Maintenant, sélectionnez des pods avec plusieurs sélecteurs d'étiquettes :

kubectl get pods -l app=nginx,environment=development

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30m

Supprimez une étiquette d'un pod :

kubectl label pods nginx-deployment-xxx-yyy environment-

Exemple de sortie :

pod/nginx-deployment-xxx-yyy unlabeled

Démontrons la sélection d'étiquettes dans les services :

kubectl describe service nginx-clusterip-service

Recherchez la section "Selector", qui montre comment les services utilisent les étiquettes pour identifier les pods.

Points clés sur les étiquettes :

Les étiquettes sont des paires clé - valeur attachées aux objets Kubernetes.
Elles sont utilisées pour organiser, sélectionner et filtrer des ressources.
Elles peuvent être ajoutées, modifiées ou supprimées dynamiquement.
Les services et les déploiements utilisent les étiquettes pour gérer les pods associés.

Supprimer et gérer les services

Dans cette étape, vous allez apprendre à supprimer et gérer les services Kubernetes en utilisant les commandes kubectl. Comprendre la gestion des services est crucial pour maintenir et nettoyer vos ressources Kubernetes.

Tout d'abord, liste les services actuels :

kubectl get services

Exemple de sortie :

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        1h
nginx-clusterip-service     ClusterIP   10.104.xxx.xxx   <none>        80/TCP         45m
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   45m

Supprimez un service spécifique en utilisant kubectl delete :

kubectl delete service nginx-clusterip-service

Exemple de sortie :

service "nginx-clusterip-service" deleted

Vérifiez la suppression du service :

kubectl get services

Exemple de sortie :

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        1h
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   45m

Pour démontrer plus clairement la suppression de plusieurs services, recréons nos services puis supprimons-les ensemble :

## Recreate services
kubectl apply -f nginx-clusterip-service.yaml
kubectl apply -f nginx-nodeport-service.yaml

## Delete multiple services at once
kubectl delete service nginx-clusterip-service nginx-nodeport-service

Exemple de sortie :

service "nginx-clusterip-service" deleted
service "nginx-nodeport-service" deleted

Vérifiez que tous les services ont été supprimés (à l'exception du service kubernetes par défaut) :

kubectl get services

Exemple de sortie :

NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   1h

Points clés concernant la suppression de services :

La suppression d'un service supprime le point d'accès réseau
Les pods ne sont pas supprimés lorsqu'un service est supprimé
Le service kubernetes par défaut ne peut pas être supprimé
Vous pouvez supprimer des services en utilisant le nom, un fichier YAML ou des étiquettes (labels)
Plusieurs services peuvent être supprimés simultanément en les listant ou en utilisant des sélecteurs d'étiquettes

Présentation des bases de l'ingress et exemple simple de fichier YAML pour l'ingress

Dans cette étape, vous allez apprendre ce qu'est l'ingress Kubernetes, un moyen puissant de gérer l'accès externe aux services dans un cluster Kubernetes.

Qu'est-ce que l'ingress ?

L'ingress est un objet API qui gère l'accès externe aux services dans un cluster Kubernetes, généralement via HTTP. L'ingress offre les fonctionnalités suivantes :

Équilibrage de charge : Répartit le trafic entre plusieurs services back-end.
Terminaison SSL/TLS : Gère les connexions sécurisées.
Hébergement virtuel basé sur le nom : Route les requêtes vers différents services en fonction du nom d'hôte.
Routage basé sur le chemin : Route les requêtes vers différents services en fonction du chemin de l'URL.

L'ingress se compose de deux composants :

Ressource Ingress : Un objet API Kubernetes qui définit les règles de routage.
Contrôleur Ingress : L'implémentation qui applique les règles définies dans la ressource Ingress.

Remarque : Ce laboratoire ne propose qu'une introduction de base à l'ingress. Dans les environnements de production, les configurations d'ingress peuvent être beaucoup plus complexes, notamment avec des routages avancés, de l'authentification, des limitations de débit, etc.

Activons l'addon Ingress dans Minikube :

minikube addons enable ingress

Exemple de sortie :

💡  ingress est un addon maintenu par Kubernetes. Pour toute question, contactez minikube sur GitHub.
🔉  ingress a été activé avec succès

Créons un déploiement pour deux applications d'exemple :

kubectl create deployment web1 --image=nginx:alpine
kubectl create deployment web2 --image=httpd:alpine

Exposons ces déploiements sous forme de services :

kubectl expose deployment web1 --port=80 --type=ClusterIP --name=web1-service
kubectl expose deployment web2 --port=80 --type=ClusterIP --name=web2-service

Créons un fichier YAML pour l'ingress :

nano ingress-example.yaml

Ajoutons la configuration d'ingress suivante :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - http:
        paths:
          - path: /web1
            pathType: Prefix
            backend:
              service:
                name: web1-service
                port:
                  number: 80
          - path: /web2
            pathType: Prefix
            backend:
              service:
                name: web2-service
                port:
                  number: 80

Composants clés de cette configuration d'ingress :

metadata.annotations : Configurations spécifiques pour le contrôleur Ingress.
spec.rules : Définissent comment le trafic est routé vers les services.
path : Chemin d'URL qui sera correspondu.
pathType : Comment le chemin doit être correspondu (Prefix, Exact ou ImplementationSpecific).
backend.service : Le service et le port vers lesquels le trafic sera routé.

Appliquons la configuration d'ingress :

kubectl apply -f ingress-example.yaml

Vérifions la ressource Ingress :

kubectl get ingress

Exemple de sortie :

NAME              CLASS   HOSTS   ADDRESS        PORTS   AGE
example-ingress   nginx   *       192.168.49.2   80      1m

Voyons les détails de l'ingress :

kubectl describe ingress example-ingress

La sortie de l'exemple montrera les règles de routage et les services back-end.

Testons l'ingress :

## Obtenez l'adresse IP de Minikube
minikube ip

## Testez l'accès aux services via l'ingress
curl $(minikube ip)/web1
curl $(minikube ip)/web2

Chaque commande devrait retourner la page par défaut du serveur web correspondant.

Dans les environnements de production, l'ingress peut être configuré avec :

Plusieurs règles basées sur le nom d'hôte.
Des certificats TLS pour HTTPS.
Des mécanismes d'authentification.
Des limitations de débit.
Des configurations de délai d'attente personnalisées.
Une affinité de session.
Et de nombreuses autres fonctionnalités avancées.

Pour une couverture plus complète de l'ingress, reportez-vous à la documentation de Kubernetes et envisagez d'explorer la documentation des contrôleurs d'ingress dédiés comme l'ingress NGINX ou Traefik.

Résumé

Dans ce laboratoire, vous avez appris à démarrer et à vérifier un cluster Kubernetes local en utilisant Minikube, ce qui est essentiel pour développer et tester des applications Kubernetes sur votre machine locale. Vous avez ensuite créé et déployé un simple déploiement de serveur web NGINX en utilisant un manifeste YAML, démontrant le processus de définition et d'application de ressources Kubernetes. De plus, vous avez appris à créer un service Kubernetes pour exposer votre application en interne ou en externe, ainsi qu'à utiliser des étiquettes (labels) pour organiser et sélectionner des ressources. Enfin, vous avez exploré les bases de l'Ingress Kubernetes et avez vu un exemple simple de YAML pour Ingress.