Présentation de la création et de l'exécution de tâches

Ce document décrit le processus d'exécution et les options de création des tâches. Les tâches par lot vous permettent d'exécuter des charges de travail de traitement par lot surGoogle Cloud. Pour en savoir plus sur les composants d'une tâche et les conditions préalables à l'utilisation de Batch, consultez la section Premiers pas avec Batch.

Fonctionnement de la création et de l'exécution de tâches

Pour utiliser Batch, vous devez créer un job qui spécifie votre charge de travail et ses exigences, puis Batch l'exécute automatiquement.

Le fonctionnement de la création et de l'exécution des tâches est décrit dans les sections suivantes:

Cycle de vie des jobs

Cette section décrit le cycle de vie d'une tâche et de ses tâches, de la création à la suppression.

Pour chaque charge de travail que vous souhaitez exécuter sur Batch, vous suivez le processus de base suivant:

  1. Créer une tâche:vous définissez la charge de travail que vous souhaitez exécuter en spécifiant les exécutables, les tâches et toute autre exigence d'une tâche. Les détails de la création d'une tâche sont présentés dans la section Options de création de tâches de ce document.
  2. Surveillez et dépannez la tâche:une fois que vous avez terminé de créer une tâche, elle est automatiquement mise en file d'attente, planifiée et exécutée sur les ressources spécifiées. Vous pouvez afficher les détails d'une tâche créée ou de l'une de ses tâches pour connaître son état actuel. Si nécessaire, vous pouvez annuler une tâche (Aperçu) pour l'arrêter ou l'empêcher de s'exécuter. Une fois qu'une tâche est en cours d'exécution ou terminée, vous pouvez également la surveiller et l'analyser à l'aide de journaux. Si une tâche échoue, vous pouvez la résoudre à l'aide de messages d'erreur, d'événements d'état ou de journaux pour diagnostiquer le problème avant de recréer la tâche.
  3. Supprimez ou exportez la tâche:les informations d'une tâche dans Batch restent disponibles jusqu'à ce que vous ou Google Cloud les supprimiez.Google Cloud supprime automatiquement une tâche 60 jours après sa fin. Avant cette date, vous pouvez supprimer la tâche vous-même ou, si vous devez conserver les informations, vous pouvez exporter les informations de la tâche dans un lot avant qu'elle ne soit supprimée. Les informations sur une tâche stockées dans d'autres services Google Cloud ne sont pas affectées lorsque la tâche est supprimée et sont soumises à des règles de conservation distinctes. Par exemple, les journaux d'une tâche sont automatiquement conservés et supprimés conformément aux règles de conservation de Cloud Logging.

Une fois que vous avez créé une tâche, elle passe par les états suivants:

  1. En file d'attente (QUEUED) : la requête de tâche a été acceptée et est en attente dans la file d'attente. La tâche reste dans la file d'attente jusqu'à ce que les ressources requises soient disponibles et que les tâches qui la précèdent aient été évaluées.
  2. Planifiée (SCHEDULED) : la tâche a été sélectionnée dans la file d'attente pour commencer à s'exécuter et les ressources sont en cours d'allocation.

  3. En cours d'exécution (RUNNING) : les ressources de la tâche ont été créées avec succès et ses tâches peuvent commencer à s'exécuter.

    Lorsqu'une tâche est en cours d'exécution, chacune de ses tâches passe par les états suivants:

    1. En attente (PENDING) : la tâche attend une VM sur laquelle s'exécuter.
    2. Attribué (ASSIGNED) : une VM a été attribuée à la tâche pour son exécution.
    3. Running (RUNNING) (En cours d'exécution):la tâche s'exécute sur une VM.

    4. Une tâche se termine dans l'un des états suivants:

      • Réussite (SUCCEEDED) : la tâche a réussi, car chacun de ses exécutables remplit l'une des conditions suivantes:

        • L'exécutable a réussi (il a renvoyé un code de sortie de zéro).
        • L'exécutable a échoué (il a renvoyé un code de sortie différent de zéro), mais il s'agissait d'un exécutable non critique (vous avez activé le champ ignoreExitStatus de l'exécutable).
        • Le code exécutable n'a pas terminé, mais il s'agissait d'un code exécutable en arrière-plan (vous avez activé le champ background du code exécutable).

      • Échec (FAILED) : la tâche a échoué et a cessé de s'exécuter, car au moins un exécutable ne remplissait pas les conditions précédentes.

    Les ressources de la tâche sont supprimées avant la fin de la tâche.

  4. Une tâche se termine dans l'un des états suivants:

    • Succeeded (SUCCEEDED) : la tâche a réussi, car toutes ses tâches ont réussi.
    • Failed (FAILED) : la tâche a échoué et a cessé de s'exécuter, car au moins une de ses tâches a échoué.
    • Annulée (CANCELLED) : un utilisateur a annulé la tâche (Aperçu) avant qu'elle ne réussisse ou échoue.

