Tutoriel Kubernetes : Un guide pour débutants sur le déploiement d'applications

Les bases de Kubernetes : Pods, déploiements, services et espaces de noms

Maintenant que nous avons mis en place un cluster et vérifié que tout fonctionne, il est temps de créer notre première application.

Mais avant de créer la première application, il est essentiel de comprendre les bases de Kubernetes. Si vous souhaitez une introduction plus approfondie à Kubernetes, , je vous recommande de suivre le cours Introduction à Kubernetes.

Les concepts les plus élémentaires de Kubernetes sont les pods, les déploiements et les services. La connaissance de ces trois types de ressources peut vous aider à créer des applications puissantes. C'est pourquoi nous allons nous y intéresser de plus près.

Qu'est-ce qu'un pod ?

Un pod est la plus petite unité déployable dans Kubernetes. Il exécute un ou plusieurs conteneurs étroitement couplés avec le même stockage, le même réseau et le même espace de noms. Un pod est toujours planifié sur un nœud Kubernetes. 

Vous pouvez définir le nombre de ressources que votre pod doit obtenir (par exemple, l'unité centrale et la mémoire). 

Un exemple d'application avec deux conteneurs pourrait être votre conteneur d'application et un conteneur d'aide qui regroupe les journaux et les envoie quelque part. 

Caractéristiques d'un pod :

• Cas unique : Chaque pod exécute une seule instance de votre application.
• Ephémère par nature : Les modules sont conçus pour être temporaires et sont remplacés en cas de défaillance ou de mise à jour.

Exemple de YAML pour la création d'un pod :

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Vous pouvez ensuite installer le pod à l'aide de kubectl :

kubectl apply -f pod.yaml

Cela démarre un Pod nommé my-pod, qui exécute un serveur web nginx pour vous.

Que sont les déploiements ?

Un déploiement est un objet Kubernetes de niveau supérieur utilisé pour gérer le cycle de vie des pods. Il s'assure que le nombre souhaité de répliques du pod est en cours d'exécution et gère les mises à jour et les retours en arrière. 

Caractéristiques d'un déploiement :

• Gestion des répliques: Veille à ce que le nombre souhaité de modules soit toujours en cours d'exécution.
• Auto-guérison: Remplace automatiquement les dosettes défectueuses.
• Mises à jour en continu: Met à jour la version de l'application étape par étape sans interruption de service (si configuré).

Voyons à quoi ressemblerait un fichier YAML de déploiement qui crée à nouveau un serveur web nginx, mais cette fois avec trois répliques :

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

Vous pouvez installer ce déploiement avec kubectl :

kubectl apply -f deployment.yaml

Ce qui précède crée un déploiement nommé nginx-deployment qui crée trois Pods, chacun exécutant le conteneur nginx. 

Qu'est-ce qu'un service ?

Venons-en à la dernière partie : Les services. 

Un service est une abstraction qui fournit un accès réseau stable aux pods, même si leurs adresses IP changent. Il sert de pont entre vos applications et les clients externes. 

Mais pourquoi cela est-il nécessaire ? Chaque pod a son adresse IP. Pourquoi ne pouvons-nous pas utiliser directement cette adresse IP ? 

Nous le pouvons ! Mais nous ne devrions pas. Pourquoi ? 

Parce qu'un pod est éphémère, il est tué par le déploiement et un nouveau pod est mis à l'échelle chaque fois que votre pod n'est pas en bonne santé. Ce nouveau pod a alors une adresse IP différente. Cela signifierait que le client souhaitant utiliser votre application devrait modifier en permanence l'adresse IP chaque fois qu'un Pod tombe en panne, ce qui peut arriver fréquemment.

C'est là qu'un service entre en jeu : il recherche tous les pods correspondant à une étiquette particulière et leur achemine automatiquement le trafic. Si un pod devient malsain, le service arrête d'envoyer du trafic à ce pod. Et si un nouveau pod apparaît, il commencera à envoyer du trafic vers le nouveau pod. 

Le service distribue également le trafic entre toutes les répliques de votre déploiement, ce qui est fantastique car cela signifie que vous pouvez créer plus d'instances de votre application pour distribuer le trafic sans avoir à gérer cela via votre logique d'application.

Types de services :

• ClusterIP (par défaut): Expose le service au sein du cluster.
• NodePort: Expose le service sur un port accessible en dehors du cluster.
• LoadBalancer: S'intègre aux fournisseurs de cloud pour exposer le service via un équilibreur de charge.

Exemple YAML pour exposer notre serveur web nginx à l'extérieur du cluster :

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Vous pouvez à nouveau créer ce service à l'aide de kubectl :

kubectl apply -f service.yaml

Ce service distribuerait maintenant le trafic entrant à tous les pods avec l'étiquette app=nginx sur le port 80. 

Si vous exécutez une commande describe sur votre service nouvellement créé, vous devriez voir qu'il y a maintenant trois points d'extrémité, où chaque point d'extrémité représente l'adresse IP du pod qui est actuellement en cours d'exécution :

kubectl describe service nginx-service

La commande ci-dessus devrait renvoyer quelque chose de similaire : 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Relations entre les pods, les déploiements et les services

Pour résumer rapidement :

• Cosse: Représentent des instances d'application individuelles.
• Déploiements: Gérer le cycle de vie des gousses et veiller à ce qu'elles soient en bonne santé.
• Services: Fournir un accès stable aux pods et permettre une communication externe ou interne.

Qu'est-ce qu'un espace de nommage ?

Les espaces de noms dans Kubernetes vous permettent d'organiser et d'isoler les ressources au sein d'un cluster. Vous pouvez les considérer comme des grappes virtuelles au sein de la même grappe physique. 

Avantages de l'utilisation des espaces de noms :

• Séparation des préoccupations: Différentes équipes ou applications peuvent opérer dans leur propre espace de noms sans affecter les autres. 
• Gestion des ressources: Vous pouvez définir des quotas et des limites de ressources pour différents espaces de noms.
• Sécurité et contrôle d'accès: Les politiques peuvent être appliquées au niveau de l'espace de noms.

Par défaut, Kubernetes est livré avec quelques espaces de noms intégrés :

• par défaut: Les espaces de noms par défaut dans lesquels les ressources sont créées, sauf indication contraire.
• kube-system: Utilisé pour les composants internes de Kubernetes (par exemple, le serveur API, le planificateur, etc.).
• kube-public: Un espace de noms lisible par le public.
• kube-node-lease: Utilisé pour le cursus des battements de cœur des nœuds.

Vous pouvez créer un espace de noms à l'aide d'un fichier YAML : 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace

Enregistrez cela dans un fichier appelé namespace.yaml et appliquez-le à l'aide de : 

kubectl apply -f namespace.yaml

Lorsque vous exécutez la commande ci-dessous, vous devriez voir une liste de tous les espaces de noms par défaut répertoriés et de l'espace de noms nouvellement créé : 

kubectl get namespaces

Vous pouvez ensuite créer des ressources dans cet espace de noms en définissant simplement l'espace de noms dans la section des métadonnées de votre ressource. 

Notre déploiement nginx ressemblerait à ce qui suit si nous voulions le créer dans votre espace de noms nouvellement créé :

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

Vous devez maintenant indiquer explicitement que vous souhaitez récupérer les ressources de votre espace de noms nouvellement créé à l'aide de l'argument -n :

kubectl get deployment -n my-namespace

Gérer votre première application avec Kubernetes

Ok, maintenant que vous êtes familiarisé avec les concepts de base de Kubernetes, il est temps de déployer notre première application web sur Kubernetes et d'essayer d'y accéder. 

Dans ce chapitre, nous allons créer un serveur web nginx, exposer ce serveur web au monde extérieur via un service, mettre à l'échelle cette application pour simuler un comportement à fort trafic, et mettre à jour l'application à l'aide d'une mise à jour continue vers une version plus récente.

Alors, commençons à faire des choses amusantes !

Création d'un déploiement d'application web simple

La première étape consiste à créer un déploiement pour notre serveur web qui crée un conteneur en utilisant l'image Nginx.

Copiez le code ci-dessous et enregistrez-le dans un fichier appelé nginx-deployment.yaml.

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

Ensuite, appliquez ce déploiement à votre cluster à l'aide de la commande suivante :

kubectl apply -f nginx-deployment.yaml

Vous pouvez alors vérifier que le pod fonctionne : 

kubectl get pods

Exposer l'application à l'aide d'un service

Nous devons exposer le serveur web nginx au monde extérieur via un service. Pour cela, nous créons un service de type NodePort, car nous voulons accéder au serveur web nginx depuis notre machine locale en dehors du cluster Kubernetes.

Créez donc un fichier appelé nginx-service.yaml et ajoutez-y le contenu suivant :

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Vous pouvez ensuite appliquer le service à l'aide de la commande ci-dessous :

kubectl apply -f nginx-service.yaml

Enfin, vous pouvez utiliser minikube pour obtenir l'URL de votre serveur web nginx :

minikube service nginx-service --url

Ouvrez cette URL dans votre navigateur, et vous devriez voir la page d'accueil de votre serveur web nginx.

Capture d'écran de la page d'accueil d'un serveur web nginx dans un navigateur local.

Mise à l'échelle de l'application

Nous avons donc un Pod opérationnel. Mais il se peut qu'un grand nombre d'utilisateurs visitent notre page web. C'est pourquoi, dans Kubernetes, vous pouvez rapidement faire évoluer votre application pour avoir plus de Pods opérationnels. 

Le service détectera automatiquement tous les pods appartenant à ce déploiement et répartira les demandes entrantes vers tous les pods utilisant le serveur web nginx. Cela permet d'améliorer les performances globales de notre page web en cas de forte affluence.

Nous allons donc faire évoluer notre application vers 3 répliques à l'aide de la commande ci-dessous :

kubectl scale deployment nginx-deployment --replicas=3

Vous pouvez maintenant récupérer tous les Pods en cours d'exécution, qui devraient être au nombre de trois :

kubectl get pods

Vous pouvez également utiliser la commande ci-dessous pour obtenir tous les points d'extrémité auxquels notre nginx-service est connecté. Vous devriez obtenir trois points d'extrémité, chaque point d'extrémité étant sa propre adresse IP interne :

kubectl get endpoints nginx-service

Mises à jour en continu

Maintenant, nous avons un autre avantage significatif de l'utilisation de Kubernetes : Mises à jour en continu.

Une mise à jour continue vise à éviter toute interruption de votre application web. Imaginez les pertes financières subies par des entreprises telles qu'Amazon si leur page web était indisponible à chaque fois qu'Amazon mettait en place une nouvelle version.

À l'aide d'une mise à jour continue, Kubernetes met à l'échelle un nouveau pod, vérifie s'il est sain, puis met à l'échelle l'ancien. 

Par défaut, Kubernetes s'assure qu'au moins 75 % du nombre souhaité de Pods sont opérationnels, 25 % étant le nombre maximum indisponible. Cela signifie que dans notre cas, où nous avons trois répliques opérationnelles, Kubernetes n'ajoutera qu'un nouveau pod à la fois, vérifiera si celui-ci est sain et réduira l'échelle d'un autre pod si c'est le cas. Il répétera ce processus jusqu'à ce que tous les Pods soient mis à jour avec la nouvelle version.

Nous allons donc changer la version de notre image nginx de latest à 1.23:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23

Vous pouvez ensuite contrôler l'état du déploiement à l'aide de : 

kubectl rollout status deployment/nginx-deployment

Le résultat devrait ressembler à ce qui suit : 

Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out

Et pendant que le déploiement se poursuit, votre page web est accessible en permanence, sans aucun temps d'arrêt !

N'est-ce pas formidable ?

Gestion des ressources Kubernetes

Kubernetes fournit des outils puissants pour inspecter, modifier et supprimer des ressources de tous types. Comprendre comment gérer efficacement les ressources permet d'améliorer le dépannage, l'allocation des ressources et la maintenance globale de la grappe. 

Dans cette section, nous aborderons d'autres commandes essentielles qui vous aideront à gérer efficacement vos ressources et à les dépanner en cas de problème.

Visualisation des ressources de la grappe

Avant de modifier des ressources, il est essentiel de visualiser et d'inspecter les ressources actuellement en cours d'exécution dans votre cluster.

Vous pouvez, par exemple, lister tous les Pods, Services et Déploiements en cours d'exécution pour voir ce qui se passe dans votre cluster : 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deployments

Si vous souhaitez approfondir une ressource spécifique, vous pouvez utiliser lacommande describe :

kubectl describe deployment nginx-deployment

Vous obtiendrez ainsi davantage d'informations, notamment sur les mises à jour en continu, la mise à l'échelle ou les événements d'extraction d'images. C'est le premier point vers lequel vous pouvez vous tourner en cas de problème.

Vous pouvez également consulter les journaux d'un pod en cours d'exécution pour voir ce qui se passe à l'intérieur de ce pod à l'aide de la commande suivante :

kubectl logs <pod-name>

Suppression des ressources

Il est également essentiel de nettoyer les ressources au cas où elles ne seraient plus utilisées afin de libérer les ressources du cluster pour de nouvelles applications. 

Vous pouvez supprimer un pod en utilisant :

kubectl delete pod <pod-name>

Nous pouvons le faire pour l'un de nos pods nginx. Cependant, un nouveau Pod devrait être mis à l'échelle instantanément, car ils sont gérés via un déploiement, qui essaie toujours d'avoir trois répliques opérationnelles. 

Dans ce cas, nous devons donc supprimer le site nginx-deployment: 

kubectl delete deployment nginx-deployment

Après l'exécution de cette commande, tous les Pods nginx en cours d'exécution devraient être supprimés. 

Nous pouvons également supprimer toutes les ressources d'un espace de noms. La commande suivante supprimerait toutes nos ressources, qui ont été créées pardéfaut dans l'espace de noms default :

kubectl delete all --all

Conclusion

Félicitations ! Vous avez atteint la fin et avez réussi à faire vos premiers pas dans Kubernetes. 

En suivant ce tutoriel, vous avez appris à :

• Mettez en place un cluster Kubernetes local à l'aide de minikube.
• Travaillez avec des pods, des déploiements, des services et des espaces de noms (les blocs de construction essentiels de Kubernetes).
• Déployez et gérez une application web simple dans Kubernetes.
• Faites évoluer les applications de manière dynamique et effectuez des mises à jour sans interruption de service.
• Gérez les ressources Kubernetes en les répertoriant, en les décrivant et en les supprimant.

Kubernetes peut sembler complexe au départ (en tout cas, c'était le cas pour moi). Mais le fait de le décomposer en concepts fondamentaux le rend plus accessible. 

Continuez à expérimenter et déployez davantage d'applications. 

La meilleure façon d'apprendre Kubernetes est de le faire, alors commencez à construire !

Pour améliorer encore vos compétences en matière de Kubernetes, envisagez d'explorer :

• Travailler avec les ConfigMaps et les Secrets : Stockez et gérez les paramètres de configuration en toute sécurité.
• Volumes persistants : Découvrez comment stocker des données qui survivent aux redémarrages de Pod à l'aide de volumes persistants.
• Mise en réseau et contrôleurs d'entrée : Mettre en place un routage basé sur un domaine et gérer le trafic externe.
• Barre : Utilisez les diagrammes Helm pour empaqueter et déployer efficacement des applications complexes.
• Kubernetes dans le cloud : Expérimentez les services Kubernetes gérés tels que AWS EKS, Azure AKS ou Google GKE.

Enfin, le cursus Conteneurisation et virtualisation avec Docker et Kubernetes sur DataCamp est une excellente ressource pour s'entraîner avec Docker et Kubernetes.