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

Ce document explique le processus d'exécution et les options de création des jobs. Les jobs 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'un job et sur les conditions préalables à l'utilisation de Batch, consultez 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.

Les sections suivantes décrivent en détail la création et l'exécution des jobs :

Cycle de vie des jobs

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

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

  1. Créer un job : vous définissez la charge de travail que vous souhaitez exécuter en spécifiant les exécutables, les tâches et les autres exigences d'un job. Les détails de la création d'un job sont présentés dans la section Options de création de job de ce document.
  2. Surveiller le job et résoudre les problèmes : une fois le job créé, il est automatiquement mis en file d'attente, planifié et exécuté sur les ressources spécifiées. Vous pouvez afficher les détails d'un job créé ou de l'une de ses tâches pour connaître l'état actuel. Si nécessaire, vous pouvez annuler un job pour l'arrêter ou l'empêcher de s'exécuter. Une fois un job en cours d'exécution ou terminé, vous pouvez également le surveiller et l'analyser à l'aide des journaux. Si un job échoue, vous pouvez le dépanner à l'aide des messages d'erreur, des événements d'état ou des journaux pour diagnostiquer le problème avant de recréer le job.
  3. Supprimer ou exporter le job : les informations d'un job dans Batch restent disponibles jusqu'à ce que vous ou Google Cloud les supprimiez.Google Cloud supprime automatiquement un job 60 jours après sa fin. Avant cela, vous pouvez éventuellement supprimer le job vous-même. Si vous devez conserver les informations, vous pouvez les exporter dans Batch avant la suppression du job. Les informations sur un job stockées dans d'autres services Google Cloud ne sont pas affectées lorsqu'un job est supprimé et sont soumises à des règles de conservation distinctes. Par exemple, les journaux d'un job sont automatiquement conservés et supprimés conformément à la règle de conservation de Cloud Logging.

