Commande Exec de Kubernetes

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser la commande Kubernetes exec pour exécuter des commandes à l'intérieur d'un conteneur s'exécutant dans un pod Kubernetes. Vous commencerez par des exemples simples et progresserez progressivement vers des scénarios plus complexes.

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 exec

La commande kubectl exec est utilisée pour exécuter des commandes directement à l'intérieur d'un conteneur dans un pod. Elle est particulièrement utile pour le débogage et l'inspection des environnements de conteneurs.

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

kubectl exec -h

Vous verrez la sortie suivante :

Execute a command in a container.

Examples:
  ## Get output from running the 'date' command from pod mypod, using the first container by default
  kubectl exec mypod -- date

  ## Get output from running the 'date' command in ruby-container from pod mypod
  kubectl exec mypod -c ruby-container -- date

  ## Switch to raw terminal mode; sends stdin to 'bash' in ruby-container from pod mypod
  ## and sends stdout/stderr from 'bash' back to the client
  kubectl exec mypod -c ruby-container -i -t -- bash -il

  ## List contents of /usr from the first container of pod mypod and sort by modification time
  ## If the command you want to execute in the pod has any flags in common (e.g. -i),
  ## you must use two dashes (--) to separate your command's flags/arguments
  ## Also note, do not surround your command and its flags/arguments with quotes
  ## unless that is how you would execute it normally (i.e., do ls -t /usr, not "ls -t /usr")
  kubectl exec mypod -i -t -- ls -t /usr

  ## Get output from running 'date' command from the first pod of the deployment mydeployment, using the first container by default
  kubectl exec deploy/mydeployment -- date

  ## Get output from running 'date' command from the first pod of the service myservice, using the first container by default
  kubectl exec svc/myservice -- date

Exécution d'une commande dans un conteneur

Dans cette étape, vous apprendrez à exécuter une commande dans un conteneur s'exécutant dans un pod.

Commencez par créer un déploiement (deployment) avec une seule réplique et un conteneur Nginx :
```
kubectl create deployment nginx --image=nginx --replicas=1
```

Attendez que le pod soit prêt :

kubectl wait --for=condition=Ready pod -l app=nginx

Utilisez la commande kubectl exec pour exécuter une commande à l'intérieur du conteneur Nginx :
```
kubectl exec -it POD_NAME -- /bin/bash
```
Remplacez POD_NAME par le nom du pod créé à l'étape 1. Vous pouvez obtenir le POD_NAME avec la commande kubectl get pod -l app=nginx.

Exécution d'une commande dans un conteneur spécifique

Dans cette étape, vous apprendrez à exécuter une commande dans un conteneur spécifique s'exécutant dans un pod avec plusieurs conteneurs.

Créez un pod avec deux conteneurs : Nginx et BusyBox :

cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: nginx-busybox
spec:
  containers:
  - name: nginx
    image: nginx
  - name: busybox
    image: busybox
    command:
      - sleep
      - "3600"
EOF

Attendez que le pod soit prêt :

kubectl wait --for=condition=Ready pod nginx-busybox

Utilisez la commande kubectl exec pour exécuter une commande à l'intérieur du conteneur BusyBox :
```
kubectl exec nginx-busybox -c busybox -- ls /bin
```

Exécution d'une commande avec un terminal virtuel (TTY)

Dans cette étape, vous apprendrez à exécuter une commande avec un terminal virtuel (tty) dans un conteneur.

Utilisez la commande kubectl exec avec les options -it pour exécuter une commande avec un terminal virtuel (tty) :
```
kubectl exec -it nginx-busybox -- /bin/sh
```
Une fois dans le shell du conteneur, exécutez une commande :
```
echo "Hello, world!"
```
Quittez le shell du conteneur :
```
exit
```

Exécution d'une commande avec des variables d'environnement

Dans cette étape, vous apprendrez à exécuter une commande avec des variables d'environnement à l'intérieur d'un conteneur.

Créez un déploiement (deployment) avec une seule réplique et un conteneur Nginx avec une variable d'environnement :
```
kubectl run nginx-env --image=nginx --env="MY_VAR=my-value"
```

Attendez que le pod soit prêt :

kubectl wait --for=condition=Ready pod -l run=nginx-env

Utilisez la commande kubectl exec pour exécuter une commande à l'intérieur du conteneur Nginx qui affiche la variable d'environnement :
```
kubectl exec nginx-env -- sh -c 'echo $MY_VAR'
```
Remplacez nginx-env par le nom du pod créé à l'étape 1.

Résumé

Félicitations, vous avez réussi le laboratoire (lab) sur la commande exec de Kubernetes! Dans ce laboratoire, vous avez appris à utiliser la commande kubectl exec pour exécuter des commandes à l'intérieur de conteneurs s'exécutant dans des pods Kubernetes. Vous avez également appris à exécuter des commandes dans des conteneurs spécifiques, à exécuter des commandes avec un terminal virtuel (tty) et à exécuter des commandes avec des variables d'environnement. Ces compétences sont essentielles pour déboguer les problèmes dans un cluster Kubernetes.