Créer et exécuter un job qui utilise des volumes de stockage

Ce document explique comment créer et exécuter un job par lot qui utilise un ou plusieurs volumes de stockage externe. Options de stockage externe : nouvelles ou existantes les disques persistants, les nouveaux SSD locaux, les buckets Cloud Storage existants, et d'un système de fichiers réseau (NFS, Network File System) existant tel qu'un Partage de fichiers Filestore.

Que vous ajoutiez ou non des volumes de stockage externe, chaque La VM Compute Engine dédiée à une tâche dispose d'un disque de démarrage qui fournit de l'espace de stockage pour obtenir l'image du système d'exploitation (OS) et les instructions associés au job. Pour en savoir plus sur la configuration du disque de démarrage pour une tâche, consultez la page Consultez plutôt la page Présentation de l'environnement d'OS de VM.

Avant de commencer

Créer un job qui utilise des volumes de stockage

Une tâche peut éventuellement utiliser un ou plusieurs des types suivants de de volumes de stockage externes. Pour en savoir plus, sur tous les types de volumes de stockage les différences et les restrictions qui s'appliquent à chacun d'eux, consultez la documentation Options de stockage des VM Compute Engine

Vous pouvez autoriser une tâche à utiliser chaque volume de stockage en les incluant dans la définition de votre job et spécifier Chemin d'accès au montage (mountPath) dans vos exécutables. Pour savoir comment créer un job utilisant des volumes de stockage, consultez une ou plusieurs des sections suivantes:

Utiliser un disque persistant

Un job qui utilise des disques persistants est soumis aux restrictions suivantes:

  • Tous les disques persistants: consultez les Restrictions pour tous les disques persistants.

  • Disques persistants nouveaux ou existants: chaque disque persistant d'une tâche peut être soit nouvelle (définie et créée avec le job), soit existante (déjà définie dans le job créées dans votre projet et spécifiées dans la tâche). Pour utiliser un disque persistant, cela doit être formaté et installé sur le qui doivent se trouver au même emplacement que le disque persistant. installe par lots tous les disques persistants que vous incluez dans un job ; formate tout nouveau disque persistant, mais vous devez formater et désinstaller tout les disques persistants existants qu'une tâche doit utiliser.

    les options de localisation acceptées ; options de format, et options d'installation entre les disques persistants nouveaux et existants, comme décrit dans tableau:

    Nouveaux disques persistants Disques persistants existants
    Options de mise en forme

    Le disque persistant est formaté automatiquement avec Système de fichiers ext4.

    Vous devez formater le disque persistant utiliser un Système de fichiers ext4 avant de les utiliser pour une tâche.

    Options d'installation

    Toutes les options sont acceptées.

    Toutes les options, sauf l'écriture, sont acceptées. Cela est dû à restrictions de mode multi-écriture.

    Vous devez dissocier le disque persistant des VM auxquelles il est associé avant de l'utiliser pour un job.
    Options d'emplacement

    Vous ne pouvez créer que des disques persistants zonaux.

    Vous pouvez sélectionner n'importe quel lieu pour votre mission. La couche persistante disques sont créés dans la zone dans laquelle votre projet s'exécute.

    Vous pouvez sélectionner des disques persistants zonaux et régionaux.


    Vous devez définir le lieu du projet (ou, si vous en avez spécifié, uniquement le emplacements autorisés) à uniquement les emplacements contenant l'ensemble des ressources disques. Par exemple, pour un disque persistant zonal, le rôle L'emplacement doit être la zone du disque. pour un disque persistant régional, l'emplacement du job doit correspondre à la région du disque ou, si en spécifiant des zones, l'une des zones spécifiques ou les deux disque persistant régional.

  • Modèles d'instances: si vous souhaitez utiliser un modèle d'instance de VM lors de la création de ce job, vous devez associer un ou plusieurs disques persistants pour ce job dans l'instance modèle. Sinon, si vous ne souhaitez pas utiliser de modèle d'instance, vous devez associer un ou plusieurs disques persistants directement dans la définition du job.

Vous pouvez créer une tâche qui utilise un disque persistant à l'aide du la console Google Cloud, gcloud CLI, l'API Batch, Go, Java, Node.js, Python ou C++.

Console

À l'aide de la console Google Cloud, l'exemple suivant crée un job qui exécute un script pour lire un fichier à partir d'un disque persistant zonal existant située dans la zone us-central1-a. L'exemple de script suppose que le job dispose d'un disque persistant zonal existant qui contient un fichier texte nommé example.txt dans le répertoire racine.

Facultatif: Créer un exemple de disque persistant zonal

