Créer et exécuter une tâche qui utilise des volumes de stockage

Ce document explique comment créer et exécuter une tâche par lot utilisant un ou plusieurs volumes de stockage externes. Les options de stockage incluent les disques persistants nouveaux ou existants, les nouveaux SSD locaux, les buckets Cloud Storage existants et un système de fichiers en réseau (NFS) existant, tel qu'un partage de fichiers Filestore.

Avant de commencer

Créer une tâche qui utilise des volumes de stockage

Par défaut, chaque VM Compute Engine d'une tâche possède un seul disque persistant de démarrage contenant le système d'exploitation. Vous pouvez également créer une tâche qui utilise des volumes de stockage supplémentaires. Plus précisément, les VM d'une tâche peuvent utiliser un ou plusieurs des types de volumes de stockage suivants. Pour en savoir plus sur tous les types de volumes de stockage, ainsi que sur les différences et les restrictions applicables à chacun, consultez la documentation sur les options de stockage de VM Compute Engine.

Vous pouvez autoriser une tâche à utiliser chaque volume de stockage en l'incluant dans la définition de votre tâche et en spécifiant son chemin d'installation (mountPath) dans vos exécutables. Pour savoir comment créer une tâche qui utilise des volumes de stockage, consultez une ou plusieurs des sections suivantes:

Utiliser un disque persistant

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

  • Tous les disques persistants: consultez les restrictions concernant tous les disques persistants.

  • Disques persistants nouveaux ou existants: chaque disque persistant d'une tâche peut être nouveau (défini et créé avec la tâche) ou existant (déjà créé dans votre projet et spécifié dans la tâche). Pour utiliser un disque persistant, il doit être formaté et installé sur les VM du job, qui doivent se trouver au même emplacement que le disque persistant. Batch installe tous les disques persistants que vous incluez dans une tâche, puis formate les nouveaux disques persistants. Toutefois, vous devez formater et désinstaller tous les disques persistants existants que vous souhaitez utiliser pour une tâche.

    Les options d'emplacement, les options de format et les options d'installation compatibles varient entre les disques persistants nouveaux et existants, comme décrit dans le tableau suivant:

    Nouveaux disques persistants Disques persistants existants
    Options de mise en forme

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

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

    Options de montage

    Toutes les options sont acceptées.

    Toutes les options, sauf l'écriture, sont acceptées. Cela est dû aux restrictions du mode rédacteur.

    Vous devez détacher le disque persistant de toutes les VM auxquelles il est associé avant de l'utiliser pour une tâche.
    Options d'emplacement

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

    Vous pouvez sélectionner n'importe quel lieu pour votre tâche. Les disques persistants sont créés dans la zone d'exécution de votre projet.

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


    Vous devez définir l'emplacement de la tâche (ou, si spécifié, ses emplacements autorisés) sur uniquement les emplacements contenant tous les disques persistants de la tâche. Par exemple, pour un disque persistant zonal, l'emplacement du job doit être la zone du disque. Pour un disque persistant régional, l'emplacement du job doit être soit la région du disque, soit, si vous spécifiez des zones, l'une des zones spécifiques ou l'une des zones où se trouve le 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 cette tâche, vous devez associer tous les disques persistants de cette tâche dans le modèle d'instance. Sinon, si vous ne souhaitez pas utiliser de modèle d'instance, vous devez associer tous les disques persistants directement dans la définition de la tâche.

Vous pouvez créer une tâche qui utilise un disque persistant à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Batch.

