Créer et exécuter une tâche qui utilise des GPU

Ce document explique comment créer et exécuter un job qui utilise un processeur graphique (GPU). Pour en savoir plus sur les fonctionnalités et les restrictions des GPU, consultez À propos des GPU dans la documentation Compute Engine.

Lorsque vous créez un job par lot, vous pouvez éventuellement utiliser des GPU pour accélérer des charges de travail spécifiques. Les cas d'utilisation courants des jobs qui utilisent des GPU incluent le traitement intensif des données et les charges de travail d'intelligence artificielle (IA) telles que le machine learning (ML). Vous pouvez également accélérer les charges de travail d'IA et de ML en utilisant des TPU.

Avant de commencer

  1. Si vous n'avez jamais utilisé Batch, consultez Premiers pas avec Batch et activez Batch en remplissant les conditions préalables pour les projets et les utilisateurs.

  2. Pour obtenir les autorisations nécessaires pour créer un job, demandez à votre administrateur de vous accorder les rôles IAM suivants :

    Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

    Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un job qui utilise des GPU

Pour créer un job qui utilise des GPU, procédez comme suit :

  1. Planifier la configuration d'un job qui utilise des GPU
  2. Créez un job avec les exigences et les méthodes que vous avez identifiées. Pour obtenir des exemples de création de job à l'aide des options recommandées, consultez la section Créer un job qui utilise des GPU de ce document.

Planifier la configuration d'un job qui utilise des GPU

Avant de créer un job qui utilise des GPU, planifiez les exigences de configuration du job, comme expliqué dans les sections suivantes :

  1. Sélectionner le type de machine GPU et l'option de consommation
  2. Installez les pilotes de GPU.
  3. Définir des ressources de VM compatibles

Étape 1 : Sélectionnez le type de machine GPU et l'option de consommation

Les exigences d'un job varient en fonction du type de machine GPU et de l'option de consommation que vous préférez, et les options de chacun peuvent être interdépendantes.

Pour sélectionner le type de machine GPU et l'option de consommation pour votre job, procédez comme suit :

  1. Identifiez et sélectionnez votre priorité :

  2. Effectuez la sélection restante en fonction de ce qui est compatible avec votre première sélection.

    1. Pour identifier les options compatibles avec votre première sélection, consultez Disponibilité des options de consommation par type de machine dans la documentation Compute Engine.

    2. Consultez la section restante pour Sélectionner l'option de consommation ou Sélectionner le type de machine GPU, respectivement.

Sélectionner le type de machine GPU

Pour sélectionner le type de machine GPU pour un job et comprendre ses exigences, procédez comme suit :

  1. Sélectionnez un type de machine GPU : pour examiner les types de machines GPU disponibles (les combinaisons valides de type de GPU, de nombre de GPU et de type de machine (vCPU et mémoire)) et leurs cas d'utilisation recommandés, consultez Types de machines GPU et Famille de machines optimisées pour les accélérateurs dans la documentation Compute Engine.

  2. Comprendre les exigences de job pour votre type de machine GPU : Les champs requis pour qu'un job spécifie un type de machine GPU varient en fonction des catégories du tableau suivant :

    Types de machines avec GPU et exigences de job associées

    GPU pour les VM optimisées pour les accélérateurs : les VM dont le type de machine appartient à la famille de machines optimisées pour les accélérateurs sont automatiquement associées à un type et un nombre spécifiques de ces GPU.

    Pour utiliser des GPU pour les VM optimisées pour les accélérateurs, nous vous recommandons de spécifier le type de machine. Chaque type de machine optimisé pour les accélérateurs n'est compatible qu'avec un type et un nombre spécifiques de GPU. Par conséquent, le résultat est équivalent, que vous spécifiiez ou non ces valeurs en plus du type de machine optimisé pour les accélérateurs.

    Plus précisément, Batch permet également de spécifier uniquement le type et le nombre de GPU pour les VM optimisées pour l'accélérateur, mais les options de processeur virtuel et de mémoire qui en résultent sont souvent très limitées. Par conséquent, nous vous recommandons de vérifier que les options de vCPU et de mémoire disponibles sont compatibles avec les exigences de la tâche du job.

    GPU pour les VM N1 : ces GPU nécessitent que vous spécifiiez le type et la quantité à associer à chaque VM. Ils doivent être associés à des VM avec un type de machine de la série de machines N1.

    Pour utiliser des GPU pour les VM N1, nous vous recommandons de spécifier au moins le type et le nombre de GPU. Assurez-vous que la combinaison de valeurs correspond à l'une des options de GPU valides pour les types de machines N1. Les options de processeur virtuel et de mémoire pour les VM N1 qui utilisent un type et un nombre spécifiques de GPU sont assez flexibles. Sauf si vous créez le job à l'aide de la console Google Cloud , vous pouvez laisser Batch sélectionner automatiquement un type de machine qui répond aux exigences des tâches du job.
