Comment surveiller l'état et les journaux des jobs Kubernetes

KubernetesBeginner
Pratiquer maintenant

Introduction

Kubernetes est une plateforme d'orchestration de conteneurs puissante qui aide à gérer les applications conteneurisées sur plusieurs hôtes. Une fonctionnalité importante de Kubernetes est son système de gestion des jobs (job management system), qui vous permet d'exécuter des charges de travail orientées batch jusqu'à leur achèvement. Dans ce tutoriel, vous apprendrez à surveiller l'état des jobs Kubernetes et à analyser leurs logs (journaux), des compétences essentielles pour garantir le bon fonctionnement de vos applications conteneurisées.

À la fin de ce tutoriel, vous serez capable de créer des jobs Kubernetes, de vérifier leur statut et d'examiner leurs logs pour résoudre efficacement les problèmes.

Configuration de votre environnement Kubernetes

Avant de pouvoir surveiller les jobs Kubernetes, nous devons configurer un environnement Kubernetes fonctionnel. Nous utiliserons Minikube, un outil qui crée un cluster Kubernetes à nœud unique sur votre machine locale.

Installation de Minikube

Minikube est déjà installé sur votre VM. Vérifions l'installation en vérifiant la version :

minikube version

Vous devriez voir une sortie similaire à celle-ci :

minikube version: v1.29.0
commit: ddac20b4b34a9c8c857fc602203b6ba2679794d3

Démarrage de Minikube

Maintenant, démarrons Minikube pour créer un cluster Kubernetes local :

minikube start --driver=docker

Cette commande prendra quelques minutes pour se terminer. Vous verrez une série de messages au fur et à mesure que Minikube télécharge les composants nécessaires et démarre le cluster.

Une fois terminé, vous devriez voir un message comme :

🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Vérification de l'installation de Kubernetes

Vérifions que notre cluster Kubernetes fonctionne correctement en vérifiant l'état du nœud :

kubectl get nodes

Vous devriez voir une sortie similaire à celle-ci :

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

Vérifiez également que les composants principaux de Kubernetes sont en cours d'exécution :

kubectl get pods -n kube-system

Vous devriez voir plusieurs pods en cours d'exécution, y compris des composants tels que kube-apiserver, kube-controller-manager, et d'autres.

Maintenant que nous avons un cluster Kubernetes en cours d'exécution, nous sommes prêts à créer et à surveiller des jobs.

Création de votre premier Job Kubernetes

Dans cette étape, nous allons créer un simple job Kubernetes qui exécutera un conteneur, effectuera une tâche, puis se terminera. Cela nous donnera quelque chose à surveiller dans les étapes suivantes.

Comprendre les Jobs Kubernetes

Un Job Kubernetes est un contrôleur qui crée un ou plusieurs pods et s'assure qu'ils se terminent avec succès. Les jobs sont utiles pour les processus par lots, les tâches ponctuelles ou toute tâche qui doit s'exécuter jusqu'à son achèvement plutôt qu'indéfiniment.

Création d'un fichier de configuration de Job

Créons un simple fichier de configuration de job. Ouvrez un terminal et créez un nouveau fichier appelé hello-job.yaml dans votre répertoire de projet :

cd ~/project
nano hello-job.yaml

Copiez et collez le contenu YAML suivant dans le fichier :

apiVersion: batch/v1
kind: Job
metadata:
  name: hello-job
spec:
  template:
    spec:
      containers:
        - name: hello
          image: busybox:1.28
          command: ["sh", "-c", 'echo "Hello, Kubernetes!" && sleep 5']
      restartPolicy: Never
  backoffLimit: 4

Cette configuration définit un job nommé hello-job qui :

  • Utilise l'image de conteneur busybox:1.28
  • Exécute une commande qui affiche "Hello, Kubernetes!" puis se met en veille pendant 5 secondes
  • A une politique de redémarrage de Never (Jamais), ce qui signifie qu'il ne redémarrera pas après l'achèvement
  • A une backoffLimit de 4, ce qui signifie qu'il essaiera jusqu'à 4 fois en cas d'échec

Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et quittez nano avec Ctrl+X.

Création du Job

Maintenant, créons le job dans notre cluster Kubernetes :

kubectl apply -f hello-job.yaml

Vous devriez voir la sortie :

job.batch/hello-job created

Félicitations ! Vous venez de créer votre premier job Kubernetes. Dans l'étape suivante, nous apprendrons à surveiller son statut.

Surveillance de l'état des Jobs Kubernetes