Console

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

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

  1. Associez un nouveau disque persistant vide nommé example-disk à une VM Linux dans la zone us-central1-a, puis exécutez des commandes sur la VM pour formater et installer le disque. Pour obtenir des instructions, consultez la page Ajouter un disque persistant à votre VM.

    Ne vous déconnectez pas encore de la VM.

  2. Pour créer example.txt sur le disque persistant, exécutez les commandes suivantes 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 au 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. Dissocier le disque persistant de la VM

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

    • Sinon, dissociez le disque persistant. Pour obtenir des instructions, consultez la page Dissocier et réassocier des disques de démarrage, et dissocier le disque persistant example-disk au lieu du disque de démarrage de la VM.

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

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

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre.

  3. Dans le champ Job name (Nom de la tâche), saisissez un nom pour la tâche.

    Par exemple, saisissez example-disk-job.

  4. Dans le champ Région, sélectionnez l'emplacement pour cette tâche.

    Par exemple, sélectionnez us-central1 (Iowa) (par défaut).

  5. Dans le champ Zone, sélectionnez la zone contenant les disques persistants zonaux existants que vous souhaitez utiliser pour cette tâche.

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

  6. Dans le volet Nouvel exécutable, ajoutez au moins un script ou un conteneur à exécuter pour cette tâche.

    Par exemple, pour exécuter un script qui affiche 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 où vous prévoyez d'installer le disque persistant sur les VM de cette tâche (par exemple, /mnt/disks/example-disk).

    3. Cliquez sur OK.

  7. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour cette tâche.

    Par exemple, saisissez 1.

  8. Dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément.

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

  9. Pour chaque disque persistant zonal existant que vous souhaitez installer sur ce job, procédez comme suit:

    1. Cliquez sur Ajouter un volume. Le volet Nouveau volume s'affiche.

    2. Dans le volet Nouveau volume, procédez comme suit:

    3. Dans la section Type de volume, sélectionnez Disque persistant.

    4. Dans le menu Disque, sélectionnez un disque persistant zonal existant que vous souhaitez installer sur cette tâche. Le disque doit se trouver dans la même zone que cette tâche.

      Par exemple, sélectionnez le disque persistant zonal existant que vous avez préparé, situé dans la zone us-central1-a et contenant le fichier example.txt.

    5. Facultatif: Si vous souhaitez renommer ce disque persistant zonal, procédez comme suit:

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

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

    6. Dans le champ Chemin d'installation, saisissez le chemin d'installation (MOUNT_PATH) de ce disque persistant:

      Par exemple:

      /mnt/disks/EXISTING_PERSISTENT_DISK_NAME

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

      Par exemple, remplacez EXISTING_PERSISTENT_DISK_NAME par example-disk.

    7. Cliquez sur OK.

  10. (Facultatif) Configurez les autres champs de cette tâche.

    Par exemple, utilisez les valeurs par défaut pour tous les autres champs.

  11. Cliquez sur Créer.

    La page Liste de tâches affiche la tâche que vous avez créée.

gcloud

À l'aide de gcloud CLI, l'exemple suivant crée une tâche qui associe et installe un disque persistant existant et un nouveau disque persistant. La tâche comporte trois tâches qui exécutent chacune un script pour créer un fichier sur le nouveau 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 utilisant des disques persistants à l'aide de gcloud CLI, exécutez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, spécifiez les disques persistants dans le champ instances, puis 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 cette tâche, 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: ID de votre projet.
      • EXISTING_PERSISTENT_DISK_NAME: nom d'un disque persistant existant.
      • EXISTING_PERSISTENT_DISK_LOCATION: emplacement d'un disque persistant existant. Pour chaque disque persistant zonal existant, l'emplacement du job doit être la zone du disque. Pour chaque disque persistant régional existant, l'emplacement du job doit être soit la région du disque, soit, si vous spécifiez des zones, l'une des zones spécifiques ou l'une des zones où se trouve le disque persistant régional. Si vous ne spécifiez aucun disque persistant existant, vous pouvez sélectionner n'importe quel emplacement. En savoir plus sur le champ allowedLocations.
      • NEW_PERSISTENT_DISK_SIZE: taille du nouveau disque persistant en Go. Les tailles autorisées dépendent du type de disque persistant, mais le minimum est souvent de 10 Go (10) et le maximum de 64 To (64000).
      • NEW_PERSISTENT_DISK_TYPE: type de disque du nouveau disque persistant (pd-standard, pd-balanced, pd-ssd ou pd-extreme).
      • NEW_PERSISTENT_DISK_NAME: nom du nouveau disque persistant.

    • Si vous utilisez un modèle d'instance de VM pour cette tâche, créez un fichier JSON comme indiqué précédemment, en remplaçant le champ instances par le code suivant:

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

      où INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques persistants, ce modèle d'instance doit définir et associer les disques persistants que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un nouveau disque persistant nommé NEW_PERSISTENT_DISK_NAME, ainsi qu'un disque persistant existant nommé 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 de la tâche.

    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

