Aller au contenu principal

Lab 7.3 - Jobs et CronJobs

Objectifs du Lab​

À la fin de ce lab, vous serez capable de:

  • Créer et exécuter des Jobs pour des tâches ponctuelles.
  • Comprendre les différents types de Jobs (complet, parallèle).
  • Créer des CronJobs pour des tâches planifiées.
  • Gérer l'historique des Jobs.
  • Surveiller l'exécution des Jobs et CronJobs.

Durée Estimée​

45-60 minutes

Prérequis​

  • kubectl installé et configuré.
  • Cluster Kubernetes local fonctionnel (minikube ou kind).
  • Connaissances sur les Jobs et CronJobs (Chapitre 7.3).

Partie 1: Création d'un Job Simple​

Un Job crée un ou plusieurs Pods et garantit qu'un certain nombre d'entre eux se terminent avec succès.

Étape 1.1: Créer un Job Simple​

Créez un fichier job-simple.yaml:

# job-simple.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: job-simple
spec:
  template:
    spec:
      containers:
      - name: task
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args: ["echo 'Tâche terminée avec succès!' && date"]
      restartPolicy: Never # Jobs utilisent Never ou OnFailure

Explication:

  • restartPolicy: Never: Le Pod ne sera pas redémarré automatiquement s'il échoue. Pour les Jobs, utilisez Never ou OnFailure.
  • Le Job crée un Pod qui exécute la commande et se termine.

Appliquez le Job:

kubectl apply -f job-simple.yaml

Étape 1.2: Vérifier l'Exécution​

Vérifiez le statut du Job:

kubectl get jobs

Vérifiez les Pods créés:

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

Une fois le Pod terminé, vérifiez les logs:

kubectl logs -l job-name=job-simple

Vous devriez voir le message "Tâche terminée avec succès!" et la date.

Étape 1.3: Vérifier le Statut Complet​

Vérifiez les détails du Job:

kubectl describe job job-simple

Vous devriez voir que le Job est Complete avec 1/1 complété.

Partie 2: Job avec Plusieurs Completions​

Un Job peut être configuré pour s'exécuter plusieurs fois (parallèlement ou séquentiellement).

Étape 2.1: Créer un Job avec Completions​

Créez un fichier job-multiple.yaml:

# job-multiple.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: job-multiple
spec:
  completions: 5 # Le Job doit s'exécuter 5 fois avec succès
  parallelism: 2 # Exécuter 2 Pods en parallèle à la fois
  template:
    spec:
      containers:
      - name: task
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args: ["echo 'Tâche $(date +%s)' && sleep 2"]
      restartPolicy: Never

Explication:

  • completions: 5: Le Job doit compléter 5 exécutions réussies.
  • parallelism: 2: Maximum 2 Pods s'exécutent en parallèle à la fois.

Appliquez le Job:

kubectl apply -f job-multiple.yaml

Étape 2.2: Observer l'Exécution​

Surveillez les Pods en temps réel:

kubectl get pods -l job-name=job-multiple -w

Vous devriez voir 2 Pods s'exécuter en parallèle, puis d'autres se créer jusqu'à ce que 5 complétions soient atteintes.

Vérifiez le statut du Job:

kubectl get job job-multiple

Une fois terminé, vous devriez voir 5/5 complétions.

Partie 3: Job avec Backoff Limit​

Le backoffLimit définit le nombre de tentatives en cas d'échec.

Étape 3.1: Créer un Job qui Échoue​

Créez un fichier job-failure.yaml:

# job-failure.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: job-failure
spec:
  backoffLimit: 3 # Maximum 3 tentatives en cas d'échec
  template:
    spec:
      containers:
      - name: task
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args: ["exit 1"] # Échoue intentionnellement
      restartPolicy: Never

Appliquez le Job:

kubectl apply -f job-failure.yaml

Étape 3.2: Observer les Tentatives​

Surveillez les Pods:

kubectl get pods -l job-name=job-failure -w

