Le debut d'une grande aventure K8s

Introduction

Bienvenue à tous dans cette troisième partie de notre série dédiée à Kubernetes !

Jusqu’à présent, nous avons exploré des concepts théoriques, mais aujourd’hui, passons aux choses sérieuses avec une démonstration pratique. Cet article servira de tremplin vers des posts plus détaillés à venir, où nous approfondirons des sujets comme les bases de données, le réseau, le stockage, et bien d’autres facettes passionnantes de Kubernetes.

Dans ce post, nous allons déployer une application simple sur un cluster Kubernetes. Cette application évoluera au fil des prochains articles pour intégrer davantage de fonctionnalités et de complexité, afin de démontrer tout le potentiel de Kubernetes.

Avant de procéder au déploiement, nous commencerons par créer notre application et la conteneuriser avec Docker. Prêts à plonger dans l’univers Kubernetes ? Allons-y !

1. Création de l’application

Comme dirait l’un de mes professeurs : commençons par le commencement.

La création de notre application sera notre première étape. Car, comme vous le savez, avant de déployer, il faut d’abord créer. Sans application à déployer, à quoi bon Kubernetes ?

L’application idéale pour débuter avec Kubernetes est un serveur web simple. Cette simplicité nous permettra de nous concentrer sur les concepts fondamentaux avant d’augmenter la complexité au fil des articles.

Pour cette démonstration, nous allons créer un serveur web basique en PHP. Voici le code de la page web qui sera servie par notre application :

<?php
echo "Kubernetes, c'est trop facile ! ;) ";
?>

Un message simple pour un début prometteur.

2. Conteneurisation de l’application

Pour exécuter notre serveur web sur Kubernetes, nous avons besoin d’une image Docker. Cette image inclura un serveur web Apache2 avec le support de PHP. Voici le contenu du Dockerfile qui nous permettra de construire cette image :

FROM php:8.3-apache
COPY src/ /var/www/html/

Explication :

1. FROM php:8.3-apache : Nous utilisons une image de base officielle qui combine Apache et PHP.
2. COPY src/ /var/www/html/ : Nous copions les fichiers du dossier src/ (contenant notre index.php) vers le dossier racine web d’Apache.

Si vous avez suivi mon tutoriel sur Docker ici, vous savez déjà comment ce processus fonctionne. Pour les nouveaux arrivants, pas d’inquiétude, tout sera expliqué en détail !

Structure du projet :

Voici à quoi ressemble la structure du projet pour l’instant :

.
├── Dockerfile
└── src
    └── index.php

1. Dockerfile : Définit la construction de l’image.
2. src/index.php : Contient le code source de l’application.

Construction de l’image Docker :

Pour construire l’image, exécutez la commande suivante depuis la racine de votre projet :

docker build -t tutanka01/k8s:art3 .

(Pensez à remplacer tutanka01/k8s:art3 par votre nom d’utilisateur Docker Hub, egalement il faudra sur dockerhub avoir créé un repository nommé k8s)

Une fois l’image faite, vous allez voir quelque chose qui resseble a ça :

Une fois que tout est prêt, vous pouvez exécuter la commande suivante pour tester votre image :

docker run -d -p 8060:80 tutanka01/k8s:art3

Accédez ensuite à http://localhost:8060 pour voir votre application en action.

Enfin, pensez à pousser votre image sur Docker Hub. Cette étape est tres importante pour la suite de l’article ! Si vous ne voulez pas vous embêter, vous pouvez directement utiliser mon image déjà disponible ici

3. Création du cluster Kubernetes

Passons maintenant aux choses sérieuses : la création de notre cluster Kubernetes. Pour cela, les options ne manquent pas. Vous pourriez, par exemple, déployer un cluster sur des conteneurs avec KinD (Kubernetes in Docker), utiliser Minikube, ou encore choisir un service cloud comme GCP, AWS ou Azure via leurs services EKS, GKE ou AKS respectifs.

Pour ce tutoriel, nous allons créer un vrai cluster Kubernetes, mais sans passer par le cloud. Nous utiliserons K3s, une distribution Kubernetes légère, rapide, et certifiée par la CNCF.

Petite parenthèse : Si vous ne connaissez pas la CNCF (Cloud Native Computing Foundation), c’est l’organisme qui supervise Kubernetes et de nombreux autres projets open source. Si vous êtes curieux de découvrir cet écosystème, je vous recommande de jeter un œil à leur incroyable tableau de bord : CNCF Landscape. Vous y trouverez des centaines de projets, tous classés par catégories, pour explorer les outils open source du cloud-native.

C’est quoi K3s ?

Avant de rentrer dans le vif du sujet, répondons à une question essentielle : Pourquoi K3s existe-t-il ?

Kubernetes est sans aucun doute un outil extrêmement puissant. Mais, comme tout ce qui est puissant, il est aussi complexe et exigeant. Cette complexité, combinée à son appétit en ressources, en fait parfois un choix difficile à justifier, surtout pour les environnements limités ou les petits projets.

C’est là qu’intervient K3s.

Développé par Rancher, K3s, est une version allégée de Kubernetes conçue pour répondre à ces problématiques. Mais attention, allégé ne veut pas dire moins capable. K3s est une distribution Kubernetes complète, certifiée par la CNCF. Autrement dit, ce n’est pas une version alternative ou un dérivé, mais bien un Kubernetes conforme aux standards officiels.

Pourquoi K3s ?

