Exécuter une tâche

Vous trouverez sur cette page la procédure à suivre pour exécuter des tâches dans Google Kubernetes Engine.

Présentation

Dans GKE, une tâche est un objet contrôleur qui représente un travail fini. Les tâches diffèrent des autres objets contrôleurs dans le sens où ils gèrent le travail au fur et à mesure de son exécution, plutôt que de gérer un état souhaité en continu (comme le nombre total de pods en cours d'exécution).

Ces types d'objets contrôleurs sont utiles pour les tâches de calcul volumineuses et les tâches par lots. Grâce à eux, l'exécution parallèle de pods est possible. Vous pouvez vous servir d'une tâche pour exécuter en parallèle des éléments de travail indépendants, mais liés : envoi d'e-mails, affichage d'images, transcodage de fichiers, analyse de clés de base de données, etc. Toutefois, les tâches ne sont pas conçues pour les processus parallèles en communication proche, tels que les flux continus de processus en arrière-plan.

Deux types de tâches sont disponibles dans GKE :

  • Tâches non parallèles : ces tâches créent un seul pod (qui est recréé s'il se termine sur un échec) et s'arrêtent lorsque le pod se termine avec succès.
  • Tâches parallèles avec nombre d'achèvements : ces tâches se terminent lorsqu'un certain nombre de pods se terminent avec succès. Vous pouvez spécifier le nombre d'achèvements souhaité à l'aide du champ completions.

Les tâches sont représentées par les objets Tâches Kubernetes. Lorsqu'une tâches est créée, le contrôleur de tâche crée un ou plusieurs pods et s'assure qu'ils se terminent correctement. Une fois les pods terminés, une tâche analyse le nombre de pods ayant terminé leur travail avec succès. Lorsque le nombre souhaité d'achèvements est atteint, la tâche est terminée.

Comme pour les autres contrôleurs, un contrôleur de tâche crée un pod si l'un de ses pods échoue ou est supprimé.

Avant de commencer

Pour préparer ce que nous allons réaliser, procédez comme suit :

  • Assurez-vous d'avoir activé l'API Google Kubernetes Engine.
  • Activer l'API Google Kubernetes Engine
  • Assurez-vous d'avoir installé le SDK Cloud.
  • Définissez votre ID de projet par défaut :
    gcloud config set project [PROJECT_ID]
  • Si vous utilisez des clusters zonaux, définissez votre zone de calcul par défaut :
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si vous utilisez des clusters régionaux, définissez votre région de calcul par défaut :
    gcloud config set compute/region [COMPUTE_REGION]
  • Installez la dernière mise à jour de gcloud :
    gcloud components update

Créer une tâche

Vous pouvez créer une tâche en utilisant la commande kubectl apply avec un fichier manifeste.

Voici un exemple de manifeste de tâche :

apiVersion: batch/v1
kind: Job
metadata:
  # Unique key of the Job instance
  name: example-job
spec:
  template:
    metadata:
      name: example-job
    spec:
      containers:
      - name: pi
        image: perl
        command: ["perl"]
        args: ["-Mbignum=bpi", "-wle", "print bpi(2000)"]
      # Do not restart containers after they exit
      restartPolicy: Never
  

Copiez le manifeste dans un fichier nommé config.yaml et créez la tâche :

kubectl apply -f config.yaml

Cette tâche calcule pi sur 2 000 emplacements, puis l'imprime.

La seule condition requise pour un objet Tâche concerne le champ template du pod, qui doit être renseigné.

Nombre de tâches terminées

Une tâche est finie lorsqu'un nombre spécifique de pods se termine avec succès. Par défaut, une tâche non parallèle avec un seul pod est finie dès que le pod se termine correctement.

Dans le cas d'une tâche parallèle, vous pouvez définir un nombre d'achèvements à l'aide du champ facultatif completions. Ce champ indique combien de pods doivent être terminés avec succès avant la fin de la tâche. La valeur indiquée dans le champ completions doit être une valeur positive non nulle.

Si vous ne renseignez pas le champ completions ou si vous spécifiez une valeur nulle, la réussite d'un pod signalera la réussite de tous les pods.

Copiez le fichier config.yaml de l'exemple précédent dans un fichier nommé config-2.yaml. Dans le fichier config-2.yaml, redéfinissez le champ name sur example-job-2 et ajoutez completions: 8 au champ spec de la tâche. Vous spécifiez ainsi qu'il doit y avoir huit achèvements réussis :

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job-2
spec:
  completions: 8
  template:
    metadata:
      name: example-job-2
    spec:
      ...

Créez la tâche :

kubectl apply -f config-2.yaml

La valeur par défaut de completions est 1. Lorsque completions est défini, le champ parallelism est défini par défaut sur 1, sauf si vous le configurez autrement. Si aucun des deux champs n'est défini, leur valeur par défaut est 1.

Gérer le parallélisme

Par défaut, les pods des tâches ne s'exécutent pas en parallèle. Le champ facultatif parallelism précise le nombre maximal de pods qu'une tâche doit exécuter simultanément à un moment donné.

Le nombre réel de pods s'exécutant dans un état stable peut être inférieur à la valeur de parallelism si le travail restant est inférieur à la valeur de parallelism. Si vous avez également défini la valeur completions, le nombre réel de pods s'exécutant en parallèle ne dépasse pas le nombre d'achèvements restants. Une tâche peut limiter la création de pods en réponse à un nombre trop important d'échecs de création de pod.

Copiez le fichier config.yaml de l'exemple précédent dans un fichier nommé config-3.yaml. Dans le fichier config-3.yaml, redéfinissez le champ name sur example-job-3 et ajoutez parallelism: 5 au champ spec de la tâche. Vous spécifiez ainsi qu'il doit y avoir cinq pods simultanés en cours d'exécution :

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job-3
spec:
  parallelism: 5
  template:
    metadata:
      name: example-job-3
    spec:
      ...

Créez la tâche :

kubectl apply -f config-3.yaml

La valeur par défaut de parallelism est 1, sauf si vous la définissez autrement. Si la valeur est définie sur 0, la tâche est suspendue jusqu'à ce que la valeur soit augmentée.

Spécifier un délai

Par défaut, une tâche crée des pods indéfiniment si ses pods échouent continuellement. Pour éviter que la tâche tente indéfiniment de recréer des pods, vous pouvez spécifier une durée maximale à l'aide du champ facultatif activeDeadlineSeconds.

Un délai accorde à une tâche une durée spécifique en secondes pour exécuter ses tâches avant de se terminer.

Pour spécifier un délai, ajoutez la valeur activeDeadlineSeconds au champ spec de la tâche dans le fichier manifeste. Par exemple, la configuration suivante indique que la tâche a 100 secondes pour se terminer avec succès :

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job
spec:
  activeDeadlineSeconds: 100
  template:
    metadata:
      name: example-job
    spec:
      ...

Si une tâche ne se termine pas correctement avant le délai, elle se termine avec l'état DeadlineExceeded. Cela entraîne l'arrêt de la création de pods et la suppression des pods existants.

Spécifier un sélecteur de pod

Il peut être utile de spécifier manuellement un sélecteur si vous souhaitez mettre à jour le modèle de pod d'une tâche et que vous voulez que les pods actuels de la tâche soient exécutés sous la tâche mise à jour.

Une tâche est instanciée avec un champ selector. Le sélecteur (selector) génère un identifiant unique pour les pods de la tâche. L'ID généré ne chevauche aucune autre tâche. En règle générale, vous n'avez pas besoin de définir ce champ vous-même : la définition d'une valeur selector en chevauchement avec une autre tâche peut entraîner des problèmes au niveau des pods de l'autre tâche. Pour définir le champ vous-même, vous devez spécifier manualSelector: True dans le champ spec de la tâche.

Par exemple, vous pouvez exécuter kubectl get job my-job --output=yaml pour afficher la spécification de la tâche, qui contient le sélecteur généré pour ses pods :

kind: Job
metadata:
  name: my-job
...
spec:
  completions: 1
  parallelism: 1
  selector:
    matchLabels:
      controller-uid: a8f3d00d-c6d2-11e5-9f87-42010af00002
...

Lorsque vous créez une tâche, vous pouvez définir la valeur manualSelector sur True, puis spécifier la valeur job-uid du champ selector comme suit :

kind: Job
metadata:
  name: my-new-job
  ...
spec:
  manualSelector: true
  selector:
    matchLabels:
      job-uid: a8f3d00d-c6d2-11e5-9f87-42010af00002
  ...

Les pods créés par my-new-job utilisent l'ID unique précédent.

Inspecter une tâche

kubectl

Pour vérifier l'état d'une tâche, exécutez la commande suivante :

kubectl describe job my-job

Pour afficher toutes les ressources de pod de votre cluster, y compris les pods créés par la tâche qui sont terminés, exécutez la commande suivante :

kubectl get pods -a

L'indicateur -a précise que toutes les ressources du type spécifié (dans ce cas, les pods) doivent être affichées.

Console

Après avoir créé une tâche à l'aide de kubectl, vous pouvez l'inspecter en procédant comme suit :

  1. Accédez au menu "Charges de travail" de Google Kubernetes Engine dans la console GCP.

    Accéder au menu "Charges de travail"

  2. Sélectionnez la charge de travail souhaitée dans le menu.

Vous pouvez inspecter la tâche en suivant les méthodes ci-dessous :

  • Pour voir la configuration en direct de la tâche, cliquez sur YAML.
  • Pour voir tous les événements liés à la tâche, cliquez sur Événements.
  • Pour voir l'historique des révisions de la tâche, cliquez sur Historique des révisions.

Effectuer le scaling d'une tâche

kubectl

Pour procéder au scaling d'une tâche, exécutez la commande suivante :

kubectl scale job my-job --replicas=[VALUE]

kubectl scale change le nombre de pods qui s'exécutent simultanément. Plus précisément, cette commande remplace la valeur du champ parallelism par la valeur [VALUE] que vous spécifiez.

Console

Pour procéder au scaling d'une tâche, procédez comme suit :

  1. Accédez au menu Charges de travail de Google Kubernetes Engine dans la console GCP.

    Accéder au menu "Charges de travail"

  2. Sélectionnez la charge de travail souhaitée dans le menu.

  3. Cliquez sur Faire évoluer.

  4. Dans le champ Instances dupliquées, saisissez le nombre d'instances dupliquées souhaité.

  5. Cliquez sur Faire évoluer.

Supprimer une tâche

Lorsqu'une tâche est terminée, elle arrête de créer des pods. L'objet de l'API Job n'est pas supprimé lorsqu'il est terminé, ce qui vous permet d'afficher son état. Les pods créés par la tâche ne sont pas supprimés, mais terminés. La conservation des pods vous permet de consulter leurs journaux et d'interagir avec eux.

kubectl

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

kubectl delete job my-job

Lorsque vous supprimez une tâche, tous ses pods sont également supprimés.

Pour supprimer une tâche en conservant ses pods, spécifiez l'indicateur --cascade false :

kubectl delete jobs my-job --cascade false

Console

Pour supprimer une tâche, procédez comme suit :

  1. Accédez au menu "Charges de travail" de Google Kubernetes Engine dans la console GCP.

    Accéder au menu "Charges de travail"

  2. Dans le menu, sélectionnez la charge de travail souhaitée.

  3. Cliquez sur Supprimer.

  4. Dans le menu de confirmation, cliquez sur Supprimer.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Kubernetes Engine