Si vous souhaitez créer un disque persistant zonal que vous pouvez utiliser pour exécutez l'exemple de script, procédez comme suit avant de créer votre job:

  1. Associez un nouveau disque persistant vide nommé example-disk à une VM Linux dans le us-central1-a, puis exécuter les commandes de formatage et d'installation sur la VM sur le disque. Pour savoir comment procéder, consultez Ajoutez un disque persistant à votre VM.

    Ne vous déconnectez pas pour le moment de la VM.

  2. Pour créer example.txt sur le disque persistant, exécutez la commande suivante : sur la VM:

    1. Pour remplacer le répertoire de travail actuel par le répertoire racine du disque persistant, saisissez la commande suivante:

      cd VM_MOUNT_PATH

      Remplacez VM_MOUNT_PATH par le chemin d'accès vers Répertoire dans lequel le disque persistant a été installé sur cette VM à l'étape précédente, par exemple, /mnt/disks/example-disk.

    2. Appuyez sur la touche Enter.

    3. Pour créer et définir un fichier nommé example.txt, saisissez la commande suivante:

      cat > example.txt

    4. Appuyez sur la touche Enter.

    5. Saisissez le contenu du fichier. Par exemple, saisissez Hello world!.

    6. Pour enregistrer le fichier, appuyez sur Ctrl+D (ou Command+D sous macOS).

    Lorsque vous avez terminé, vous pouvez vous déconnecter de la VM.

  3. Dissociez le disque persistant de la VM.

    • Si vous n'avez plus besoin de la VM, vous pouvez supprimer la VM, ce qui dissocie automatiquement le disque persistant.

    • Sinon, dissociez le disque persistant. Pour savoir comment procéder, consultez Dissocier et réassocier des disques de démarrage et dissociez le disque persistant example-disk au lieu du disque de démarrage de la VM.

Créer un job qui utilise le disque persistant zonal existant

Pour créer une tâche utilisant des disques persistants zonaux existants à l'aide du console Google Cloud, procédez comme suit:

  1. Dans la console Google Cloud, accédez à la page Liste des tâches.

    Accéder à la liste des jobs

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

  3. Configurez la page Détails de la tâche:

    1. (Facultatif) Dans le champ Job name (Nom du job), personnalisez le nom du job.

      Par exemple, saisissez example-disk-job.

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

      1. Dans la fenêtre New runnable (Nouvel exécutable), ajoutez au moins un script ou conteneur pour l'exécution de ce job.

        Par exemple, pour exécuter un script qui imprime le contenu d'un fichier nommé example.txt et situé dans le répertoire racine du disque persistant utilisé par cette tâche, procédez comme suit:

        1. Cochez la case Script. Une zone de texte s'affiche.

        2. Dans la zone de texte, saisissez le script suivant:

          echo "Here is the content of the example.txt file in the persistent disk."