Sélectionner l'option de consommation

Cette section explique comment sélectionner l'option de consommation pour un job et les exigences de job pour chaque option.

Les options de consommation disponibles pour Batch et leurs exigences de job sont expliquées dans le tableau suivant. Ce tableau liste les options de consommation en fonction de leurs cas d'utilisation, de la plus facile à la moins facile à obtenir. Assurez-vous que l'option de consommation que vous sélectionnez répond également à vos exigences en termes de tarification, de temps d'exécution et de compatibilité avec les types de machines. Pour en savoir plus sur le choix d'une option de consommation, consultez également Améliorer l'obtention des ressources, la documentation Compute Engine sur les modèles de provisionnement et la documentation AI Hypercomputer sur les options de consommation.

Options de consommation et exigences liées aux jobs

Réservations

  • Cas d'utilisation : nous vous recommandons d'utiliser des réservations pour les jobs si vous souhaitez un niveau d'assurance très élevé de la disponibilité des ressources et que vous ne pouvez pas utiliser de réservations en mode calendrier, ou si vous disposez déjà de réservations qui pourraient être inutilisées.

  • Détails : une fois qu'une réservation est créée, elle entraîne des coûts pour les VM spécifiées au même prix que l'exécution des VM jusqu'à ce que vous supprimiez la réservation. Les VM qui consomment une réservation n'entraînent pas de frais distincts, mais les réservations entraînent des frais, quelle que soit la consommation.

    Pour en savoir plus sur les réservations, consultez la documentation Compute Engine.

Batch utilise des réservations pour les jobs qui peuvent consommer des VM réservées inutilisées. Pour en savoir plus sur les exigences des jobs pour l'utilisation des réservations, consultez la page Assurer la disponibilité des ressources à l'aide de réservations de VM.

Réservations en mode Agenda

  • Cas d'utilisation : nous recommandons les réservations en mode Agenda pour les jobs si vous souhaitez utiliser un type de machine GPU compatible avec les réservations en mode Agenda et que vous avez besoin d'un niveau d'assurance très élevé de la disponibilité des ressources pendant au moins un jour et jusqu'à 90 jours.

  • Détails : avant de créer un job, vous devez demander ou identifier une réservation en mode Agenda que vous pouvez utiliser. Si Compute Engine répond à une demande de réservation future en mode Agenda, la réservation en mode Agenda créée automatiquement entraîne les mêmes coûts que l'exécution des VM spécifiées pendant toute la période de réservation, selon les tarifs de Dynamic Workload Scheduler, qui offrent des remises allant jusqu'à 53 % par rapport aux tarifs à la demande. Une fois que vous avez identifié une réservation en mode calendrier créée automatiquement que vous pouvez utiliser, la création d'un job qui utilise une réservation en mode calendrier est très semblable à la création d'un job qui utilise une réservation.

    Pour en savoir plus sur les réservations en mode calendrier, consultez la documentation Compute Engine.

