¶ Présentation
Je vous propose ici un parcours pratique pour découvrir Kubernetes, avec pour cette première partie les objectifs suivants :
- Comprendre les concepts de base de Kubernetes
- Installer et configurer un environnement Kubernetes local
- Maîtriser les commandes essentielles de kubectl
- Explorer l'interface de Kubernetes via le dashboard
Mais tout d'abord, quelques mots sur Kubernetes.
¶ Introduction à Kubernetes
¶ Histoire de Kubernetes
Kubernetes, souvent abrégé en K8s, est un orchestrateur de conteneurs open-source initialement développé par Google. Son origine remonte à Borg, un système interne de gestion de clusters utilisé par Google pour exécuter des milliers d'applications conteneurisées. En 2014, Google a ouvert le projet sous le nom de Kubernetes, qui est aujourd’hui maintenu par la Cloud Native Computing Foundation (CNCF).
¶ Principes fondamentaux de Kubernetes
Kubernetes repose sur plusieurs principes clés :
- Automatisation : Gestion automatique des déploiements, des mises à jour et de la mise à l’échelle.
- Évolutivité : Capacité à gérer un grand nombre de conteneurs répartis sur plusieurs machines.
- Résilience : Redémarrage automatique des conteneurs défaillants, reprogrammation sur d'autres nœuds en cas de panne.
- Déclaratif : Utilisation de fichiers YAML pour déclarer l'état souhaité du cluster.
¶ Pourquoi Kubernetes ?
L’objectif principal de Kubernetes est de fournir une plateforme permettant d'exécuter et de gérer des conteneurs à grande échelle, tout en assurant leur haute disponibilité, leur résilience et leur observabilité. Il permet ainsi aux équipes DevOps de déployer, gérer et mettre à l’échelle des applications conteneurisées de manière efficace.
¶ Composants et concepts principaux de Kubernetes
Kubernetes est composé de plusieurs éléments clés :
¶ Control Plane
Il gère l’ensemble du cluster et prend des décisions sur le placement des pods, leur mise à l’échelle et leur redémarrage en cas de défaillance. Il comprend :
- kube-apiserver : Interface de communication principale entre les utilisateurs et le cluster.
- etcd : Base de données clé-valeur stockant l’état global du cluster.
- kube-scheduler : Assigne les nouveaux pods aux nœuds disponibles.
- kube-controller-manager : Assure le bon fonctionnement des différents contrôleurs (gestion des pods, réplication, etc.).
¶ Nœuds (Nodes)
Chaque nœud exécute les charges de travail sous forme de pods et contient les composants suivants :
- kubelet : Agent s'exécutant sur chaque nœud pour assurer la gestion des conteneurs.
- cAdvisor : Intégré au kubelet, cet outil collecte et expose des métriques sur l'utilisation des ressources des conteneurs (CPU, mémoire, etc.).
- kube-proxy : Gère le réseau et la distribution du trafic vers les pods en maintenant les règles de routage et en assurant la connectivité entre les services du cluster.
- Container Runtime : Moteur de conteneurisation comme Docker ou containerd pour exécuter les conteneurs.
¶ Masters et Workers
Un cluster Kubernetes est généralement structuré autour d’un ensemble de nœuds maîtres (Masters) et de nœuds de travail (Workers) :
- Les nœuds maîtres gèrent le contrôle du cluster, prenant en charge les décisions de planification et d’orchestration.
- Les nœuds de travail exécutent les charges de travail (les pods).
¶ Namespaces
Les namespaces permettent de segmenter un cluster Kubernetes en plusieurs espaces isolés. Ils sont utiles pour :
- Séparer les environnements (développement, test, production).
- Gérer les accès et les ressources par équipe ou projet.
- Éviter les conflits de noms entre différentes applications.
¶ Pods
Le pod est le plus petit élément déployable dans Kubernetes, il représente un ou plusieurs conteneurs partageant le même réseau et espace de stockage.
¶ Services
Ils permettent de rendre accessibles les applications en exposant les pods de manière stable, même si leur adresse IP change.
¶ Deployments
Gèrent la mise en place et la mise à jour des pods en assurant la tolérance aux pannes.
¶ Scalabilité
Kubernetes permet une mise à l’échelle des applications de deux manières :
- Scalabilité horizontale (scale-out/in)
Ajout ou suppression de pods pour ajuster dynamiquement les ressources en fonction de la charge. Kubernetes gère très bien cette approche en ajoutant ou supprimant des réplicas de pods en fonction de la charge. C'est le modèle privilégié pour la montée en charge, et c'est une des grandes forces de Kubernetes. - Scalabilité verticale (scale-up/down)
Augmentation ou diminution des ressources allouées à un pod donné (CPU, RAM) en fonction des besoins.
Cependant :- Cela nécessite souvent de redémarrer le pod.
- Kubernetes ne redimensionne pas automatiquement les ressources d'un pod (sauf en utilisant un Vertical Pod Autoscaler).
- Il y a des limites physiques à cette approche (un seul pod ne peut pas dépasser la capacité d’un nœud).
Bref, la scalabilité verticale n'est pas le sens privilégié de Kubernetes, même si elle est gérée.
Voici, pour résumer, un schéma issu de l'article Wikipedia concernant Kubernetes :
¶ Configurations déclaratives
Kubernetes utilise des fichiers de configuration déclaratifs, au format YAML. Ces fichiers de configuration déclaratifs permettent de définir l'état souhaité du système de manière précise et reproductible. Cela assure une cohérence dans les déploiements, quel que soit l'environnement.
Plutôt que de spécifier une série d'étapes pour atteindre un état, on décrit simplement l'état final désiré. Kubernetes se charge ensuite de maintenir cet état, simplifiant ainsi la gestion à long terme des applications et infrastructures. Ceci apporte de nombreux avantages :
- Contrôle de version : les fichiers YAML peuvent être facilement versionnés dans des systèmes de contrôle de code source comme GitHub, permettant un suivi des modifications et une collaboration efficace.
- Automatisation : l'approche déclarative facilite l'automatisation des déploiements, des mises à jour et des rollbacks. Elle s'intègre parfaitement avec les pratiques DevOps et les pipelines CI/CD.
- Flexibilité et complexité : YAML supporte des structures de données complexes, permettant de décrire des configurations sophistiquées tout en restant lisible.
- Auto-réparation : Kubernetes surveille continuellement l'état réel du système et le compare à l'état déclaré, effectuant automatiquement des ajustements si nécessaire pour maintenir la configuration souhaitée.
Cette approche déclarative offre ainsi une gestion plus robuste, flexible et maintenable des applications conteneurisées dans Kubernetes.
¶ Les grands atouts de Kubernetes
Kubernetes offre de nombreux avantages pour la gestion des applications conteneurisées. Voici les principaux atouts de cette plateforme d'orchestration :
- Scalabilité automatique : Kubernetes ajuste automatiquement les ressources en fonction de la charge, créant ou supprimant des conteneurs selon les besoins. Cela permet d'optimiser les performances et d'éviter la surconsommation des ressources.
- Haute disponibilité et résilience : le système assure une haute disponibilité grâce à des mécanismes de redondance et de tolérance aux pannes. En cas de défaillance d'un conteneur ou d'un nœud, Kubernetes le remplace automatiquement, minimisant ainsi les temps d'arrêt.
- Portabilité et flexibilité : Kubernetes fonctionne sur divers environnements, qu'il s'agisse de clouds publics, privés ou de datacenters on-premise. Cette portabilité permet de déployer des applications de manière cohérente dans différents environnements.
- Optimisation des ressources : en orchestrant efficacement les conteneurs, Kubernetes maximise l'utilisation des ressources informatiques, réduisant ainsi les coûts d'infrastructure.
- Automatisation des tâches complexes : les tâches de déploiement, de mise à jour et de surveillance des applications sont automatisées, libérant les équipes techniques pour se concentrer sur l'innovation.
- Gestion efficace des microservices : Kubernetes facilite la gestion des architectures microservices, permettant un développement et un déploiement continus plus rapides et plus fiables.
- Écosystème open-source robuste : avec une communauté active et un écosystème en constante évolution, Kubernetes reste à la pointe de l'innovation technologique.
¶ Inconvénients de Kubernetes
Bien que Kubernetes soit une plateforme puissante pour l'orchestration de conteneurs, elle présente plusieurs inconvénients notables :
- Complexité : Kubernetes est réputé pour sa complexité, avec de nombreux concepts et un vocabulaire technique spécifique à maîtriser. Cette complexité entraîne une courbe d'apprentissage abrupte, ce qui peut ralentir son adoption et nécessiter une formation approfondie des équipes (développeurs, opérateurs, testeurs).
- Ressources et performances
- Consommation importante de ressources pour les nœuds de contrôle et le réseau.
- Risque de surutilisation ou sous-utilisation des ressources en cas de mauvaise configuration, impactant les performances et les coûts.
- Problèmes potentiels de scalabilité si mal configuré, malgré des limites théoriques élevées.
- Sécurité
- Les configurations par défaut ne sont pas toujours optimisées pour la sécurité.
- Gestion complexe des accès, des politiques réseau et des secrets.
- Nécessité de mises à jour et de correctifs fréquents pour maintenir la sécurité.
- Maintenance et gestion
- Mises à jour fréquentes (tous les 3 mois) nécessitant une attention constante.
- Nombreuses tâches manuelles pour la configuration, la maintenance et le débogage du cluster.
- Risque d'interruptions de service lors des mises à niveau, surtout dans les configurations à nœud unique.
- Dépendance technologique
- Fonctionne uniquement avec des conteneurs, ce qui peut nécessiter une adaptation des applications existantes.
- Principalement conçu pour Linux, limitant son utilisation avec d'autres systèmes.
- Fiabilité et disponibilité
- Une petite interruption dans le réseau du cluster peut potentiellement arrêter toute l'opération.
- Dans les configurations à nœud unique, la défaillance du nœud entraîne l'arrêt complet du système.
En conclusion, bien que Kubernetes offre de nombreux avantages, son adoption doit être soigneusement évaluée en fonction des besoins spécifiques du projet et des ressources disponibles pour gérer sa complexité et ses exigences.
¶ Présentation de Minikube
Minikube est un outil qui permet de créer et gérer un cluster Kubernetes local sur une seule machine. Il est principalement destiné à l'apprentissage, aux tests et au développement, en évitant la complexité d'un cluster multi-nœuds.
Pourquoi utiliser Minikube ?
- Il offre un environnement Kubernetes complet et fonctionnel sans nécessiter d'infrastructure complexe.
- Il est léger et facile à installer, utilisant des hyperviseurs (VirtualBox, Hyper-V) ou Docker comme backend.
- Il permet de tester et expérimenter les fonctionnalités de Kubernetes avant un déploiement en production.
- Il intègre des outils pratiques comme minikube dashboard, qui fournit une interface web pour visualiser les ressources Kubernetes.
¶ Installation de l'environnement
¶ Prérequis
- Ordinateur avec au moins 4 Go de RAM, 2 cœurs CPU et 20 Go d'espace disque
- Système d'exploitation : GNU/Linux
- Droits d'administration sur la machine
- Docker CE installé
¶ Préparation de la VM
Je vous propose donc de partir d'un clone de la machine Debian GUI du miniLAB, que nous allons "muscler" un peu selon les indications ci-dessus.
Clonage :
Configuration :
On démarre notre VM debian-minikube et on se logge avec l'utilisateur sudoer.
¶ Installation de Docker CE
Enfin, avant de rentrer dans le vif du sujet, on installe Docker CE selon la méthode recommandée, déjà rencontrée pendant les TP Docker, et qui est résumée ici.
¶ Préinstallation
Vérifions les mises à jour et l'installation des paquets prérequis :
sudo apt update && sudo apt upgrade
sudo apt -y install ca-certificates curl fonts-noto-color-emoji bash-completion
Supprimons ensuite les paquets qui pourraient être en conflit (peu probable avec une machine toute neuve) :
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt remove $pkg; done
On ajoute la clé publique GPG Docker officielle au trousseau apt :
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
Utilisez la commande suivante (sur une seule ligne) pour ajouter le dépôt stable :
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
On relance une mise à jour de l’index apt et on en profite pour faire les mises à jour éventuelles :
sudo apt update && sudo apt upgrade
¶ Installation
On peut maintenant installer la dernière version de Docker CE et ses outils :
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Pour vérifier l’état du service Docker Engine, un classique :
systemctl status docker
¶ Postintallation
Ajoutez votre utilisateur au groupe Docker (adaptez bien entendu en fonction du nom choisi) :
sudo adduser pascal docker
Il faut déconnecter et reconnecter l’utilisateur pour que l’appartenance au groupe soit prise en compte.
Activer Docker au démarrage avec systemd (par sécurité) :
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
Enfin on teste Docker en exécutant l'image hello-world :
docker run hello-world
Il est prudent de réaliser un snapshot de la VM à ce stade.
¶ Installation des outils
¶ kubectl
kubectl est l’outil en ligne de commande permettant d’interagir avec un cluster Kubernetes. Il sert à déployer, gérer et surveiller les ressources Kubernetes.
Principales fonctionnalités :
- Interagir avec l’API Kubernetes pour créer, mettre à jour ou supprimer des ressources.
- Déployer et gérer des applications sous forme de pods, de services, de déploiements, etc.
- Obtenir des informations sur l’état du cluster et des workloads en cours d’exécution.
- Déboguer et diagnostiquer des problèmes dans le cluster.
Pour l'installer, on télécharge le binaire :
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
Que l'on rend exécutable dans le système :
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
Petite vérification :
kubectl version --client
On installe également l'autocomplétion spécifique de kubectl pour le bash :
echo 'source <(kubectl completion bash)' >> ~/.bashrc
source ~/.bashrc
¶ Minikube
Téléchargement du binaire minikube-linux-amd64 :
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
et installation sur le système avec le nom minikube :
sudo install minikube-linux-amd64 /usr/local/bin/minikube
Vérification :
minikube version
Il est prudent de réaliser un snapshot de la VM à ce stade.
¶ Démarrage du cluster Minikube
Démarrage d'un cluster avec le driver Docker avec les options par défaut :
minikube start --driver=docker
Après quelques instants, le cluster est prêt :
😄 minikube v1.35.0 sur Debian 12.10 (vbox/amd64)
✨ Utilisation du pilote docker basé sur la configuration de l'utilisateur
📌 Utilisation du pilote Docker avec le privilège root
👍 Démarrage du nœud "minikube" primary control-plane dans le cluster "minikube"
🚜 Extraction de l'image de base v0.0.46...
💾 Téléchargement du préchargement de Kubernetes v1.32.0...
> preloaded-images-k8s-v18-v1...: 333.57 MiB / 333.57 MiB 100.00% 20.36 M
> gcr.io/k8s-minikube/kicbase...: 500.31 MiB / 500.31 MiB 100.00% 19.64 M
🔥 Création de docker container (CPU=2, Memory=2200Mo) ...
🐳 Préparation de Kubernetes v1.32.0 sur Docker 27.4.1...
▪ Génération des certificats et des clés
▪ Démarrage du plan de contrôle ...
▪ Configuration des règles RBAC ...
🔗 Configuration de bridge CNI (Container Networking Interface)...
🔎 Vérification des composants Kubernetes...
▪ Utilisation de l'image gcr.io/k8s-minikube/storage-provisioner:v5
🌟 Modules activés: storage-provisioner, default-storageclass
🏄 Terminé ! kubectl est maintenant configuré pour utiliser "minikube" cluster et espace de noms "default" par défaut.
Vérifions la présence du cluster :
minikube profile list
ce qui donne :
|----------|-----------|---------|--------------|------|---------|--------|-------|----------------|--------------------|
| Profile | VM Driver | Runtime | IP | Port | Version | Status | Nodes | Active Profile | Active Kubecontext |
|----------|-----------|---------|--------------|------|---------|--------|-------|----------------|--------------------|
| minikube | docker | docker | 192.168.49.2 | 8443 | v1.32.0 | OK | 1 | * | * |
|----------|-----------|---------|--------------|------|---------|--------|-------|----------------|--------------------|
On voit qu'une IP sur un nouveau réseau est mentionné. Jetons un oeil à la table de routage du système :
ip -c route
qui retourne :
default via 192.168.1.1 dev enp0s3
169.254.0.0/16 dev enp0s3 scope link metric 1000
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1 linkdown
192.168.1.0/24 dev enp0s3 proto kernel scope link src 192.168.1.116
192.168.49.0/24 dev br-2af7a79010e7 proto kernel scope link src 192.168.49.1
A l'instar de Docker (avec l'interface docker0), minikube a créé une interface et un réseau spécifiques pour le cluster (ligne 5).
¶ Découverte des commandes kubectl
¶ Vérifier la version
kubectl version
¶ Information sur le cluster
kubectl cluster-info
¶ Liste des nœuds
kubectl get nodes
Un seul nœud pour le moment, le master :
NAME STATUS ROLES AGE VERSION
minikube Ready control-plane 19m v1.32.0
¶ Détails d'un nœud
kubectl describe node minikube
Beaucoup d'informations sont retournées par cette commande, notamment :
¶ Informations générales sur le nœud
Name: minikube
Roles: control-plane
Labels: beta.kubernetes.io/arch=amd64
beta.kubernetes.io/os=linux
kubernetes.io/arch=amd64
kubernetes.io/hostname=minikube
kubernetes.io/os=linux
minikube.k8s.io/commit=dd5d320e41b5451cdf3c01891bc4e13d189586ed-dirty
minikube.k8s.io/name=minikube
minikube.k8s.io/primary=true
minikube.k8s.io/updated_at=2025_03_15T19_04_21_0700
minikube.k8s.io/version=v1.35.0
node-role.kubernetes.io/control-plane=
node.kubernetes.io/exclude-from-external-load-balancers=
Annotations: kubeadm.alpha.kubernetes.io/cri-socket: unix:///var/run/cri-dockerd.sock
node.alpha.kubernetes.io/ttl: 0
volumes.kubernetes.io/controller-managed-attach-detach: true
CreationTimestamp: Sat, 15 Mar 2025 19:04:18 +0100
- Name : Nom du nœud.
- Roles : Rôle du nœud (master ou worker).
- Labels : Métadonnées utilisées pour identifier le nœud.
- Annotations : Informations supplémentaires utilisées par Kubernetes ou d'autres outils.
- CreationTimestamp : Date de création du nœ
¶ Conditions du nœud
Conditions:
Type Status LastHeartbeatTime LastTransitionTime Reason Message
---- ------ ----------------- ------------------ ------ -------
MemoryPressure False Sat, 15 Mar 2025 19:24:25 +0100 Sat, 15 Mar 2025 19:04:16 +0100 KubeletHasSufficientMemory kubelet has sufficient memory available
DiskPressure False Sat, 15 Mar 2025 19:24:25 +0100 Sat, 15 Mar 2025 19:04:16 +0100 KubeletHasNoDiskPressure kubelet has no disk pressure
PIDPressure False Sat, 15 Mar 2025 19:24:25 +0100 Sat, 15 Mar 2025 19:04:16 +0100 KubeletHasSufficientPID kubelet has sufficient PID available
Ready True Sat, 15 Mar 2025 19:24:25 +0100 Sat, 15 Mar 2025 19:04:18 +0100 KubeletReady kubelet is posting ready status
- Ready : True si le nœud est prêt à exécuter des pods.
- DiskPressure : True si le nœud manque d’espace disque.
- MemoryPressure : True si le nœud manque de mémoire.
- PIDPressure : True si le nœud manque de processus disponibles.
- NetworkUnavailable : True si le réseau est inopérant.
¶ Informations sur le matériel
Capacity:
cpu: 2
ephemeral-storage: 19480400Ki
hugepages-2Mi: 0
memory: 4009232Ki
pods: 110
Allocatable:
cpu: 2
ephemeral-storage: 19480400Ki
hugepages-2Mi: 0
memory: 4009232Ki
pods: 110
- Capacity : Ressources totales du nœud (CPU, mémoire, nombre maximum de pods).
- Allocatable : Ressources réellement disponibles pour Kubernetes (soustraction des ressources système).
¶ Informations sur l’image et le runtime des conteneurs
System Info:
Machine ID: 1c02c414cb79487d9a9d79cfe798032e
System UUID: 04e59769-c364-4c84-a45e-15f026c660cb
Boot ID: b924ab65-269b-459d-ba70-0f5559dc14e7
Kernel Version: 6.1.0-30-amd64
OS Image: Ubuntu 22.04.5 LTS
Operating System: linux
Architecture: amd64
Container Runtime Version: docker://27.4.1
Kubelet Version: v1.32.0
Kube-Proxy Version: v1.32.0
- OS Image : Système d’exploitation du nœud.
- Kernel Version : Version du noyau Linux.
- Container Runtime : Moteur de conteneurisation utilisé (containerd, Docker, etc.).
- Kubelet Version : Version de kubelet installée.
- Kube-Proxy Version : Version de kube-proxy.
¶ Plages d'adresses IP des Pods
PodCIDR: 10.244.0.0/24
PodCIDRs: 10.244.0.0/24
- PodCIDR : Plage d’adresses IP allouée au nœud pour attribuer des adresses aux pods qui y seront exécutés.
- PodCIDRs : (Introduit dans les versions récentes de Kubernetes) Il peut y avoir plusieurs CIDR si le cluster supporte plusieurs plages IP par nœud.
¶ liste des pods
Liste des pods actuellement en cours d’exécution sur le nœud (non "terminés").
On voit notamment que les services de contrôle et de gestion de Kubernetes sont eux-mêmes des pods, dans le namespace kube-system :
Non-terminated Pods: (7 in total)
Namespace Name CPU Requests CPU Limits Memory Requests Memory Limits Age
--------- ---- ------------ ---------- --------------- ------------- ---
kube-system coredns-668d6bf9bc-9l4cc 100m (5%) 0 (0%) 70Mi (1%) 170Mi (4%) 21m
kube-system etcd-minikube 100m (5%) 0 (0%) 100Mi (2%) 0 (0%) 22m
kube-system kube-apiserver-minikube 250m (12%) 0 (0%) 0 (0%) 0 (0%) 22m
kube-system kube-controller-manager-minikube 200m (10%) 0 (0%) 0 (0%) 0 (0%) 22m
kube-system kube-proxy-tkl9f 0 (0%) 0 (0%) 0 (0%) 0 (0%) 21m
kube-system kube-scheduler-minikube 100m (5%) 0 (0%) 0 (0%) 0 (0%) 22m
kube-system storage-provisioner 0 (0%) 0 (0%) 0 (0%) 0 (0%) 22m
¶ Utilisation des ressources et état des pods
Affiche l’utilisation du CPU et de la mémoire par rapport aux capacités du nœud.
Allocated resources:
(Total limits may be over 100 percent, i.e., overcommitted.)
Resource Requests Limits
-------- -------- ------
cpu 750m (37%) 0 (0%)
memory 170Mi (4%) 170Mi (4%)
ephemeral-storage 0 (0%) 0 (0%)
hugepages-2Mi 0 (0%) 0 (0%)
¶ Événements récents
Affiche les événements récents (logs) liés au nœud, utiles pour diagnostiquer des problèmes.
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Starting 21m kube-proxy
Warning PossibleMemoryBackedVolumesOnDisk 22m kubelet The tmpfs noswap option is not supported. Memory-backed volumes (e.g. secrets, emptyDirs, etc.) might be swapped to disk and should no longer be considered secure.
Normal Starting 22m kubelet Starting kubelet.
Normal NodeAllocatableEnforced 22m kubelet Updated Node Allocatable limit across pods
Normal NodeHasSufficientMemory 22m kubelet Node minikube status is now: NodeHasSufficientMemory
Normal NodeHasNoDiskPressure 22m kubelet Node minikube status is now: NodeHasNoDiskPressure
Normal NodeHasSufficientPID 22m kubelet Node minikube status is now: NodeHasSufficientPID
Normal RegisteredNode 22m node-controller Node minikube event: Registered Node minikube in Controller
¶ Lister les namespaces (espaces de noms)
kubectl get namespaces
NAME STATUS AGE
default Active 51m
kube-node-lease Active 51m
kube-public Active 51m
kube-system Active 51m
Kubernetes utilise les namespaces pour isoler et organiser les ressources au sein d'un cluster. Voici les rôles des quatre namespaces initiaux :
¶ default
- C'est le namespace par défaut où sont placés les objets qui ne spécifient pas explicitement de namespace.
- Il permet de commencer à utiliser un nouveau cluster sans avoir à créer de namespace au préalable.
- Bien qu'utilisé par défaut, il est recommandé de créer des namespaces personnalisés pour différentes applications, équipes ou environnements afin d'éviter l'encombrement et les conflits potentiels.
¶ kube-node-lease
- Ce namespace contient les objets Lease associés à chaque nœud du cluster.
- Il permet aux kubelets d'envoyer des heartbeats (battements de cœur) au plan de contrôle.
- Ces heartbeats permettent de détecter rapidement les défaillances des nœuds.
¶ kube-public
- Ce namespace est lisible par tous les clients, y compris ceux qui ne sont pas authentifiés.
- Il est principalement réservé à l'usage du cluster, pour les ressources qui doivent être visibles et lisibles publiquement dans l'ensemble du cluster.
- Il peut être utilisé pour stocker des informations de configuration publiques, mais ne doit jamais contenir de données sensibles en raison de son accessibilité ouverte.
¶ kube-system
- Ce namespace est réservé aux objets créés par le système Kubernetes.
- Il contient les composants du Control Plane Kubernetes et d'autres pods liés au système.
- On y trouve notamment le serveur API Kubernetes, le scheduler, le gestionnaire de contrôleur et des add-ons comme DNS et les plugins réseau.
- L'accès à ce namespace doit être strictement contrôlé car il contient des composants critiques essentiels au fonctionnement du cluster.
¶ Décrire un namespace
kubectl describe namespace kube-system
¶ Lister les pods dans le namespace kube-system
kubectl get pods -n kube-system
¶ Premiers déploiements
¶ Déployer un serveur web nginx
kubectl create deployment nginx-demo --image=nginx
¶ Vérifier le déploiement
kubectl get deployments
¶ Voir les pods créés
kubectl get pods
Cette commande retourne les pods du namespace default ; pour voir les pods de tous les namespaces :
kubectl get pods --all-namespaces
¶ Exposer le service
kubectl expose deployment nginx-demo --type=NodePort --port=80
¶ Lister les services
kubectl get services
qui retourne :
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 65m
nginx-demo NodePort 10.97.158.161 <none> 80:31739/TCP 23s
On distingue ici deux types de services : ClusterIP et NodePort.
Dans Kubernetes, les services ClusterIP et NodePort sont deux types de services utilisés pour exposer des applications, mais ils diffèrent dans leur portée et leur accessibilité.
¶ ClusterIP
- C'est le type de service par défaut dans Kubernetes.
- Il expose le service uniquement à l'intérieur du cluster.
- Utilisé pour la communication entre les pods au sein du même cluster Kubernetes.
- Accessible via une adresse IP virtuelle (ClusterIP) et un port spécifique.
- Idéal pour les services internes qui n'ont pas besoin d'être exposés à l'extérieur du cluster.
¶ NodePort
- Construit sur la base du service ClusterIP, offrant toutes ses fonctionnalités.
- Expose le service à l'extérieur du cluster Kubernetes.
- Ouvre un port spécifique (dans la plage 30000-32767 par défaut) sur tous les nœuds du cluster.
- Permet l'accès au service depuis l'extérieur en utilisant l'adresse IP de n'importe quel nœud du cluster et le port NodePort attribué.
- Crée automatiquement un service ClusterIP correspondant.
- Utile pour exposer des applications à des clients externes au cluster, tout en conservant la possibilité d'accès interne.
Le choix entre ClusterIP et NodePort dépend des besoins d'accessibilité de l'application. ClusterIP est préféré pour les services internes, tandis que NodePort est utilisé lorsqu'une exposition externe est nécessaire, tout en gardant à l'esprit les implications en termes de sécurité et de gestion du trafic.
¶ Obtenir l'URL d'accès via Minikube
minikube service nginx-demo --url
Cette commande retourne l'url permettant d'accéder au service, ici : la page web par défaut de Nginx :
¶ Manipulation avancée
¶ Scaling manuel
¶ Augmenter le nombre de réplicas
kubectl scale deployment nginx-demo --replicas=3
¶ Vérification
kubectl get pods
Le service utilise désormais trois pods :
NAME READY STATUS RESTARTS AGE
nginx-demo-87cd4cbb7-9xnnw 1/1 Running 0 73m
nginx-demo-87cd4cbb7-chgqh 1/1 Running 0 6s
nginx-demo-87cd4cbb7-x4wrh 1/1 Running 0 6s
¶ Mise à jour de l'application
Changer l'image du déploiement :
kubectl set image deployment/nginx-demo nginx=nginx:1.19
Suivre le déploiement
kubectl rollout status deployment/nginx-demo
Changer l'image puis aussitôt suivre le déploiement :
kubectl set image deployment/nginx-demo nginx=nginx:1.26 && kubectl rollout status deployment/nginx-demo
¶ Rollback en cas de problème
- En cas d'erreur, revenir à la version précédente :
kubectl rollout undo deployment/nginx-demo
- Afficher l'historique des révisions :
kubectl rollout history deployment/nginx-demo
¶ Exploration du dashboard Kubernetes
Activation du dashboard :
minikube dashboard
Exploration du dashboard :
- Parcourir les différentes sections : Deployments, Pods, Services, etc.
- Créer un déploiement via l'interface
- Observer les logs des pods
- Explorer les métriques disponibles
Exercices pratiques personnels :
- Créer un déploiement d'une application de votre choix (par exemple caddy)
- Exposer l'application via un service de type NodePort
- Mettre à l'échelle le déploiement à 2 réplicas
- Effectuer une mise à jour de l'image de l'application
- Explorer les logs des pods via kubectl et via le dashboard
- Nettoyer les ressources créées
¶ Gestion du cluster minikube
Voici enfin des commandes pour gérer le cycle de vie du cluster Minikube.
¶ Mettre en pause le cluster (sans supprimer les ressources)
minikube pause
¶ Reprendre un cluster mis en pause
minikube unpause
¶ Arrêter le cluster (éteindre la VM/conteneur)
minikube stop
¶ Redémarrer un cluster arrêté
minikube start
¶ Réinitialiser un cluster existant (conserve le profil)
minikube delete
¶ Puis redémarrer
minikube start
¶ Afficher l'état actuel de Minikube
minikube status
¶ Obtenir l'adresse IP du cluster
minikube ip
¶ Se connecter à la VM de Minikube en SSH
minikube ssh
Il est intéressant de remarquer ici que minikube est un container Docker, dans lequel tourne une instance de Docker (Docker imbriqué, ou DinD : Docker-in-Docker), avec un certain nombre d'images en cours d'exécution :
docker ps
¶ Afficher les logs de Minikube
minikube logs
¶ Supprimer le cluster
minikube delete
¶ Supprimer tous les clusters et profils (nettoyage global)
minikube delete --all
¶ Bilan
Au terme de ce premier parcours que j'espère vous avez pu suivre avec attention et sans encombre, vous avez pu :
- Découvrir les concepts fondamentaux de Kubernetes
- Gérer un cluster Minikube (démarrage, arrêt, suppression)
- Utiliser les commandes de base de kubectl
- Déployer des applications simples sur Kubernetes
- Comprendre et manipuler les concepts de base : pod, déploiement, service
- Naviguer dans le dashboard Kubernetes
