Commande kubectl run dans Kubernetes

Introduction

La commande kubectl run est l'une des méthodes les plus simples et les plus polyvalentes pour créer des ressources dans Kubernetes. Elle vous permet de déployer rapidement des conteneurs, de créer des tâches (jobs) pour le traitement par lots ou de configurer des déploiements (deployments) pour gérer plusieurs réplicas d'une application. Ce laboratoire (LabEx) est conçu pour aider les débutants à comprendre les bases de la commande kubectl run et à l'utiliser efficacement.

À la fin de ce laboratoire, vous saurez comment :

Démarrer et vérifier un cluster Minikube.
Créer un pod en utilisant kubectl run.
Créer un déploiement (deployment) avec plusieurs réplicas.
Exécuter une tâche (job) pour le traitement par lots.
Nettoyer les ressources pour maintenir votre cluster.

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. 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 :

Démarrez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes mono - noeud sur votre machine locale.
- Minikube peut prendre quelques minutes à démarrer en fonction des 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 listés comme Running (en cours d'exécution).
- Si le cluster n'est pas en cours d'exécution, relancez la commande 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 propose 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 :

Créer et exécuter une image particulière dans un pod.

Exemples :
## Démarrer un pod nginx
kubectl run nginx --image=nginx

## Démarrer un pod hazelcast et permettre au conteneur d'exposer le port 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701

## Démarrer un pod hazelcast et définir les variables d'environnement "DNS_DOMAIN=cluster" et "POD_NAMESPACE=default" dans le conteneur
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

## Démarrer un pod hazelcast et définir les étiquettes (labels) "app=hazelcast" et "env=prod" dans le conteneur
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

## Mode simulation (dry run) ; afficher les objets API correspondants sans les créer
kubectl run nginx --image=nginx --dry-run=client

## Démarrer un pod nginx, mais surcharger la spécification avec un ensemble partiel de valeurs analysées à partir de JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": {... } }'

## Démarrer un pod busybox et le maintenir au premier plan, ne pas le redémarrer s'il se termine
kubectl run -i -t busybox --image=busybox --restart=Never

## Démarrer le pod nginx en utilisant la commande par défaut, mais utiliser des arguments personnalisés (arg1.. argN) pour cette commande
kubectl run nginx --image=nginx -- <arg1> <arg2>... <argN>

## Démarrer le pod nginx en utilisant une commande différente et des arguments personnalisés
kubectl run nginx --image=nginx --command -- <cmd> <arg1>... <argN>

Créer un Pod

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

Créer 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 de Nginx.
Vérifier 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 devrait afficher Running lorsque le pod est prêt.

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

Créer un déploiement et mettre à l'échelle les replicas

Un déploiement (deployment) gère un ensemble de pods et s'assure qu'ils s'exécutent comme souhaité. Il est utile pour mettre à l'échelle et mettre à jour des applications.

Créer 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.
Mettre à l'échelle le déploiement à 3 réplicas :

Étant donné que le drapeau --replicas est déprécié, nous allons mettre à l'échelle le déploiement en utilisant kubectl scale à la place.

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érifier 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 dans la colonne READY.
- Vérifiez que trois pods sont listés dans la sortie de kubectl get pods.

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

kubectl describe pod <pod-name>

Créer un Job

Un travail (job) est utilisé pour exécuter des tâches qui doivent se terminer avec succès. Par exemple, des tâches par lots (batch jobs) ou des tâches de traitement de données. Nous allons utiliser kubectl run pour créer un travail et vérifier son exécution.

Créer le travail

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

kubectl run busybox-job --image=busybox --restart=OnFailure -- echo "Hello from Kubernetes"

Le drapeau --restart=OnFailure spécifie qu'il s'agit d'un travail.
La commande echo définit la tâche que le travail va exécuter.

Vérifier l'état du travail

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

kubectl get jobs

Sortie attendue :

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

COMPLETIONS : Indique que le travail s'est exécuté avec succès une fois (1/1).
Si aucun travail n'est listé, il peut avoir été automatiquement supprimé. Passez à l'étape suivante pour vérifier son pod.

Vérifier le pod du travail

Étant donné qu'un travail 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        0/1     Completed   0          30s

Le champ STATUS devrait afficher Completed, indiquant que le travail s'est terminé.

Vérifier la sortie du travail

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

kubectl logs busybox-job

Sortie attendue :

Hello from Kubernetes

Cela confirme que le travail s'est exécuté avec succès.

Nettoyage

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

Supprimer les ressources :

Exécutez les commandes suivantes :

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

Vérifier le nettoyage :

Vérifiez qu'aucune ressource ne reste :
```
kubectl get pods
kubectl get deployments
```
- Assurez-vous que la sortie ne liste pas 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 et gérer des pods, des déploiements (deployments) et des travaux (jobs).
Nettoyer les ressources pour maintenir le cluster organisé.

La commande kubectl run offre un moyen simple et puissant de déployer des applications et de gérer les charges de travail dans Kubernetes. En pratiquant ces étapes, vous pouvez construire une solide base pour des flux de travail Kubernetes plus avancés.