cat MOUNT_PATH/example.txt

          Remplacez MOUNT_PATH par le chemin d'accès vers où vous prévoyez d'installer le disque persistant sur les VM ce job (par exemple, /mnt/disks/example-disk).

        3. Cliquez sur OK.

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

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

      3. Dans le champ Parallélisme, saisissez le nombre de tâches à qui s'exécutent 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 de ressources. La page Spécifications des ressources s'ouvre.

    2. Sélectionnez le lieu de cette tâche. Pour utiliser un disque persistant zonal existant, les VM d'un job doivent se trouver dans la même zone.

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

        Ainsi, pour utiliser l'exemple de disque persistant zonal, sélectionnez us-central1 (Iowa) (par défaut).

      2. Dans le champ Zone, sélectionnez une zone.

        Par exemple, sélectionnez us-central1-a (Iowa).

  5. Configurez la page Configurations supplémentaires:

    1. Dans le volet de gauche, cliquez sur Configurations supplémentaires. La page Configurations supplémentaires s'ouvre.

    2. Pour chaque disque persistant zonal existant que vous souhaitez installer sur cette tâche, procédez comme suit:

      1. Dans la section Volume de stockage, cliquez sur Ajouter un volume. La fenêtre Nouveau volume s'affiche.

      2. Dans la fenêtre Nouveau volume, procédez comme suit:

        1. Dans la section Type de volume, sélectionnez Persistent Disk (par défaut)

        2. Dans la liste Disque, sélectionnez un disque persistant zonal existant que vous souhaitez installer ce travail. Le disque doit se trouver dans le même dans cette zone.

          Par exemple, sélectionnez le disque persistant zonal existant que vous avez préparées, qui se trouve us-central1-a et contient le fichier example.txt.

        3. Facultatif: Si vous souhaitez renommer ce disque persistant zonal, effectuer les opérations suivantes:

          1. Sélectionnez Personnaliser le nom de l'appareil.

          2. Dans le champ Nom de l'appareil, saisissez le nouveau nom de votre disque.

        4. Dans le champ Mount path (Chemin d'accès au montage), saisissez le chemin d'accès au montage. (MOUNT_PATH) pour cet persistant standard:

          Par exemple, saisissez ce qui suit:

          /mnt/disks/EXISTING_PERSISTENT_DISK_NAME

          Remplacer EXISTING_PERSISTENT_DISK_NAME par le nom du disque. Si vous avez renommé le persistant zonal, utilisez le nouveau nom.

          Par exemple, remplacez EXISTING_PERSISTENT_DISK_NAME avec example-disk

        5. Cliquez sur OK.

  6. Facultatif: configurez le autres champs pour cette tâche.

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

  8. Cliquez sur Créer.

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

gcloud

Avec la gcloud CLI, l'exemple suivant crée une tâche qui associe et installe un disque persistant existant et un nouveau disque persistant. Le job comporte trois tâches qui exécutent chacune un script pour créer un fichier dans la nouvelle disque persistant nommé output_task_TASK_INDEX.txt où TASK_INDEX est l'index de chaque tâche: 0, 1 et 2.

Pour créer une tâche qui utilise des disques persistants à l'aide du gcloud CLI, utilisez la Commande gcloud batch jobs submit Dans le fichier de configuration JSON du job, spécifiez les disques persistants dans le fichier instances et installez le disque persistant dans le champ volumes.

  1. Créez un fichier JSON.

    • Si vous n'utilisez pas de modèle d'instance pour ce job, créez un fichier JSON avec le contenu suivant:

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      Remplacez les éléments suivants :

      • PROJECT_ID: le ID du projet de votre projet.
      • EXISTING_PERSISTENT_DISK_NAME: nom d'un disque persistant existant.
      • EXISTING_PERSISTENT_DISK_LOCATION: le d'un disque persistant existant. Pour chaque zone existante disque persistant, l'emplacement du job doit être la zone du disque ; pour sur chaque disque persistant régional existant, l'emplacement du job soit la région du disque, soit, si vous spécifiez des zones, un ou aux deux zones spécifiques où le disque persistant régional se trouve. Si vous ne spécifiez aucune instance persistante disques persistants, vous pouvez sélectionner n'importe quel emplacement. En savoir plus sur les Champ allowedLocations.
      • NEW_PERSISTENT_DISK_SIZE: taille du un nouveau disque persistant en Go. La tailles autorisées dépendent du type de disque persistant, mais le minimum est souvent 10 Go (10) et le maximum est souvent de 64 To (64000).
      • NEW_PERSISTENT_DISK_TYPE: le type de disque du nouveau disque persistant, pd-standard, pd-balanced, pd-ssd ou pd-extreme. Type de disque par défaut pour les disques non amorçables disques persistants est pd-standard.
      • NEW_PERSISTENT_DISK_NAME: nom du nouveau disque persistant.

    • Si vous utilisez à l'aide d'un modèle d'instance de VM pour ce job, créez un fichier JSON comme indiqué précédemment, mais remplacez Champ instances par les éléments suivants:

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      où INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour ce job. Pour un emploi qui utilise disques persistants, ce modèle d'instance doit définir et rattacher que le job doit utiliser. Pour cet exemple, le modèle doit définir et associer un nouveau disque persistant nommé NEW_PERSISTENT_DISK_NAME et et associer un disque persistant existant EXISTING_PERSISTENT_DISK_NAME

  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.

    • LOCATION: emplacement du travail.

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

API

Avec l'API Batch, l'exemple suivant crée un job qui associe et installe un disque persistant existant et un nouveau disque disque. Le job comporte trois tâches qui exécutent chacune un script pour créer un fichier dans la nouvelle un disque persistant nommé output_task_TASK_INDEX.txt où TASK_INDEX correspond à l'index de chaque tâche: 0, 1 et 2.

Pour créer une tâche qui utilise des disques persistants à l'aide du l'API Batch, utilisez la Méthode jobs.create. Dans la requête, spécifiez les disques persistants instances et installez le disque persistant dans le champ volumes.

  • Si vous n'utilisez pas de modèle d'instance pour ce job, effectuez les opérations suivantes : requête:

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

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • PROJECT_ID: le ID du projet de votre projet.
    • LOCATION: emplacement du travail.
    • JOB_NAME: nom de la tâche.
    • EXISTING_PERSISTENT_DISK_NAME: nom d'un disque persistant existant.
    • EXISTING_PERSISTENT_DISK_LOCATION: le d'un disque persistant existant. Pour chaque zone existante disque persistant, l'emplacement du job doit être la zone du disque ; pour sur chaque disque persistant régional existant, l'emplacement du job soit la région du disque, soit, si vous spécifiez des zones, un ou aux deux zones spécifiques où le disque persistant régional se trouve. Si vous ne spécifiez aucune instance persistante disques persistants, vous pouvez sélectionner n'importe quel emplacement. En savoir plus sur les Champ allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: taille du un nouveau disque persistant en Go. La tailles autorisées dépendent du type de disque persistant, mais le minimum est souvent 10 Go (10) et le maximum est souvent de 64 To (64000).
    • NEW_PERSISTENT_DISK_TYPE: le type de disque du nouveau disque persistant, pd-standard, pd-balanced, pd-ssd ou pd-extreme. Type de disque par défaut pour les disques non amorçables disques persistants est pd-standard.
    • NEW_PERSISTENT_DISK_NAME: nom du nouveau disque persistant.

  • Si vous utilisez à l'aide d'un modèle d'instance de VM pour ce job, créez un fichier JSON comme indiqué précédemment, mais remplacez Champ instances par les éléments suivants:

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    Où INSTANCE_TEMPLATE_NAME est le nom. du modèle d'instance pour ce job. Pour un emploi qui utilise disques persistants, ce modèle d'instance doit définir et rattacher que le job doit utiliser. Pour cet exemple, le modèle doit définir et associer un nouveau disque persistant nommé NEW_PERSISTENT_DISK_NAME et et associer un disque persistant existant EXISTING_PERSISTENT_DISK_NAME

Go

Pour créer un job par lot qui utilise des jobs nouveaux ou existants : des disques persistants standards les bibliothèques clientes Cloud pour Go, utilisez la Fonction CreateJob et inclure les éléments suivants:

Pour voir un exemple de code d'un cas d'utilisation similaire, consultez Utilisez un bucket Cloud Storage.

Java

Pour créer un job par lot qui utilise des jobs nouveaux ou existants : des disques persistants standards les bibliothèques clientes Cloud pour Java, utilisez la Cours CreateJobRequest et inclure les éléments suivants:

Pour voir un exemple de code d'un cas d'utilisation similaire, consultez Utilisez un bucket Cloud Storage.

Node.js

Pour créer un job par lot qui utilise des jobs nouveaux ou existants : des disques persistants standards les bibliothèques clientes Cloud pour Node.js, utilisez le Méthode createJob et inclure les éléments suivants:

  • Pour associer des disques persistants aux VM pour un job, incluez l'un des éléments suivants: <ph type="x-smartling-placeholder">
  • Pour installer les disques persistants dans la tâche, utilisez la Classe Volume avec la propriété deviceName et la propriété mountPath. Pour les nouveaux disques persistants, utilisez également la classe Propriété mountOptions pour permettre l'écriture.

Pour voir un exemple de code d'un cas d'utilisation similaire, consultez Utilisez un bucket Cloud Storage.

Python

Pour créer un job par lot qui utilise des jobs nouveaux ou existants : des disques persistants standards les bibliothèques clientes Cloud pour Python, utilisez Fonction CreateJob et inclure les éléments suivants:

  • Pour associer des disques persistants aux VM pour un job, incluez l'un des éléments suivants: <ph type="x-smartling-placeholder">
  • Pour installer les disques persistants dans la tâche, utilisez la Classe Volume avec l'attribut device_name et mount_path. Pour les nouveaux disques persistants, utilisez également la classe mount_options pour permettre l'écriture.

Pour voir un exemple de code d'un cas d'utilisation similaire, consultez Utilisez un bucket Cloud Storage.

C++

Pour créer un job par lot qui utilise des jobs nouveaux ou existants : des disques persistants standards bibliothèques clientes Cloud pour C++, utilisez Fonction CreateJob et inclure les éléments suivants:

  • Pour associer des disques persistants aux VM pour un job, incluez l'un des éléments suivants: <ph type="x-smartling-placeholder">
      </ph>
    • Si vous n'utilisez pas de modèle d'instance de VM pour ce job, utilisez la méthode set_remote_path.
    • Si vous utilisez un modèle d'instance de VM pour ce job, utilisez le set_instance_template.
  • Pour installer les disques persistants dans la tâche, utilisez le champ volumes avec les champs deviceName et mountPath. Pour les nouveaux disques persistants, utilisez le champ mountOptions pour activer l'écriture.

Pour voir un exemple de code d'un cas d'utilisation similaire, consultez Utilisez un bucket Cloud Storage.

Utiliser un disque SSD local

Une tâche qui utilise des disques SSD locaux présente les restrictions suivantes:

Vous pouvez créer une tâche qui utilise un disque SSD local à l'aide de la classe gcloud CLI ou l'API Batch. L'exemple suivant explique comment créer une tâche qui crée, associe et installe un SSD local. Le poste comporte également trois tâches que chacun exécute un script pour créer un fichier dans le SSD local nommé output_task_TASK_INDEX.txt où TASK_INDEX est l'index de chaque tâche: 0, 1 et 2.

gcloud

Pour créer une tâche qui utilise des disques SSD locaux à l'aide de la classe gcloud CLI, utilisez la Commande gcloud batch jobs submit Dans le fichier de configuration JSON du job, créez et associez les disques SSD locaux dans le fichier instances et installez les disques SSD locaux dans le champ volumes.

  1. Créez un fichier JSON.

    • Si vous n'utilisez pas de modèle d'instance pour ce job, créez un fichier JSON avec le contenu suivant:

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      Remplacez les éléments suivants :

      • MACHINE_TYPE: le type de machine, qui peut être prédéfini ou custom des VM de la tâche. La nombre autorisé de SSD locaux dépend du type de machine pour les VM de votre job.
      • LOCAL_SSD_NAME: nom d'un disque SSD local créé pour ce job.
      • LOCAL_SSD_SIZE: taille de tous les SSD locaux en Go. Chaque disque SSD local a une capacité de 375 Go. cette valeur doit être un multiple de 375 Go. Pour Par exemple, pour deux disques SSD locaux, définissez cette valeur sur 750 Go.

    • Si vous utilisez à l'aide d'un modèle d'instance de VM pour ce job, créez un fichier JSON comme indiqué précédemment, mais remplacez Champ instances par les éléments suivants:

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      où INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour ce job. Pour un emploi qui utilise des disques SSD locaux, ce modèle d'instance doit définir et associer sur les SSD locaux que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un disque SSD local nommé LOCAL_SSD_NAME

  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION: emplacement du travail.
    • JSON_CONFIGURATION_FILE: chemin d'accès d'un fichier JSON contenant les détails de configuration du job.

API

Pour créer une tâche qui utilise des disques SSD locaux à l'aide de la classe l'API Batch, utilisez la Méthode jobs.create. Dans la requête, créez et associez les disques SSD locaux dans le instances et installez les disques SSD locaux dans le champ volumes.

  • Si vous n'utilisez pas de modèle d'instance pour ce job, effectuez les opérations suivantes : requête:

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

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • PROJECT_ID: le ID du projet de votre projet.
    • LOCATION: emplacement du travail.
    • JOB_NAME: nom de la tâche.
    • MACHINE_TYPE: le type de machine, qui peut être prédéfini ou custom des VM de la tâche. La nombre autorisé de SSD locaux dépend du type de machine pour les VM de votre job.
    • LOCAL_SSD_NAME: nom d'un disque SSD local créé pour ce job.
    • LOCAL_SSD_SIZE: taille de tous les SSD locaux en Go. Chaque disque SSD local a une capacité de 375 Go. cette valeur doit être un multiple de 375 Go. Pour Par exemple, pour deux disques SSD locaux, définissez cette valeur sur 750 Go.

  • Si vous utilisez à l'aide d'un modèle d'instance de VM pour ce job, créez un fichier JSON comme indiqué précédemment, mais remplacez Champ instances par les éléments suivants:

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    Où INSTANCE_TEMPLATE_NAME est le nom. du modèle d'instance pour ce job. Pour un emploi qui utilise des disques SSD locaux, ce modèle d'instance doit définir et associer sur les SSD locaux que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un disque SSD local nommé LOCAL_SSD_NAME

Utiliser un bucket Cloud Storage

Pour créer un job utilisant un bucket Cloud Storage existant, sélectionnez l'une des méthodes suivantes:

  • Recommandation: Installez un bucket directement sur les VM de votre job en spécifiant le bucket de la définition du job, comme indiqué dans cette section. Lorsque le job s'exécute, le bucket est automatiquement installé sur les VM pour votre job en utilisant Cloud Storage FUSE :
  • Créer une tâche avec des tâches qui accèdent directement à bucket Cloud Storage à l'aide de l'outil de ligne de commande gsutil ou des bibliothèques clientes pour l'API Cloud Storage. Pour savoir comment accéder à un bucket Cloud Storage directement depuis une VM, consultez la dans la documentation Compute Engine Écrire et lire des données dans des buckets Cloud Storage

Avant de créer un job utilisant un bucket, créez un bucket ou identifiez un bucket existant. Pour en savoir plus, consultez créer des buckets ; Répertoriez les buckets.

Vous pouvez créer une tâche qui utilise un bucket Cloud Storage à l'aide de la classe la console Google Cloud, gcloud CLI, l'API Batch, Go, Java, Node.js, Python ou C++.

L'exemple suivant explique comment créer une tâche qui installe un bucket Cloud Storage. Le job comporte également trois tâches exécutées chacune un script pour créer un fichier dans le bucket output_task_TASK_INDEX.txt où TASK_INDEX est l'index de chaque tâche: 0, 1 et 2.

Console

Pour créer une tâche qui utilise un bucket Cloud Storage à l'aide de la classe console Google Cloud, procédez comme suit:

  1. Dans la console Google Cloud, accédez à la page Liste des tâches.

    Accéder à la liste des jobs

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

  3. Configurez la page Détails de la tâche:

    1. (Facultatif) Dans le champ Job name (Nom du job), personnalisez le nom du job.

      Par exemple, saisissez example-bucket-job.

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

      1. Dans la fenêtre New runnable (Nouvel exécutable), ajoutez au moins un script ou conteneur pour l'exécution de ce job.

        Par exemple:

        1. Cochez la case Script. Une zone de texte s'affiche.

        2. Dans la zone de texte, saisissez le script suivant:

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

          Remplacez MOUNT_PATH par le d'installation que les exécutables de ce job utilisent pour accéder à un bucket Cloud Storage existant. Le chemin d'accès doit commencer par /mnt/disks/, suivi d'un répertoire ou d'un chemin d'accès de votre choix. Par exemple, si vous souhaitez représenter dans un répertoire nommé my-bucket, définissez chemin d'installation vers /mnt/disks/my-bucket.

        3. Cliquez sur OK.

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

        Par exemple, saisissez 3.

      3. Dans le champ Parallélisme, saisissez le nombre de tâches à qui s'exécutent simultanément.

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

  4. Configurez la page Configurations supplémentaires:

    1. Dans le volet de gauche, cliquez sur Configurations supplémentaires. La page Configurations supplémentaires s'ouvre.

    2. Pour chaque bucket Cloud Storage que vous souhaitez installer cette tâche, procédez comme suit:

      1. Dans la section Volume de stockage, cliquez sur Ajouter un volume. La fenêtre Nouveau volume s'affiche.

      2. Dans la fenêtre Nouveau volume, procédez comme suit:

        1. Dans la section Type de volume, sélectionnez Bucket Cloud Storage.

        2. Dans le champ Nom du bucket de stockage, saisissez le nom dans un bucket existant.

          Par exemple, saisissez le bucket que vous avez spécifié dans ce est exécutable.

        3. Dans le champ Mount path (Chemin d'accès au montage), saisissez le chemin d'accès au montage (MOUNT_PATH), que vous spécifié dans l'exécutable.

        4. Cliquez sur OK.

  5. Facultatif: configurez le autres champs pour cette tâche.

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

  7. Cliquez sur Créer.

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

gcloud

Pour créer une tâche qui utilise un bucket Cloud Storage à l'aide de la classe gcloud CLI, utilisez la Commande gcloud batch jobs submit Dans le fichier de configuration JSON du job, installez le bucket volumes.

Par exemple, pour créer une tâche qui génère des fichiers dans un bucket Cloud Storage:

  1. Créez un fichier json contenant les éléments suivants :

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • BUCKET_PATH: chemin d'accès au répertoire du bucket auquel cette tâche doit accéder, qui doit commencer par le nom dans le bucket. Par exemple, pour un bucket nommé BUCKET_NAME, le chemin d'accès BUCKET_NAME représente le répertoire racine. du bucket et le chemin d'accès BUCKET_NAME/subdirectory représente le sous-répertoire subdirectory.
    • MOUNT_PATH: chemin d'accès à l'installation que les exécutables utilisent pour accéder à ce bucket. Le chemin d'accès doit commencer par /mnt/disks/ suivi d'un répertoire ou d'un chemin d'accès de votre choix. Pour par exemple, si vous souhaitez représenter ce bucket avec un répertoire nommé my-bucket : définissez le chemin d'installation sur /mnt/disks/my-bucket.

  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION: emplacement du travail.
    • JSON_CONFIGURATION_FILE: chemin d'accès d'un fichier JSON contenant les détails de configuration du job.

API

Pour créer une tâche qui utilise un bucket Cloud Storage à l'aide de la classe l'API Batch, utilisez la Méthode jobs.create et monter le bucket dans le champ volumes.

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}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: le ID du projet de votre projet.
  • LOCATION: emplacement du travail.
  • JOB_NAME: nom de la tâche.
  • BUCKET_PATH: chemin d'accès au répertoire du bucket auquel cette tâche doit accéder, qui doit commencer par le nom du bucket. Par exemple, pour un bucket nommé BUCKET_NAME, le chemin d'accès BUCKET_NAME représente la racine le répertoire du bucket et le chemin d'accès BUCKET_NAME/subdirectory représente le sous-répertoire subdirectory.
  • MOUNT_PATH: chemin d'accès à l'installation que les exécutables utilisent pour accéder à ce bucket. Le chemin d'accès doit commencer par /mnt/disks/ suivi d'un répertoire ou d'un chemin d'accès de votre choix. Par exemple, si vous souhaitez représenter ce bucket avec répertoire nommé my-bucket, définissez le chemin d'installation sur /mnt/disks/my-bucket

Go

Go

Pour en savoir plus, consultez les API Go par lot documentation de référence.

Pour vous authentifier auprès de Batch, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	batchpb "google.golang.org/genproto/googleapis/cloud/batch/v1"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJobWithBucket(w io.Writer, projectID, region, jobName, bucketName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"
	// jobName := "some-bucket"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

	// Specify the Google Cloud Storage bucket to mount
	volume := &batchpb.Volume{
		Source: &batchpb.Volume_Gcs{
			Gcs: &batchpb.GCS{
				RemotePath: bucketName,
			},
		},
		MountPath:    "/mnt/share",
		MountOptions: []string{},
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Volumes:       []*batchpb.Volume{volume},
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

Pour en savoir plus, consultez les API Java par lot documentation de référence.

Pour vous authentifier auprès de Batch, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import com.google.cloud.batch.v1.AllocationPolicy;
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.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.GCS;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
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.cloud.batch.v1.Volume;
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 CreateWithMountedBucket {

  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 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";

    // Name of the bucket to be mounted for your Job.
    String bucketName = "BUCKET_NAME";

    createScriptJobWithBucket(projectId, region, jobName, bucketName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJobWithBucket(String projectId, String region, String jobName,
      String bucketName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    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 from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // 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();

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
              .setCpuMilli(500)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .addVolumes(volume)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).build();

      // 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 "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              .putLabels("mount", "bucket")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .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());
    }
  }
}

Node.js

Node.js

Pour en savoir plus, consultez les API Node.js par lot documentation de référence.

Pour vous authentifier auprès de Batch, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';
/**
 * The name of the bucket to be mounted.
 */
// const bucketName = 'YOUR_BUCKET_NAME';

// 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();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.Runnable.Script();
runnable.script.text =
  'echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt';
// 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];

const gcsBucket = new batch.GCS();
gcsBucket.remotePath = bucketName;
const gcsVolume = new batch.Volume();
gcsVolume.gcs = gcsBucket;
gcsVolume.mountPath = '/mnt/share';
task.volumes = [gcsVolume];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.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 "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

callCreateJob();

Python

Python

Pour en savoir plus, consultez les API Python par lot documentation de référence.

Pour vous authentifier auprès de Batch, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

from google.cloud import batch_v1


def create_script_job_with_bucket(
    project_id: str, region: str, job_name: str, bucket_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.

    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.
        bucket_name: name of the bucket to be mounted for your Job.

    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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

    gcs_bucket = batch_v1.GCS()
    gcs_bucket.remote_path = bucket_name
    gcs_volume = batch_v1.Volume()
    gcs_volume.gcs = gcs_bucket
    gcs_volume.mount_path = "/mnt/share"
    task.volumes = [gcs_volume]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
    resources.memory_mib = 16
    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 "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script", "mount": "bucket"}
    # 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)

C++

C++

Pour en savoir plus, consultez les API C++ par lot documentation de référence.

Pour vous authentifier auprès de Batch, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id, std::string const& bucket_name) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it, and then override the GCS remote path.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
            }
          }
          volumes { mount_path: "/mnt/share" }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    job->mutable_task_groups(0)
        ->mutable_task_spec()
        ->mutable_volumes(0)
        ->mutable_gcs()
        ->set_remote_path(bucket_name);
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Utiliser un système de fichiers en réseau

