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 les conditions préalables à l'utilisation de Batch, consultez Premiers pas avec Batch.

Fonctionnement de la création et de l'exécution de jobs

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

Les détails de la création et de l'exécution des jobs sont décrits dans les sections suivantes :

Cycle de vie du job

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 éléments exécutables, les tâches et toutes les autres exigences d'un job. La procédure de création d'un job est présentée dans la section Options de création de job de ce document.
  2. Surveiller et dépanner le job : une fois que vous avez terminé de créer un job, celui-ci 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 voir 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 qu'un job est 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 en utilisant les messages d'erreur, les événements d'état ou les 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 ou, si vous devez conserver les informations, vous pouvez exporter les informations du job dans Batch avant sa suppression. 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.

Après avoir créé un job, il passe par les états suivants :

  1. En file d'attente (QUEUED) : la demande de job 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é, ce qui se produit 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 temps d'attente maximal dans la file d'attente, Batch échoue automatiquement au lieu de le planifier.
  2. Planifié (SCHEDULED) : le job a été sélectionné dans la file d'attente pour démarrer l'exécution et les ressources sont en cours d'allocation.

  3. En cours d'exécution (RUNNING) : les ressources du job ont bien été créées et ses tâches peuvent commencer à s'exécuter.

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

    1. En attente (PENDING) : la tâche attend qu'une VM s'exécute.
    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 runnables remplissait l'une des conditions suivantes :

        • L'élément exécutable a réussi (il a renvoyé un code de sortie égal à 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).
        • 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 s'est arrêtée, car au moins un élément exécutable ne remplissait pas les conditions précédentes.

    Les ressources du job sont supprimées avant la fin du job.

  4. Un job se termine dans l'un des états suivants :

    • Réussite (SUCCEEDED) : le job a réussi, car toutes ses tâches ont réussi.
    • Échec (FAILED) : le job a échoué et s'est arrêté, car au moins une de ses tâches a échoué.
    • Annulé (CANCELLED) : un utilisateur a annulé le job avant qu'il ne réussisse ou n'échoue.

Pour en savoir plus, consultez les sections États des jobs et É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 ont plus de chances de s'exécuter et de se terminer plus rapidement s'ils sont plus petits et ne nécessitent que quelques ressources courantes. Les exemples de jobs de la documentation Batch, qui sont généralement très petits et utilisent un minimum de ressources, peuvent s'exécuter 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, selon les facteurs suivants :

  • Prérequis de job spécifiés par l'utilisateur : tous les prérequis que vous souhaitez remplir avant la planification du job.

    Par défaut, un job n'a pas de prérequis. Vous pouvez éventuellement spécifier qu'un job ne peut pas être planifié tant qu'un ou plusieurs jobs existants n'ont pas réussi ou échoué. Pour en savoir plus, consultez Planifier des jobs dépendants (preview).

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

    Vous pouvez éventuellement spécifier la priorité d'un job en incluant l'option --priority pour la 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 faible) et 99 (priorité la plus élevée). Définir une priorité plus élevée peut aider un job à s'exécuter plus rapidement que les jobs 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 jobs en file d'attente ont la même priorité, le job créé en premier a la priorité la plus élevée.

  • Disponibilité des ressources du job : disponibilité des ressources requises pour le job dans les emplacements 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 dans cet emplacement. Dans ce cas, le job é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 des 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 rapidement lorsque vous avez besoin de moins de ressources plus courantes et que vous ne limitez pas l'exécution du job à des zones spécifiques d'une région.

    Pour en savoir plus sur les ressources d'un job, consultez la section Exécution d'un job de 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 de votre projet pour les ressources et les requêtes 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 faire échouer le job et afficher une erreur associée.

    Vous pouvez éviter les retards et les erreurs pour votre job en créant des jobs qui respectent toutes les limites applicables et en vous assurant que votre projet dispose d'un quota suffisant. Pour en savoir plus, consultez Quotas et limites de Batch.

Exécution du job

Le temps nécessaire à l'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 de règle 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 du nombre de tâches parallèles par VM autorisé par les ressources du job et d'autres options de configuration, comme expliqué dans la section Ressources du job de ce document.
  • Dans l'ordre (IN_ORDER) : les tâches s'exécutent une par une dans l'ordre croissant de l'index.

Ressources de job

Chaque job par lot s'exécute sur un groupe d'instances géré (MIG) régional, qui est un groupe d'une ou de plusieurs instances de machines virtuelles (VM) Compute Engine correspondantes, chacune située dans l'une des zones incluses. Chaque VM dispose d'un 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 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 l'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 de ressources de calcul par tâche (computeResource).

  • Ressources de VM : vous pouvez éventuellement spécifier les VM du job, telles que le type de machine et l'OS, ainsi que des ressources supplémentaires telles que des GPU, des TPU et des volumes de stockage, 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 ne définissez pas ces champs (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 selon les 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 de manière IN_ORDER, le job ne comporte qu'une seule 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 de 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 est la plus petite des deux valeurs suivantes : 20 tâches ou, 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 détermine 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 "vCPU par tâche" (cpuMilli).

Options de création de jobs

Créer et exécuter un job de base explique les principes fondamentaux, 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 jobs, envisagez de créer un job qui utilise une ou plusieurs des options de configuration supplémentaires suivantes :

  • Contrôlez 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). Un cas d'utilisation courant de MPI est celui des 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. Cela permet de ne pas spécifier directement les 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 des jobs qui utilisent des GPU incluent les charges de travail de traitement de données intensif, d'intelligence artificielle (IA) ou de machine learning (ML).

      • La page Utiliser des TPU pour un job explique comment définir un job qui utilise un ou plusieurs TPU (Tensor Processing Units). Les cas d'utilisation courants des jobs qui utilisent des TPU incluent les charges de travail d'inférence, d'évaluation, d'ajustement et d'entraînement de l'intelligence artificielle (IA) et du machine learning (ML).

      • La page 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 des disques persistants nouveaux ou existants, de nouveaux disques 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 de l'OS de la VM explique quand et comment personnaliser l'environnement du système d'exploitation (OS) de la VM pour un job, y compris l'image de l'OS de la 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 (preview) explique comment spécifier un job qui ne s'exécute pas tant qu'un ou plusieurs jobs de dépendance existants n'ont pas réussi ou échoué. Si vous avez une charge de travail avec des besoins en 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 nécessitant beaucoup de ressources de calcul (comme le traitement des données).

      • La section Automatiser les nouvelles tentatives de tâches explique comment relancer automatiquement les tâches d'un job après tous les échecs ou certains échecs spécifiés. Les nouvelles tentatives automatiques peuvent aider à réduire les difficultés de dépannage et la durée d'exécution globale requise 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 élément exécutable. En évitant les temps d'exécution excessifs, vous pouvez réduire les coûts et les retards inattendus.

      • Améliorer l'obtention des ressources :

      • Réduire la latence :

        • Colocaliser des VM pour réduire la latence explique comment réduire la latence réseau entre les VM d'un job en exigeant qu'elles soient physiquement proches les unes des autres. Cet avantage en termes de performances peut être particulièrement utile pour les jobs qui ont des communications réseau fréquentes 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