Explorer et déboguer les applications Kubernetes

Introduction

Dans ce laboratoire, vous allez explorer et déboguer des applications Kubernetes. Vous allez démarrer un cluster Kubernetes local en utilisant Minikube, déployer une application exemple et apprendre diverses techniques de débogage telles que l'inspection de la configuration de l'application, la visualisation des journaux (logs), l'exécution de commandes à l'intérieur des pods et l'examen des événements du cluster. Ces compétences sont essentielles pour le développement et la résolution de problèmes d'applications basées sur Kubernetes.

Skills Graph

Démarrer le cluster Kubernetes

Dans cette étape, vous apprendrez comment démarrer et vérifier un cluster Kubernetes local en utilisant Minikube. C'est une première étape essentielle pour développer et tester des applications Kubernetes sur votre machine locale.

Tout d'abord, démarrez le cluster Minikube :

minikube start

Exemple de sortie :

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Maintenant, vérifiez l'état du cluster en utilisant plusieurs commandes :

minikube status
kubectl get nodes

Exemple de sortie :

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Ces commandes confirment que :

1. Minikube fonctionne correctement
2. Un cluster Kubernetes local a été créé
3. Le cluster est prêt à être utilisé
4. Vous avez un cluster à nœud unique avec des capacités de plan de contrôle (control plane)

Vérifions le contexte (context) du cluster pour nous assurer que vous êtes connecté au bon cluster :

kubectl config current-context

Exemple de sortie :

minikube

Cela vérifie que kubectl est configuré pour utiliser le cluster Minikube.

Déployer une application exemple

Dans cette étape, vous apprendrez à créer et à déployer une application Kubernetes simple en utilisant des manifestes YAML. Nous créerons à la fois un Pod et un Deployment pour illustrer différentes manières de déployer des applications.

Tout d'abord, créez un répertoire pour vos manifestes Kubernetes :

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Créez un manifeste Pod NGINX simple :

nano nginx-pod.yaml

Ajoutez le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80

Appuyez sur Ctrl+X, puis Y, et Enter pour enregistrer et quitter.

Maintenant, créez un manifeste Deployment :

nano nginx-deployment.yaml

Ajoutez le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Appliquez les manifestes pour créer les ressources :

kubectl apply -f nginx-pod.yaml
kubectl apply -f nginx-deployment.yaml

Exemple de sortie :

pod/nginx-pod created
deployment.apps/nginx-deployment created

Vérifiez les ressources créées :

kubectl get pods
kubectl get deployments

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          1m
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           1m

Attendez que le deployment crée les réplicas. La colonne READY doit afficher 3/3 lorsque tous les réplicas sont prêts.

Principales différences entre Pod et Deployment :

• Pod : Instance unique d'une application
• Deployment : Gère plusieurs réplicas et assure l'auto-réparation (self-healing)

Vérifier la configuration de l'application

Dans cette étape, vous allez apprendre à inspecter et à récupérer les détails de configuration des déploiements (Deployments) et des pods Kubernetes en utilisant diverses commandes kubectl. Comprendre comment examiner les configurations des ressources est crucial pour la résolution de problèmes et la compréhension de la configuration de votre application.

Tout d'abord, récupérons la configuration YAML du pod que nous avons créé à l'étape précédente :

kubectl get pod nginx-pod -o yaml

Exemple de sortie (partielle) :

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  namespace: default
  labels:
    app: nginx
spec:
  containers:
    - image: nginx:latest
      imagePullPolicy: Always
      name: nginx
      ports:
        - containerPort: 80
      resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always

Maintenant, examinons la configuration du déploiement :

kubectl get deployment nginx-deployment -o yaml

Exemple de sortie (partielle) :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: default
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Utilisez kubectl describe pour obtenir des informations plus détaillées sur les ressources :

kubectl describe pod nginx-pod
kubectl describe deployment nginx-deployment

Exemple de sortie pour describe pod (partielle) :

Name:         nginx-pod
Namespace:    default
Priority:     0
Node:         minikube/172.17.0.2
Start Time:   [timestamp]
Labels:       app=nginx
Annotations:  <none>
Status:       Running
IP:           172.17.0.5
Containers:
  nginx:
    Container ID:   docker://[container-id]
    Image:          nginx:latest
    Image ID:       docker-pullable://nginx@[image-digest]
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
    Ready:          True
    Restart Count:  0
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True

Vous pouvez également utiliser la sortie au format JSON pour des formats plus faciles à traiter par machine :

