Cette page a été traduite par l'API Cloud Translation.

Migrer vers Batch depuis Cloud Life Sciences

Cette page explique comment migrer de Cloud Life Sciences vers Batch.

Google Cloud a annoncé que Cloud Life Sciences était obsolète depuis le 17 juillet 2023 et qu'il serait arrêté le 8 juillet 2025. Toutefois, Batch est généralement disponible et constitue un successeur complet qui prend en charge tous les cas d'utilisation de Cloud Life Sciences.

En savoir plus sur Batch, Cloud Life Sciences et les étapes de lancement des produits

Comparaison entre Cloud Life Sciences et Batch

La migration de Cloud Life Sciences vers Batch consiste principalement à comprendre comment utiliser Batch pour les charges de travail que vous exécutez actuellement en exécutant des pipelines Cloud Life Sciences.

Pour savoir comment exécuter vos charges de travail Cloud Life Sciences sur Batch, consultez les sections suivantes :

Présentation
Opérations de base
Rôles et autorisations IAM
Fonctionnalités correspondantes

Présentation

Un pipeline Cloud Life Sciences décrit une séquence d'actions (conteneurs) à exécuter et l'environnement dans lequel exécuter les conteneurs.

Un job Batch décrit un tableau d'une ou de plusieurs tâches et l'environnement dans lequel les exécuter. Vous définissez la charge de travail d'un job comme une séquence d'un ou plusieurs exécutables (conteneurs et/ou scripts) à exécuter. Chaque tâche d'un job représente une exécution de sa séquence d'exécutables.

Les pipelines Cloud Life Sciences peuvent être exprimés sous forme de jobs Batch à tâche unique.

Par exemple, les exemples suivants décrivent un pipeline Cloud Life Sciences simple et son équivalent en tant que job Batch :

Pipeline Cloud Life Sciences	Job par lot
{ "actions": [ { "imageUri": "bash", "commands": [ "-c", "echo Hello, world!" ] } ] }	{ "taskGroups" : [{ "taskSpec" : { "runnables" : [{ "container":{ "imageUri": "bash", "commands": [ "-c", "echo Hello, world!" ] } }] } }] }

Pipeline Cloud Life Sciences

Job par lot

  {
    "actions": [
      {
        "imageUri": "bash",
        "commands": [
          "-c",
          "echo Hello, world!"
        ]
      }
    ]
  }

    {
      "taskGroups" : [{
        "taskSpec" : {
          "runnables" : [{
            "container":{
              "imageUri": "bash",
              "commands": [
                "-c",
                "echo Hello, world!"
              ]
            }
          }]
        }
      }]
    }

Les tâches par lot multitâches sont semblables aux pipelines Cloud Life Sciences copiés.