Batch utilise des réservations en mode Agenda pour les jobs qui effectuent toutes les opérations suivantes :

VM à démarrage flexible

  • Cas d'utilisation : nous recommandons les VM Flex-start si votre job peut tolérer une disponibilité au mieux en échange d'un tarif réduit et d'un délai d'exécution maximal de sept jours.

    Par rapport aux VM à la demande et aux VM Spot, les VM Flex-start peuvent vous permettre d'accéder plus facilement à de nombreuses ressources GPU simultanément. Par exemple, les VM Flex-start peuvent être utiles pour planifier des jobs en atténuant les retards ou les problèmes causés par l'indisponibilité des ressources.

  • Détails : si une requête de création d'un job utilisant des VM à démarrage flexible est satisfaite, les VM sont facturées au tarif du programmeur de charge de travail dynamique, qui offre des remises allant jusqu'à 53 % par rapport au tarif à la demande.

    Apprenez-en plus sur les Flex-start VM dans la documentation Compute Engine.

Batch utilise des VM à démarrage flexible pour les jobs qui effectuent toutes les opérations suivantes :

À la demande

  • Cas d'utilisation : l'option à la demande est rapide et simple à utiliser. Il s'agit donc de l'option de consommation par défaut pour la plupart des jobs1. Toutefois, nous ne recommandons pas l'option à la demande si une autre option de consommation correspond mieux à vos priorités ou si vous rencontrez régulièrement des problèmes d'obtention de ressources.

  • Détails : Le modèle à la demande est généralement le moyen par défaut d'accéder aux VM Compute Engine. Le mode à la demande vous permet d'accéder aux ressources (si elles sont disponibles) lorsqu'elles sont demandées. Les ressources ne sont pas supprimées tant que le job n'est pas terminé ou que la limite de temps d'exécution n'est pas atteinte.

Batch utilise par défaut des ressources à la demande pour la plupart des jobs. Si vous souhaitez vous assurer qu'un job utilise la tarification à la demande, procédez comme suit :1

1 Exception : pour les jobs qui utilisent la série de machines A3, le comportement par défaut est unique. Nous vous recommandons de ne pas utiliser de VM à la demande et de ne pas laisser le champ provisioningModel non défini. Utilisez plutôt les exigences de job pour les VM Flex-start. L'utilisation à la demande n'est pas recommandée pour la série de machines A3 en raison de la faible disponibilité des ressources. Par conséquent, si un job utilise la série de machines A3, bloque les réservations et que le champ provisioningModel n'est pas défini ou est défini sur STANDARD, l'option de consommation par défaut est unique : le comportement est semblable à celui des VM Flex-start, qui limite la durée d'exécution à sept jours. Toutefois, cela n'est pas recommandé, car ces jobs ne bénéficient pas des remises de la tarification du programmeur de charge de travail dynamique. Si votre job avec des VM A3 peut tolérer une limite de durée d'exécution de sept jours, nous vous recommandons d'utiliser des VM à démarrage flexible plutôt que des VM à la demande. Sinon, vous ne pouvez pas vous assurer que les jobs avec des VM A3 utilisent la capacité à la demande, sauf si vous définissez provisioningModel sur STANDARD et que vous vérifiez manuellement que le job ne peut pas consommer de réservations, sans définir le champ reservation sur NO_RESERVATION.

Les VM Spot

  • Cas d'utilisation : nous vous recommandons d'utiliser des VM Spot pour réduire les coûts des charges de travail tolérantes aux pannes.

  • Détails : si une requête de création d'un job utilisant des VM Spot est satisfaite, les VM sont facturées au tarif des VM Spot, qui peut changer souvent et peut offrir la remise la plus importante, jusqu'à 91 % de réduction par rapport au tarif à la demande. Toutefois, les VM Spot ne sont pas toujours disponibles et peuvent être préemptées à tout moment.

    En savoir plus sur les VM Spot et les recommandations pour les jobs avec des VM Spot