kubectl get pod nginx-pod -o json

Éléments clés à rechercher lors de l'inspection des configurations :

• Métadonnées de la ressource (nom, étiquettes, espace de noms)
• Image et ports des conteneurs
• Nombre de réplicas (pour les déploiements)
• État et conditions de la ressource

Afficher les journaux (logs) d'une application

Dans cette étape, vous allez apprendre à afficher et à inspecter les journaux des pods Kubernetes en utilisant la commande kubectl logs. L'affichage des journaux est essentiel pour comprendre le comportement de l'application, résoudre les problèmes et surveiller les performances de l'application.

Tout d'abord, liste les pods disponibles pour vous assurer que vous travaillez avec les bonnes ressources :

kubectl get pods

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          20m
nginx-deployment-xxx-yyy            1/1     Running   0          20m
nginx-deployment-xxx-zzz            1/1     Running   0          20m
nginx-deployment-xxx-www            1/1     Running   0          20m

Affiche les journaux d'un pod spécifique :

## Afficher les journaux du pod nginx-pod
kubectl logs nginx-pod

Exemple de sortie :

/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
...
2023/xx/xx [notice] xxxx#x: signal process started

Affiche les journaux des pods d'un déploiement (Deployment) :

## Afficher les journaux d'un pod spécifique dans le déploiement
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')
kubectl logs $POD_NAME

Explore les options supplémentaires d'affichage des journaux :

## Afficher les 50 dernières lignes des journaux
kubectl logs nginx-pod --tail=50

## Suivre les journaux en temps réel
kubectl logs -f nginx-pod

Exemple de suivi des journaux :

[real-time log output will be displayed]

Quitte la vue en temps réel des journaux en appuyant sur Ctrl + C.

Pour les pods multi-conteneurs, spécifie le nom du conteneur :

## Si un pod a plusieurs conteneurs
kubectl logs nginx-pod -c nginx

Techniques clés d'affichage des journaux :

• Afficher l'historique complet des journaux
• Limiter le nombre de lignes de journaux
• Suivre les journaux en temps réel
• Spécifier le conteneur dans les pods multi-conteneurs

Déboguer en utilisant kubectl exec

Dans cette étape, vous allez apprendre à utiliser kubectl exec pour exécuter des commandes à l'intérieur d'un pod Kubernetes, ce qui est essentiel pour le débogage et l'investigation des environnements de conteneurs.

Tout d'abord, vérifiez les pods disponibles :

kubectl get pods

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          30m
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Exécutez un shell interactif dans le pod nginx-pod :

kubectl exec -it nginx-pod -- /bin/bash

Exemple d'interactions à l'intérieur du pod :

## Vérifier la configuration d'nginx
cat /etc/nginx/nginx.conf

## Vérifier les packages installés
apt update && apt list --installed

## Quitter le shell du pod
exit

Assurez-vous de taper exit pour quitter le shell interactif et revenir au prompt du shell.

Exécutez des commandes spécifiques sans entrer dans un shell interactif :

## Vérifier la version d'nginx
kubectl exec nginx-pod -- nginx -v

## Lister les fichiers dans le répertoire racine du site web
kubectl exec nginx-pod -- ls /usr/share/nginx/html

Pour les pods d'un déploiement (Deployment), sélectionnez un pod spécifique :

## Obtenir le nom d'un pod du déploiement
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')

## Exécuter des commandes dans le pod du déploiement
kubectl exec -it $POD_NAME -- /bin/bash

Techniques clés avec kubectl exec :

• Exécuter des shells interactifs
• Exécuter des commandes spécifiques
• Explorer l'intérieur des pods
• Déboguer les configurations de conteneurs

Utiliser kubectl describe pour la résolution de problèmes

Dans cette étape, vous allez apprendre à utiliser kubectl describe pour diagnostiquer et résoudre les problèmes liés aux ressources Kubernetes. Cette commande fournit des informations détaillées sur l'état des pods, des déploiements (Deployments) et des composants du cluster.

Tout d'abord, créons un déploiement problématique pour démontrer le débogage :

cd ~/project/k8s-manifests
nano problematic-deployment.yaml

Ajoutez le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: debug-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: debug
  template:
    metadata:
      labels:
        app: debug
    spec:
      containers:
        - name: debug-container
          image: non-existent-image:latest
          ports:
            - containerPort: 80

Appliquez le déploiement :

kubectl apply -f problematic-deployment.yaml

