Kubernetes (K8s) : guide complet pour débuter

Kubernetes, également appelé K8s, est devenu une technologie incontournable dans l’univers du cloud, du DevOps et de l’administration des infrastructures modernes.

Il permet d’automatiser le déploiement, la gestion et la mise à l’échelle d’applications exécutées dans des conteneurs. Mais pour un débutant, les notions de cluster, Pod, Node ou Deployment peuvent rapidement sembler complexes.

Bonne nouvelle : il est possible de découvrir Kubernetes directement sur son ordinateur, sans louer plusieurs serveurs ni disposer d’une infrastructure cloud.

Dans ce guide, nous allons comprendre les principaux concepts de Kubernetes, installer un environnement local avec Docker Desktop sous Windows et déployer une première application Nginx à l’aide de kubectl.

Nous aborderons également les premières bonnes pratiques de sécurité à connaître avant d’envisager un déploiement en production.

1. Qu’est-ce que Kubernetes (K8s) ?

Kubernetes est une plateforme open source d’orchestration de conteneurs, initialement développée par Google et aujourd’hui hébergée par la Cloud Native Computing Foundation (CNCF).

Son rôle consiste à automatiser différentes opérations liées à l’exécution des applications :

• Déployer des applications conteneurisées.
• Maintenir un nombre défini d’instances en fonctionnement.
• Redémarrer ou remplacer certains composants défaillants.
• Répartir le trafic entre plusieurs instances.
• Adapter les ressources applicatives à la charge.
• Faciliter les mises à jour et les retours arrière.

L’abréviation K8s provient des huit lettres situées entre le K et le s de Kubernetes.

Pourquoi Kubernetes a-t-il été créé ?

Imaginons une application web composée de plusieurs conteneurs Docker.

Sur un seul serveur, il est relativement simple de les exécuter avec Docker Compose.

Mais lorsque l’application doit fonctionner sur plusieurs serveurs, les opérations deviennent plus complexes.

Comment répartir les conteneurs ? Comment remplacer automatiquement une instance défaillante ? Comment déployer une nouvelle version sans interrompre le service ?

Kubernetes répond à ces problématiques en permettant de déclarer l’état souhaité de l’application.

Il cherche ensuite à maintenir cet état en fonction des ressources disponibles.

2. Docker et Kubernetes : quelles différences ?

Docker et Kubernetes sont souvent utilisés ensemble, mais ils remplissent des fonctions différentes.

Docker fournit notamment les outils nécessaires à la construction et à l’exécution de conteneurs.

Kubernetes organise l’exécution de ces applications conteneurisées à l’échelle d’un cluster.

Il faut préciser que Kubernetes ne dépend pas directement de Docker Engine. Il utilise des moteurs d’exécution compatibles avec la Container Runtime Interface, comme containerd.

Pour débuter, Docker Desktop reste néanmoins une solution pratique, puisqu’il permet de disposer d’un environnement Kubernetes local.

Pour aller plus loin, Kubernetes ne se limite pas à l’administration des conteneurs. Il joue également un rôle dans l’architecture et l’évolution des applications SaaS. Découvrez notre analyse sur Kubernetes (K8s) : qu’est-ce que c’est et pourquoi l’utiliser ?, publiée sur Naxialis, pour comprendre ses avantages, ses limites et les situations dans lesquelles son adoption est pertinente pour une entreprise.

3. Comprendre l’architecture de Kubernetes

Avant d’installer Kubernetes, il est important de comprendre ses principaux composants.

Le cluster Kubernetes

Un cluster est un ensemble de machines administrées par Kubernetes.

Il peut comporter un seul nœud pour les tests ou plusieurs nœuds pour des infrastructures distribuées.

Le Control Plane

Le Control Plane constitue la partie qui pilote le cluster.

Il comprend notamment :

• API Server : point d’entrée des demandes adressées à Kubernetes.
• Scheduler : sélectionne les nœuds sur lesquels exécuter les nouveaux Pods.
• Controller Manager : exécute des contrôleurs qui surveillent et rapprochent l’état réel de l’état souhaité.
• etcd : base de données clé-valeur utilisée pour conserver l’état du cluster.