À l'aide de l'API Batch, l'exemple suivant crée une tâche qui associe et installe un disque persistant existant et un nouveau disque persistant. La tâche comporte trois tâches qui exécutent chacune un script pour créer un fichier sur le nouveau 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 de l'API Batch, utilisez la méthode jobs.create. Dans la requête, spécifiez les disques persistants dans le champ instances, puis installez le disque persistant dans le champ volumes.

  • Si vous n'utilisez pas de modèle d'instance pour cette tâche, exécutez la requête suivante:

    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: ID de votre projet.
    • LOCATION: emplacement de la tâche.
    • JOB_NAME: nom de la tâche.
    • EXISTING_PERSISTENT_DISK_NAME: nom d'un disque persistant existant.
    • EXISTING_PERSISTENT_DISK_LOCATION: emplacement d'un disque persistant existant. Pour chaque disque persistant zonal existant, l'emplacement du job doit être la zone du disque. Pour chaque disque persistant régional existant, l'emplacement du job doit être soit la région du disque, soit, si vous spécifiez des zones, l'une ou les deux zones spécifiques où se trouve le disque persistant régional. Si vous ne spécifiez aucun disque persistant existant, vous pouvez sélectionner n'importe quel emplacement. En savoir plus sur le champ allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: taille du nouveau disque persistant en Go. Les tailles autorisées dépendent du type de disque persistant, mais le minimum est souvent de 10 Go (10) et le maximum de 64 To (64000).
    • NEW_PERSISTENT_DISK_TYPE: type de disque du nouveau disque persistant (pd-standard, pd-balanced, pd-ssd ou pd-extreme).
    • NEW_PERSISTENT_DISK_NAME: nom du nouveau disque persistant.

  • Si vous utilisez un modèle d'instance de VM pour cette tâche, créez un fichier JSON comme indiqué précédemment, en remplaçant le champ instances par le code suivant:

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

    Où INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques persistants, ce modèle d'instance doit définir et associer les disques persistants que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un nouveau disque persistant nommé NEW_PERSISTENT_DISK_NAME, ainsi qu'un disque persistant existant nommé EXISTING_PERSISTENT_DISK_NAME.

Utiliser un 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 SSD local à l'aide de gcloud CLI ou de l'API Batch. L'exemple suivant explique comment créer une tâche qui crée, associe et installe un disque SSD local. La tâche comporte également trois tâches qui exécutent chacune un script pour créer un fichier sur 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 gcloud CLI, exécutez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, créez et associez les disques SSD locaux dans le champ instances, puis 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 cette tâche, 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: type de machine, qui peut être prédéfini ou personnalisé, parmi les VM du job. Le nombre de SSD locaux autorisés dépend du type de machine pour les VM de votre job.
      • LOCAL_SSD_NAME: nom d'un SSD local créé pour cette tâche.
      • LOCAL_SSD_SIZE: taille de tous les disques SSD locaux en Go. La taille de chaque SSD local est de 375 Go. Cette valeur doit donc être un multiple de 375 Go. Par exemple, pour deux disques SSD locaux, définissez cette valeur sur 750 Go.

    • Si vous utilisez un modèle d'instance de VM pour cette tâche, créez un fichier JSON comme indiqué précédemment, en remplaçant le champ instances par le code suivant:

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

      où INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques SSD locaux, ce modèle d'instance doit définir et associer les disques SSD locaux que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un 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 de la tâche.
    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

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

  • Si vous n'utilisez pas de modèle d'instance pour cette tâche, exécutez la requête suivante:

    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: ID de votre projet.
    • LOCATION: emplacement de la tâche.
    • JOB_NAME: nom de la tâche.
    • MACHINE_TYPE: type de machine, qui peut être prédéfini ou personnalisé, parmi les VM du job. Le nombre de SSD locaux autorisés dépend du type de machine pour les VM de votre job.
    • LOCAL_SSD_NAME: nom d'un SSD local créé pour cette tâche.
    • LOCAL_SSD_SIZE: taille de tous les disques SSD locaux en Go. La taille de chaque SSD local est de 375 Go. Cette valeur doit donc être un multiple de 375 Go. Par exemple, pour deux disques SSD locaux, définissez cette valeur sur 750 Go.

  • Si vous utilisez un modèle d'instance de VM pour cette tâche, créez un fichier JSON comme indiqué précédemment, en remplaçant le champ instances par le code suivant:

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

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

Utiliser un bucket Cloud Storage