Maintenant, utilisez kubectl describe pour examiner le déploiement :

kubectl describe deployment debug-deployment

Exemple de sortie :

Name:                   debug-deployment
Namespace:              default
CreationTimestamp:      [timestamp]
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=debug
Replicas:               2 desired | 0 available | 2 total | 2 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Conditions:
  Type           Status   Reason
  ----           ------   ------
  Available      False    MinimumReplicasUnavailable
  Progressing    False    ProgressDeadlineExceeded
OldReplicaSets:  <none>
NewReplicaSet:   debug-deployment-xxx (2/2 replicas created)
Events:
  Type     Reason                    Age   From                   Message
  ----     ------                    ----  ----                   -------
  Warning  FailedCreate              1m    deployment-controller  Failed to create pod
  Normal   ScalingReplicaSet         1m    deployment-controller  Scaled up replica set

Décrivons les pods pour obtenir plus de détails :

kubectl describe pods -l app=debug

Exemple de sortie :

Name:           debug-deployment-xxx-yyy
Namespace:      default
Priority:       0
Node:           minikube/172.17.0.2
Start Time:     [timestamp]
Labels:         app=debug
Annotations:    <none>
Status:         Pending
Conditions:
  Type           Status
  Initialized    True
  Ready          False
  PodScheduled   True
Events:
  Type     Reason                  Age   From               Message
  ----     ------                  ----  ----               -------
  Warning  FailedCreatePodSandBox  1m    kubelet            Failed to create pod sandbox
  Warning  Failed                  1m    kubelet            Failed to pull image

Décrivons les ressources des nœuds :

kubectl describe nodes minikube

Techniques clés de résolution de problèmes :

• Identifier l'état des déploiements et des pods
• Afficher les messages d'erreur détaillés
• Comprendre pourquoi les ressources ne fonctionnent pas
• Vérifier l'état des nœuds et du cluster

Examiner les événements du cluster (kubectl get events) pour trouver des indices et des chronologies

Dans cette étape, vous allez apprendre à utiliser kubectl get events pour étudier les événements à l'échelle du cluster, comprendre les activités du système et diagnostiquer les problèmes dans votre environnement Kubernetes.

Tout d'abord, affichez tous les événements du cluster :

kubectl get events

Exemple de sortie :

LAST SEEN   TYPE      REASON                 OBJECT                           MESSAGE
10m         Warning   FailedCreate           deployment/debug-deployment     Failed to create pod
5m          Normal    Scheduled              pod/nginx-pod                   Successfully assigned default/nginx-pod to minikube
3m          Normal    Pulled                 pod/nginx-deployment-xxx-yyy    Container image "nginx:latest" already present on machine

Filtrez les événements par espace de noms (namespace) :

kubectl get events -n default

Utilisez des options plus détaillées pour afficher les événements :

## Surveiller les événements en temps réel
kubectl get events -w

## Obtenir les événements triés par horodatage
kubectl get events --sort-by='.metadata.creationTimestamp'

Créez un scénario personnalisé pour générer des événements :

cd ~/project/k8s-manifests
nano event-test-deployment.yaml

Ajoutez le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: event-test
spec:
  replicas: 3
  selector:
    matchLabels:
      app: event-test
  template:
    metadata:
      labels:
        app: event-test
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          resources:
            limits:
              cpu: "100m"
              memory: "50Mi"

Appliquez le déploiement et examinez les événements :

kubectl apply -f event-test-deployment.yaml
kubectl get events

Filtrage avancé des événements :

## Filtrer par type d'événement
kubectl get events --field-selector type=Warning

## Filtrer par ressource spécifique
kubectl get events --field-selector involvedObject.kind=Deployment

Techniques clés d'examen des événements :

• Afficher les événements à l'échelle du cluster
• Filtrer les événements par espace de noms
• Surveiller les événements en temps réel
• Identifier les événements d'avertissement et d'erreur

Résumé

Dans ce laboratoire, vous avez appris à démarrer et à vérifier un cluster Kubernetes local en utilisant Minikube, ce qui est une étape essentielle pour le développement et les tests d'applications Kubernetes sur votre machine locale. Vous avez également appris à créer et à déployer une application Kubernetes simple en utilisant des manifestes YAML, y compris un Pod et un Deployment. De plus, vous avez exploré diverses commandes pour inspecter la configuration, afficher les journaux (logs), déboguer et résoudre les problèmes de l'application, ce qui vous a permis de mieux comprendre comment gérer et surveiller les applications Kubernetes.