CronJobs

Autopilot Standard

Les tâches cron sont en disponibilité générale dans Google Kubernetes Engine (GKE) version 1.21 et ultérieure. Ce document explique comment exécuter des tâches cron dans GKE. Les tâches cron sont une fonctionnalité intégrée de Kubernetes. Pour en savoir plus, consultez la documentation Kubernetes sur les tâches cron.

Présentation

Les tâches cron créent des tâches Kubernetes de façon récurrente. Les tâches cron vous permettent d'automatiser des tâches régulières telles que la création de sauvegardes, la création de rapports, l'envoi d'e-mails ou les tâches de nettoyage.

Les tâches cron sont créées, gérées, mises à l'échelle et supprimées de la même manière que les tâches classiques. Le nombre exact d'objets de tâche créés dépend de plusieurs facteurs. Pour en savoir plus, consultez la section Limites des tâches cron.

Pour plus d'informations sur les tâches, consultez la page Exécuter une tâche.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Créer une tâche cron

Vous pouvez créer une tâche cron à l'aide d'un fichier manifeste. Par exemple, le fichier manifeste YAML suivant affiche l'heure actuelle ainsi qu'une chaîne une fois par minute, tout en conservant les valeurs par défaut pour les paramètres de la tâche cron :

# cronjob.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  concurrencyPolicy: Allow
  startingDeadlineSeconds: 100
  suspend: false
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox
            args:
            - /bin/sh
            - -c
            - date; echo "Hello, World!"
          restartPolicy: OnFailure

Pour créer cette tâche cron, enregistrez le fichier manifeste YAML dans un fichier et appliquez-le au cluster :

kubectl apply -f PATH_TO_FILE

Remplacez PATH_TO_FILE par le chemin d'accès au fichier manifeste YAML.

Configurer une tâche cron

Vous pouvez spécifier les paramètres suivants lorsque vous créez une tâche cron :

Quand la tâche cron doit s'exécuter
L'action réalisée par une tâche cron
Le délai de démarrage de la tâche cron
Si les tâches simultanées sont autorisées pour la tâche cron
Si les nouvelles tâches sont suspendues
Le nombre d'exécutions enregistrées par la tâche cron dans son historique

Spécifier quand une tâche cron doit s'exécuter

Le champ spec.schedule définit quand et à quelle fréquence la tâche cron doit s'exécuter. Cette définition suit le format crontab Unix standard. Toutes les heures des tâches cron sont exprimées en temps UTC : Les champs sont au nombre de 5, séparés par des espaces. Ces champs représentent les éléments suivants :

Minutes (valeur comprise entre 0 et 59)
Heures (valeur comprise entre 0 et 23)
Jour du mois (valeur comprise entre 1 et 31)
Mois (valeur comprise entre 1 et 12)
Jour de la semaine (entre 0 et 6 à partir du dimanche)

Vous pouvez utiliser les caractères spéciaux suivants dans n'importe lequel des champs spec.schedule :

? est un caractère générique correspondant à un seul caractère.
* est un caractère générique correspondant à un nombre quelconque (zéro ou plus) de caractères.
/ permet de spécifier un intervalle pour un champ. Par exemple, si le premier champ (celui des minutes) présente une valeur de */5, cela signifie "toutes les cinq minutes". Si le cinquième champ (celui des jours de la semaine) présente la valeur 0/5, cela signifie "un dimanche sur cinq".

Spécifier les tâches à exécuter par une tâche cron

spec.jobTemplate décrit les actions à réaliser par la tâche cron, y compris les images de conteneur, les commandes exécutées par les conteneurs et les règles de redémarrage de la tâche cron. Pour en savoir plus sur les éléments à inclure dans spec.jobTemplate, consultez la documentation Kubernetes sur les tâches cron.

Spécifier un délai

Le champ facultatif startingDeadlineSeconds indique un délai maximal, exprimé en secondes, pour lancer la tâche cron si celle-ci manque son démarrage planifié pour une raison quelconque. Les tâches cron manquées sont considérées comme des échecs.

Pour spécifier un délai, ajoutez la valeur startingDeadlineSeconds au champ spec dans le fichier manifeste de la tâche cron. Par exemple, le fichier manifeste suivant indique que la tâche cron a 100 secondes pour démarrer :

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  startingDeadlineSeconds: 100
  jobTemplate:
    spec:
    ...

Spécifier une règle de simultanéité

Le champ facultatif spec.concurrencyPolicy indique comment traiter les exécutions simultanées d'une tâche créée par le contrôleur cron. Si vous ne définissez pas de valeur, le fonctionnement par défaut autorise plusieurs tâches simultanées.

concurrencyPolicy accepte les valeurs suivantes :

