Exécution de conteneurs dans des Pods

Introduction

Dans ce laboratoire (lab), vous apprendrez à exécuter des conteneurs dans des Pods Kubernetes. Les Pods sont l'unité la plus petite et la plus simple dans Kubernetes, et ils peuvent contenir un ou plusieurs conteneurs. L'exécution de conteneurs dans des Pods offre de nombreux avantages, notamment une meilleure utilisation des ressources, un mise à l'échelle plus facile et un déploiement plus efficace.

Skills Graph

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.

1. Accédez à votre répertoire de travail :

   Ouvrez le terminal et accédez au dossier de projet par défaut :

   cd /home/labex/project

2. 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.

3. 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.

Créer un Pod avec un seul conteneur

La première étape consiste à créer un Pod avec un seul conteneur. Pour ce faire, vous allez créer un fichier YAML qui définit le Pod et son conteneur.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-1
spec:
  containers:
    - name: my-container
      image: nginx

Enregistrez le code ci - dessus dans un fichier nommé /home/labex/project/pod-single-container.yaml et exécutez la commande suivante :

kubectl apply -f /home/labex/project/pod-single-container.yaml

Cette commande créera un Pod nommé my-pod-1 avec un seul conteneur nommé my-container qui exécute l'image Nginx.

Créer un Pod avec plusieurs conteneurs

La deuxième étape consiste à créer un Pod avec plusieurs conteneurs. Pour ce faire, vous allez modifier le fichier YAML précédent pour ajouter un autre conteneur.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-2
spec:
  containers:
    - name: my-container
      image: nginx
    - name: my-sidecar
      image: busybox
      command: ["sh", "-c", "echo Hello from the sidecar! && sleep 3600"]

Enregistrez le code ci-dessus dans un fichier nommé /home/labex/project/pod-multiple-containers.yaml et exécutez la commande suivante :

kubectl apply -f /home/labex/project/pod-multiple-containers.yaml

Cette commande créera un Pod nommé my-pod-2 avec deux conteneurs. Le premier conteneur exécute l'image Nginx, et le deuxième conteneur exécute l'image BusyBox et affiche un message dans la console.

Créer un Pod avec des variables d'environnement

La troisième étape consiste à créer un Pod avec des variables d'environnement. Pour ce faire, vous allez modifier le fichier YAML pour ajouter des variables d'environnement au conteneur Nginx.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-3
spec:
  containers:
    - name: my-container
      image: nginx
      env:
        - name: MY_ENV_VAR
          value: "Hello World!"

Enregistrez le code ci - dessus dans un fichier nommé /home/labex/project/pod-env-vars.yaml et exécutez la commande suivante :

kubectl apply -f /home/labex/project/pod-env-vars.yaml

Cette commande créera un Pod nommé my-pod-3 avec un seul conteneur nommé my-container qui exécute l'image Nginx et dispose d'une variable d'environnement nommée MY_ENV_VAR avec la valeur Hello World!.

Créer un Pod avec des ConfigMaps

La quatrième étape consiste à créer un Pod avec des ConfigMaps. Une ConfigMap est une ressource Kubernetes qui vous permet de stocker des données de configuration (comme des variables d'environnement, des fichiers de configuration) séparément du code de votre application. Cette séparation facilite la modification de la configuration sans avoir à reconstruire vos conteneurs.

Découpons cela en étapes simples :

1. Tout d'abord, créez une ConfigMap :

   kubectl create configmap my-config --from-literal=MY_ENV_VAR=labex

   Cette commande crée une ConfigMap nommée my-config qui stocke une seule paire clé-valeur :

   • Clé : MY_ENV_VAR
   • Valeur : labex

   Vous pouvez vérifier que la ConfigMap a été créée et voir son contenu en utilisant :

   kubectl get configmap my-config -o yaml

2. Ensuite, créez un Pod qui utilise cette ConfigMap :

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-pod-4
   spec:
     containers:
       - name: my-container
         image: nginx
         envFrom:
           - configMapRef:
               name: my-config

   Enregistrez ce YAML dans /home/labex/project/pod-configmap.yaml et appliquez-le :

   kubectl apply -f /home/labex/project/pod-configmap.yaml

Cela créera un Pod qui a accès à la valeur de configuration que nous avons stockée dans la ConfigMap. La valeur sera disponible sous forme de variable d'environnement à l'intérieur du conteneur. Vous pouvez vérifier cela en exécutant :

kubectl exec -it my-pod-4 -- env | grep MY_ENV_VAR

Créer un Pod avec des Volumes Persistants

La cinquième étape consiste à créer un Pod avec un Volume Persistant (Persistent Volume - PV) et une Demande de Volume Persistant (Persistent Volume Claim - PVC). Les PV et les PVC sont utilisés pour stocker et accéder aux données de manière persistante lors des redémarrages des Pods.

Pour ce faire, vous allez d'abord créer un PV.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

Enregistrez le code ci - dessus dans un fichier nommé /home/labex/project/pv.yaml et exécutez la commande suivante :

kubectl apply -f /home/labex/project/pv.yaml

Cette commande créera un PV nommé my-pv avec une capacité de 1Gi et un chemin d'hôte de /mnt/data.

Ensuite, vous allez créer une PVC qui demande 1Gi de stockage à partir du PV.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Enregistrez le code ci - dessus dans un fichier nommé /home/labex/project/pvc.yaml et exécutez la commande suivante :

kubectl apply -f /home/labex/project/pvc.yaml

Cette commande créera une PVC nommée my-pvc qui demande 1Gi de stockage.

Enfin, vous allez modifier le fichier YAML pour ajouter un volume et un montage de volume au conteneur Nginx.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-5
spec:
  containers:
    - name: my-container
      image: nginx
      volumeMounts:
        - name: my-volume
          mountPath: /mnt/data
  volumes:
    - name: my-volume
      persistentVolumeClaim:
        claimName: my-pvc

Enregistrez le code ci - dessus dans un fichier nommé /home/labex/project/pod-pv.yaml et exécutez la commande suivante :

kubectl apply -f /home/labex/project/pod-pv.yaml

Cette commande créera un Pod nommé my-pod-5 avec un seul conteneur nommé my-container qui exécute l'image Nginx et a un montage de volume à /mnt/data qui est soutenu par la PVC nommée my-pvc.

Résumé

Félicitations! Vous avez terminé ce laboratoire et appris à exécuter des conteneurs dans des Pods Kubernetes. Vous avez également appris à créer des Pods avec plusieurs conteneurs, des variables d'environnement, des ConfigMaps et des Volumes Persistants. Ce sont des concepts puissants qui vous aideront à construire des applications plus résilientes et évolutives.