Pour en savoir plus, consultez les sections États des tâches et États des jobs dans la documentation de référence.

Mise en file d'attente et planification des tâches

En règle générale, les tâches sont plus susceptibles de s'exécuter et de se terminer plus rapidement si elles sont plus petites et ne nécessitent que quelques ressources communes. Pour les exemples de tâches de la documentation Batch, qui sont généralement très petites et utilisent des ressources minimales, leur exécution peut prendre aussi peu que quelques minutes.

Plus précisément, le temps nécessaire à la mise en file d'attente et à la planification d'une tâche varie selon les tâches et les moments en fonction des facteurs suivants:

  • Conditions préalables de la tâche spécifiées par l'utilisateur:conditions préalables que vous devez remplir avant la planification de la tâche.

    Par défaut, une tâche n'a aucun prérequis. Vous pouvez éventuellement spécifier qu'une tâche ne peut pas être planifiée tant qu'une ou plusieurs tâches existantes n'ont pas abouti ou échoué. Pour en savoir plus, consultez la section Planifier des tâches dépendantes (Aperçu).

  • Priorité de la tâche:priorité d'une tâche par rapport aux priorités des autres tâches de votre projet.

    Vous pouvez éventuellement spécifier la priorité d'une tâche en incluant l'indicateur --priority pour gcloud CLI ou le champ JSON priority. Vous pouvez définir la priorité d'une tâche comme un nombre compris entre 0 (priorité la plus basse) et 99 (priorité la plus élevée). Définir une priorité plus élevée peut aider une tâche à s'exécuter plus tôt que les tâches de priorité inférieure de votre projet.

    Si vous ne configurez pas la priorité d'un job, la priorité la plus basse, 0, est utilisée par défaut. Si deux tâches en file d'attente ont la même priorité, la tâche créée en premier a la priorité la plus élevée.

  • Disponibilité des ressources de tâche:disponibilité des ressources requises par la tâche dans les emplacements autorisés.

    Tout d'abord, une tâche ne peut pas s'exécuter si vous spécifiez des ressources qui ne sont pas proposées à cet emplacement. Dans ce cas, la tâche échoue avec une erreur de disponibilité de la zone.

    Deuxièmement, un job est plus susceptible d'être retardé ou d'échouer si l'une de ses ressources requises est à faible capacité par rapport à la demande actuelle en raison d'erreurs de disponibilité des ressources. Par conséquent, votre tâche peut s'exécuter plus tôt lorsque vous avez besoin de moins de ressources plus courantes et que vous n'empêchez pas l'exécution de la tâche dans les zones d'une région.

    Pour en savoir plus sur les ressources d'une tâche, consultez la section Exécution de la tâche de ce document. Pour en savoir plus sur les emplacements que vous pouvez spécifier pour un job Batch et ses ressources, consultez la page Emplacements.

  • Quotas et limites:seuils de votre projet pour les Google Cloud ressources et les requêtes.

    Une tâche ne peut pas s'exécuter si elle dépasse une limite ou le quota de votre projet pour l'une des ressources ou des requêtes requises. Dans ce cas, Batch peut retarder une tâche et la relancer ultérieurement, ou échouer et afficher une erreur associée.

    Vous pouvez éviter les retards et les erreurs dans votre tâche en créant des tâches qui respectent toutes les limites pertinentes et en vous assurant que votre projet dispose d'un quota suffisant. Pour en savoir plus, consultez la section Quotas et limites par lot.

Exécution du job

Le temps d'exécution d'une tâche peut varier en fonction de la planification des tâches et des ressources de la tâche.

Planification des tâches

Lorsqu'un job s'exécute, ses tâches sont planifiées en fonction du champ de stratégie de planification (schedulingPolicy), qui vous permet de spécifier l'une des options suivantes:

  • Dès que possible (AS_SOON_AS_POSSIBLE) (par défaut) : les tâches s'exécutent dès que les ressources sont disponibles et peuvent s'exécuter en parallèle. Le nombre de tâches exécutées à la fois dépend des tâches parallèles par VM autorisées par les ressources de la tâche et d'autres options de configuration, comme expliqué dans la section Ressources de tâche de ce document.
  • Dans l'ordre (IN_ORDER) : les tâches sont exécutées une par une dans l'ordre croissant de l'indice.