Une fois que vous avez créé un job, il passe par les états suivants :

  1. En file d'attente (QUEUED) : la demande de tâche a été acceptée et est en attente dans la file d'attente. Le job reste dans la file d'attente de votre projet jusqu'à ce qu'il puisse être planifié, c'est-à-dire lorsque les ressources requises sont disponibles et que les jobs qui le précèdent ont été évalués. Toutefois, pour éviter que vos jobs ne deviennent obsolètes, si un job dépasse le délai d'attente maximal dans la file d'attente, Batch le fait échouer automatiquement au lieu de le planifier.
  2. Planifié (SCHEDULED) : le job a été sélectionné dans la file d'attente pour être exécuté et les ressources sont en cours d'allocation.

  3. En cours d'exécution (RUNNING) : les ressources du job 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ée (ASSIGNED) : une VM a été attribuée à la tâche pour son exécution.
    3. En cours d'exécution (RUNNING) : la tâche est en cours d'exécution sur une VM.

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

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

        • L'exécutable a réussi (a renvoyé un code de sortie égal à zéro).
        • L'exécutable a échoué (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).
        • L'exécutable ne s'est pas terminé, mais il s'agissait d'un exécutable en arrière-plan (vous avez activé le champ background de l'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. Un job se termine dans l'un des états suivants :

    • Réussie (SUCCEEDED) : la tâche a réussi, car toutes ses tâches ont réussi.
    • Échec (FAILED) : la tâche a échoué et a cessé de s'exécuter, car au moins l'une de ses tâches a échoué.
    • Annulée (CANCELLED) : un utilisateur a annulé le job avant qu'il ne réussisse ou échoue.

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

Mise en file d'attente et planification des jobs

En général, les jobs sont plus susceptibles de s'exécuter et de se terminer plus rapidement s'ils sont plus petits et ne nécessitent que quelques ressources courantes. Pour les exemples de jobs de la documentation Batch, qui sont généralement très petits et utilisent un minimum de ressources, vous pouvez les voir se terminer en quelques minutes seulement.

Plus précisément, le temps nécessaire à la mise en file d'attente et à la planification d'un job varie en fonction des jobs et des moments, en fonction des facteurs suivants :

  • Conditions préalables du job spécifiées par l'utilisateur : toutes les conditions préalables que vous devez remplir avant que le job ne soit planifié.

    Par défaut, un job ne présente 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 réussi ou échoué. Pour en savoir plus, consultez Planifier des jobs dépendants (aperçu).

  • Priorité du job : priorité d'un job par rapport à celle des autres jobs de votre projet.

    Vous pouvez éventuellement spécifier la priorité d'un job en incluant l'indicateur --priority pour gcloud CLI ou le champ JSON priority. Vous pouvez définir la priorité d'un job sous la forme d'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é, celle qui a été créée en premier a la priorité la plus élevée.

  • Disponibilité des ressources de job : disponibilité des ressources requises pour le job dans les lieux autorisés.

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

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

    Pour en savoir plus sur les ressources d'un job, consultez Exécution d'un job dans ce document. Pour en savoir plus sur les emplacements que vous pouvez spécifier pour un job par lot et ses ressources, consultez la page Emplacements.

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

    Un job ne peut pas s'exécuter s'il dépasse une limite ou le quota de votre projet pour l'une des ressources ou requêtes requises. Dans ce cas, Batch peut retarder un job et le relancer ultérieurement, ou le faire échouer et afficher une erreur associée.

    Pour éviter les retards et les erreurs dans vos jobs, créez-en qui respectent toutes les limites applicables et assurez-vous que votre projet dispose d'un quota suffisant. Pour en savoir plus, consultez Quotas et limites pour les requêtes par lot.

Exécution du job

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

Planification des tâches

Lorsqu'un job s'exécute, ses tâches sont planifiées en fonction du champ "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 simultanément dépend des tâches parallèles par VM autorisées par les ressources du job et d'autres options de configuration, comme expliqué dans Ressources du job dans ce document.
  • Dans l'ordre (IN_ORDER) : les tâches s'exécutent une par une, dans l'ordre croissant des index.

Ressources pour les tâches

Chaque job Batch 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 correspondantes, chacune étant située dans l'une des zones incluses. Chaque VM dispose d'un matériel dédié pour les cœurs de processeur (plus précisément les processeurs virtuels (vCPU)) et la mémoire, qui affectent les performances de votre job, 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 job.

Pendant la durée d'exécution d'un job, Batch crée et supprime automatiquement les ressources qui répondent à vos spécifications. Lorsque vous créez un job, 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 Ressources de calcul par tâche (computeResource).

  • Ressources de VM : vous pouvez également spécifier les VM du job (type de machine et OS, par exemple) et les ressources supplémentaires (GPU et volumes de stockage, par exemple), principalement à l'aide des champs de la règle de ressources de VM (instances[].policy) ou du champ instances[].instanceTemplate alternatif. (Vous pouvez également utiliser les champs instanceFlexibilityPolicy si vous souhaitez autoriser plusieurs types de machines pour un job.)

    Si vous laissez ces champs non définis (ce qui n'est pas possible lorsque vous créez un job à l'aide de la consoleGoogle 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 pour différents jobs en fonction de la planification des tâches et des exigences matérielles que vous avez spécifiées. Si vous spécifiez que les tâches d'un job doivent s'exécuter 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'un job s'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 un job. Le nombre réel de VM créées pour un job peut être inférieur à cette valeur, par exemple si Batch estime qu'il est plus rapide d'exécuter un job sur moins de ressources que d'attendre d'en avoir plus. Cette valeur est également limitée par les limites de VM simultanées par job.
  • \({taskCount}\) : nombre total de tâches pour le job, que vous définissez à l'aide du champ "Nombre de tâches" (taskCount).

  • \({parallelTasksPerVM}\) : nombre maximal de tâches pouvant être exécutées simultanément sur une VM.

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

    • La valeur minimale est d'une tâche.

    • La valeur maximale correspond à la plus petite valeur entre 20 tâches et, si elle est définie, la valeur du champ Nombre maximal de tâches parallèles par job (parallelism).

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

      Sinon, si taskCountPerNode n'est pas défini, Batch choisit une valeur en divisant le nombre total de ressources de calcul (plus précisément 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 job.

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

Options de création de jobs

Créer et exécuter un job 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 d'en créer une qui utilise une ou plusieurs des options de configuration supplémentaires suivantes :

  • Contrôler l'accès à un job :

  • Configurez des options supplémentaires pour un job :

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

    • Personnalisez les ressources sur lesquelles un job 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 le créez. Il s'agit d'une alternative à la spécification directe des ressources d'un job à l'aide du champ instances[].policy.

      • Utiliser des GPU pour un job explique comment définir un job qui utilise un ou plusieurs processeurs graphiques (GPU). Les cas d'utilisation courants pour les jobs qui utilisent des GPU incluent les charges de travail de traitement de données intensif ou de machine learning (ML).

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

      • La section Présentation de l'environnement de l'OS de VM explique quand et comment personnaliser l'environnement de l'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'un job :

      • Améliorer la surveillance et l'analyse :

      • Planifier des jobs dépendants (aperçu) explique comment spécifier un job qui ne s'exécute que lorsqu'un ou plusieurs jobs de dépendance existants ont réussi ou échoué. Si votre charge de travail a des besoins en ressources variables, vous pouvez réduire les coûts et l'utilisation du quota 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 d'exécution des tâches explique comment relancer automatiquement les tâches d'un job après tous les échecs ou certains échecs spécifiques. Les nouvelles tentatives automatisées peuvent aider à réduire les frictions liées au dépannage et le temps d'exécution global requis pour les jobs qui rencontrent des erreurs temporaires. Par exemple, utilisez les nouvelles tentatives automatiques pour un job qui s'exécute 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 durées d'exécution excessives, vous pouvez réduire les coûts et les retards inattendus.

      • Améliorer l'obtention des ressources :

      • Réduire la latence :

        • Colocaliser les VM pour réduire la latence explique comment réduire la latence du réseau entre les VM d'un job en exigeant que les VM soient situées physiquement à proximité les unes des autres. Ce gain de performances peut être particulièrement utile pour les jobs qui communiquent fréquemment sur le réseau entre les VM, comme les tâches qui communiquent à l'aide de bibliothèques MPI.

        • Utiliser le streaming d'images explique comment améliorer le temps de démarrage des jobs en diffusant des images de conteneurs depuis Artifact Registry.

  • Utilisez des services supplémentaires pour créer et exécuter des jobs :

Étapes suivantes