# Tutoriel Kubernetes : les premiers pas

Kubernetes (également appelé K8s) permet une gestion efficace de grands ensembles de conteneurs et automatise de nombreux processus dans le développement logiciel. En seulement quelques étapes, il est possible d’installer un cluster Kubernetes performant et fonctionnel.

## Étape 1 : préparer le système

Dans ce tutoriel, nous prenons comme exemple une installation Kubernetes sous **[Ubuntu](https://www.ionos.fr/digitalguide/serveur/know-how/ubuntu-le-systeme-linux-pour-tous/)**.

Pour commencer, assurez-vous que le système est prêt. Pour cela, ouvrez le terminal et effectuez d’abord une mise à jour du système pour vérifier que tous les paquets sont à jour :

```bash
sudo apt update && sudo apt upgrade -y
```

Ensuite, installez les principaux utilitaires nécessaires pour l’installation de Kubernetes et Minikube. Utilisez alors la commande suivante :

```bash
sudo apt install -y curl wget ca-certificates gnupg lsb-release
```

Ces outils vous assurent une utilisation sécurisée de sources externes ainsi que le téléchargement et l’installation sans difficulté d’autres paquets logiciels.

## Étape 2 : installer kubectl

[Kubernetes](https://www.ionos.fr/digitalguide/serveur/know-how/kubernetes/) repose sur deux types de serveurs : le nœud de contrôle (*control plane*) et les nœuds de travail (*workers*). Ceux-ci n’ont pas forcément besoin d’être installés sur des machines physiques distinctes. Grâce aux [machines virtuelles](https://www.ionos.fr/digitalguide/serveur/know-how/machine-virtuelle/), il est possible d’exécuter plusieurs nœuds Kubernetes sur un seul ordinateur. Pour les tests, l’outil gratuit [Minikube](https://www.ionos.fr/digitalguide/serveur/outils/minikube-de-kubernetes/) s’avère particulièrement pratique, car il permet de travailler localement avec Kubernetes. Comme Minikube nécessite une machine virtuelle ou [Docker](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-que-docker/), il dépend donc d’un [hyperviseur](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-hyperviseur/) ou d’un logiciel de conteneur. L’outil **kubectl** est également requis.

Note Dans ce tutoriel, nous vous présentons les bases de Kubernetes avec Docker. Vous pouvez toutefois réaliser la même opération à l’aide d’un logiciel de virtualisation comme VirtualBox.

Tout d’abord, installez kubectl (CLI Kubernetes) sur votre système. Ce programme est nécessaire pour **gérer les clusters**.

```bash
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

Note Les commandes d’installation dépendent de votre architecture système.

## Étape 3 : installer Docker

Avant d’utiliser Minikube, assurez-vous que **Docker** est installé sur votre système. En tant que *runtime* de conteneur, Docker permet à Minikube d’**exécuter des [cluster Kubernetes](https://www.ionos.fr/digitalguide/serveur/know-how/cluster-kubernetes/)** sans avoir recours à un logiciel de virtualisation. Installez Docker avec la commande suivante :

```bash
sudo apt install -y docker.io
```

Pour utiliser Docker sans droits *root*, ajoutez votre compte utilisateur au groupe Docker :

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Vous devrez éventuellement vous déconnecter puis vous reconnecter afin que la modification soit prise en compte. Vérifiez ensuite l’installation avec la commande suivante :

```bash
docker run hello-world
```

Si un court message de confirmation s’affiche, cela signifie que Docker est correctement installé et prêt à être utilisé avec Minikube.

## Étape 4 : installer et démarrer Minikube

À l’étape suivante, installez **Minikube** dans une version compatible et configurez Docker comme pilote. Téléchargez d’abord la version adaptée de Minikube, rendez le fichier exécutable, puis déplacez-le dans un répertoire système afin que la commande soit disponible partout :

```bash
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-arm64
chmod +x minikube-linux-arm64
sudo mv minikube-linux-arm64 /usr/local/bin/minikube
```

Après l’installation, vous pouvez vérifier que Minikube est correctement configuré avec la commande suivante :

```bash
minikube version
```

Ensuite, démarrez Minikube avec la commande suivante :

```bash
minikube start --driver=docker
```

Dans ce scénario, Minikube utilise Docker comme runtime de conteneur et crée le cluster Kubernetes directement dans l’environnement Docker. Lors du démarrage, kubectl devrait être configuré automatiquement. Pour passer de la ligne de commande à une [interface graphique (GUI)](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quest-ce-quune-gui/), exécutez la commande supplémentaire suivante :

```bash
minikube dashboard
```

Le tableau de bord s’ouvre alors dans votre navigateur par défaut.

[![Image: Tableau de bord Kubernetes](https://www.ionos.fr/digitalguide/fileadmin/_processed_/6/7/csm_kubernetes-dashboard_549c1e7bb8.webp "Tableau de bord Kubernetes")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-dashboard.jpg) Le tableau de bord Kubernetes s’ouvre alors dans le navigateur, comme illustré ci-dessous avec un tableau de bord encore vide. ## Étape 5 : utiliser Kubernetes

Au démarrage de Minikube, un **cluster** avec un seul nœud est créé automatiquement. Vous pouvez le vérifier à l’aide d’une commande kubectl :

```bash
kubectl get nodes
```

Depuis le tableau de bord, vous pouvez désormais **créer des déploiements**. Cliquez sur le bouton « Create » (en haut à droite) pour ouvrir l’éditeur Web. Dans les formats [JSON](https://www.ionos.fr/digitalguide/serveur/know-how/json-cest-quoi/) ou [YAML](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quest-ce-que-yaml/), vous pouvez y définir un déploiement. Une fois créé, Kubernetes génère automatiquement plusieurs *pods*. Vous pouvez ensuite ajuster le nombre de pods souhaité en **mettant à l’échelle le déploiement**. Cette option est accessible via le bouton à trois points situé à côté du déploiement.

[![Image: Tableau de bord Kubernetes avec un déploiement et trois pods](https://www.ionos.fr/digitalguide/fileadmin/_processed_/f/9/csm_kubernetes-overview-deployment-pods_70f88067c3.webp "Tableau de bord Kubernetes avec un déploiement et trois pods")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-overview-deployment-pods.jpg) Le tableau de bord Kubernetes affiche ici un déploiement actif accompagné de trois pods. [![Image: Mise à l’échelle d’un déploiement dans Kubernetes](https://www.ionos.fr/digitalguide/fileadmin/_processed_/3/b/csm_kubernetes-scale-resources_a09c6390b2.webp "Mise à l’échelle d’un déploiement dans Kubernetes")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-scale-resources.jpg) L’exemple ci-dessous illustre la mise à l’échelle d’un déploiement dans le tableau de bord Kubernetes. Vous pouvez aussi créer des déploiements directement depuis le terminal. Pour cela, le contenu doit au préalable être intégré dans une [image Docker](https://www.ionos.fr/digitalguide/serveur/know-how/les-images-docker/) et avoir été déposé dans un registre.

```bash
kubectl create deployment --image=[chemin vers l’image]
```

De nombreuses informations peuvent être obtenues via des commandes saisies dans l’invite de commandes.

**Quels sont les déploiements existants ?**

```bash
kubectl get deployments
```

**Combien y a-t-il de pods ?**

```bash
kubectl get pods
```

**Quels services sont disponibles ?**

```bash
kubectl get services
```

**Quels nœuds sont actifs ?**

```bash
kubectl get nodes
```

[![Image: Terminal avec différentes commandes et sorties Kubernetes](https://www.ionos.fr/digitalguide/fileadmin/_processed_/f/5/csm_screenshot-kubernetes-ubuntu-terminal_4c2f4d2127.webp "Terminal avec différentes commandes et sorties Kubernetes")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/screenshot-kubernetes-ubuntu-terminal.jpg) L’exemple ci-dessus montre l’exécution de différentes commandes Kubernetes dans le terminal et leurs résultats. ## Étape 6 : publier le déploiement

Jusqu’à présent, vous avez simplement démarré votre déploiement, mais vous ne l’avez pas encore publié. La publication est déclenchée en créant un **service** :

```bash
kubectl expose deploy test-deployment
```

Cette méthode permet cependant uniquement de publier le service au sein du cluster. Pour pouvoir accéder au déploiement **en dehors du cluster**, il est nécessaire d’ajouter des *flags* supplémentaires :

```bash
kubectl expose deploy test-deployment --type=LoadBalancer --port=8080
```

Il est alors possible de **lancer le service** avec Minikube :

```bash
minikube service test-deployment
```

Si vous souhaitez **supprimer le service**, vous pouvez utiliser la commande correspondante :

```bash
kubectl delete service test-deployment
```

De plus, il est possible de **supprimer le déploiement** :

```bash
kubectl delete deployment test-deployment
```

Pour finir, il suffit d’**arrêter le processus** pour fermer Minikube :

```bash
minikube stop
```

Si vous ne souhaitez plus utiliser la machine virtuelle ou le runtime de conteneur, vous pouvez **le supprimer**.

```bash
minikube delete
```

Les réglages effectués et les déploiements créés seront alors également supprimés. Si vous relancez Minikube, vous travaillerez alors avec un cluster vide.


This is a markdown version of: [https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-kubernetes/](https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-kubernetes/) for AI/LLM consumption.