Maintenant que nous avons un job en cours d'exécution dans notre cluster Kubernetes, apprenons à surveiller son état. La surveillance de l'état des jobs est cruciale pour comprendre si vos jobs se terminent avec succès ou rencontrent des erreurs.

Vérification de l'état du Job avec kubectl

L'outil principal pour surveiller les ressources Kubernetes est kubectl. Utilisons-le pour vérifier l'état de notre job :

kubectl get jobs

Vous devriez voir une sortie similaire à celle-ci :

NAME        COMPLETIONS   DURATION   AGE
hello-job   1/1           10s        30s

Cette sortie affiche :

  • NAME : Le nom du job
  • COMPLETIONS : Le nombre de pods terminés / achèvements souhaités
  • DURATION : La durée d'exécution du job
  • AGE : Le temps écoulé depuis la création du job

Si votre job affiche 0/1 sous COMPLETIONS, il est peut-être encore en cours d'exécution ou a échoué. Attendez quelques secondes et exécutez à nouveau la commande.

Obtention d'informations détaillées sur le Job

Pour obtenir des informations plus détaillées sur un job, utilisez la commande describe :

kubectl describe job hello-job

Cette commande fournit des informations complètes sur le job, notamment :

  • Les labels et les annotations
  • Les détails du sélecteur
  • Les exigences de parallélisme et d'achèvement
  • Les statuts des pods
  • Les événements liés au job

Recherchez la section Events en bas, qui affiche les événements importants tels que la création et l'achèvement des pods.

Comprendre l'état du Job

Un job peut avoir plusieurs états :

  • Active : Le job est toujours en cours d'exécution
  • Completed (Terminé) : Le job s'est terminé avec succès
  • Failed (Échoué) : Le job a échoué après avoir atteint sa limite de backoff

Vérifions si le pod de notre job est terminé :

kubectl get pods

Vous devriez voir quelque chose comme :

NAME              READY   STATUS      RESTARTS   AGE
hello-job-abcd1   0/1     Completed   0          1m

La colonne STATUS affiche Completed, indiquant que notre job s'est exécuté avec succès.

Création d'un Job qui prend plus de temps

Créons un autre job qui prendra plus de temps à se terminer afin que nous puissions l'observer dans l'état Active :

cd ~/project
nano long-job.yaml

Copiez et collez le contenu YAML suivant :

apiVersion: batch/v1
kind: Job
metadata:
  name: long-job
spec:
  template:
    spec:
      containers:
        - name: long
          image: busybox:1.28
          command:
            [
              "sh",
              "-c",
              'echo "Starting long job..." && sleep 30 && echo "Long job completed!"'
            ]
      restartPolicy: Never
  backoffLimit: 4

Enregistrez le fichier et quittez nano. Ensuite, créez le job :

kubectl apply -f long-job.yaml

Maintenant, vérifions son état immédiatement :

kubectl get jobs

Vous devriez voir que long-job affiche 0/1 completions car il est toujours en cours d'exécution. Si vous continuez à vérifier toutes les quelques secondes, vous le verrez finalement passer à 1/1 après environ 30 secondes.

Cela démontre comment vous pouvez surveiller la progression de vos jobs en temps réel en utilisant kubectl.

Analyse des journaux des Jobs Kubernetes

Être capable de visualiser et d'analyser les journaux de vos jobs Kubernetes est essentiel pour le débogage et la compréhension du comportement des jobs. Dans cette étape, nous allons explorer comment accéder et analyser les journaux des jobs que nous avons créés.

Obtention des noms des pods pour nos Jobs

Avant de pouvoir visualiser les journaux, nous devons connaître les noms des pods créés par nos jobs. Chaque job crée un ou plusieurs pods avec des noms qui incluent le nom du job et un suffixe aléatoire.

Listons tous les pods liés à nos jobs :

kubectl get pods --show-labels

Cela affichera tous les pods ainsi que leurs labels. Recherchez les pods avec des labels tels que job-name=hello-job ou job-name=long-job.

Alternativement, vous pouvez filtrer les pods par nom de job :

kubectl get pods -l job-name=hello-job

Cela affichera uniquement les pods qui appartiennent au job hello-job.

Visualisation des journaux des Jobs

Maintenant que nous connaissons les noms de nos pods, nous pouvons visualiser les journaux de nos jobs. Utilisez la commande suivante, en remplaçant <pod-name> par le nom réel de votre pod :

kubectl logs <pod-name>

Par exemple, si votre pod s'appelle hello-job-abcd1, vous exécuteriez :

kubectl logs hello-job-abcd1