Les Nodes

Les Nodes sont les machines qui exécutent les applications.

Chaque nœud de travail dispose notamment d’un agent appelé kubelet, d’un moteur d’exécution de conteneurs et des composants réseau nécessaires.

Les Pods

Le Pod est la plus petite unité déployable de Kubernetes.

Il contient généralement un conteneur applicatif, mais peut en regrouper plusieurs qui partagent certaines ressources.

Les Deployments

Un Deployment permet de définir et de maintenir des instances applicatives.

Par exemple, un Deployment peut demander à Kubernetes de conserver trois réplicas d’une application Nginx.

Si un Pod disparaît, Kubernetes cherche à le remplacer.

Les Services

Les Pods peuvent être remplacés et changer d’adresse IP.

Un Service fournit un point d’accès réseau stable à un ensemble de Pods et peut distribuer le trafic entre plusieurs instances.

4. Installer Kubernetes sur Windows avec Docker Desktop

Pour ce tutoriel, nous utiliserons Docker Desktop et PowerShell.

Cette méthode permet d’exécuter Kubernetes localement, sans infrastructure cloud.

Prérequis

Avant de commencer, vérifiez que votre environnement dispose :

• De Windows 10 ou Windows 11 compatible.
• De Docker Desktop installé et fonctionnel.
• Du backend WSL 2 configuré si vous utilisez cette méthode.
• De suffisamment de mémoire et de ressources processeur.
• De l’outil kubectl.

Les ressources nécessaires varient selon la configuration du cluster et les applications exécutées.

Étape 1 : activer Kubernetes

Ouvrez Docker Desktop.

Accédez à la section Kubernetes, puis activez la fonctionnalité de cluster local.

Selon la version de Docker Desktop, les options de création et de configuration peuvent différer.

Attendez que l’interface indique que le cluster est prêt.

Étape 2 : vérifier la connexion au cluster

Ouvrez PowerShell et exécutez :

kubectl config get-contexts

Cette commande affiche les contextes Kubernetes configurés sur votre ordinateur.

Dans un environnement Docker Desktop, le contexte peut apparaître sous le nom :

docker-desktop

Pour sélectionner explicitement ce contexte :

kubectl config use-context docker-desktop

Cette commande n’est nécessaire que si vous souhaitez utiliser ce cluster et que le contexte courant est différent.

Étape 3 : vérifier les nœuds

Exécutez :

kubectl get nodes

Un résultat typique pour un cluster local fonctionnel ressemble à ceci :

NAME             STATUS   ROLES           AGE   VERSION
docker-desktop   Ready    control-plane   50s   v1.30.5

La version et l’âge affichés dépendent de votre installation.

Le statut Ready indique que le nœud est disponible pour exécuter des charges de travail.

Votre environnement Kubernetes local est maintenant prêt à accueillir une première application.

5. Déployer sa première application avec Kubernetes

Nous allons maintenant déployer un serveur web Nginx.

Nginx est un serveur HTTP largement utilisé pour servir des sites web et agir comme reverse proxy.

Il constitue un bon exemple pour découvrir les mécanismes de déploiement Kubernetes.

Étape 1 : créer un Deployment

Dans PowerShell, exécutez :

kubectl create deployment demo-nginx --image=nginx:stable --replicas=2

Cette commande demande à Kubernetes de créer un Deployment nommé demo-nginx, utilisant l’image nginx:stable, avec deux réplicas.

Kubernetes tente alors de démarrer deux Pods.

Étape 2 : vérifier le Deployment

Exécutez :

kubectl get deployments

Lorsque le déploiement est prêt, le résultat devrait ressembler à ceci :

NAME         READY   UP-TO-DATE   AVAILABLE   AGE
demo-nginx   2/2     2            2           1m

Le champ READY indique le nombre de réplicas prêts par rapport au nombre souhaité.

Étape 3 : afficher les Pods

Exécutez :

kubectl get pods

Vous devriez observer deux Pods portant un nom commençant par demo-nginx.