Ressources pour les offres d'emploi

Chaque job par lot s'exécute sur un groupe d'instances géré (MIG) régional, qui est un groupe d'une ou plusieurs instances de machine virtuelle (VM) Compute Engine correspondants, chacune située dans l'une des zones incluses. Chaque VM dispose de matériel dédié pour les cœurs de processeur (en particulier les processeurs virtuels (vCPU)) et la mémoire, qui affectent les performances de votre tâche, ainsi que d'un disque de démarrage, qui stocke une image de système d'exploitation (OS) et des instructions pour exécuter votre tâche.

Au moment de l'exécution d'un job, Batch crée et supprime automatiquement les ressources qui répondent à vos spécifications. Lorsque vous créez une tâche, vous configurez ses ressources en spécifiant les éléments suivants:

  • Ressources de calcul par tâche:sauf si les valeurs par défaut sont suffisantes, vous devez spécifier les ressources de calcul (processeurs virtuels, mémoire et (si nécessaire) espace de stockage supplémentaire sur le disque de démarrage) requises pour l'exécution de chaque tâche. Pour en savoir plus, consultez les champs de ressources de calcul par tâche (computeResource).

  • Ressources de VM:vous pouvez également spécifier les VM de la tâche (comme le type de machine et l'OS, ainsi que des ressources supplémentaires telles que les GPU et les volumes de stockage) à l'aide des champs de stratégie de ressources de VM (instances[].policy) ou du champ instances[].instanceTemplate. Si vous laissez ces champs non définis (ce qui n'est pas possible lorsque vous créez une tâche à l'aide de la console Google Cloud), Batch tente automatiquement de sélectionner des VM compatibles et n'ajoute aucune ressource supplémentaire.

Le nombre de VM et le nombre de tâches pouvant s'exécuter simultanément sur chaque VM varient selon les jobs en fonction de la planification des tâches et des exigences matérielles spécifiées. Si vous spécifiez que les tâches d'un job doivent s'exécuter avec IN_ORDER, le job dispose d'une VM et n'exécute qu'une seule tâche à la fois. Sinon, si les tâches d'une tâche exécutent AS_SOON_AS_POSSIBLE, vous pouvez estimer le nombre de VM et le nombre de tâches simultanées à l'aide de la formule suivante:

\[{vmsPerJob}=\frac{taskCount}{parallelTasksPerVm}\]

Cette formule comporte les valeurs suivantes:

  • \({vmsPerJob}\): nombre maximal de VM pour une tâche. Le nombre réel de VM créées pour une tâche peut être inférieur à ce nombre. Par exemple, si Batch estime qu'il est plus rapide d'exécuter une tâche avec moins de ressources qu'd'attendre plus de ressources. Cette valeur est également limitée par les limites de VM simultanées par tâche.
  • \({taskCount}\): nombre total de tâches de la tâche, que vous définissez à l'aide du champ "nombre de tâches (taskCount)".

  • \({parallelTasksPerVM}\): nombre maximal de tâches pouvant s'exécuter simultanément sur une VM.

    Cette valeur est déterminée par tous les critères suivants:

    • La valeur minimale est de 1 tâche.

    • La valeur maximale correspond à la plus petite valeur entre 20 tâches et, le cas échéant, la valeur du champ Nombre maximal de tâches parallèles par tâche (parallelism).

    • Si le champ "Nombre maximal de tâches parallèles par VM (taskCountPerNode)" est défini, cette valeur est utilisée.

      Dans le cas contraire, si taskCountPerNode n'est pas défini, Batch décide d'une valeur en divisant le nombre total de ressources de calcul (en particulier les processeurs virtuels) par VM par la quantité requise pour chaque tâche:

      \[{parallelTasksPerVm}=\frac{vcpusPerVm}{vcpusPerTask}\]

      Cette formule comporte les valeurs suivantes:

      • \({vcpusPerVm}\): nombre total de processeurs virtuels par VM, déterminé par le type de machine des VM de votre tâche.

      • \({vcpusPerTask}\): nombre de vCPU par tâche, déterminé en convertissant les unités du champ Nombre de vCPU par tâche (cpuMilli).

Options de création d'une tâche

Créer et exécuter une tâche de base explique les principes de base, y compris comment définir un exécutable à l'aide d'un script ou d'une image de conteneur, et comment configurer des variables d'environnement prédéfinies et personnalisées.

Une fois que vous avez compris les principes de base de la création de tâches, envisagez de créer une tâche qui utilise une ou plusieurs des options de configuration supplémentaires suivantes:

  • Contrôler l'accès à une tâche:

  • Configurez des options supplémentaires pour une tâche:

    • Configurer la communication des tâches à l'aide d'une bibliothèque MPI explique comment configurer une tâche avec des tâches interdépendantes qui communiquent entre elles sur différentes VM à l'aide d'une bibliothèque MPI (Message Passing Interface). Les charges de travail de calcul hautes performances (HPC) à couplage fort sont un cas d'utilisation courant de MPI.

    • Personnalisez les ressources sur lesquelles une tâche s'exécute:

      • Définir les ressources d'un job à l'aide d'un modèle d'instance de VM explique comment spécifier un modèle de VM Compute Engine pour définir les ressources d'un job lorsque vous en créez un. Il s'agit d'une alternative à la spécification directe des ressources d'une tâche à l'aide du champ instances[].policy.

      • Utiliser des GPU pour une tâche explique comment définir une tâche qui utilise une ou plusieurs unités de traitement graphique (GPU). Les cas d'utilisation courants des tâches qui utilisent des GPU incluent le traitement intensif des données ou les charges de travail de machine learning (ML).

      • Utiliser des volumes de stockage pour une tâche explique comment définir une tâche pouvant accéder à un ou plusieurs volumes de stockage externes. Les options de stockage incluent de nouveaux disques persistants ou existants, de nouveaux SSD locaux, des buckets Cloud Storage existants et un système de fichiers réseau (NFS) existant, tel qu'un partage de fichiers Filestore.

      • La présentation de l'environnement d'OS de VM explique quand et comment vous pouvez personnaliser l'environnement du système d'exploitation (OS) de VM pour un job, y compris l'image de l'OS de VM et les disques de démarrage du job.

    • Optimisez différents aspects d'une tâche:

      • Améliorez la surveillance et l'analyse:

      • Planifier des tâches dépendantes (Aperçu) explique comment spécifier une tâche qui ne s'exécute pas tant qu'un ou plusieurs jobs de dépendance existants n'ont pas réussi ou échoué. Si votre charge de travail présente des exigences de ressources variables, vous pouvez réduire les coûts et l'utilisation des quotas en séparant les types de VM utilisés pour les opérations à faible demande (comme la préparation des données) et les opérations gourmandes en calcul (comme le traitement des données).

      • Automatiser les nouvelles tentatives de tâches explique comment relancer automatiquement les tâches d'un job après toutes les erreurs ou celles spécifiées. Les nouvelles tentatives automatiques peuvent contribuer à réduire les difficultés de dépannage et le temps d'exécution global requis pour les tâches qui rencontrent des erreurs temporaires. Par exemple, utilisez des tentatives automatiques pour un job exécuté sur des VM Spot, qui offrent des remises importantes, mais qui ne sont pas toujours disponibles et peuvent être préemptées à tout moment.

      • Limiter les durées d'exécution à l'aide de délais avant expiration explique comment limiter la durée d'exécution d'une tâche ou d'un exécutable. En évitant les temps d'exécution excessifs, vous pouvez réduire les coûts et les retards inattendus.

      • Assurer la disponibilité des ressources à l'aide de réservations de VM explique comment configurer une tâche pouvant s'exécuter sur des VM réservées. L'utilisation de VM réservées peut vous aider à réduire le temps de planification d'un job, à éviter les erreurs de disponibilité des ressources et à optimiser les coûts.

      • Réduire la latence:

        • Colocaliser des VM pour réduire la latence explique comment réduire la latence réseau entre les VM d'une tâche en exigeant que les VM soient physiquement proches les unes des autres. Cet avantage en termes de performances peut s'avérer particulièrement utile pour les tâches qui effectuent des communications réseau fréquentes entre les VM, telles que les tâches qui communiquent à l'aide de bibliothèques MPI.

        • Utiliser le streaming d'images explique comment améliorer le délai de démarrage des jobs en diffusant des images de conteneur à partir d'Artifact Registry.

  • Utilisez des services supplémentaires pour créer et exécuter des tâches:

Étape suivante