Valeur	Signification
`Allow`	Les tâches simultanées sont autorisées. Il s'agit de la valeur par défaut.
`Forbid`	Les tâches simultanées sont interdites, et aucune nouvelle tâche ne peut démarrer tant que les tâches en attente ne sont pas terminées ou n'ont pas expiré.
`Replace`	Les tâches simultanées sont interdites et toute tâche en cours est annulée pour lancer la nouvelle tâche.

Suspendre les exécutions ultérieures

Le champ facultatif spec.suspend, lorsqu'il est défini sur true, empêche l'exécution de nouvelles tâches, mais autorise les tâches en cours à se terminer.

Spécifier des limites sur l'historique

Une tâche cron crée un pod chaque fois qu'elle s'exécute. La section Afficher l'historique des tâches cron détaille comment consulter l'état de fin des exécutions récentes d'une tâche cron, ainsi que les journaux relatifs à chaque pod.

Vous pouvez configurer le nombre d'exécutions de tâches cron ayant réussi ou échoué qui doivent être enregistrées en spécifiant les valeurs correspondantes dans spec.successfulJobsHistoryLimit et spec.failedJobsHistoryLimit. Par défaut, successfulJobsHistoryLimit est défini sur 3 et failedJobsHistoryLimit sur 1.

Par exemple, le fichier manifeste suivant indique à GKE d'enregistrer jusqu'à cinq exécutions de tâches cron réussies et 10 exécutions de tâches cron ayant échoué :

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  startingDeadlineSeconds: 100
  successfulJobsHistoryLimit: 5
  failedJobsHistoryLimit: 10
  jobTemplate:
    spec:
    ...

Vous pouvez désactiver la conservation de l'historique d'exécution des tâches cron ayant réussi ou échoué en définissant la valeur correspondante sur 0. La désactivation de la conservation de l'historique peut compliquer le débogage des échecs. Par exemple, le fichier manifeste suivant indique à GKE de n'enregistrer que les exécutions de tâches cron ayant échoué :

kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  startingDeadlineSeconds: 100
  successfulJobsHistoryLimit: 0
  failedJobsHistoryLimit: 10
  jobTemplate:
    spec:
    ...

Inspecter une tâche cron

Pour vérifier la configuration d'une tâche cron, utilisez kubectl describe :

kubectl describe cronjob CRONJOB_NAME

Remplacez CRONJOB_NAME par le nom de la tâche cron à inspecter.

Afficher l'historique des tâches cron

Une tâche cron s'exécute dans un pod. Par défaut, Kubernetes conserve les journaux des pods arrêtés représentant, pour chaque tâche cron, les trois dernières exécutions réussies et la tâche ayant échoué la plus récente. Vous pouvez modifier ou désactiver ces valeurs par défaut en modifiant les limites de l'historique des tâches cron.

Pour afficher l'historique d'une tâche cron, commencez par répertorier tous les pods. Les tâches cron ayant réussi apparaissent dans l'état Completed. Les tâches ayant échoué présentent un état tel que RunContainerError, CrashLoopBackOff ou tout autre état indiquant un échec.

NAME                                READY   STATUS              RESTARTS   AGE
hello-1556555640-9bc5r              0/1     Completed           0          3m6s
hello-1556555700-cm6wk              0/1     Completed           0          2m6s
hello-1556555760-62wf5              0/1     Completed           0          66s
hello-1556555820-rl8kl              0/1     Completed           0          5s
hello-failed-1556555820-wrvt2       0/1     RunContainerError   1          5s

Vous pouvez forcer l'échec d'une tâche en modifiant l'exemple de fichier manifeste dans la section Créer une tâche cron. Remplacez le champ args dans spec.containers par une commande non valide ou un chemin d'accès qui n'existe pas, et remplacez la valeur metadata.name par une valeur indiquant que vous effectuez un test des échecs.

Pour afficher les journaux d'une tâche cron spécifique, exécutez la commande suivante :

kubectl logs POD_NAME

Remplacez POD_NAME par le nom du pod que vous souhaitez inspecter.

Le résultat ressemble à ce qui suit :

container_linux.go:247: starting container process caused
"exec: \"/in/sh\": stat /in/sh: no such file or directory"

Supprimer une tâche cron

Pour supprimer une tâche cron, exécutez la commande suivante :

kubectl delete cronjob CRONJOB_NAME

Lorsque vous supprimez une tâche cron, le récupérateur de mémoire de Kubernetes supprime automatiquement les tâches associées et empêche toute nouvelle tâche de démarrer.

Étapes suivantes

Lisez la documentation Kubernetes sur les tâches cron.
Découvrez comment exécuter une tâche ponctuelle.