Pour créer une tâche qui utilise un bucket Cloud Storage existant, sélectionnez l'une des méthodes suivantes:

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

Avant de créer une tâche qui utilise un bucket, créez un bucket ou identifiez un bucket existant. Pour en savoir plus, consultez les sections Créer des buckets et Répertorier les buckets.

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

L'exemple suivant explique comment créer une tâche qui installe un bucket Cloud Storage. La tâche comporte également trois tâches qui exécutent 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 console Google Cloud, procédez comme suit:

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

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre.

  3. Dans le champ Job name (Nom de la tâche), saisissez example-bucket-job.

  4. Dans le champ Région, sélectionnez l'emplacement pour cette tâche.

    Par exemple, sélectionnez us-central1 (Iowa) (par défaut).

  5. Dans le champ Zone, sélectionnez any (par défaut).

  6. Dans la section Modèle de provisionnement de VM, sélectionnez Standard (par défaut).

  7. Cliquez sur Usage général.

  8. Dans le champ Série, sélectionnez E2 (par défaut).

  9. Dans le champ Type de machine, sélectionnez e2-medium (2 vCPU, 4 Go de mémoire) (par défaut).

  10. Dans le volet Nouvel exécutable, 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 Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

      Où MOUNT_PATH est le chemin d'installation que les exécutables de cette tâche utilisent pour accéder à un bucket Cloud Storage existant. Le chemin d'accès doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. 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.

    3. Cliquez sur OK.

  11. Dans le champ Nombre de tâches, saisissez 3.

  12. Dans le champ Parallélisme, saisissez 1 (par défaut).

  13. Dans la section Ressources de tâche, spécifiez la quantité de ressources de VM requise pour chaque tâche en procédant comme suit:

    1. Dans le champ Cœurs, saisissez 1 (par défaut).

    2. Dans le champ Memory (Mémoire), saisissez 0.5 (valeur par défaut).

  14. Cliquez sur Ajouter un volume. Le volet Nouveau volume s'affiche.

  15. Dans le volet 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 d'un bucket existant.

      Par exemple, saisissez le bucket que vous avez spécifié dans l'environnement d'exécution de ce job.

    3. Dans le champ Chemin d'accès au montage, saisissez le chemin d'installation du bucket (MOUNT_PATH), que vous avez spécifié à l'étape précédente.

    4. Cliquez sur OK.

  16. Cliquez sur Créer.

La page Liste de tâches 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 gcloud CLI, exécutez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, installez le bucket dans le champ volumes.

Par exemple, pour créer une tâche qui génère des fichiers dans 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 vous souhaitez accéder à cette tâche. Il doit commencer par le nom du bucket. Par exemple, pour un bucket nommé BUCKET_NAME, le chemin BUCKET_NAME représente le répertoire racine du bucket et le chemin BUCKET_NAME/subdirectory représente le sous-répertoire subdirectory.
    • MOUNT_PATH: chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce bucket. Le chemin d'accès doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. 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 de la tâche.
    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Pour créer une tâche qui utilise un bucket Cloud Storage à l'aide de l'API Batch, utilisez la méthode jobs.create et installez-le 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: ID de votre projet.
  • LOCATION: emplacement de la tâche.
  • JOB_NAME: nom de la tâche.
  • BUCKET_PATH: chemin du répertoire du bucket auquel vous souhaitez accéder à cette tâche. Il doit commencer par le nom du bucket. Par exemple, pour un bucket nommé BUCKET_NAME, le chemin BUCKET_NAME représente le répertoire racine du bucket et le chemin BUCKET_NAME/subdirectory représente le sous-répertoire subdirectory.
  • MOUNT_PATH: chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce bucket. Le chemin d'accès doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. 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.

Go

Go

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

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: %v", 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: %v", err)
	}

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

	return nil
}

Java

Java

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


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 la documentation de référence de l'API par lot Node.js. 