Batch utilise des VM Spot pour les jobs qui répondent à toutes les conditions suivantes :

  • Définissez le champ provisioningModel sur SPOT.
  • (Facultatif) Empêchez la consommation des réservations. Vous ne pouvez pas utiliser de VM Spot avec des réservations. Plus précisément, le job peut éventuellement définir le champ reservation sur NO_RESERVATION. Pour en savoir plus, consultez Créer et exécuter un job qui ne peut pas consommer de VM réservées.

Étape 2 : Installez les pilotes de GPU

Pour utiliser des GPU pour un job, vous devez installer les pilotes de GPU. Pour installer des pilotes de GPU, sélectionnez l'une des méthodes suivantes :

Étape 3 : Définir des ressources de VM compatibles

Pour en savoir plus sur les exigences et les options permettant de définir les ressources de VM pour un job, consultez Ressources de job.

En résumé, vous devez effectuer toutes les opérations suivantes lorsque vous définissez les ressources de VM pour un job qui utilise des GPU :

  • Assurez-vous que le type de machine GPU est disponible à l'emplacement des VM de votre job.

    Pour savoir où les types de machines GPU sont disponibles, consultez Emplacements des GPU dans la documentation Compute Engine.

  • Si vous spécifiez le type de machine du job, assurez-vous qu'il dispose de suffisamment de processeurs virtuels et de mémoire pour répondre aux exigences de la tâche du job. Vous devez spécifier le type de machine du job chaque fois que vous créez un job à l'aide de la console Google Cloud . Nous vous recommandons de le faire chaque fois que vous créez un job qui utilise des GPU pour des VM optimisées pour les accélérateurs.

  • Assurez-vous de définir les ressources de VM pour un job à l'aide d'une méthode valide :

    • Définissez les ressources de VM directement à l'aide du champ instances[].policy (recommandé si possible). Cette méthode est illustrée dans les exemples.
    • Définissez les ressources de VM via un modèle à l'aide du champ instances[].instanceTemplate. Cette méthode est requise pour installer manuellement des pilotes de GPU via une image personnalisée. Pour en savoir plus, consultez Définir des ressources de job à l'aide d'un modèle d'instance de VM.

Créer un job qui utilise des GPU

Les sections suivantes expliquent comment créer un exemple de job pour chaque option de consommation. Plus précisément, les exemples de jobs utilisent les options recommandées : tous installent automatiquement les pilotes de GPU et tous définissent directement les ressources de VM.

Option d'utilisation Exemples d'instructions de job
Réservations ou réservations en mode Agenda

Garantir la disponibilité des ressources à l'aide de réservations de VM
VM à démarrage flexible

Utiliser des GPU et des VM Flex-start
VM à la demande ou VM Spot

Sélectionnez l'une des options suivantes en fonction de votre type de machine GPU :

Utiliser des GPU et des VM à démarrage flexible

Vous pouvez créer un job qui utilise des GPU pour les VM A3 via Dynamic Workload Scheduler à l'aide de la gcloud CLI ou de l'API Batch.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, spécifie un type de machine GPU compatible avec les VM Flex-start, bloque les réservations et s'exécute dans un emplacement compatible avec le type de machine GPU.

    Par exemple, pour créer un job de script de base qui utilise des VM à démarrage flexible et des GPU pour les VM optimisées pour les accélérateurs, créez un fichier JSON avec le contenu suivant.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : indique si les pilotes de GPU doivent être installés automatiquement ou non. Lorsque ce champ est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

    • MACHINE_TYPE : type de machine GPU compatible avec les VM à démarrage flexible. Pour en savoir plus, consultez Disponibilité des options de consommation par type de machine dans la documentation Compute Engine.

    • ALLOWED_LOCATIONS : emplacements autorisés pour le job. Assurez-vous que l'emplacement des ressources Compute Engine du job propose le type de machine GPU que vous souhaitez pour ce job en utilisant l'une des options suivantes :

      • Par défaut, si vous omettez le champ allowedLocations[], un job s'exécute sur les ressources Compute Engine créées dans la région de l'emplacement du job (LOCATION).
      • Si vous incluez le champ allowedLocations[], le job ne peut s'exécuter que sur les ressources Compute Engine créées dans les emplacements spécifiés.

  2. Pour créer et exécuter le job, utilisez la commande gcloud batch jobs submit :

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Remplacez les éléments suivants :

    • JOB_NAME : nom du job.

    • LOCATION : emplacement du job.

    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration du job.

API

Envoyez une requête POST à la méthode jobs.create qui installe les pilotes de GPU, spécifie un type de machine GPU compatible avec les VM Flex-start, bloque les réservations et s'exécute dans un emplacement compatible avec le type de machine GPU.

Par exemple, pour créer un job de script de base qui utilise des VM à démarrage flexible et des GPU pour les VM optimisées pour les accélérateurs, envoyez la requête suivante :

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet de votre projet.

  • LOCATION : emplacement du job.

  • JOB_NAME : nom du job.

  • INSTALL_GPU_DRIVERS : indique si les pilotes de GPU doivent être installés automatiquement ou non. Lorsque ce champ est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

  • MACHINE_TYPE : type de machine GPU compatible avec les VM à démarrage flexible. Pour en savoir plus, consultez Disponibilité des options de consommation par type de machine dans la documentation Compute Engine.

  • ALLOWED_LOCATIONS : emplacements autorisés pour le job. Assurez-vous que l'emplacement des ressources Compute Engine du job propose le type de machine GPU que vous souhaitez pour ce job en utilisant l'une des options suivantes :

    • Par défaut, si vous omettez le champ allowedLocations[], un job s'exécute sur les ressources Compute Engine créées dans la région de l'emplacement du job (LOCATION).
    • Si vous incluez le champ allowedLocations[], le job ne peut s'exécuter que sur les ressources Compute Engine créées dans les emplacements spécifiés.

Utiliser des GPU pour les VM optimisées pour les accélérateurs

Vous pouvez créer un job qui utilise des GPU pour les VM optimisées pour les accélérateurs à l'aide de laGoogle Cloud console, de la gcloud CLI, de l'API Batch, de Java, de Node.js ou de Python.

Console

Pour créer un job qui utilise des GPU à l'aide de la console Google Cloud , procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Liste des jobs.

    Accéder à la liste des jobs

  2. Cliquez sur Créer. La page Créer un job par lot s'ouvre. Dans le volet de gauche, la page Informations sur le job est sélectionnée.

  3. Configurez la page Détails du job :

    1. Facultatif : Dans le champ Nom du job, personnalisez le nom du job.

      Par exemple, saisissez example-gpu-job.

    2. Configurez la section Détails de la tâche :

      1. Dans la fenêtre Nouvel élément exécutable, ajoutez au moins un script ou un conteneur pour que ce job s'exécute.

        Par exemple, pour créer un job de script de base, procédez comme suit :

        1. Cochez la case Script. Un champ s'affiche.

        2. Dans le champ, saisissez le script suivant :

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Cliquez sur OK.

      2. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour ce job.

        Par exemple, saisissez 3.

      3. Facultatif : dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément.

        Par exemple, saisissez 1 (valeur par défaut).

  4. Configurez la page Spécifications des ressources :

    1. Dans le volet de gauche, cliquez sur Spécifications des ressources. La page Spécifications des ressources s'ouvre.

    2. Dans la section Modèle de provisionnement de VM, sélectionnez l'une des options suivantes pour l'option de consommation des VM de ce job :

      • Si votre job peut tolérer la préemption et que vous souhaitez utiliser des VM Spot à prix réduit, sélectionnez Spot.

      • Sinon, pour utiliser des VM à la demande, sélectionnez Standard (par défaut).

    3. Sélectionnez l'emplacement de ce job.

      1. Dans le champ Région, sélectionnez une région.

      2. Dans le champ Zone, effectuez l'une des opérations suivantes :

        • Si vous souhaitez limiter l'exécution de ce job à une zone spécifique, sélectionnez une zone.

        • Sinon, sélectionnez any (par défaut).

    4. Sélectionnez le type de machine GPU pour les VM de ce job :

      1. Dans les options de famille de machines, cliquez sur GPU.

      2. Dans le champ Type de GPU, sélectionnez le type de GPU. Ensuite, dans le champ Nombre de GPU, sélectionnez le nombre de GPU pour chaque VM.

        Si vous avez sélectionné l'un des types de GPU pour les VM optimisées pour l'accélérateur, le champ Type de machine n'autorise qu'une seule option pour le type de machine en fonction du type et du nombre de GPU que vous avez sélectionnés.

      3. Pour installer automatiquement les pilotes de GPU, sélectionnez Installation du pilote de GPU (par défaut).

    5. Configurez la quantité de ressources de VM requises pour chaque tâche :

      1. Dans le champ Cœurs, saisissez le nombre de vCPUs par tâche.

        Par exemple, saisissez 1 (valeur par défaut).

      2. Dans le champ Mémoire, saisissez la quantité de RAM en Go par tâche.

        Par exemple, saisissez 0.5 (valeur par défaut).

    6. Cliquez sur OK.

  5. Facultatif : Configurez les autres champs de ce job.

  6. Facultatif : pour examiner la configuration du job, cliquez sur Aperçu dans le volet de gauche.

  7. Cliquez sur Créer.

    La page Informations sur la tâche affiche la tâche que vous avez créée.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, spécifie un type de machine de la famille de machines optimisées pour les accélérateurs et s'exécute dans un emplacement disposant du type de machine GPU.

    Par exemple, pour créer un job de script de base qui utilise des GPU pour des VM optimisées pour les accélérateurs, créez un fichier JSON avec le contenu suivant :

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : indique si les pilotes de GPU doivent être installés automatiquement ou non. Lorsque ce champ est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

    • PROVISIONING_MODEL : modèle de provisionnement pour votre option de consommation : STANDARD pour les VM à la demande ou SPOT pour les VM Spot.

    • MACHINE_TYPE : type de machine de la famille de machines optimisées pour les accélérateurs.

    • ALLOWED_LOCATIONS : emplacements autorisés pour le job. Assurez-vous que l'emplacement des ressources Compute Engine du job propose le type de machine GPU que vous souhaitez pour ce job en utilisant l'une des options suivantes :

      • Par défaut, si vous omettez le champ allowedLocations[], un job s'exécute sur les ressources Compute Engine créées dans la région de l'emplacement du job (LOCATION).
      • Si vous incluez le champ allowedLocations[], le job ne peut s'exécuter que sur les ressources Compute Engine créées dans les emplacements spécifiés.

  2. Pour créer et exécuter le job, utilisez la commande gcloud batch jobs submit :

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Remplacez les éléments suivants :

    • JOB_NAME : nom du job.

    • LOCATION : emplacement du job.

    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration du job.

API

Envoyez une requête POST à la méthode jobs.create qui installe les pilotes de GPU, spécifie un type de machine de la famille de machines optimisées pour les accélérateurs et s'exécute dans un emplacement disposant du type de machine GPU.

Par exemple, pour créer un job de script de base qui utilise des GPU pour des VM optimisées pour les accélérateurs, envoyez la requête suivante :

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet de votre projet.

  • LOCATION : emplacement du job.

  • JOB_NAME : nom du job.

  • INSTALL_GPU_DRIVERS : indique si les pilotes de GPU doivent être installés automatiquement ou non. Lorsque ce champ est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

  • PROVISIONING_MODEL : modèle de provisionnement pour votre option de consommation : STANDARD pour les VM à la demande ou SPOT pour les VM Spot.

  • MACHINE_TYPE : type de machine de la famille de machines optimisées pour les accélérateurs.

  • ALLOWED_LOCATIONS : emplacements autorisés pour le job. Assurez-vous que l'emplacement des ressources Compute Engine du job propose le type de machine GPU que vous souhaitez pour ce job en utilisant l'une des options suivantes :

    • Par défaut, si vous omettez le champ allowedLocations[], un job s'exécute sur les ressources Compute Engine créées dans la région de l'emplacement du job (LOCATION).
    • Si vous incluez le champ allowedLocations[], le job ne peut s'exécuter que sur les ressources Compute Engine créées dans les emplacements spécifiés.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String machineType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJob();

Python 

from google.cloud import batch_v1


def create_gpu_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "g2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Utiliser des GPU pour les VM N1

Vous pouvez créer un job qui utilise des GPU pour les VM N1 à l'aide de la console Google Cloud , de la gcloud CLI, de l'API Batch, de Java, de Node.js ou de Python.

Console

Pour créer un job qui utilise des GPU à l'aide de la console Google Cloud , procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Liste des jobs.

    Accéder à la liste des jobs

  2. Cliquez sur Créer. La page Créer un job par lot s'ouvre. Dans le volet de gauche, la page Informations sur le job est sélectionnée.

  3. Configurez la page Détails du job :

    1. Facultatif : Dans le champ Nom du job, personnalisez le nom du job.

      Par exemple, saisissez example-gpu-job.

    2. Configurez la section Détails de la tâche :

      1. Dans la fenêtre Nouvel élément exécutable, ajoutez au moins un script ou un conteneur pour que ce job s'exécute.

        Par exemple, pour créer un job de script de base, procédez comme suit :

        1. Cochez la case Script. Un champ s'affiche.

        2. Dans le champ, saisissez le script suivant :

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Cliquez sur OK.

      2. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour ce job.

        Par exemple, saisissez 3.

      3. Facultatif : dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément.

        Par exemple, saisissez 1 (valeur par défaut).

  4. Configurez la page Spécifications des ressources :

    1. Dans le volet de gauche, cliquez sur Spécifications des ressources. La page Spécifications des ressources s'ouvre.

    2. Dans la section Modèle de provisionnement de VM, sélectionnez l'une des options suivantes pour l'option de consommation des VM de ce job :

      • Si votre job peut tolérer la préemption et que vous souhaitez utiliser des VM Spot à prix réduit, sélectionnez Spot.

      • Sinon, pour utiliser des VM à la demande, sélectionnez Standard (par défaut).

    3. Sélectionnez l'emplacement de ce job.

      1. Dans le champ Région, sélectionnez une région.

      2. Dans le champ Zone, effectuez l'une des opérations suivantes :

        • Si vous souhaitez limiter l'exécution de ce job à une zone spécifique, sélectionnez une zone.

        • Sinon, sélectionnez any (par défaut).

    4. Sélectionnez le type de machine GPU pour les VM de ce job :

      1. Dans les options de famille de machines, cliquez sur GPU.

      2. Dans le champ Type de GPU, sélectionnez le type de GPU.

        Si vous avez sélectionné l'un des types de GPU pour les VM N1, le champ Série est défini sur N1.

      3. Dans le champ Nombre de GPU, sélectionnez le nombre de GPU pour chaque VM.

      4. Dans le champ Type de machine, sélectionnez le type de machine.

      5. Pour installer automatiquement les pilotes de GPU, sélectionnez Installation du pilote de GPU (par défaut).

    5. Configurez la quantité de ressources de VM requises pour chaque tâche :

      1. Dans le champ Cœurs, saisissez le nombre de vCPUs par tâche.

        Par exemple, saisissez 1 (valeur par défaut).

      2. Dans le champ Mémoire, saisissez la quantité de RAM en Go par tâche.

        Par exemple, saisissez 0.5 (valeur par défaut).

    6. Cliquez sur OK.

  5. Facultatif : Configurez les autres champs de ce job.

  6. Facultatif : pour examiner la configuration du job, cliquez sur Aperçu dans le volet de gauche.

  7. Cliquez sur Créer.

    La page Informations sur la tâche affiche la tâche que vous avez créée.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, définit les sous-champs type et count du champ accelerators[] et s'exécute dans un emplacement disposant du type de machine GPU.

    Par exemple, pour créer un job de script de base qui utilise des GPU pour les VM N1 et permet à Batch de sélectionner le type de machine N1 exact, créez un fichier JSON avec le contenu suivant :

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : indique si les pilotes de GPU doivent être installés automatiquement ou non. Lorsque ce champ est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

    • PROVISIONING_MODEL : modèle de provisionnement pour votre option de consommation : STANDARD pour les VM à la demande ou SPOT pour les VM Spot.

    • GPU_TYPE : type de GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. N'utilisez ce champ que pour les GPU des VM N1.

    • GPU_COUNT : nombre de GPU du type spécifié. Pour en savoir plus sur les options valides, consultez Types de machines GPU pour la série de machines N1. N'utilisez ce champ que pour les GPU des VM N1.

    • ALLOWED_LOCATIONS : emplacements autorisés pour le job. Assurez-vous que l'emplacement des ressources Compute Engine du job propose le type de machine GPU que vous souhaitez pour ce job en utilisant l'une des options suivantes :

      • Par défaut, si vous omettez le champ allowedLocations[], un job s'exécute sur les ressources Compute Engine créées dans la région de l'emplacement du job (LOCATION).
      • Si vous incluez le champ allowedLocations[], le job ne peut s'exécuter que sur les ressources Compute Engine créées dans les emplacements spécifiés.

  2. Pour créer et exécuter le job, utilisez la commande gcloud batch jobs submit :

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Remplacez les éléments suivants :

    • JOB_NAME : nom du job.

    • LOCATION : emplacement du job.

    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration du job.

API

Envoyez une requête POST à la méthode jobs.create qui installe les pilotes de GPU, définit les sous-champs type et count du champ accelerators[] et utilise un emplacement disposant du type de machine GPU.

Par exemple, pour créer un job de script de base qui utilise des GPU pour les VM N1 et permet à Batch de sélectionner le type de machine N1 exact, envoyez la requête suivante :

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet de votre projet.

  • LOCATION : emplacement du job.

  • JOB_NAME : nom du job.

  • INSTALL_GPU_DRIVERS : indique si les pilotes de GPU doivent être installés automatiquement ou non. Lorsque ce champ est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

  • PROVISIONING_MODEL : modèle de provisionnement pour votre option de consommation : STANDARD pour les VM à la demande ou SPOT pour les VM Spot.

  • GPU_TYPE : type de GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. N'utilisez ce champ que pour les GPU des VM N1.

  • GPU_COUNT : nombre de GPU du type spécifié. Pour en savoir plus sur les options valides, consultez Types de machines GPU pour la série de machines N1. N'utilisez ce champ que pour les GPU des VM N1.

  • ALLOWED_LOCATIONS : emplacements autorisés pour le job. Assurez-vous que l'emplacement des ressources Compute Engine du job propose le type de machine GPU que vous souhaitez pour ce job en utilisant l'une des options suivantes :

    • Par défaut, si vous omettez le champ allowedLocations[], un job s'exécute sur les ressources Compute Engine créées dans la région de l'emplacement du job (LOCATION).
    • Si vous incluez le champ allowedLocations[], le job ne peut s'exécuter que sur les ressources Compute Engine créées dans les emplacements spécifiés.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJobN1();

Python 

from google.cloud import batch_v1


def create_gpu_job(
    project_id: str, region: str, zone: str, job_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-16"

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Étapes suivantes