Vous pouvez créer une tâche qui utilise un système de fichiers réseau (NFS, Network File System) existant tel qu'un Partage de fichiers Filestore à l'aide de la console Google Cloud, de gcloud CLI ou API Batch.

Avant de créer un job qui utilise un NFS, assurez-vous que votre le pare-feu du réseau est correctement configuré pour autoriser le trafic les VM de votre job et le NFS. Pour en savoir plus, consultez Configurez des règles de pare-feu pour Filestore.

L'exemple suivant explique comment créer une tâche qui spécifie et monte un NFS. Le poste comporte également trois tâches qui exécutent chacune un script pour créer un fichier dans le NFS nommé output_task_TASK_INDEX.txt où TASK_INDEX est l'index de chaque tâche: 0, 1 et 2.

Console

Pour créer une tâche qui utilise un NFS à l'aide de la console Google Cloud, effectuer les opérations suivantes:

  1. Dans la console Google Cloud, accédez à la page Liste des tâches.

    Accéder à la liste des jobs

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

  3. Configurez la page Détails de la tâche:

    1. (Facultatif) Dans le champ Job name (Nom du job), personnalisez le nom du job.

      Par exemple, saisissez example-nfs-job.

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

      1. Dans la fenêtre New runnable (Nouvel exécutable), ajoutez au moins un script ou conteneur pour l'exécution de ce job.

        Par exemple:

        1. Cochez la case Script. Une zone de texte s'affiche.

        2. Dans la zone de texte, saisissez le script suivant:

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

          Remplacez MOUNT_PATH par le d'installation que l'exécutable du job utilise pour accéder à ce NFS. Le chemin d'accès doit commencer par /mnt/disks/, suivi d'une ou chemin d'accès de votre choix. Par exemple, si vous représenter ce NFS avec un répertoire nommé my-nfs : définissez le chemin d'installation sur /mnt/disks/my-nfs.

        3. Cliquez sur OK.

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

        Par exemple, saisissez 3.

      3. Dans le champ Parallélisme, saisissez le nombre de tâches à qui s'exécutent simultanément.

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

  4. Configurez la page Configurations supplémentaires:

    1. Dans le volet de gauche, cliquez sur Configurations supplémentaires. La page Configurations supplémentaires s'ouvre.

    2. Pour chaque bucket Cloud Storage que vous souhaitez installer cette tâche, procédez comme suit:

      1. Dans la section Volume de stockage, cliquez sur Ajouter un volume. La fenêtre Nouveau volume s'affiche.

      2. Dans la fenêtre Nouveau volume, procédez comme suit:

        1. Dans la section Type de volume : Sélectionnez Network file system (Système de fichiers en réseau).

        2. Dans le champ Serveur de fichiers, saisissez l'adresse IP du serveur sur lequel le NFS que vous avez spécifié dans le fichier exécutable de ce job se trouve.

          Par exemple, si votre NFS est un le partage de fichiers Filestore, puis l'adresse IP de Filestore que vous pouvez obtenir décrire l'instance Filestore.

        3. Dans le champ Chemin d'accès distant, saisissez un chemin d'accès le NFS que vous avez spécifié à l'étape précédente.

          Le chemin du répertoire NFS doit commencer par / suivi du répertoire racine du NFS.

        4. Dans le champ Mount path (Chemin d'accès au montage), saisissez le chemin d'accès au (MOUNT_PATH), que vous avez spécifiée dans à l'étape précédente.

    3. Cliquez sur OK.

  5. Facultatif: configurez le autres champs pour cette tâche.

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

  7. Cliquez sur Créer.

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

gcloud

Pour créer une tâche qui utilise un NFS à l'aide de la classe gcloud CLI, utilisez la Commande gcloud batch jobs submit Dans le fichier de configuration JSON du job, installez le NFS au format volumes.

  1. Créez un fichier json contenant les éléments suivants :

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • NFS_IP_ADDRESS: le Adresse IP du NFS. Par exemple, si votre NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de Filestore que vous pouvez obtenir décrire l'instance Filestore.
    • NFS_PATH: chemin d'accès au répertoire NFS auquel vous souhaitez que cette tâche puisse accéder, qui doit commencer par un / suivi du répertoire racine du NFS. Par exemple, pour un Partage de fichiers Filestore nommé FILE_SHARE_NAME, le chemin d'accès /FILE_SHARE_NAME représente la racine du partage de fichiers et le chemin d'accès /FILE_SHARE_NAME/subdirectory représente le sous-répertoire subdirectory.
    • MOUNT_PATH: chemin d'accès à l'installation exécutables utilisent pour accéder à ce NFS. Le chemin d'accès doit commencer par /mnt/disks/ suivi d'un répertoire ou d'un chemin d'accès de votre choix. Par exemple, si vous souhaitez représenter ce NFS avec un répertoire nommé my-nfs, définissez le chemin d'installation sur /mnt/disks/my-nfs.

  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION: emplacement du travail.
    • JSON_CONFIGURATION_FILE: chemin d'accès d'un fichier JSON contenant les détails de configuration du job.

API

Pour créer une tâche qui utilise un NFS à l'aide de la classe l'API Batch, utilisez la Méthode jobs.create et monter le NFS dans le champ volumes.

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}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: le ID du projet de votre projet.
  • LOCATION: emplacement du travail.
  • JOB_NAME: nom de la tâche.
  • NFS_IP_ADDRESS: le Adresse IP du système de fichiers réseau. Par exemple, si votre NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de Filestore que vous pouvez obtenir décrire l'instance Filestore.
  • NFS_PATH: chemin d'accès au répertoire NFS auquel vous souhaitez que cette tâche puisse accéder, qui doit commencer par un / suivi du répertoire racine du NFS. Par exemple, pour un Partage de fichiers Filestore nommé FILE_SHARE_NAME, le chemin d'accès /FILE_SHARE_NAME représente la racine du partage de fichiers et le chemin d'accès /FILE_SHARE_NAME/subdirectory représente un sous-répertoire.
  • MOUNT_PATH: chemin d'accès à l'installation exécutables utilisent pour accéder à ce NFS. Le chemin d'accès doit commencer par /mnt/disks/ suivi d'un répertoire ou d'un chemin d'accès de votre choix. Par exemple, si vous souhaitez représenter ce NFS avec un répertoire nommé my-nfs, définissez le chemin d'installation sur /mnt/disks/my-nfs.

Étape suivante