Leurs suffixes sont générés automatiquement par Kubernetes.

Si les Pods sont en cours de création, attendez quelques instants puis relancez la commande.

Pour obtenir davantage de détails :

kubectl get pods -o wide

Cette commande affiche notamment les adresses IP internes et les nœuds sur lesquels les Pods sont exécutés.

6. Accéder à l’application Nginx

Les Pods fonctionnent maintenant, mais notre application n’est pas encore directement accessible depuis le navigateur Windows.

Nous allons créer un Service Kubernetes, puis utiliser un transfert de port local.

Étape 1 : créer un Service

Exécutez :

kubectl expose deployment demo-nginx --port=80 --target-port=80 --type=ClusterIP

Cette commande crée un Service interne nommé demo-nginx.

Vérifiez sa présence :

kubectl get services

Étape 2 : transférer le port

Dans PowerShell, exécutez :

kubectl port-forward service/demo-nginx 8080:80

Conservez cette fenêtre PowerShell ouverte pendant le test.

Étape 3 : ouvrir Nginx

Dans votre navigateur, accédez à :

http://localhost:8080

Si le déploiement fonctionne correctement, la page d’accueil de Nginx apparaît.

Vous venez de déployer une application conteneurisée sur Kubernetes et d’y accéder depuis votre ordinateur.

Le transfert de port est destiné au développement et au diagnostic. Ce n’est pas une méthode de publication adaptée à un service de production.

7. Tester la capacité de Kubernetes à remplacer un Pod

L’un des intérêts de Kubernetes est sa capacité à maintenir l’état souhaité d’une application.

Nous allons observer ce comportement.

Étape 1 : identifier les Pods

Exécutez :

kubectl get pods

Notez le nom d’un des Pods demo-nginx.

Étape 2 : supprimer un Pod

Remplacez NOM_DU_POD par le nom réel :

kubectl delete pod NOM_DU_POD

Étape 3 : observer le remplacement

Exécutez :

kubectl get pods -w

L’option -w permet de surveiller les changements en temps réel.

Kubernetes devrait créer un nouveau Pod afin de retrouver les deux réplicas demandés par le Deployment.

Pour interrompre la surveillance, utilisez Ctrl + C.

Ce mécanisme illustre le fonctionnement déclaratif de Kubernetes : le Deployment définit l’état souhaité et ses contrôleurs cherchent à le maintenir.

Il ne s’agit toutefois pas d’une garantie contre toutes les pannes, notamment celles qui affectent l’ensemble du nœud ou les ressources disponibles.

8. Modifier le nombre de réplicas

Kubernetes permet également d’ajuster le nombre d’instances applicatives.

Pour passer de deux à quatre réplicas :

kubectl scale deployment demo-nginx --replicas=4

Vérifiez ensuite :

kubectl get deployments
kubectl get pods

Lorsque les ressources sont disponibles, Kubernetes crée les Pods supplémentaires.

Pour revenir à deux réplicas :

kubectl scale deployment demo-nginx --replicas=2

Cette opération correspond à une mise à l’échelle manuelle.

Kubernetes dispose également d’un mécanisme appelé Horizontal Pod Autoscaler (HPA), qui peut automatiser certains ajustements à partir de métriques.

9. Les commandes kubectl essentielles pour débuter

kubectl est l’outil en ligne de commande permettant de communiquer avec l’API Kubernetes.

Voici quelques commandes utiles à connaître :

Pour diagnostiquer un Pod qui ne démarre pas, les commandes describe, logs et get events constituent généralement un bon point de départ.

10. Les premières bonnes pratiques de sécurité Kubernetes

Un cluster Kubernetes fonctionnel n’est pas nécessairement un cluster sécurisé.

Avant de déployer des applications en production, plusieurs précautions doivent être prises.

Limiter les privilèges des conteneurs

Évitez d’exécuter des conteneurs avec des privilèges élevés lorsque cela n’est pas nécessaire.

Les paramètres de sécurité des Pods permettent notamment de restreindre les capacités Linux et l’exécution en tant qu’utilisateur root.