Vous devriez voir la sortie :

Hello, Kubernetes!

C'est le message que notre job était programmé pour afficher.

Vérifions également les journaux de notre job plus long. Tout d'abord, trouvez le nom du pod :

kubectl get pods -l job-name=long-job

Ensuite, affichez ses journaux :

kubectl logs <long-job-pod-name>

Vous devriez voir :

Starting long job...
Long job completed!

Visualisation des journaux des Jobs terminés

L'un des avantages des jobs Kubernetes est que vous pouvez visualiser les journaux même après que le job soit terminé. Ceci est très utile à des fins de débogage et d'audit.

Créons un job qui échouera, afin de voir comment le déboguer :

cd ~/project
nano failed-job.yaml

Copiez et collez le contenu YAML suivant :

apiVersion: batch/v1
kind: Job
metadata:
  name: failed-job
spec:
  template:
    spec:
      containers:
        - name: failed
          image: busybox:1.28
          command: ["sh", "-c", 'echo "Attempting task..." && exit 1']
      restartPolicy: Never
  backoffLimit: 2

Ce job quittera toujours avec le code d'état 1, ce qui indique un échec. Enregistrez le fichier et quittez nano, puis créez le job :

kubectl apply -f failed-job.yaml

Attendez quelques instants que le job tente et échoue plusieurs fois (jusqu'à la limite de backoff). Ensuite, vérifiez son état :

kubectl get jobs failed-job

Vous devriez voir qu'il affiche 0/1 completions et a atteint la date limite d'achèvement.

Examinons maintenant ce qui s'est mal passé en vérifiant les journaux des pods ayant échoué :

kubectl get pods -l job-name=failed-job

Vous verrez plusieurs pods, tous dans l'état Error. Choisissez-en un et affichez ses journaux :

kubectl logs <failed-pod-name>

Vous devriez voir :

Attempting task...

Les journaux du pod montrent que la tâche a commencé, mais s'est ensuite terminée avec un code d'erreur. Ces informations sont cruciales pour le débogage des échecs de job.

Suivi des journaux en temps réel

Si vous souhaitez suivre les journaux d'un job en cours d'exécution en temps réel, vous pouvez utiliser l'option -f :

kubectl logs -f <pod-name>

Ceci est particulièrement utile pour les jobs de longue durée où vous souhaitez voir la sortie au fur et à mesure qu'elle se produit.

Créons un autre job de longue durée pour démontrer :

cd ~/project
nano counter-job.yaml

Copiez et collez le contenu YAML suivant :

apiVersion: batch/v1
kind: Job
metadata:
  name: counter-job
spec:
  template:
    spec:
      containers:
        - name: counter
          image: busybox:1.28
          command:
            [
              "sh",
              "-c",
              'for i in $(seq 1 5); do echo "Count: $i"; sleep 5; done'
            ]
      restartPolicy: Never

Enregistrez le fichier et quittez nano, puis créez le job :

kubectl apply -f counter-job.yaml

Maintenant, suivons ses journaux. Tout d'abord, trouvez le nom du pod :

kubectl get pods -l job-name=counter-job

Ensuite, suivez ses journaux :

kubectl logs -f <counter-job-pod-name>

Vous verrez le compte s'incrémenter toutes les 5 secondes :

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5

Appuyez sur Ctrl+C pour arrêter de suivre les journaux.

En comprenant comment accéder et analyser les journaux, vous pouvez efficacement dépanner et déboguer vos jobs Kubernetes.

Techniques avancées de surveillance des Jobs

Maintenant que vous connaissez les bases de la surveillance des jobs Kubernetes, explorons des techniques plus avancées qui peuvent vous aider à surveiller les jobs plus efficacement, en particulier dans les environnements de production.

Utilisation des labels pour l'organisation des Jobs

Les labels sont des paires clé-valeur qui peuvent être attachées aux ressources Kubernetes. Ils sont utiles pour organiser et sélectionner des sous-ensembles de ressources. Créons un job avec des labels personnalisés :

cd ~/project
nano labeled-job.yaml

Copiez et collez le contenu YAML suivant :

apiVersion: batch/v1
kind: Job
metadata:
  name: labeled-job
  labels:
    department: engineering
    app: demo
    environment: training
spec:
  template:
    spec:
      containers:
        - name: labeled
          image: busybox:1.28
          command: ["sh", "-c", 'echo "This is a labeled job" && sleep 10']
      restartPolicy: Never

Enregistrez le fichier et quittez nano, puis créez le job :

kubectl apply -f labeled-job.yaml

Vous pouvez maintenant filtrer les jobs par leurs labels :

kubectl get jobs -l department=engineering

Cela affichera uniquement les jobs avec le label department=engineering.

Vous pouvez utiliser plusieurs labels pour un filtrage plus spécifique :

kubectl get jobs -l department=engineering,environment=training

Surveillance des événements de Job

Kubernetes génère des événements pour divers changements d'état dans vos jobs. Ces événements peuvent fournir des informations précieuses sur le cycle de vie de vos jobs.

Visualisons les événements liés à nos jobs :

kubectl get events --sort-by=.metadata.creationTimestamp

Cette commande affiche tous les événements dans votre espace de noms, triés par heure. Vous pouvez filtrer les événements liés à un job spécifique :

kubectl get events --field-selector involvedObject.name=labeled-job

Ces événements peuvent vous aider à comprendre quand et pourquoi les jobs ont été créés, démarrés ou ont rencontré des problèmes.

Utilisation de JSONPath pour une sortie personnalisée

Kubernetes vous permet d'utiliser JSONPath pour extraire des champs spécifiques de la sortie des commandes kubectl. Ceci est utile pour se concentrer sur des aspects particuliers de vos jobs :

kubectl get job labeled-job -o jsonpath='{.status.succeeded}'

Cette commande affichera le nombre de pods réussis pour le labeled-job.

Pour obtenir l'heure de création d'un job :

kubectl get job labeled-job -o jsonpath='{.metadata.creationTimestamp}'

Création d'un CronJob pour une exécution planifiée

Pour les tâches qui doivent s'exécuter selon un calendrier, Kubernetes fournit des CronJobs. Créons un simple CronJob :

cd ~/project
nano simple-cronjob.yaml

Copiez et collez le contenu YAML suivant :

apiVersion: batch/v1
kind: CronJob
metadata:
  name: simple-cronjob
spec:
  schedule: "*/1 * * * *" ## Run every minute
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: hello
              image: busybox:1.28
              command: ["sh", "-c", 'date; echo "Hello from CronJob"']
          restartPolicy: Never

Enregistrez le fichier et quittez nano, puis créez le CronJob :

kubectl apply -f simple-cronjob.yaml

Vérifiez que le CronJob a été créé :

kubectl get cronjobs

Vous devriez voir une sortie similaire à :

NAME             SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
simple-cronjob   */1 * * * *   False     0        <none>          10s

Attendez une minute ou deux, puis recherchez les jobs créés par le CronJob :

kubectl get jobs

Vous devriez voir des jobs avec des noms comme simple-cronjob-<timestamp>.

Pour afficher les journaux de la dernière exécution du CronJob, trouvez d'abord le pod :

kubectl get pods --sort-by=.metadata.creationTimestamp

Ensuite, affichez ses journaux :

kubectl logs <latest-cronjob-pod>

Les CronJobs sont puissants pour planifier des tâches récurrentes dans votre cluster Kubernetes, et les mêmes techniques de surveillance que nous avons apprises peuvent également leur être appliquées.

Nettoyage

Avant de terminer, nettoyons les ressources que nous avons créées :

kubectl delete job hello-job long-job failed-job counter-job labeled-job
kubectl delete cronjob simple-cronjob

Cela supprimera tous les jobs et le CronJob de votre cluster.

Résumé

Dans ce tutoriel, vous avez appris à surveiller efficacement les jobs Kubernetes et à analyser leurs journaux. Vous savez maintenant comment :

  • Configurer un environnement Kubernetes en utilisant Minikube
  • Créer des jobs Kubernetes avec diverses configurations
  • Surveiller l'état des jobs en utilisant kubectl get et kubectl describe
  • Accéder et analyser les journaux des jobs en utilisant kubectl logs
  • Utiliser des techniques avancées comme les labels, les événements et JSONPath pour une surveillance plus efficace
  • Créer des jobs planifiés en utilisant les CronJobs

Ces compétences sont essentielles pour gérer les applications conteneurisées dans un environnement Kubernetes, vous permettant d'assurer la fiabilité et la performance de vos processus par lots. En comprenant comment suivre la progression des jobs et résoudre les problèmes grâce aux journaux, vous pouvez maintenir des charges de travail Kubernetes efficaces et sans erreur.

Au fur et à mesure que vous poursuivez votre parcours Kubernetes, envisagez d'explorer des sujets plus avancés tels que la gestion des ressources, le parallélisme des jobs et l'intégration avec des solutions de surveillance externes comme Prometheus et Grafana.