• Léger : Le fichier binaire de K3s est minuscule en comparaison avec Kubernetes classique. Moins de dépendances, donc moins de poids.
• Simple : K3s simplifie considérablement le processus d’installation et de gestion. En gros, un seul binaire suffit pour avoir un cluster fonctionnel.
• Peu gourmand : Il est conçu pour fonctionner sur des machines avec des ressources limitées, comme un Raspberry Pi ou un serveur de homelab.
• Production Ready : K3s n’est pas seulement destiné aux tests ou aux petits projets. Vous pouvez l’utiliser en production sans problème.

Note importante : K3s supprime certaines fonctionnalités non essentielles de Kubernetes (comme les plugins cloud inutiles en local). Mais rassurez-vous, tout ce que vous apprenez avec K3s est transférable à un cluster Kubernetes standard.

K3s coche donc toutes les cases : légèreté, simplicité et compatibilité. Que ce soit pour apprendre Kubernetes, pour expérimenter dans un homelab ou même pour des environnements de production légers, K3s est une excellente option.

En savoir plus

Je ne vais pas m’étendre davantage sur la théorie. Si vous voulez aller plus loin, je vous recommande cet excellent article qui explique très bien ce qu’est K3s et ses cas d’utilisation :
Traefik Glossary - K3s Explained.

Notre infrastructure :

Pour ce projet, nous allons déployer un cluster Kubernetes composé de trois nœuds , un master et deux workers. Voici à quoi ressemblera notre infrastructure :

C’est une architecture très simple, mais suffisante pour notre projet. Ce schéma évoluera au fil des articles, et nous mettrons en place des architectures de plus en plus complexes.

Installation de K3s :

Commençons par l’installation de nos machines. Pour ce projet, je vais utiliser des machines virtuelles que je vais créer sur mon serveur Proxmox. Toutefois, vous pouvez utiliser n’importe quelle solution de votre choix. Pour ce projet, voici les caractéristiques des machines virtuelles utilisées :

• Master Node :

  • OS : Ubuntu 24.04
  • CPU : 2
  • RAM : 2 Go
  • Disque : 20 Go

• Worker Node 1 et 2 :

  • OS : Ubuntu 24.04
  • CPU : 4
  • RAM : 4 Go
  • Disque : 30 Go

Je vais omettre les étapes d’installation d’Ubuntu, mais si vous avez besoin d’aide, n’hésitez pas à me contacter. Une fois vos machines prêtes, vous pouvez procéder à l’installation de K3s. Pour cela, rendez-vous sur la page officielle de K3s de K3s et suivez les instructions.

Selon la documentation officielle, pour installer K3s, il suffit de lancer la commande suivante sur le master :

curl -sfL https://get.k3s.io | sh -

Vous verrez normalement quelque chose qui ressemble a ça :

Et voilà, en à peine 20 secondes, vous avez un nœud maître K3s fonctionnel. Pour info, voici les quelques paquets qui ont été installés :

• k3s : Le binaire principal de K3s.
• kubectl : Le client Kubernetes.
• crictl : Un outil pour interagir avec le runtime CRI.
• ctr : Un outil pour interagir avec containerd.

Donc en a peine 40Mo, vous avez installé tout ça ! C’est pas beau ça ?

Pour tester si tout s’est bien initialisé, vous pouvez lancer cette commande sur le master :

sudo kubectl get nodes

Vous devriez voir quelque chose ressemblant à l’image ci-dessus. Si c’est le cas, c’est que tout s’est bien passé. Passons maintenant à l’ajout des nœuds workers.

Ajout des noeuds workers :

Une fois que nous avons créé le nœud maître, nous devons obtenir ce qu’on appelle un token pour pouvoir ajouter des nœuds workers. En plus de ce token, il nous faut l’adresse IP du nœud maître. C’est pour cela qu’il est tres important d’avoir une adresse IP fixe pour tous les nœuds du cluster.

Pour obtenir le token de votre nœud maître, vous devez simplement chercher dans le fichier /var/lib/rancher/k3s/server/node-token :

sudo cat /var/lib/rancher/k3s/server/node-token

Voici à quoi ressemble le token, vous pouvez le copier pour l’utiliser plus tard. Une fois que vous avez le token, vous pouvez utiliser cette commande sur vos deux nœuds workers pour les ajouter au cluster :

curl -sfL https://get.k3s.io | K3S_URL=https://192.168.9.200 K3S_TOKEN=<votretoken> sh -s - 

Une fois cette commande lancée, en moins de 20 secondes, vos nœuds workers seront installés et prêts à rejoindre le cluster.

Pour vérifier que tout a été bien installé, vous pouvez lancer la commande suivante sur le nœud maître :

sudo kubectl get nodes -o wide

Vous devriez voir vos 2 nœuds workers ajoutés à votre cluster, comme montré sur la capture d’écran ci-dessus.

Conclusion : On s’arrête là… pour l’instant !

Et voilà, vous avez maintenant un cluster K3s fonctionnel, prêt à être exploré et utilisé ! Ce n’est que le début d’un voyage dans l’univers de Kubernetes, et il y a encore tant à découvrir : gestion des ressources, déploiement d’applications, intégration d’outils de monitoring et bien plus encore.

Ce guide a posé les bases, mais les possibilités sont infinies. Dans les prochains articles, nous irons encore plus loin en ajoutant des fonctionnalités avancées, en optimisant l’infrastructure, et en déployant l’applications que nous avons crée. Mais pour l’instant, profitez de ce que vous avez construit et commencez à expérimenter.

N’oubliez pas : chaque étape franchie vous rapproche de la maîtrise complète de Kubernetes, et chaque défi surmonté vous prépare à relever de nouveaux défis encore plus passionnants. Alors, à vos claviers, et rendez-vous dans le prochain article !

En attendant, n’hésitez pas à partager vos idées, vos retours ou vos questions dans les commentaires. Ensemble, continuons à faire grandir cette aventure Kubernetes !