Protéger l’accès à l’API Kubernetes

L’API Server est un composant central du cluster.

Son accès doit être contrôlé à l’aide de mécanismes d’authentification et d’autorisation adaptés.

Le contrôle d’accès basé sur les rôles, appelé RBAC, permet d’attribuer des permissions précises.

Contrôler les images de conteneurs

Utilisez des images provenant de sources fiables, maintenues et régulièrement mises à jour.

Des outils comme Trivy peuvent analyser les images pour identifier des vulnérabilités connues.

Protéger les secrets

Les identifiants, clés API et mots de passe ne doivent pas être intégrés directement aux images ou aux fichiers de configuration publics.

Kubernetes propose des objets Secret, mais leur utilisation doit s’accompagner de contrôles d’accès adaptés et, selon l’environnement, du chiffrement au repos et d’une solution de gestion des secrets.

Limiter les communications réseau

Les NetworkPolicies permettent de définir des règles de communication entre certains Pods.

Leur application effective nécessite un plugin réseau compatible.

Maintenir le cluster à jour

Les composants Kubernetes et les applications doivent faire l’objet d’un suivi régulier.

Les mises à jour contribuent à corriger des vulnérabilités et à maintenir la compatibilité de l’infrastructure.

Pour les environnements sensibles, des outils comme kube-bench et Kubescape peuvent aider à évaluer certaines configurations de sécurité.

11. Les erreurs fréquentes lorsqu’on débute avec Kubernetes

Les Pods restent en Pending

Un Pod en état Pending n’a pas encore pu démarrer correctement.

Cela peut notamment provenir de ressources insuffisantes, de contraintes de planification ou de volumes indisponibles.

Pour examiner la situation :

kubectl describe pod NOM_DU_POD

Une image ne peut pas être téléchargée

Un Pod peut afficher un état ImagePullBackOff.

Cela peut indiquer une image inexistante, une erreur de registre ou un problème d’authentification.

Vérifiez le nom de l’image et les événements du Pod.

Le cluster ne répond pas

Si kubectl ne parvient pas à contacter Kubernetes, commencez par vérifier le contexte courant :

kubectl config current-context

Puis vérifiez l’état de Kubernetes dans Docker Desktop.

L’application n’est pas accessible

Vérifiez que les Pods sont prêts, que le Service existe et que le transfert de port est actif.

Pour notre exemple :

kubectl get pods
kubectl get services
kubectl port-forward service/demo-nginx 8080:80

Assurez-vous également que le port local 8080 n’est pas déjà utilisé par une autre application.

12. Nettoyer son environnement de test

Après avoir terminé le tutoriel, vous pouvez supprimer les ressources créées.

Supprimez le Deployment :

kubectl delete deployment demo-nginx

Puis le Service :

kubectl delete service demo-nginx

Vérifiez le résultat :

kubectl get deployments
kubectl get services

Ces commandes suppriment les ressources de démonstration du namespace courant, sans supprimer le cluster Kubernetes lui-même.

Conclusion : quelles sont les prochaines étapes pour apprendre Kubernetes ?

Kubernetes peut sembler complexe au premier abord, mais ses concepts deviennent plus accessibles lorsqu’on les expérimente.

Avec ce premier tutoriel, nous avons découvert les éléments essentiels d’un cluster, installé un environnement local et déployé une application Nginx.

Nous avons également observé comment Kubernetes maintient un nombre de réplicas et comment accéder à une application à l’aide d’un Service.

Pour aller plus loin, les prochaines étapes consistent à apprendre les manifestes YAML, les ConfigMaps, les Secrets, les volumes persistants et les mécanismes de déploiement avancés.

La sécurité doit également faire partie intégrante de cet apprentissage.

Chez Cyberconseils, nous abordons les technologies d’infrastructure avec une attention particulière portée à la sécurité des applications, à la gestion des vulnérabilités et aux bonnes pratiques de configuration.

Comprendre le fonctionnement de Kubernetes constitue une première étape importante pour administrer et sécuriser des infrastructures conteneurisées.