Recherche de site Web

Un guide du débutant sur les tâches Kubernetes et CronJobs

Utilisez Jobs et CronJobs pour contrôler et gérer les pods et conteneurs Kubernetes.

Kubernetes est le moteur d'orchestration par défaut pour les conteneurs. Ses options de contrôle et de gestion des pods et des conteneurs incluent :

  1. Déploiements
  2. Ensembles avec état
  3. Ensembles de réplicas

Chacune de ces fonctionnalités a son propre objectif, avec pour fonction commune de garantir le fonctionnement continu des pods. En cas de panne, ces contrôleurs redémarrent ou replanifient les pods pour garantir que les services des pods continuent de fonctionner.

Comme l'explique la documentation Kubernetes, une tâche Kubernetes crée un ou plusieurs pods et garantit qu'un nombre spécifié de pods se termine une fois la tâche (tâche) terminée.

Tout comme dans un système d'exploitation classique, la possibilité d'effectuer des tâches automatisées et planifiées sans interaction de l'utilisateur est importante dans le monde Kubernetes. Mais les tâches Kubernetes font bien plus que simplement exécuter des tâches automatisées, et il existe de multiples façons de les utiliser :

  1. Emplois
  2. Emplois Cron
  3. Files d'attente de travail (cela dépasse le cadre de cet article)

Cela semble simple, n'est-ce pas ? Eh bien, peut-être. Quiconque travaille sur des conteneurs et des applications de microservices sait que certains nécessitent que les services soient transitoires afin de pouvoir effectuer des tâches spécifiques pour les applications ou au sein des clusters Kubernetes.

Dans cet article, j'expliquerai pourquoi les tâches Kubernetes sont importantes, comment créer des tâches et des CronJobs, et quand les utiliser pour les applications exécutées sur le cluster Kubernetes.

Différences entre les tâches Kubernetes et les CronJobs

Les tâches Kubernetes sont utilisées pour créer des pods transitoires qui effectuent les tâches spécifiques auxquelles ils sont affectés. Les CronJobs font la même chose, mais ils exécutent des tâches selon un calendrier défini.

Les tâches jouent un rôle important dans Kubernetes, notamment pour exécuter des processus par lots ou des opérations ad hoc importantes. Les tâches diffèrent des autres contrôleurs Kubernetes dans la mesure où elles exécutent des tâches jusqu'à leur achèvement, plutôt que de gérer l'état souhaité, comme dans les déploiements, les ReplicaSets et les StatefulSets.

Comment créer des tâches Kubernetes et des CronJobs

Avec ce bagage en main, vous pouvez commencer à créer des Jobs et des CronJobs.

Conditions préalables

Pour réaliser cet exercice, vous devez disposer des éléments suivants :

  1. Un cluster Kubernetes fonctionnel ; vous pouvez l'installer avec :

    • CentOS 8
    • Minikube
  2. La ligne de commande kubectl Kubernetes

Voici le déploiement Minikube que j'ai utilisé pour cette démonstration :

$ minikube version
minikube version: v1.8.1

$ kubectl cluster-info
Kubernetes master is running at https://172.17.0.59:8443
KubeDNS is running at https://172.17.0.59:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

$ kubectl get nodes
NAME       STATUS   ROLES    AGE   VERSION
minikube   Ready    master   88s   v1.17.3

Emplois Kubernetes

Comme toute autre chose dans le monde Kubernetes, vous pouvez créer des tâches Kubernetes avec un fichier de définition. Créez un fichier appelé sample-jobs.yaml à l'aide de votre éditeur préféré.

Voici un extrait du fichier que vous pouvez utiliser pour créer un exemple de tâche Kubernetes :

apiVersion: batch/v1          ## The version of the Kubernetes API
kind: Job                     ## The type of object for jobs
metadata:
 name: job-test
spec:                         ## What state you desire for the object
 template:
   metadata:
     name: job-test
   spec:
     containers:
     - name: job
       image: busybox                  ##  Image used
       command: ["echo", "job-test"]   ##  Command used to create logs for verification later
     restartPolicy: OnFailure          ##  Restart Policy in case container failed

