Commande Kubernetes Run

Introduction

La commande kubectl run est un moyen simple de créer un Pod dans Kubernetes. Les versions modernes de Kubernetes n'utilisent plus kubectl run pour créer des Deployments ou des Jobs ; ce laboratoire associe donc kubectl run aux commandes dédiées à ces ressources. Ce laboratoire est conçu pour aider les débutants à comprendre quelle commande utiliser pour chaque type de charge de travail.

À la fin de ce laboratoire, vous apprendrez à :

Démarrer et vérifier un cluster Minikube.
Créer un pod en utilisant kubectl run.
Créer un déploiement avec plusieurs réplicas.
Créer et inspecter un Job pour le traitement par lots.
Nettoyer les ressources pour maintenir votre cluster propre.

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes opérationnel. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

Accédez à votre répertoire de travail :

Ouvrez le terminal et accédez au dossier de projet par défaut :
```
cd /home/labex/project
```
Démarrez Minikube :

Lancez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes à nœud unique sur votre machine locale.
- Le démarrage de Minikube peut prendre quelques minutes selon les performances de votre système.
Vérifiez que Minikube est en cours d'exécution :

Vérifiez l'état du cluster Minikube :
```
minikube status
```
- Recherchez des composants tels que kubelet et apiserver indiqués comme Running.
- Si le cluster n'est pas en cours d'exécution, relancez minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Explorer la commande kubectl run

La commande kubectl run est utilisée pour créer et exécuter une image spécifique dans un pod. Elle offre de nombreuses options pour personnaliser le comportement, l'environnement et les spécifications du pod.

Exécutez la commande suivante pour afficher les options disponibles pour kubectl run :

kubectl run -h

Vous verrez la sortie suivante :

Create and run a particular image in a pod.

Examples:
## Start a nginx pod
kubectl run nginx --image=nginx

## Start a hazelcast pod and let the container expose port 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701

## Start a hazelcast pod and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

## Start a hazelcast pod and set labels "app=hazelcast" and "env=prod" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

## Dry run; print the corresponding API objects without creating them
kubectl run nginx --image=nginx --dry-run=client

## Start a nginx pod, but overload the spec with a partial set of values parsed from JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'

## Start a busybox pod and keep it in the foreground, don't restart it if it exits
kubectl run -i -t busybox --image=busybox --restart=Never

## Start the nginx pod using the default command, but use custom arguments (arg1 .. argN) for that command
kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>

## Start the nginx pod using a different command and custom arguments
kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>

Créer un Pod

Un pod est la plus petite unité déployable dans Kubernetes et représente un ou plusieurs conteneurs fonctionnant ensemble. Dans cette étape, nous allons créer un pod exécutant un serveur web Nginx.

Créez le pod :

Exécutez la commande suivante pour créer un pod nommé nginx-pod :
```
kubectl run nginx-pod --image=nginx
```
- L'option --image spécifie l'image de conteneur à utiliser. Ici, nous utilisons l'image officielle Nginx.
Vérifiez le pod :

Vérifiez que le pod est en cours d'exécution :
```
kubectl get pods
```
- Recherchez nginx-pod dans la sortie.
- La colonne STATUS doit afficher Running lorsque le pod est prêt.

Si l'état du pod affiche Pending, Kubernetes est peut-être encore en train de télécharger l'image du conteneur. Attendez quelques instants et relancez kubectl get pods.

Créer un Deployment et mettre à l'échelle les réplicas

Un deployment gère un ensemble de pods et s'assure qu'ils fonctionnent comme souhaité. Il est utile pour la mise à l'échelle et la mise à jour des applications.

Créez le déploiement :

Exécutez la commande suivante pour créer un déploiement nommé nginx-deployment :
```
kubectl create deployment nginx-deployment --image=nginx
```
- L'option --image spécifie l'image de conteneur à utiliser.
Mettez à l'échelle le déploiement à 3 réplicas :

Comme l'indicateur --replicas est obsolète, nous allons mettre à l'échelle le déploiement en utilisant kubectl scale.

Utilisez la commande kubectl scale pour ajuster le nombre de réplicas :
```
kubectl scale deployment nginx-deployment --replicas=3
```
- Cela garantit que trois pods sont en cours d'exécution dans le cadre du déploiement.
Vérifiez le déploiement et ses réplicas :

Vérifiez l'état du déploiement et des pods :
```
kubectl get deployments
kubectl get pods
```
- Assurez-vous que le déploiement affiche 3 réplicas sous la colonne READY.
- Vérifiez que trois pods sont listés dans la sortie de kubectl get pods.

Si un pod n'est pas à l'état Running, cela peut être dû à des ressources insuffisantes dans le cluster. Vérifiez les événements du pod avec :

kubectl describe pod <pod-name>

Créer un Job

Dans cette étape, vous allez créer un Job Kubernetes pour exécuter une tâche par lots rapide. Un Job suit l'achèvement réussi, c'est donc la ressource appropriée lorsqu'une commande doit s'exécuter puis se terminer, au lieu de rester active comme un Pod à longue durée de vie.

Créez le job

Exécutez la commande suivante pour créer un job nommé busybox-job :

kubectl create job busybox-job --image=busybox -- echo "Hello from Kubernetes"

kubectl create job crée une ressource Job au lieu d'un Pod autonome.
La commande echo définit la tâche que le Job va exécuter.

Vérifiez l'état du job

Exécutez la commande suivante pour vérifier le job :

kubectl get jobs

Sortie attendue :

NAME          COMPLETIONS   DURATION   AGE
busybox-job   1/1           5s         10s

COMPLETIONS : Indique que le Job s'est terminé avec succès une fois (1/1).
Si aucun Job n'est encore listé, attendez quelques secondes et relancez kubectl get jobs.

Vérifiez le pod du job

Comme un job s'exécute à l'intérieur d'un pod, utilisez la commande suivante pour vérifier le pod :

kubectl get pods

Sortie attendue :

NAME                      READY   STATUS      RESTARTS   AGE
busybox-job-abcde         0/1     Completed   0          30s

Le nom du Pod inclut un suffixe généré car il appartient au Job.
Le champ STATUS doit afficher Completed, indiquant que le Pod du Job s'est terminé avec succès.

Vérifiez la sortie du job

Inspectez les journaux (logs) du Job pour vérifier la sortie :

kubectl logs job/busybox-job

Sortie attendue :

Hello from Kubernetes

Cela confirme que le job a été exécuté avec succès.

Nettoyage

Pour garder votre cluster propre, supprimez les ressources que vous avez créées pendant le laboratoire.

Supprimez les ressources :

Exécutez les commandes suivantes :

kubectl delete pod nginx-pod
kubectl delete deployment nginx-deployment
kubectl delete job busybox-job

Vérifiez le nettoyage :

Vérifiez qu'aucune ressource ne subsiste :
```
kubectl get pods
kubectl get deployments
```
- Assurez-vous que la sortie ne liste plus les ressources que vous avez créées.

Résumé

Dans ce laboratoire, vous avez appris à :

Démarrer et vérifier un cluster Minikube.
Utiliser kubectl run pour créer un Pod et utiliser des commandes dédiées pour créer des Deployments et des Jobs.
Nettoyer les ressources pour garder le cluster organisé.

Vous avez également vu comment Kubernetes utilise différentes commandes pour différents types de charges de travail. En pratiquant ces étapes, vous pouvez construire une base solide pour des flux de travail Kubernetes plus avancés.