Contrairement à Cloud Life Sciences, Batch vous permet de planifier automatiquement plusieurs exécutions de votre charge de travail. Vous indiquez le nombre de fois que vous souhaitez exécuter la séquence d'exécutables pour un job en définissant le nombre de tâches. Lorsqu'un job comporte plusieurs tâches, vous spécifiez la façon dont vous souhaitez que chaque exécution varie en référençant l'index de la tâche dans vos exécutables. Vous pouvez également configurer les plannings relatifs des tâches d'un job (par exemple, si vous souhaitez autoriser l'exécution de plusieurs tâches en parallèle ou exiger que les tâches s'exécutent dans l'ordre séquentiel et une à la fois). Batch gère la planification des tâches du job : lorsqu'une tâche se termine, le job lance automatiquement la tâche suivante, le cas échéant.

Par exemple, consultez le job par lot suivant. Cet exemple de job comporte 100 tâches qui s'exécutent sur 10 instances de machine virtuelle (VM) Compute Engine. Il y a donc environ 10 tâches qui s'exécutent en parallèle à tout moment. Chaque tâche de cet exemple de job n'exécute qu'un seul exécutable : un script qui affiche un message et l'index de la tâche, défini par la variable d'environnement prédéfinie BATCH_TASK_INDEX.

{
  "taskGroups" : [{
    "taskSpec" : {
      "runnables" : [{
        "script":{
          "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}."
        }
      }]
    },
    "taskCount": 100,
    "parallelism": 10
  }]
}

Les workflows qui impliquent la création et la surveillance de plusieurs pipelines Cloud Life Sciences similaires peuvent parfois être simplifiés en tirant parti de la planification intégrée de Batch.

Opérations de base

Cette section décrit les opérations de base dans Cloud Life Sciences par rapport à Batch.

Le tableau suivant récapitule les options d'opérations de base pour Cloud Life Sciences et Batch.

Fonctionnement de base	Options Cloud Life Sciences	Options de traitement par lot
Exécutez une charge de travail.	Exécutez un pipeline.	Créez et exécutez un job.
Affichez toutes vos charges de travail.	Répertorie les opérations de longue durée.	Affichez la liste de vos jobs.
Affichez les détails et l'état d'une charge de travail.	Obtenez les détails d'une opération de longue durée. Interroge une opération de longue durée.	Affichez les détails d'un job. Affichez la liste des tâches d'un job. Affichez les détails d'une tâche.
Arrêtez et supprimez une charge de travail.	Annule une opération de longue durée.	Supprimez (et annulez) un job. Vérifiez l'état d'une demande de suppression de job.

Les opérations de base pour Cloud Life Sciences et Batch présentent quelques différences clés.

Tout d'abord, les ressources d'opération de longue durée ne jouent pas le même rôle dans Batch que dans Cloud Life Sciences. Les ressources d'opération de longue durée (ROLD) dans Cloud Life Sciences sont la ressource principale utilisée pour lister et afficher vos pipelines. Toutefois, les ressources d'opération de longue durée dans Batch et d'autres API Google Cloud ne sont utilisées que pour surveiller l'état d'une requête qui prend beaucoup de temps à se terminer. Plus précisément, dans Batch, la seule requête qui renvoie une ressource d'opération de longue durée est la suppression d'un job. Pour en savoir plus sur les ressources d'opération de longue durée pour Batch, consultez la documentation de référence de l'API Batch pour la ressource REST projects.locations.operations. Au lieu d'utiliser des ressources d'opération de longue durée, Batch dispose de ressources de job que vous pouvez afficher et supprimer pour vos charges de travail.

Ensuite, l'affichage des détails d'une charge de travail dans Batch implique des opérations différentes de celles de Cloud Life Sciences. Vous pouvez afficher une tâche pour voir ses détails et son état. Toutefois, chaque tâche d'un job possède également ses propres détails et son propre état, que vous pouvez consulter en affichant la liste des tâches d'un job et les détails d'une tâche.

Pour vous aider à mieux comprendre les opérations de base pour Cloud Life Sciences par rapport à Batch, les sections suivantes fournissent des exemples de commandes Google Cloud CLI et de chemins de requêtes d'API pour certaines de ces opérations de base.

Exemples de commandes de la gcloud CLI

Pour gcloud CLI, les commandes Cloud Life Sciences commencent par gcloud beta lifesciences et les commandes Batch commencent par gcloud batch. Par exemple, consultez les commandes gcloud CLI suivantes.

Exemples de commandes gcloud CLI Cloud Life Sciences :
- Exécutez un pipeline :
```
gcloud beta lifesciences pipelines run \
  --project=PROJECT_ID \
  --regions=LOCATION \
  --pipeline-file=JSON_CONFIGURATION_FILE
```
- Obtenez les détails d'une opération de longue durée :
```
gcloud beta lifesciences operations describe OPERATION_ID
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de projet de votre projet.
- LOCATION : emplacement du pipeline.
- JSON_CONFIGURATION_FILE : fichier de configuration JSON pour le pipeline.
- OPERATION_ID : identifiant de l'opération de longue durée, renvoyé par la requête d'exécution du pipeline.
Exemples de commandes gcloud CLI par lot :
- Créez et exécutez un job :
```
gcloud batch jobs submit JOB_NAME \
  --project=PROJECT_ID \
  --location=LOCATION \
  --config=JSON_CONFIGURATION_FILE
```
- Afficher les détails d'un job :
```
gcloud batch jobs describe JOB_NAME \
  --project=PROJECT_ID \
  --location=LOCATION \
```
- Pour afficher la liste des tâches d'un job :
```
gcloud batch tasks list \
  --project=PROJECT_ID \
  --location=LOCATION \
  --job=JOB_NAME
```
- Affichez les détails d'une tâche :
```
gcloud batch tasks describe TASK_INDEX \
  --project=PROJECT_ID \
  --location=LOCATION \
  --job=JOB_NAME \
  --task_group=TASK_GROUP
```
- Supprimer (et annuler) une tâche :
```
gcloud batch jobs delete JOB_NAME \
  --project=PROJECT_ID \
  --location=LOCATION
```
Remplacez les éléments suivants :
- JOB_NAME : nom du job.
- PROJECT_ID : ID de projet de votre projet.
- LOCATION : emplacement du job.
- JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration du job.
- TASK_INDEX : index de la tâche dont vous souhaitez afficher les détails. Dans un groupe de tâches, l'index de tâche commence à 0 pour la première tâche et augmente de 1 pour chaque tâche supplémentaire. Par exemple, un groupe de tâches contenant quatre tâches possède les index 0, 1, 2 et 3.
- TASK_GROUP_NAME : nom du groupe de tâches dont vous souhaitez afficher les détails. La valeur doit être définie sur group0.

Exemples de chemins de requête API

Pour les API, Cloud Life Sciences utilise des chemins de requête lifesciences.googleapis.com, tandis que Batch utilise des chemins de requête batch.googleapis.com. Par exemple, consultez les chemins d'accès aux requêtes API suivants. Contrairement à Cloud Life Sciences, Batch ne dispose pas d'API RPC, mais uniquement d'une API REST.

Exemples de chemins de requête API Cloud Life Sciences :
- Exécutez un pipeline :
```
POST https://lifesciences.googleapis.com/v2beta/projects/PROJECT_ID/locations/LOCATION/pipelines:run
```
- Obtenez les détails d'une opération de longue durée :
```
GET https://lifesciences.googleapis.com/v2beta/projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de projet de votre projet.
- LOCATION : emplacement du pipeline.
- OPERATION_ID : identifiant de l'opération de longue durée, renvoyé par la requête d'exécution du pipeline.
Exemples de chemins de requête API par lot :
- Créez et exécutez un job :
```
POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
```
- Afficher les détails d'un job :
```
GET https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs/JOB_NAME
```
- Pour afficher la liste des tâches d'un job :
```
GET https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs/JOB_NAME/taskGroups/TASK_GROUP/tasks
```
- Supprimer un job
```
DELETE https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs/JOB_NAME
```
- Vérifiez l'état de la demande de suppression du job :
```
GET https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de projet de votre projet.
- LOCATION : emplacement du job.
- JOB_NAME : nom du job.
- TASK_GROUP_NAME : nom du groupe de tâches dont vous souhaitez afficher les détails. La valeur doit être définie sur group0.
- OPERATION_ID : identifiant de l'opération de longue durée renvoyé par la requête de suppression du job.

Rôles et autorisations IAM

Cette section récapitule les différences entre les rôles et les autorisations Identity and Access Management pour Cloud Life Sciences et Batch. Pour en savoir plus sur les rôles et leurs autorisations, consultez la documentation de référence sur les rôles IAM de base et prédéfinis.

Le tableau suivant décrit les rôles prédéfinis et les autorisations requises pour les utilisateurs de Cloud Life Sciences.

Rôles Cloud Life Sciences Autorisations

Rôles Cloud Life Sciences	Autorisations
Parmi les suivantes : Administrateur Cloud Life Sciences (`roles/lifesciences.admin`) sur le projet Éditeur Cloud Life Sciences (`roles/lifesciences.editor`) sur le projet Exécuteur de workflows Cloud Life Sciences (`roles/lifesciences.workflowsRunner`) sur le projet	`lifesciences.workflows.run` `lifesciences.operations.cancel` `lifesciences.operations.get` `lifesciences.operations.list`
Lecteur Cloud Life Sciences (`roles/lifesciences.viewer`) sur le projet	`lifesciences.operations.get` `lifesciences.operations.list` `resourcemanager.projects.get` `resourcemanager.projects.list`

Parmi les suivantes :

Administrateur Cloud Life Sciences (roles/lifesciences.admin) sur le projet
Éditeur Cloud Life Sciences (roles/lifesciences.editor) sur le projet
Exécuteur de workflows Cloud Life Sciences (roles/lifesciences.workflowsRunner) sur le projet

lifesciences.workflows.run
lifesciences.operations.cancel
lifesciences.operations.get
lifesciences.operations.list

Lecteur Cloud Life Sciences (roles/lifesciences.viewer) sur le projet

lifesciences.operations.get
lifesciences.operations.list
resourcemanager.projects.get
resourcemanager.projects.list

Le tableau suivant décrit certains des rôles prédéfinis et leurs autorisations pour Batch. Contrairement à Cloud Life Sciences, Batch vous demande d'accorder des autorisations aux utilisateurs et au compte de service pour un job. Pour en savoir plus sur les exigences IAM, consultez Conditions préalables pour Batch.

Attribuer des rôles aux utilisateurs par lot	Autorisations
Éditeur de tâches par lot (`roles/batch.jobsEditor`) sur le projet	`batch.jobs.create` `batch.jobs.delete` `batch.jobs.get` `batch.jobs.list` `batch.locations.get` `batch.locations.list` `batch.operations.get` `batch.operations.list` `batch.tasks.get` `batch.tasks.list` `resourcemanager.projects.get` `resourcemanager.projects.list`
Lecteur de tâches par lot (`roles/batch.jobsViewer`) sur le projet	`batch.jobs.get` `batch.jobs.list` `batch.locations.get` `batch.locations.list` `batch.operations.get` `batch.operations.list` `batch.tasks.get` `batch.tasks.list` `resourcemanager.projects.get` `resourcemanager.projects.list`
Utilisateur du compte de service (`roles/iam.serviceAccountUser`) sur le compte de service du job	`iam.serviceAccounts.actAs` `iam.serviceAccounts.get` `iam.serviceAccounts.list` `resourcemanager.projects.get` `resourcemanager.projects.list`
Rôles par lot pour les comptes de service	Autorisations
Responsable du signalement d'agent par lot (`roles/batch.agentReporter`) sur le projet	`batch.states.report`

Fonctionnalités correspondantes

Le tableau suivant décrit les fonctionnalités de Cloud Life Sciences, les fonctionnalités équivalentes pour Batch et les différences entre elles.

Chaque fonctionnalité est représentée par une description et sa syntaxe JSON. Vous pouvez utiliser la syntaxe JSON lorsque vous accédez à Batch via l'API ou lorsque vous spécifiez un fichier de configuration JSON via Google Cloud CLI. Toutefois, notez que vous pouvez également utiliser les fonctionnalités Batch par d'autres méthodes, par exemple via les champs de la console Google Cloud , les options gcloud CLI et les bibliothèques clientes, qui sont décrites dans la documentation Batch.

Pour en savoir plus sur chaque fonctionnalité et sa syntaxe JSON, consultez les ressources suivantes :

Pour Cloud Life Sciences, consultez la documentation de référence de l'API Cloud Life Sciences pour la ressource REST projects.locations.pipelines.
Pour Batch, consultez la documentation de référence de l'API Batch pour la ressource REST projects.locations.jobs.

Fonctionnalités de Cloud Life Sciences	Fonctionnalités par lot	Détails
pipeline (`pipeline`)	job (`job`) et ses tâches (`taskGroups[]`)	Un job Batch se compose d'un tableau d'une ou plusieurs tâches qui exécutent toutes les mêmes exécutables. Un pipeline Cloud Life Sciences est semblable à un job Batch avec une seule tâche. Toutefois, Cloud Life Sciences ne dispose pas d'un concept équivalent pour les tâches (ou les tâches multiples), qui sont un peu comme des répétitions d'un pipeline. Pour en savoir plus sur les jobs et les tâches, consultez la présentation de Batch.
Actions (`actions[]`) pour un pipeline	exécutables (`runnables[]`) pour les tâches d'un job	Une action Cloud Life Sciences décrit un conteneur, mais un exécutable Batch peut contenir un conteneur ou un script.
Identifiants (`credentials`) pour une action	pour un conteneur exécutable : Nom d'utilisateur (`username`) mot de passe (`password`)	Dans Cloud Life Sciences, les identifiants d'une action doivent être un dictionnaire chiffré Cloud Key Management Service avec des paires clé-valeur de nom d'utilisateur et de mot de passe. Dans Batch, le nom d'utilisateur et le mot de passe d'un conteneur exécutable se trouvent dans des champs distincts. Chaque champ peut être spécifié en texte brut ou avec le nom d'un secret Secret Manager.
pour une action : variables d'environnement (`environment`) Variables d'environnement chiffrées (`encryptedEnvironment`)	pour un environnement : variables (`variables`) Variables chiffrées (`encryptedVariables`) Variables secrètes (`secretVariables`) Environnements possibles : un exécutable (`environment` dans `runnables[]`) toutes les exécutables (`environment` dans `taskSpec`) toutes les tâches (`taskEnvironments[]` dans `taskGroups[]`)	Cloud Life Sciences vous permet de spécifier les variables d'environnement d'une action, qui sont mises en forme en texte brut ou en tant que dictionnaire chiffré. Dans Batch, cela revient à inclure dans l'environnement d'un exécutable (champ `environment` dans `runnables[]`) des variables mises en forme en texte brut (`variables`) ou en dictionnaire chiffré (`encryptedVariables`). Toutefois, Batch propose également plus d'options pour spécifier les variables d'environnement : Au lieu de spécifier des variables en texte brut ou dans un dictionnaire chiffré, vous pouvez les spécifier à l'aide de secrets Secret Manager en utilisant une variable secrète (`secretVariables`). Au lieu de spécifier une variable d'environnement pour un exécutable, vous pouvez en spécifier une pour tous les exécutables en utilisant le champ `environment` dans `taskSpec`. Au lieu de spécifier une variable d'environnement ayant la même valeur pour chaque tâche, vous pouvez spécifier une variable d'environnement ayant une valeur différente pour chaque tâche en utilisant le champ `taskEnvironments[]` dans `taskGroups[]`. Pour en savoir plus, consultez Utiliser des variables d'environnement.
Libellés pour une requête d'exécution d'un pipeline (`labels` dans le corps de la requête)	Libellés d'un job (`labels` dans la ressource de job)	Contrairement à Cloud Life Sciences, Batch n'inclut pas de champ "labels" dans la requête permettant de créer un job. L'option la plus proche pour Batch consiste à utiliser des libellés qui ne sont associés qu'au job. Batch propose plusieurs types d'étiquettes (champs `labels`) que vous pouvez utiliser lorsque vous créez un job. Pour en savoir plus, consultez Organiser des ressources à l'aide d'étiquettes.
Régions (`regions[]`) et zones (`zones[]`) pour les ressources d'un pipeline (`resources`)	Emplacements autorisés (`allowedLocations`) pour la stratégie d'emplacement des ressources d'un job (`locationPolicy`)	Dans Cloud Life Sciences, un pipeline s'exécute sur une seule VM, pour laquelle vous pouvez spécifier les régions et/ou zones souhaitées. Dans Batch, l'option équivalente est celle des emplacements autorisés pour un job. Vous pouvez définir un ou plusieurs régions ou zones, et spécifier où les VM d'un job peuvent être créées. Toutes les VM d'un même job Batch appartiennent à un seul groupe d'instances géré (MIG), qui existe dans une région spécifique. Toutefois, les VM individuelles peuvent se trouver dans différentes zones de cette région. Il est important de noter que la spécification du champ des zones géographiques autorisées pour un emploi est facultative, car elle est distincte de l'emplacement de l'emploi. Contrairement à l'emplacement du job, l'emplacement autorisé n'a pas d'incidence sur l'emplacement utilisé pour créer un job Batch et stocker les métadonnées du job. Pour en savoir plus, consultez Emplacements des lots.
pour les ressources d'un pipeline (`resources`) : la VM (`virualMachine`)	pour la règle de ressource d'un job (`allocationPolicy`) : les VM (`instances`) compte de service (`serviceAccount`) libellés (`labels` dans `allocationPolicy`) réseau (`network`)	Dans Cloud Life Sciences, vous pouvez configurer la VM (une seule) sur laquelle un pipeline s'exécute. Dans Batch, les mêmes options pour les VM sont disponibles dans les champs d'une règle d'allocation de ressources d'un job (`allocationPolicy`) : Le compte de service, les libellés et la configuration réseau des VM sont définis dans leurs champs dédiés. Le champ de VM (`instances`), que vous pouvez définir directement ou à l'aide d'un modèle d'instance, inclut les options de configuration pour le type de machine, la plate-forme de processeur minimale autorisée, le disque de démarrage et tous les autres disques associés, ainsi que tous les GPU et pilotes de GPU.
pour une action : libellés (`labels` dans `actions[]`) Option de délai avant expiration (`timeout`) Option permettant d'ignorer le code d'état de sortie (`ignoreExitStatus`) Option permettant d'exécuter l'application en arrière-plan (`runInBackground`) Option "Toujours exécuter" (`alwaysRun`)	pour un exécutable : libellés (`labels` dans `runnables[]`) Option de délai avant expiration (`timeout`) Option permettant d'ignorer le code d'état de sortie (`ignoreExitStatus`) Option permettant d'exécuter l'application en arrière-plan (`background`) Option "Toujours exécuter" (`alwaysRun`)	Ces différents indicateurs pratiques de Cloud Life Sciences sont équivalents dans Batch, sauf qu'ils sont spécifiés pour chaque exécutable (qui peut contenir un script ou un conteneur) au lieu de chaque action (conteneur).
pour une action : Option permettant de publier les ports exposés (`publishExposedPorts`) Option permettant de spécifier l'espace de noms de l'ID de processus (PID) (`pidNamespace`) et l'option permettant de spécifier les mappages de ports de conteneur à hôte (`portMappings`).	options (`options`) pour un exécutable de conteneur.	Ces options Cloud Life Sciences (et d'autres) sont compatibles avec Batch via le champ d'options (`options`) pour un exécutable de conteneur. Définissez le champ des options sur les indicateurs que vous souhaitez que Batch ajoute à la commande `docker run` (par exemple, `-P --pid mynamespace -p 22:22`).
pour une action : Option permettant de désactiver le téléchargement anticipé des images de conteneur (`disableImagePrefetch`) Option permettant de désactiver le renvoi du flux d'erreur standard (`disableStandardErrorCapture`)	aucun équivalent	Le traitement par lot précharge les images et traite les sorties de tous les exécutables de manière identique, conformément à la règle relative aux journaux du job (`logsPolicy`).
Option permettant de bloquer les réseaux externes (`blockExternalNetwork`) pour une action	Option permettant de bloquer les réseaux externes (`blockExternalNetwork`) pour un exécutable de conteneur	L'option Cloud Life Sciences permettant de bloquer les réseaux externes pour une action est semblable à l'option Batch permettant de bloquer les réseaux externes pour un conteneur. Batch propose également de nombreuses autres options de mise en réseau, par exemple pour bloquer les réseaux externes pour toutes les VM d'un job. Pour en savoir plus, consultez Présentation de la mise en réseau par lot.
montures (`mounts[]`) pour une action	Volumes pour tous les exécutables (`volumes[]` dans `taskSpec`) et options de volume pour un conteneur (`volumes[]` dans `container`)	Dans Batch, vous pouvez utiliser le champ `volumes[]` dans `taskSpec` pour définir les volumes d'un job et leurs chemins de montage. Batch monte les volumes de stockage sur les VM du job. Ces volumes sont accessibles à tous les exécutables du job (scripts ou conteneurs). Ce montage est effectué avant que la VM n'exécute des tâches ou des exécutables. De plus, Batch est compatible avec les options de volume explicites sur les exécutables de conteneur à l'aide du champ `volumes[]` dans `container`. Ces options de montage sont transmises au conteneur en tant qu'options pour l'option `--volume` de la commande `docker run`. Par exemple, la valeur `[ "/etc:/etc", "/foo:/bar" ]` est traduite en commande `docker run --volume /etc:/etc --volume /foo:/bar` sur le conteneur. Pour en savoir plus sur l'utilisation des volumes de stockage avec Batch, consultez Créer et exécuter un job qui utilise des volumes de stockage.
Option permettant d'activer Cloud Storage FUSE (`enableFuse`) pour une action	aucun équivalent	Batch gère l'installation de tous les volumes de stockage, tels qu'un bucket Cloud Storage, que vous spécifiez pour un job. Par conséquent, vous n'activez aucun outil d'installation tel que Cloud Storage FUSE pour Batch. Toutefois, vous pouvez éventuellement spécifier des options d'installation pour vos volumes de stockage à l'aide du champ `mountOptions[]`. Pour en savoir plus sur l'utilisation des buckets Cloud Storage avec Batch, consultez Créer et exécuter un job qui utilise des volumes de stockage.
Sujet Pub/Sub (`pubSubTopic`) pour une demande d'exécution d'un pipeline	pour les configurations de notification d'un job (`notifications[]`) : Sujet Pub/Sub (`pubSubTopic`) messages (`message`)	Batch permet de personnaliser davantage les mises à jour de l'état que Cloud Life Sciences. Par exemple, les utilisateurs Batch peuvent être avertis sur un thème Pub/Sub lorsque l'état des tâches individuelles change ou uniquement lorsque l'état du job global change.

Services de workflow

Si vous utilisez un service de workflow avec Cloud Life Sciences, votre processus de migration implique également la configuration d'un service de workflow pour qu'il fonctionne avec Batch. Cette section récapitule les services de workflow que vous pouvez utiliser avec Batch.

Batch est compatible avec Workflows, un service de workflow de Google Cloud. Si vous souhaitez utiliser Workflows avec Batch, consultez Exécuter un job Batch à l'aide de Workflows. Sinon, le tableau suivant décrit d'autres services de workflow que vous pouvez utiliser pour Cloud Life Sciences et Batch. Ce tableau liste les principales différences entre l'utilisation de chaque service de workflow avec Batch au lieu de Cloud Life Sciences. Il fournit également des informations sur l'utilisation de chaque service avec Batch.

Service de workflow	Différences majeures	Détails
Cromwell	Pour utiliser un fichier de configuration Cromwell pour l'API Cloud Life Sciences v2beta avec l'API Batch, apportez les modifications suivantes : Pour le champ `actor-factory`, remplacez `cromwell.backend.google.pipelines.v2beta.PipelinesApiLifecycleActorFactory` par `cromwell.backend.google.batch.GcpBatchLifecycleActorFactory`. Supprimez le champ `genomics.endpoint-url`. Générez un fichier de configuration.	Pour en savoir plus sur l'utilisation de Batch avec Cromwell, consultez la documentation Cromwell pour Batch et le tutoriel Cromwell pour Batch.
dsub	Pour exécuter votre pipeline dsub pour Cloud Life Sciences avec Batch, apportez les modifications suivantes : Pour le champ `provider`, remplacez `google-cls-v2` par `google-batch`.	Pour savoir comment utiliser Batch avec dsub, consultez la documentation dsub pour Batch.
Nextflow	Pour utiliser un fichier de configuration Nextflow pour Cloud Life Sciences avec Batch, apportez les modifications suivantes : Pour le champ `executor`, remplacez `google-lifesciences` par `google-batch`. Pour tous les préfixes `config`, remplacez `google.lifeScience` par `google.batch`.	Pour savoir comment utiliser Batch avec Nextflow, consultez un tutoriel Batch ou un tutoriel Nextflow. Pour en savoir plus sur les options de configuration, consultez la documentation Nextflow.
Snakemake	Pour utiliser un pipeline Snakemake pour l'API Cloud Life Sciences v2bêta avec l'API Batch, apportez les modifications suivantes : Assurez-vous d'utiliser Snakemake version 8 ou ultérieure. Pour en savoir plus, consultez Migration entre les versions de Snakemake. Apportez les modifications suivantes à la commande `snakemake` : Remplacez l'option `--google-lifesciences` par l'option `--executor googlebatch`. Remplacez tous les indicateurs supplémentaires qui utilisent le préfixe `--google-lifesciences-` par le préfixe `--googlebatch-`.	Pour en savoir plus sur l'utilisation de Batch avec Snakemake, consultez la documentation Snakemake pour Batch.

Étapes suivantes

Pour configurer Batch pour les nouveaux utilisateurs et projets, consultez Premiers pas.
Pour savoir comment exécuter des charges de travail à l'aide de Batch, consultez Créer un job.