> For the complete documentation index, see [llms.txt](https://docs.plenit.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.plenit.com/fr/support/tutorials/linux/how-to-set-up-kubernetes.md).
# Comment déployer un environnement Kubernetes dans Plenit
Continuez à lire si vous voulez découvrir **comment monter un environnement Kubernetes dans Plenit** et en tirer tout son jus.
Depuis que Google a libéré le projet Kubernetes il y a presque 10 ans (2014), cette technologie a gagné de plus en plus de notoriété, jusqu'à devenir un **élément indispensable** dans la gestion des microservices.
Kubernetes est une **plateforme extensible, portable et flexible** basée sur un open software (logiciel libre) qui nous permet d'administrer des charges de travail de différentes tailles et qui inclut la taille variable, permettant de Déployer toutes sortes de services, facilitant entre autres l'automatisation et la réponse aux pics de travail et à d'autres types de charges de travail changeantes.
La manière de fonctionner de Kubernetes en fait une plateforme idéale pour une gestion basée sur PaaS (Plateformes as a Service) ou IaaS (Infrastructure as a Service).
### **Comment monter un environnement Kubernetes dans Plenit ?**
#### **Pré-requis et recommandations :**
Pour mener à bien ce tutoriel et pouvoir **monter un environnement Kubernetes dans Plenit** il sera nécessaire :
* D'une part, être \*\*inscrit sur la Plateforme Plenit \*\*avec une Organisation et être enregistré sur celle-ci après \*\*avoir \*\*[**Connexion**](https://admin.jotelulu.com/){target="\_blank" rel="noopener"}.
* D'autre part, [**avoir souscrit un Abonnement de Serveurs**](https://jotelulu.com/soporte/tutoriales/como-desplegar-servidor){target="\_blank" rel="noopener"}**\[.]**
* Avoir trois\*\* Serveurs\*\* Ubuntu 22.04 déployés au sein de l'Abonnement.
```{=html}
```
* * kubernetes-nacho-1 = Maître.
* kubernetes-nacho-2 = Worker 1.
* kubernetes-nacho-3 = Worker 2.
```{=html}
```
* Un Utilisateur avec des \*\*privilèges d'administrateur \*\*soit via "root" soit via la commande "sudo".
* Selon les spécifications de Kubernetes, les machines virtuelles provisionnées doivent avoir au moins 2GB de RAM, 2 CPUs et au moins 20GB de Disque dur pour pouvoir travailler, bien qu'en fonction de l'Utilisation qui leur sera donnée il puisse être nécessaire d'augmenter ces exigences.
####
#### **Étape 1. Préparation de la machine avant le déploiement de Kubernetes**
La première chose à faire **avant de commencer le déploiement** de Kubernetes est **Mettre à jour les paquets et la distribution** pour nous assurer que nous disposons des paquets les plus à jour et des dernières sources mises à jour.
Pour cela, il faut **lancer les commandes suivantes**.
\_# sudo apt update
## sudo apt upgrade\_
Rappelons que **la commande "sudo"** est utilisée dans les **distributions Ubuntu** pour **lancer les commandes avec une élévation de privilèges**. Ce serait quelque chose comme un "Super User Do" (Faire en tant que Super Utilisateur), c'est l'équivalent d'un "RunAs" dans les environnements Microsoft.
Étape 1. Lançons la mise à jour des paquets et de la distribution
L'un des points que **nous devons contrôler** lorsque nous travaillons avec Kubernetes est l'Utilisation de la **mémoire d'échange ou SWAP**. Parfois, des problèmes se sont produits lors du passage à l'échelle des PODS, car le système ne les gère pas correctement si la SWAP du système est active.
Pour éviter des comportements erratiques, la meilleure option est **de désactiver cette option** en utilisant la commande "swapoff".
*# sudo swapoff -a*
Pour **vérifier si elle a été désactivée,** plusieurs méthodes peuvent être utilisées.
\_# free -h
## swapon -s
## cat /proc/swaps\_
Pour que **ne s'active pas au redémarrage** et ne puisse être utilisée d'aucune manière **il faut la Supprimer de la table des systèmes de fichiers**, c'est-à-dire de **"/etc/fstab"** c'est pourquoi il faut éditer et commenter les lignes où apparaît le mot "swap".
*# sudo vim /etc/fstab*
Une fois cela fait, on peut **faire la requête** avec un "cat" (si vous êtes défenseur des chats, vous pouvez utiliser n'importe quelle autre commande d'affichage) pour voir si c'est correctement sauvegardé.
*# cat /etc/fstab*
Ce processus de nettoyage du Fichier "/etc/fstab" pourrait également être réalisé avec la commande suivante :
*# sudo sed -i '/ swap / s/^/#/' /etc/fstab*
Cette commande basée sur "sed" recherche la chaîne "swap", sans appliquer de typage et place un dièse "#" qui est le symbole utilisé pour commenter du texte.
Étape 1. Désactivons la SWAP pour qu'il n'y ait pas de problèmes avec les PODS de Kubernetes
Il est possible que l'on veuille **changer le nom de la machine** pour l'identifier au sein de notre Réseau ou pour toute autre raison. Ce processus peut être réalisé avant tout le processus de mise en place des Kubernetes, raison pour laquelle nous le mentionnons avant de commencer l'opération proprement dite.
On **consulte le nom** actuel à l'aide de la **commande "hostname"**, même s'il devrait en réalité être visible comme partie du prompt Bash.
*# hostname*
Ensuite, pour **changer le nom de la machine** on lance la commande "sudo hostnamectl set-hostname" suivie du nouveau nom et on lance la commande "exec bash" afin que les changements prennent effet.
Un exemple de tout cela pourrait être :
\_# sudo hostnamectl set-hostname
## exec bash\_
Où :
* \*\*\*\* : Ce sera le nom que recevra la machine à partir de ce moment.
Un exemple pourrait être :
\_# sudo hostnamectl set-hostname kubernetes-nacho-1
## exec bash\_
Où :
* "kubernetes-nacho-1" sera le nom que recevra la machine à partir de ce moment.
Étape 1. Nous changeons le nom de la machine pour l'identifier sur le Réseau comme serveur Kubernetes
L'étape suivante est **configurer le noyau** (noyau du système) avec des **paramètres supplémentaires pour** que **Kubernetes** puisse fonctionner correctement.
Pour cela, il faut **éditer le Fichier "/etc/sysctl.conf"** en exécutant les commandes suivantes :
*# sudo tee /etc/modules-load.d/containerd.conf <*\
\&#xNAN;*/etc/containerd/config.toml».*
Après l'exécution de ces commandes, il faudra **modifier le Fichier "config.toml"** pour localiser l'entrée qui définit «SystemdCgroup = false" et **change sa valeur «SystemdCgroup = true"**.
*# sudo sed -i 's/ SystemdCgroup = false/ SystemdCgroup = true/' /etc/containerd/config.toml*
Pour terminer cette partie, il faut **redémarrer les services "containerd" et "kubelet"** car ainsi la configuration sera relue et les changements seront sauvegardés.
\_# sudo systemctl restart containerd.service
## sudo systemctl restart kubelet.service\_
L'idéal est que l'on veuille **démarrer Kubernetes** et donc le service Kubelet **à chaque démarrage de la machine,** c'est pourquoi il faudra exécuter la commande suivante :
*# sudo systemctl enable kubelet.service.*
\\
Étape 2. Préparons le système pour l'utilisation de Containerd
L'étape suivante est **lancer le cluster Kubernetes** sur le nœud maître, de sorte que lorsqu'un plan de contrôle Kubernetes est lancé via kubeadm, différents composants seront Déployés pour administrer et orchestrer le cluster.
Avec la commande suivante, les images des composants seront **téléchargées** (kube-apiserver, kube-controller-manager, kube-scheduler, etcd, kube-proxy).
*# sudo kubeadm config images pull*
Nous initialisons le nœud maître en lui passant "--pod-network-cidr" avec la plage d'adresses IP que nous avons réservée pour le Réseau de POD.
*# sudo kubeadm init --pod-network-cidr=10.0.0.0/16*
\\
Étape 2. Démarrons le cluster Kubernetes
À ce stade, il va être **configuré kubectl,** qui est l'outil avec lequel il faut administrer le cluster Kubernetes. Pour cela, il faut commencer par **créer le dossier .kube** dans le HOME et copier la configuration d'administration du cluster.
\_# mkdir -p $HOME/.kube
## sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config\_
Ensuite, il faudra **changer la propriété du Fichier** de configuration qui a été copié pour **donner la permission à l'Utilisateur** d'utiliser le fichier de configuration.
*# sudo chown $(id -u):$(id -g) $HOME/.kube/config*
Ensuite, nous allons **configurer à la fois kubectl et Calico,** qui seront nécessaires au fonctionnement de notre service Kubernetes. Pour cela, il faudra **exécuter les commandes suivantes sur le nœud maître** de manière à Déployer l'opérateur Calico.
*# kubectl create -f* [*https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/tigera-operator.yaml*](https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/tigera-operator.yaml)
\\
Étape 2. Configurons Kubctl et Calico sur notre Ubuntu
L'étape suivante consiste à **télécharger le Fichier de ressources** personnalisées pour **Calico,** qui contient différentes configurations nécessaires à l'utilisation de ce service.
*# curl* [*https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/custom-resources.yaml*](https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/custom-resources.yaml) *-O*
\\
Étape 2. Nous téléchargeons les ressources de Calico et configurons le CDIR de notre cluster Kubernetes
À ce stade, il faut **modifier le CIDR dans le Fichier de configuration "custom-resources.yaml"** pour que les ressources correspondent au Réseau de POD qui sera provisionné dans notre cas.
*# sed -i 's/cidr: 192.168.0.0/16/cidr: 10.0.0.0/16/g' custom-resources.yaml*
À ce moment-là **il est demandé à kubectl de lire le contenu du Fichier "custom-resources.yaml"** et de **créer les ressources** définies dans ce Fichier, pour cela, il faut lancer la commande suivante :
*# kubectl create -f custom-resources.yaml*
\\
Étape 2. Configurons le CDIR de notre cluster Kubernetes
Avec cela, tout devrait déjà être configuré sur notre maître, nous passons donc à la configuration des workers.
#### **Étape 3. Ajouter des workers au cluster Kubernetes**
Maintenant que le nœud maître de notre cluster Kubernetes est configuré, il est temps de **ajouter les nœuds workers au cluster, qui seront ceux qui effectueront le travail réel**, laissant au maître la tâche de coordonner.
Lorsque kubeadm est lancé sur le nœud maître, un token sera fourni et sera utilisé pour l'ajout de ces nœuds de travail, qui seront ajoutés au moyen de la commande "kubeadm join".
\*# sudo kubeadm join :\ --token \ --discovery-token-ca-cert-hash \*
Où :
* \*\*\*\* : Adresse IP du nœud maître du cluster Kubernetes.
* \*\*\*\* : Port de communication, normalement le "6443".
* \*\*\*\* : Nous passons le token de validation.
* \*\*\*\* : Nous passons le HASH du token pour pouvoir effectuer les vérifications mathématiques.
Avec cela, nous aurions déjà ajouté les workers à la structure Kubernetes et nous pourrons commencer à faire fonctionner la plateforme.
**NOTE :** *En cas de problème lors de cette procédure, vous pouvez consulter l'* [*aide à l'installation de Kubernetes*](https://kubernetes.io/es/docs/tasks/tools/included/install-kubectl-linux/){target="*blank" rel="noopener"}*.\_
### **Conclusions :**
Comme vous pouvez le voir, **monter un environnement Kubernetes dans Plenit** c'est quelque chose de très simple à faire en suivant les étapes que nous avons décrites.
Dans ce cas, nous avons vu comment Déployer le service Kubernetes sur nos Serveurs GNU/Linux, **Ubuntu 22.04** (la dernière version disponible à cette date) mais la même procédure peut être utilisée pour d'autres versions en apportant de légers changements.
Vous pouvez consulter d'autres tutoriels et articles liés à cette technologie, à GNU/Linux ou à d'autres technologies en consultant notre [blog](https://jotelulu.com/blog/){target="\_blank" rel="noopener"}.
Merci de nous avoir accompagnés !
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.plenit.com/fr/support/tutorials/linux/how-to-set-up-kubernetes.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