Vous devriez voir plusieurs Pods être créés (jusqu'à 3 tentatives) avant que le Job ne soit marqué comme Failed.

Vérifiez le statut du Job:

kubectl get job job-failure
kubectl describe job job-failure

Partie 4: Création d'un CronJob​

Un CronJob crée des Jobs de manière récurrente selon un calendrier (format cron).

Étape 4.1: Créer un CronJob​

Créez un fichier cronjob-example.yaml:

# cronjob-example.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: cronjob-example
spec:
  schedule: "*/1 * * * *" # Toutes les minutes (pour le test)
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: task
            image: busybox:1.35
            command: ["/bin/sh", "-c"]
            args: ["echo 'Exécution CronJob - $(date)'"]
          restartPolicy: OnFailure
  successfulJobsHistoryLimit: 3 # Garder 3 Jobs réussis dans l'historique
  failedJobsHistoryLimit: 1 # Garder 1 Job échoué dans l'historique

Explication:

  • schedule: "*/1 * * * *": Format cron (minute heure jour mois jour-semaine). Ici, toutes les minutes.
  • successfulJobsHistoryLimit: 3: Garde les 3 derniers Jobs réussis.
  • failedJobsHistoryLimit: 1: Garde le dernier Job échoué.

Appliquez le CronJob:

kubectl apply -f cronjob-example.yaml

Étape 4.2: Vérifier le CronJob​

Vérifiez le statut du CronJob:

kubectl get cronjob cronjob-example
# ou
kubectl get cj cronjob-example

Attendez une minute, puis vérifiez que des Jobs sont créés:

kubectl get jobs

Vous devriez voir des Jobs nommés cronjob-example-<timestamp>.

Vérifiez les Pods créés par les Jobs:

kubectl get pods

Vérifiez les logs d'un des Jobs:

JOB_NAME=$(kubectl get jobs -o jsonpath='{.items[0].metadata.name}')
kubectl logs -l job-name=$JOB_NAME

Partie 5: Suspendre un CronJob​

Vous pouvez suspendre temporairement un CronJob sans le supprimer.

Étape 5.1: Suspendre le CronJob​

Suspendre le CronJob:

kubectl patch cronjob cronjob-example -p '{"spec":{"suspend":true}}'

Vérifiez que le CronJob est suspendu:

kubectl get cronjob cronjob-example

Vous devriez voir True dans la colonne SUSPEND.

Étape 5.2: Reprendre le CronJob​

Reprendre le CronJob:

kubectl patch cronjob cronjob-example -p '{"spec":{"suspend":false}}'

Partie 6: Exemples de Schedules Cron​

Voici quelques exemples de schedules cron courants:

schedule: "0 0 * * *"        # Tous les jours à minuit
schedule: "0 */6 * * *"     # Toutes les 6 heures
schedule: "0 9 * * 1"       # Tous les lundis à 9h
schedule: "0 0 1 * *"       # Le premier jour de chaque mois à minuit
schedule: "*/30 * * * *"    # Toutes les 30 minutes

Partie 7: Nettoyage​

Supprimez les ressources créées:

# Supprimer les CronJobs (supprime aussi les Jobs associés)
kubectl delete cronjob cronjob-example

# Supprimer les Jobs
kubectl delete job job-simple job-multiple job-failure

# Supprimer les Pods restants (optionnel, normalement supprimés automatiquement)
kubectl delete pods -l job-name

Résumé du Lab​

Dans ce lab, vous avez exploré les Jobs et CronJobs. Vous avez appris à créer des Jobs pour des tâches ponctuelles, à configurer des Jobs parallèles, à gérer les échecs avec backoffLimit, et à créer des CronJobs pour des tâches planifiées récurrentes.

Prochaines Étapes​

Le dernier lab de ce module vous montrera comment utiliser les Init Containers et Sidecars pour des patterns avancés.

Lab 7.4: Init Containers et Sidecars

Lab créé le: Décembre 2024