Ensuite, appliquez les Jobs dans le cluster :

$ kubectl apply -f sample-jobs.yaml

Attendez quelques minutes que les pods soient créés. Vous pouvez afficher l'état de la création du pod :

$ kubectl get pod –watch

Après quelques secondes, vous devriez voir votre pod créé avec succès :

$ kubectl get pods
  NAME              	READY   STATUS  	RESTARTS  	 AGE
  job-test		        0/1 	Completed    	0  	     11s

Une fois les pods créés, vérifiez les logs du Job :

$ kubectl logs job-test job-test

Vous avez créé votre première tâche Kubernetes et vous pouvez en explorer les détails :

$ kubectl describe job job-test

Nettoyer les tâches :

$ kubectl delete jobs job-test

Emplois Cron Kubernetes

Vous pouvez utiliser CronJobs pour les tâches de cluster qui doivent être exécutées selon un calendrier prédéfini. Comme l'explique la documentation, ils sont utiles pour les tâches périodiques et récurrentes, comme exécuter des sauvegardes, envoyer des e-mails ou planifier des tâches individuelles pour une heure spécifique, par exemple lorsque votre cluster est susceptible d'être inactif.

Comme pour les Jobs, vous pouvez créer des CronJobs via un fichier de définition. Voici un extrait du fichier CronJob cron-test.yaml. Utilisez ce fichier pour créer un exemple de CronJob :

apiVersion: batch/v1beta1            ## The version of the Kubernetes API
kind: CronJob                        ## The type of object for Cron jobs
metadata:
  name: cron-test
spec:
  schedule: "*/1 * * * *"            ## Defined schedule using the *nix style cron syntax
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cron-test
            image: busybox            ## Image used
            args:
            - /bin/sh
            - -c
            - date; echo Hello this is Cron test
          restartPolicy: OnFailure    ##  Restart Policy in case container failed

Appliquez le CronJob à votre cluster :

$ kubectl apply -f cron-test.yaml
 cronjob.batch/cron-test created

Vérifiez que le CronJob a été créé avec la planification dans le fichier de définition :

$ kubectl get cronjob cron-test
 NAME        SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
 cron-test   */1 * * * *   False     0        <none>          10s

Après quelques secondes, vous pouvez rechercher les pods créés par la dernière tâche planifiée et afficher la sortie standard de l'un des pods :

$ kubectl logs cron-test-1604870760
  Sun Nov  8 21:26:09 UTC 2020
  Hello from the Kubernetes cluster

Vous avez créé un CronJob Kubernetes qui crée un objet une fois par exécution en fonction de la planification schedule : "*/1 * * * *". Parfois, la création peut être manquée en raison de problèmes environnementaux au sein du cluster. Ils doivent donc être idempotents.

Autres choses à savoir

Contrairement aux déploiements et aux services dans Kubernetes, vous ne pouvez pas modifier le même fichier de configuration de tâche et le réappliquer immédiatement. Lorsque vous apportez des modifications au fichier de configuration du Job, vous devez supprimer le Job précédent du cluster avant de l'appliquer.

Généralement, la création d'un Job crée un seul pod et exécute la tâche donnée, comme dans l'exemple ci-dessus. Mais en utilisant les complétions et le parallélisme, vous pouvez lancer plusieurs pods, les uns après les autres.

Utilisez vos emplois

Vous pouvez utiliser les tâches Kubernetes et CronJobs pour gérer vos applications conteneurisées. Les tâches sont importantes dans les modèles de déploiement d'applications Kubernetes où vous avez besoin d'un mécanisme de communication ainsi que d'interactions entre les pods et les plates-formes. Cela peut inclure les cas où une application a besoin d'un « contrôleur » ou d'un « observateur » pour effectuer des tâches ou doit être programmée pour s'exécuter périodiquement.

Articles connexes: