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 concernant les GPU, consultez À propos des GPU dans la documentation Compute Engine.

Lorsque vous créez un job Batch, 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).

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. Planifiez les exigences d'une tâche 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 d'un job à l'aide des options recommandées, consultez Créer un exemple de job utilisant des GPU dans ce document.

Planifier les exigences d'un job qui utilise des GPU

Avant de créer un job qui utilise des GPU, planifiez les exigences 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 les 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. Les options de chaque élément 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électionnez 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 consulter 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 des tâches pour votre type de machine GPU : Les champs requis pour qu'une tâche spécifie un type de machine GPU varient en fonction des catégories du tableau suivant :

    Types de machines avec GPU et exigences des tâches

    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. Il est donc fonctionnellement équivalent de spécifier 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 les accélérateurs, 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 processeur virtuel et de mémoire disponibles sont compatibles avec les exigences de tâches du job.

    GPU pour les VM N1 : pour ces GPU, vous devez spécifier le type et la quantité à associer à chaque VM. Ils doivent être associés à des VM dont le type de machine appartient à 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 de GPU spécifiques 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électionnez 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.

Le tableau suivant présente les options de consommation disponibles pour Batch et leurs exigences. Il les liste en fonction de leurs cas d'utilisation, de la disponibilité des ressources la plus élevée à la plus faible.

En résumé, nous recommandons à la plupart des utilisateurs de sélectionner l'option de consommation pour un job comme suit :

  • Sauf si l'une des autres conditions est remplie, utilisez des VM à démarrage flexible (Preview) (méthode recommandée si elle répond à vos exigences) ou à la demande.
  • Si votre job nécessite une très grande assurance de disponibilité des ressources ou si vous avez des réservations inutilisées que vous ne pouvez pas supprimer, utilisez des réservations en mode calendrier (aperçu) (recommandées si elles répondent à vos besoins) ou des réservations.
  • (Facultatif) Si votre charge de travail est très tolérante aux pannes, vous pouvez peut-être réduire les coûts en essayant d'utiliser des VM Spot.
Options de consommation et exigences associées

Réservations

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

  • Détails : Une fois la réservation créée, elle entraîne les coûts des VM spécifiées au même prix que si vous les exécutiez, jusqu'à ce que vous supprimiez la réservation. Les VM qui consomment une réservation n'entraînent pas de coûts distincts, mais les réservations entraînent des coûts 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 tâches qui peuvent consommer des VM réservées inutilisées. Pour en savoir plus sur les exigences liées aux jobs pour utiliser les réservations, consultez la page Assurer la disponibilité des ressources à l'aide de réservations de VM.

Réservations en mode Agenda (preview)

  • 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é quant à 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 traite 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 au tarif du programmateur de charge de travail dynamique, qui offre des remises allant jusqu'à 53 % sur le tarif à 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 remplissent toutes les conditions suivantes :

VM à démarrage flexible (preview)

  • Cas d'utilisation : nous vous recommandons d'utiliser des VM à démarrage flexible si votre job peut supporter une disponibilité au mieux en échange d'une tarification réduite et d'un délai d'exécution de sept jours maximum.

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

  • Détails : Si une demande de création d'un job qui utilise des VM à démarrage flexible est satisfaite, les VM sont facturées selon la tarification du programmeur de charge de travail dynamique, qui offre des remises allant jusqu'à 53 % sur la tarification à la demande.

    Pour en savoir plus sur les VM à démarrage flexible, consultez la documentation Compute Engine.

Batch utilise des VM à démarrage flexible pour les tâches qui remplissent toutes les conditions suivantes :

À la demande

  • Cas d'utilisation : nous recommandons par défaut le mode à la demande pour la plupart des autres tâches1.

  • Détails : l'accès à la demande est généralement la méthode par défaut pour accéder aux VM Compute Engine. L'accès à la demande vous permet d'accéder aux ressources (si elles sont disponibles) lorsque vous en faites la demande. Les ressources sont supprimées jusqu'à ce que le job se termine ou que la limite de temps d'exécution soit atteinte.

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

1Exception : 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 est indéfini ou défini sur STANDARD, l'option de consommation par défaut est unique : le comportement est semblable à celui des VM à démarrage flexible, qui limitent la durée d'exécution à sept jours. Toutefois, cette option n'est pas recommandée, 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 temps 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 demande, sauf si vous définissez provisioningModel sur STANDARD et que vous vérifiez manuellement que le job ne peut pas utiliser de réservations, sans définir le champ reservation sur NO_RESERVATION.

Les VM Spot

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

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

    Pour en savoir plus sur les VM Spot, consultez la documentation Compute Engine.

Batch utilise des VM Spot pour les jobs qui remplissent toutes les conditions suivantes :

  • Définissez le champ provisioningModel sur SPOT.
  • (Facultatif) Bloquez les 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 les pilotes de GPU, sélectionnez l'une des méthodes suivantes :

Étape 3 : Définir les 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 une tâche qui utilise des GPU :

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

    Pour savoir où les types de machines avec GPU sont disponibles, consultez la section Disponibilité des accélérateurs 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 des tâches 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 . Il est recommandé de le faire chaque fois que vous créez un job qui utilise des GPU pour les 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 la VM à l'aide d'un modèle en utilisant le champ instances[].instanceTemplate. Cette méthode est requise pour installer manuellement les pilotes de GPU via une image personnalisée. Pour en savoir plus, consultez Définir les ressources de job à l'aide d'un modèle d'instance de VM.

Créer un exemple de 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 Exemple d'instructions pour un job
Réservations ou réservations en mode Agenda (preview)

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

Utiliser des GPU et des VM à démarrage flexible
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 le planificateur de charges de travail dynamique à l'aide de 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 à démarrage flexible, 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 : lorsque la valeur est définie 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 les installe pour vous. Si vous définissez ce champ sur false (valeur 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 la section Disponibilité des options de consommation par type de machine dans la documentation Compute Engine.

    • ALLOWED_LOCATIONS : vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques d'une région dans laquelle les VM de votre job sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier des emplacements qui proposent le type de machine GPU que vous souhaitez pour ce job. Sinon, si vous omettez ce champ, assurez-vous que le type de machine GPU est disponible dans la région de la tâche.

  2. Pour créer et exécuter le job, utilisez la commande gcloud alpha 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 v1alpha 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/v1alpha/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 de votre projet.

  • LOCATION : emplacement du job.

  • JOB_NAME : nom du job.

  • INSTALL_GPU_DRIVERS : lorsque la valeur est définie 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 les installe pour vous. Si vous définissez ce champ sur false (valeur 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 la section Disponibilité des options de consommation par type de machine dans la documentation Compute Engine.

  • ALLOWED_LOCATIONS : vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques d'une région dans laquelle les VM de votre job sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier des emplacements qui proposent le type de machine GPU que vous souhaitez pour ce job. Sinon, si vous omettez ce champ, assurez-vous que le type de machine GPU est disponible dans la région de la tâche.

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 la consoleGoogle Cloud , de 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 tâches

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

  3. Configurez la page Informations sur le job :

    1. (Facultatif) Dans le champ Nom de la tâche, personnalisez le nom de la tâche.

      Par exemple, saisissez example-gpu-job.

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

      1. Dans la fenêtre Nouvel 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 résister à la préemption et que vous souhaitez bénéficier de 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-en une.

        • Sinon, sélectionnez Tous (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 les accélérateurs, le champ Type de machine ne propose qu'une seule option de 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 requise 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 Détails de la tâche affiche la tâche que vous avez créée.

gcloud

  1. Créez un fichier JSON qui installe les pilotes 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 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": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : lorsque la valeur est définie 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 les installe pour vous. Si vous définissez ce champ sur false (valeur 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 : vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques d'une région dans laquelle les VM de votre job sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier des emplacements qui proposent le type de machine GPU que vous souhaitez pour ce job. Sinon, si vous omettez ce champ, assurez-vous que le type de machine GPU est disponible dans la région de la tâche.

  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 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 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": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet.

  • LOCATION : emplacement du job.

  • JOB_NAME : nom du job.

  • INSTALL_GPU_DRIVERS : lorsque la valeur est définie 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 les installe pour vous. Si vous définissez ce champ sur false (valeur 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 : vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques d'une région dans laquelle les VM de votre job sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier des emplacements qui proposent le type de machine GPU que vous souhaitez pour ce job. Sinon, si vous omettez ce champ, assurez-vous que le type de machine GPU est disponible dans la région de la tâche.

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 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 tâches

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

  3. Configurez la page Informations sur le job :

    1. (Facultatif) Dans le champ Nom de la tâche, personnalisez le nom de la tâche.

      Par exemple, saisissez example-gpu-job.

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

      1. Dans la fenêtre Nouvel 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 résister à la préemption et que vous souhaitez bénéficier de 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-en une.

        • Sinon, sélectionnez Tous (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 requise 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 Détails de la tâche affiche la tâche que vous avez créée.

gcloud

  1. Créez un fichier JSON qui installe les pilotes 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 : lorsque la valeur est définie 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 les installe pour vous. Si vous définissez ce champ sur false (valeur 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 : vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques d'une région dans laquelle les VM de votre job sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier des emplacements qui proposent le type de machine GPU que vous souhaitez pour ce job. Sinon, si vous omettez ce champ, assurez-vous que le type de machine GPU est disponible dans la région de la tâche.

  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 qui possède le 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 de votre projet.

  • LOCATION : emplacement du job.

  • JOB_NAME : nom du job.

  • INSTALL_GPU_DRIVERS : lorsque la valeur est définie 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 les installe pour vous. Si vous définissez ce champ sur false (valeur 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 : vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques d'une région dans laquelle les VM de votre job sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier des emplacements qui proposent le type de machine GPU que vous souhaitez pour ce job. Sinon, si vous omettez ce champ, assurez-vous que le type de machine GPU est disponible dans la région de la tâche.

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