/**
 * 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 la documentation de référence de l'API par lot Python. 

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)

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) existant, tel qu'un partage de fichiers Filestore, à l'aide de la console Google Cloud, de gcloud CLI ou d'une API de traitement par lot.

Avant de créer une tâche qui utilise un NFS, assurez-vous que le pare-feu de votre réseau est correctement configuré pour autoriser le trafic entre les VM de votre tâche et le NFS. Pour en savoir plus, consultez la section Configurer des règles de pare-feu pour Filestore.

L'exemple suivant explique comment créer une tâche qui spécifie et installe un NFS. La tâche 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 bucket Cloud Storage à l'aide de la console Google Cloud, procédez comme suit:

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

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre.

  3. Dans le champ Job name (Nom de la tâche), saisissez example-nfs-job.

  4. Dans le champ Région, sélectionnez l'emplacement pour cette tâche.

    Par exemple, sélectionnez us-central1 (Iowa) (par défaut).

  5. Dans le champ Zone, sélectionnez any (par défaut).

  6. Dans la section Modèle de provisionnement de VM, sélectionnez Standard (par défaut).

  7. Cliquez sur Usage général.

  8. Dans le champ Série, sélectionnez E2 (par défaut).

  9. Dans le champ Type de machine, sélectionnez e2-medium (2 vCPU, 4 Go de mémoire) (par défaut).

  10. Dans le volet Nouvel exécutable, 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 Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

      Où MOUNT_PATH est le chemin d'installation que la tâche utilise pour accéder à ce NFS. Le chemin d'accès doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. 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.

    3. Cliquez sur OK.

  11. Dans le champ Nombre de tâches, saisissez 3.

  12. Dans le champ Parallélisme, saisissez 1 (par défaut).

  13. Dans la section Ressources de tâche, spécifiez la quantité de ressources de VM requise pour chaque tâche en procédant comme suit:

    1. Dans le champ Cœurs, saisissez 1 (par défaut).

    2. Dans le champ Memory (Mémoire), saisissez 0.5 (valeur par défaut).

  14. Cliquez sur Ajouter un volume. Le volet Nouveau volume s'affiche.

  15. Dans le volet Nouveau volume, procédez comme suit:

    1. Dans la section Type de volume, sélectionnez Système de fichiers en réseau.

    2. Dans le champ File server (Serveur de fichiers), saisissez l'adresse IP du serveur où se trouve le NFS que vous avez spécifié dans l'environnement d'exécution de cette tâche.

      Par exemple, si votre NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de la VM hébergeant le partage de fichiers Filestore, que vous pouvez obtenir en décrit la VM Filestore.

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

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

    4. Dans le champ Chemin d'installation, saisissez le chemin d'installation du NFS (MOUNT_PATH), que vous avez spécifié à l'étape précédente.

    5. Cliquez sur OK.

  16. Cliquez sur Créer.

La page Liste de tâches affiche la tâche que vous avez créée.

gcloud

Pour créer une tâche qui utilise un NFS à l'aide de gcloud CLI, exécutez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, installez le NFS dans le champ 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: adresse IP du NFS. Par exemple, si votre réseau NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de la VM hébergeant le partage de fichiers Filestore. Pour ce faire, décrivez la VM Filestore.
    • NFS_PATH: chemin du répertoire NFS auquel vous souhaitez accéder à cette tâche. Il doit commencer par / suivi du répertoire racine du NFS. Par exemple, pour un partage de fichiers Filestore nommé FILE_SHARE_NAME, le chemin /FILE_SHARE_NAME représente le répertoire racine du partage de fichiers et le chemin /FILE_SHARE_NAME/subdirectory représente le sous-répertoire subdirectory.
    • MOUNT_PATH: chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce NFS. Le chemin d'accès doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. 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 de la tâche.
    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Pour créer une tâche qui utilise un NFS à l'aide de l'API Batch, utilisez la méthode jobs.create et installez-le 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: ID de votre projet.
  • LOCATION: emplacement de la tâche.
  • JOB_NAME: nom de la tâche.
  • NFS_IP_ADDRESS: adresse IP du système de fichiers en réseau. Par exemple, si votre réseau NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de la VM hébergeant le partage de fichiers Filestore. Pour ce faire, décrivez la VM Filestore.
  • NFS_PATH: chemin du répertoire NFS auquel vous souhaitez accéder à cette tâche. Il doit commencer par / suivi du répertoire racine du NFS. Par exemple, pour un partage de fichiers Filestore nommé FILE_SHARE_NAME, le chemin /FILE_SHARE_NAME représente le répertoire racine du partage de fichiers et le chemin /FILE_SHARE_NAME/subdirectory représente un sous-répertoire.
  • MOUNT_PATH: chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce NFS. Le chemin d'accès doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. 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.

Étapes suivantes