Esta página foi traduzida pela API Cloud Translation.

Migrar do Cloud Life Sciences para o Batch

Esta página descreve como migrar para o Batch do Cloud Life Sciences.

Em 17 de julho de 2023, o Google Cloud anunciou que o Cloud Life Sciences, que estava na versão Beta, foi descontinuado. O serviço não estará mais disponível no Google Cloud após 8 de julho de 2025. No entanto, o Batch está disponível em geral e é um sucessor abrangente que oferece suporte a todos os casos de uso do Cloud Life Sciences.

Saiba mais sobre o Batch, o Cloud Life Sciences e as etapas de lançamento do produto.

Cloud Life Sciences e Batch

A migração do Cloud Life Sciences para o Batch envolve principalmente entender como usar o Batch para as cargas de trabalho que você executa executando pipelines do Cloud Life Sciences.

Para entender como executar suas cargas de trabalho do Cloud Life Sciences no Batch, consulte as seções a seguir:

Visão geral
Operações básicas
Permissões e papéis do IAM
Recursos correspondentes

Visão geral

Um pipeline do Cloud Life Sciences descreve uma sequência de ações (contêineres) a serem executadas e o ambiente em que os contêineres serão executados.

Um job em lote descreve uma matriz de uma ou mais tarefas e o ambiente para executar essas tarefas. Você define a carga de trabalho de um job como uma sequência de um ou mais executáveis (contêineres e/ou scripts) a serem executados. Cada tarefa de um job representa uma execução da sequência de executáveis.

Os pipelines do Cloud Life Sciences podem ser expressos como jobs em lote de tarefa única.

Por exemplo, os exemplos a seguir descrevem um pipeline simples do Cloud Life Sciences e o job em lote equivalente:

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

Pipeline do Cloud Life Sciences

Job em lote

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

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

Os jobs em lote com várias tarefas são semelhantes aos pipelines copiados do Cloud Life Sciences.

Ao contrário do Cloud Life Sciences, o Batch permite programar automaticamente várias execuções da carga de trabalho. Você indica o número de vezes que quer executar a sequência de executáveis para um job definindo o número de tarefas. Quando um job tem várias tarefas, você especifica como quer que cada execução varie fazendo referência ao índice da tarefa nos executáveis. Além disso, é possível configurar as programações relativas para as tarefas de um job, por exemplo, permitir que várias tarefas sejam executadas em paralelo ou exigir que as tarefas sejam executadas em ordem sequencial e uma de cada vez. O lote gerencia a programação das tarefas do job: quando uma tarefa é concluída, o job inicia automaticamente a próxima tarefa, se houver.

Por exemplo, confira o seguinte job em lote. Este job de exemplo tem 100 tarefas que são executadas em 10 instâncias de máquina virtual (VM) do Compute Engine. Portanto, há aproximadamente 10 tarefas em execução em paralelo a qualquer momento. Cada tarefa neste job de exemplo executa apenas um executável: um script que imprime uma mensagem e o índice da tarefa, que é definido pela variável de ambiente predefinida BATCH_TASK_INDEX.

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

Workflows que envolvem a criação e o monitoramento de vários pipelines semelhantes do Cloud Life Sciences às vezes podem ser simplificados usando a programação integrada do Batch.

Operações básicas

Esta seção descreve as operações básicas no Cloud Life Sciences em comparação com o Batch.

A tabela a seguir resume as opções de operações básicas para o Cloud Life Sciences e o Batch.

Operação básica	Opções do Cloud Life Sciences	Opções de lote
Executar uma carga de trabalho.	Executar um pipeline.	Crie e execute um job.
Confira todas as cargas de trabalho.	Listar operações de longa duração.	Acessar uma lista dos seus jobs.
Confira os detalhes e o status de uma carga de trabalho.	Acessar detalhes de uma operação de longa duração. Pesquisar uma operação de longa duração.	Acessar os detalhes de um job. Confira uma lista de tarefas de um job. Acessar os detalhes de uma tarefa.
Interromper e remover uma carga de trabalho.	Cancelar uma operação de longa duração.	Excluir (e cancelar) um job. Verificar o status de uma solicitação de exclusão de job.

As operações básicas do Cloud Life Sciences e do Batch têm algumas diferenças importantes.

Em primeiro lugar, os recursos de operação de longa duração não têm a mesma função no Batch que no Cloud Life Sciences. Os recursos de operação de longa duração (LROs, na sigla em inglês) no Cloud Life Sciences são o recurso principal usado para listar e acessar seus pipelines. No entanto, os recursos de operação de longa duração no Batch e em outras APIs são usados apenas para monitorar o status de uma solicitação que leva muito tempo para ser concluída. Especificamente, no Batch, a única solicitação que retorna um recurso de operação de longa duração é a exclusão de um job. Para mais informações sobre recursos de operação de longa duração para Batch, consulte a documentação de referência da API Batch para o recurso REST projects.locations.operations. Em vez de usar recursos de operação de longa duração, o Batch tem recursos de job que você pode conferir e excluir para suas cargas de trabalho.

Em segundo lugar, a visualização dos detalhes de uma carga de trabalho no Batch envolve operações diferentes do Cloud Life Sciences. É possível conferir um job para ver os detalhes e o status dele. No entanto, cada uma das tarefas de um job também tem seus próprios detalhes e status, que podem ser acessados em uma lista de tarefas de um job e nos detalhes de uma tarefa.

Para entender melhor as operações básicas do Cloud Life Sciences em comparação com o Batch, as seções a seguir apresentam exemplos de comandos da Google Cloud CLI e caminhos de solicitações de API para algumas dessas operações básicas.

Exemplos de comandos da CLI gcloud

Para CLI gcloud, os comandos do Cloud Life Sciences começam com gcloud beta lifesciences, e os comandos do Batch começam com gcloud batch. Por exemplo, consulte os seguintes comandos da CLI gcloud.

Exemplos de comandos da CLI gcloud do Cloud Life Sciences:
- Executar um pipeline:
```
gcloud beta lifesciences pipelines run \
  --project=PROJECT_ID \
  --regions=LOCATION \
  --pipeline-file=JSON_CONFIGURATION_FILE
```
- Acesse os detalhes de uma operação de longa duração:
```
gcloud beta lifesciences operations describe OPERATION_ID
```
Substitua:
- PROJECT_ID: o ID do projeto do seu projeto.
- LOCATION: o local do pipeline.
- JSON_CONFIGURATION_FILE: o arquivo de configuração JSON do pipeline.
- OPERATION_ID: o identificador da operação de longa duração, que foi retornado pela solicitação para executar o pipeline.
Exemplos de comandos da CLI gcloud em lote:
- Criar e executar um job:
```
gcloud batch jobs submit JOB_NAME \
  --project=PROJECT_ID \
  --location=LOCATION \
  --config=JSON_CONFIGURATION_FILE
```
- Para conferir os detalhes de um job:
```
gcloud batch jobs describe JOB_NAME \
  --project=PROJECT_ID \
  --location=LOCATION \
```
- Confira a lista de tarefas de um job:
```
gcloud batch tasks list \
  --project=PROJECT_ID \
  --location=LOCATION \
  --job=JOB_NAME
```
- Para conferir os detalhes de uma tarefa:
```
gcloud batch tasks describe TASK_INDEX \
  --project=PROJECT_ID \
  --location=LOCATION \
  --job=JOB_NAME \
  --task_group=TASK_GROUP
```
- Excluir (e cancelar) um job:
```
gcloud batch jobs delete JOB_NAME \
  --project=PROJECT_ID \
  --location=LOCATION
```
Substitua:
- JOB_NAME: o nome do job.
- PROJECT_ID: o ID do projeto do seu projeto.
- LOCATION: o local do job.
- JSON_CONFIGURATION_FILE: o caminho para um arquivo JSON com os detalhes de configuração do job.
- TASK_INDEX: o índice da tarefa que você quer ver os detalhes. Em um grupo de tarefas, o índice começa em 0 para a primeira tarefa e aumenta em 1 a cada tarefa adicional. Por exemplo, um grupo de tarefas que contém quatro tarefas tem os índices 0, 1, 2 e 3.
- TASK_GROUP_NAME: o nome do grupo de tarefas que você quer consultar. O valor precisa ser definido como group0.

Exemplos de caminhos de solicitação de API

Para APIs, o Cloud Life Sciences usa caminhos de solicitação lifesciences.googleapis.com, e o Batch usa caminhos de solicitação batch.googleapis.com. Por exemplo, confira os seguintes caminhos de solicitação de API. Ao contrário do Cloud Life Sciences, o Batch não tem uma API RPC, apenas uma API REST.

Exemplos de caminhos de solicitação de API do Cloud Life Sciences:
- Executar um pipeline:
```
POST https://lifesciences.googleapis.com/v2beta/projects/PROJECT_ID/locations/LOCATION/pipelines:run
```
- Acesse os detalhes de uma operação de longa duração:
```
GET https://lifesciences.googleapis.com/v2beta/projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Substitua:
- PROJECT_ID: o ID do projeto do seu projeto.
- LOCATION: o local do pipeline.
- OPERATION_ID: o identificador da operação de longa duração, que foi retornado pela solicitação para executar o pipeline.
Exemplos de caminhos de solicitação de API em lote:
- Criar e executar um job:
```
POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
```
- Para conferir os detalhes de um job:
```
GET https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs/JOB_NAME
```
- Confira a lista de tarefas de um job:
```
GET https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs/JOB_NAME/taskGroups/TASK_GROUP/tasks
```
- Excluir um job
```
DELETE https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs/JOB_NAME
```
- Verifique o status da solicitação de exclusão de job:
```
GET https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Substitua:
- PROJECT_ID: o ID do projeto do seu projeto.
- LOCATION: o local do job.
- JOB_NAME: o nome do job.
- TASK_GROUP_NAME: o nome do grupo de tarefas que você quer consultar. O valor precisa ser definido como group0.
- OPERATION_ID: o identificador da operação de longa duração, que foi retornado pela solicitação para excluir o job.

Permissões e papéis do IAM

Esta seção resume as diferenças nas permissões e funções do Identity and Access Management para o Cloud Life Sciences e o Batch. Para mais informações sobre os papéis e as permissões deles, consulte a Referência de papéis básicos e predefinidos do IAM.

A tabela a seguir descreve os papéis predefinidos e as permissões necessárias para os usuários do Cloud Life Sciences.

Papéis do Cloud Life Sciences Permissões

Papéis do Cloud Life Sciences	Permissões
Qualquer um dos seguintes: Administrador do Cloud Life Sciences (`roles/lifesciences.admin`) no projeto Editor do Cloud Life Sciences (`roles/lifesciences.editor`) no projeto Executor de fluxos de trabalho do Cloud Life Sciences (`roles/lifesciences.workflowsRunner`) no projeto	`lifesciences.workflows.run` `lifesciences.operations.cancel` `lifesciences.operations.get` `lifesciences.operations.list`
Visualizador do Cloud Life Sciences (`roles/lifesciences.viewer`) no projeto	`lifesciences.operations.get` `lifesciences.operations.list` `resourcemanager.projects.get` `resourcemanager.projects.list`

Qualquer um dos seguintes:

Administrador do Cloud Life Sciences (roles/lifesciences.admin) no projeto
Editor do Cloud Life Sciences (roles/lifesciences.editor) no projeto
Executor de fluxos de trabalho do Cloud Life Sciences (roles/lifesciences.workflowsRunner) no projeto

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

Visualizador do Cloud Life Sciences (roles/lifesciences.viewer) no projeto

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

A tabela a seguir descreve alguns dos papéis predefinidos e as permissões deles para o Batch. Ao contrário do Cloud Life Sciences, o Batch exige que você conceda permissões aos usuários e à conta de serviço para um job. Para mais informações sobre os requisitos do IAM, consulte Pré-requisitos para o Batch.

Funções em lote para usuários	Permissões
Editor de jobs em lote (`roles/batch.jobsEditor`) no projeto	`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`
Leitor de job em lote (`roles/batch.jobsViewer`) no projeto	`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`
Usuário da conta de serviço (`roles/iam.serviceAccountUser`) na conta de serviço do job	`iam.serviceAccounts.actAs` `iam.serviceAccounts.get` `iam.serviceAccounts.list` `resourcemanager.projects.get` `resourcemanager.projects.list`
Papéis em lote para contas de serviço	Permissões
Relator do agente em lote (`roles/batch.agentReporter`) no projeto	`batch.states.report`

Recursos correspondentes

A tabela a seguir descreve os recursos do Cloud Life Sciences, os recursos equivalentes do Batch e detalhes sobre as diferenças entre eles.

Cada recurso é representado por uma descrição e a sintaxe JSON. É possível usar a sintaxe JSON ao acessar o Batch pela API ou ao especificar um arquivo de configuração JSON pela Google Cloud CLI. No entanto, você também pode usar os recursos do Batch com outros métodos, como os campos do console do Google Cloud , flags da CLI gcloud e bibliotecas de cliente, que são descritos na documentação do Batch.

Para mais informações sobre cada recurso e a sintaxe JSON dele, consulte:

Para o Cloud Life Sciences, consulte a documentação de referência da API Cloud Life Sciences para o recurso REST projects.locations.pipelines.
Para o Batch, consulte a documentação de referência da API Batch para o recurso REST projects.locations.jobs.

Recursos do Cloud Life Sciences	Recursos de lote	Detalhes
pipeline (`pipeline`)	job (`job`) e as tarefas dele (`taskGroups[]`)	Um job em lote consiste em uma matriz de uma ou mais tarefas que executam todos os mesmos executáveis. Um pipeline do Cloud Life Sciences é semelhante a um job em lote com uma tarefa. No entanto, o Cloud Life Sciences não tem um conceito equivalente para tarefas (jobs com várias), que são semelhantes a repetições de um pipeline. Para mais informações sobre jobs e tarefas, consulte Visão geral do Batch.
ações (`actions[]`) para um pipeline	executáveis (`runnables[]`) para as tarefas de um job	Uma ação do Cloud Life Sciences descreve um contêiner, mas um executável em lote pode conter um contêiner ou um script.
credenciais (`credentials`) para uma ação	para um contêiner executável: Nome de usuário (`username`) senha (`password`)	No Cloud Life Sciences, as credenciais de uma ação precisam ser um dicionário criptografado do Cloud Key Management Service com pares de chave-valor de nome de usuário e senha. No lote, o nome de usuário e a senha de um contêiner executável estão em campos separados. Qualquer um dos campos pode ser especificado com texto simples ou com o nome de um secret do Secret Manager.
para uma ação: variáveis de ambiente (`environment`) variáveis de ambiente criptografadas (`encryptedEnvironment`);	para um ambiente: variáveis (`variables`) variáveis criptografadas (`encryptedVariables`); variáveis secretas (`secretVariables`); possíveis ambientes: um executável (`environment` em `runnables[]`) todos os executáveis (`environment` em `taskSpec`) todas as tarefas (`taskEnvironments[]`em `taskGroups[]`)	O Cloud Life Sciences permite especificar as variáveis de ambiente para uma ação formatada como texto simples ou como um dicionário criptografado. No lote, isso é semelhante a ter o ambiente para um executável (campo `environment` em `runnables[]`) inclua variáveis formatadas como texto simples (`variables`) ou um dicionário criptografado (`encryptedVariables`). No entanto, o Batch também tem mais opções para especificar variáveis de ambiente: Como alternativa para especificar variáveis como texto simples ou um dicionário criptografado, é possível especificar variáveis usando secrets do Secret Manager usando uma variável secreta (`secretVariables`). Como alternativa para especificar uma variável de ambiente para um executável, você pode especificar uma variável de ambiente para todos os executáveis usando o campo `environment` em `taskSpec`. Como alternativa para especificar uma variável de ambiente com o mesmo valor para cada tarefa, você pode especificar uma variável de ambiente que tenha um valor diferente para cada tarefa usando o campo `taskEnvironments[]` em `taskGroups[]`. Para mais informações, consulte Usar variáveis de ambiente.
rótulos para uma solicitação para executar um pipeline (`labels` no corpo da solicitação).	rótulos de um job (`labels` no recurso de job)	Ao contrário do Cloud Life Sciences, o Batch não inclui um campo de identificadores na solicitação para criar um novo job. A opção mais próxima para o lote é usar rótulos associados apenas ao job. O lote tem vários tipos de rótulos (campos `labels`) que podem ser usados ao criar um job. Para mais informações, consulte Organizar recursos usando rótulos.
regiões (`regions[]`) e zonas (`zones[]`) para os recursos de um pipeline (`resources`).	locais permitidos (`allowedLocations`) para a política de local de recursos de um job (`locationPolicy`)	No Cloud Life Sciences, um pipeline é executado em uma única VM, para a qual você pode especificar as regiões e/ou zonas desejadas. No lote, a opção equivalente são os locais permitidos para um job, que podem ser definidos como uma ou mais regiões ou zonas e especificam onde as VMs de um job podem ser criadas. Todas as VMs de um único job em lote pertencem a um único grupo gerenciado de instâncias (MIG), que existe em uma região específica. No entanto, as VMs individuais podem estar em diferentes zonas dessa região. Especificar o campo de locais permitidos para uma vaga é opcional, porque ele é separado do local da vaga. Ao contrário do local do job, o local permitido não afeta o local usado para criar um job em lote e armazenar os metadados do job. Para mais informações, consulte Locais de lote.
para os recursos de um pipeline (`resources`): a VM (`virualMachine`)	para a política de recursos de um trabalho (`allocationPolicy`): as VMs (`instances`). conta de serviço (`serviceAccount`) rótulos (`labels` em `allocationPolicy`) rede (`network`)	No Cloud Life Sciences, é possível configurar a VM em que um pipeline é executado. No lote, as mesmas opções para VMs estão disponíveis nos campos da política de alocação de recursos de um job (`allocationPolicy`): A conta de serviço, os rótulos e a configuração de rede das VMs são definidos nos campos dedicados. O campo VM (`instances`), que pode ser definido diretamente ou usando um modelo de instância, inclui as opções de configuração para o tipo de máquina, a plataforma de CPU mínima permitida, o disco de inicialização e todos os outros discos conectados, além de GPUs e drivers de GPU.
para uma ação: rótulos (`labels` em `actions[]`) opção para o tempo limite (`timeout`). Opção para ignorar o status de saída (`ignoreExitStatus`). opção para executar em segundo plano (`runInBackground`) opção para sempre executar (`alwaysRun`)	para um executável: rótulos (`labels` em `runnables[]`) opção para o tempo limite (`timeout`). Opção para ignorar o status de saída (`ignoreExitStatus`). opção para executar em segundo plano (`background`) opção para sempre executar (`alwaysRun`)	Essas várias flags de conveniência do Cloud Life Sciences são equivalentes no lote, exceto que são especificadas para cada executável (que pode conter um script ou contêiner) em vez de cada ação (contêiner).
para uma ação: opção para publicar portas expostas (`publishExposedPorts`) opção para especificar o namespace do ID do processo (PID) (`pidNamespace`). e a opção de especificar mapeamentos de porta de contêiner para host (`portMappings`).	opções (`options`) para um executável de contêiner	Essas e outras opções do Cloud Life Sciences são compatíveis com o Batch pelo campo de opções (`options`) para um contêiner executável. Defina o campo de opções para qualquer flag que você quer que o lote adicione ao comando `docker run`, por exemplo, `-P --pid mynamespace -p 22:22`.
para uma ação: Opção para desativar o download antecipado de imagens de contêiner (`disableImagePrefetch`). opção para desativar o retorno do fluxo de erro padrão (`disableStandardErrorCapture`)	sem equivalente	Faz a precarga em lote de imagens e processa as saídas de todos os executáveis de maneira idêntica de acordo com a política de logs do job (`logsPolicy`).
opção de bloquear redes externas (`blockExternalNetwork`) para uma ação	opção para bloquear redes externas (`blockExternalNetwork`) para um contêiner executável	A opção do Cloud Life Sciences para bloquear redes externas em uma ação é semelhante à opção do Batch para bloquear redes externas em um contêiner. O lote também tem muitas outras opções de rede, como bloquear redes externas para todas as VMs de um job. Para mais informações, consulte Visão geral da rede de lotes.
montagens (`mounts[]`) para uma ação	Volumes para todos os executáveis (`volumes[]` em `taskSpec`) e opções de volume para um contêiner (`volumes[]` em `container`)	No lote, é possível usar o campo `volumes[]` em `taskSpec` para definir os volumes de um job e os caminhos de montagem. O Batch monta volumes de armazenamento nas VMs do job, e os volumes de armazenamento são acessíveis a todos os executáveis do job (scripts ou contêineres). Essa montagem é feita antes que a VM execute tarefas ou executáveis. Além disso, o Batch oferece suporte a opções de volume explícitas em executáveis de contêiner usando o campo `volumes[]` em `container`. Essas opções de montagem são transmitidas ao contêiner como opções para a flag `--volume` do comando `docker run`. Por exemplo, o valor `[ "/etc:/etc", "/foo:/bar" ]` é traduzido para o comando `docker run --volume /etc:/etc --volume /foo:/bar` no contêiner. Para mais informações sobre como usar volumes de armazenamento com o Batch, consulte Criar e executar um job que usa volumes de armazenamento.
opção para ativar o FUSE do Cloud Storage (`enableFuse`) para uma ação	sem equivalente	O Batch processa a montagem de volumes de armazenamento, como um bucket do Cloud Storage, especificados para um job. Como resultado, você não ativa nenhuma ferramenta de montagem, como o FUSE do Cloud Storage para o Batch. No entanto, é possível especificar opções de montagem para seus volumes de armazenamento usando o campo `mountOptions[]`. Para mais informações sobre como usar buckets do Cloud Storage com o Batch, consulte Criar e executar um job que usa volumes de armazenamento.
Tópico do Pub/Sub (`pubSubTopic`) para uma solicitação de execução de um pipeline	para as configurações de notificação de um job (`notifications[]`): Tópico do Pub/Sub (`pubSubTopic`) mensagens (`message`)	O lote permite uma maior personalização das atualizações de status do que o Cloud Life Sciences. Por exemplo, os usuários do Batch podem receber notificações em um tópico do Pub/Sub quando tarefas individuais mudam de estado ou apenas quando o job em geral muda de estado.

Serviços de fluxo de trabalho

Se você usa um serviço de fluxo de trabalho com o Cloud Life Sciences, o processo de migração também envolve a configuração de um serviço de fluxo de trabalho para funcionar com o Batch. Esta seção resume os serviços de fluxo de trabalho que podem ser usados com o Batch.

O lote oferece suporte a Fluxos de trabalho, que é um serviço de fluxo de trabalho do Google Cloud. Se você quiser usar o Workflows com o Batch, consulte Executar um job do Batch usando o Workflows. Caso contrário, a tabela a seguir descreve outros serviços de fluxos de trabalho que podem ser usados para o Cloud Life Sciences e também com o Batch. Esta tabela lista as principais diferenças entre o uso de cada serviço de fluxo de trabalho com o Batch em vez do Cloud Life Sciences e detalhes sobre onde aprender mais sobre o uso de cada serviço com o Batch.

Serviço de fluxo de trabalho	Principais diferenças	Detalhes
Cromwell	Para usar um arquivo de configuração do Cromwell para a API Cloud Life Sciences v2beta com a API Batch, faça as seguintes mudanças: No campo `actor-factory`, substitua `cromwell.backend.google.pipelines.v2beta.PipelinesApiLifecycleActorFactory` por `cromwell.backend.google.batch.GcpBatchLifecycleActorFactory`. Remova o campo `genomics.endpoint-url`. Gere um novo arquivo de configuração.	Para saber mais sobre como usar o Batch com o Cromwell, consulte a documentação do Cromwell para o Batch e o tutorial do Cromwell para o Batch.
dsub	Para usar um pipeline dsub para o Cloud Life Sciences com o Batch, faça as seguintes mudanças: No campo `provider`, substitua `google-cls-v2` por `google-batch`.	Para saber mais sobre como usar o Batch com o dsub, consulte a documentação do dsub para o Batch.
Nextflow	Para usar um arquivo de configuração do Nextflow para o Cloud Life Sciences com o Batch, faça as seguintes mudanças: No campo `executor`, substitua `google-lifesciences` por `google-batch`. Para todos os prefixos `config`, substitua `google.lifeScience` por `google.batch`.	Para saber mais sobre como usar o Batch com o Nextflow, consulte o tutorial do Batch ou o tutorial do Nextflow. Para mais informações sobre as opções de configuração, consulte a documentação do Nextflow.
Snakemake	Para usar um pipeline do Snakemake para a API v2beta do Cloud Life Sciences com a API Batch, faça as seguintes mudanças: Verifique se você está usando a versão 8 ou mais recente do Snakemake. Para mais informações, consulte Migração entre versões do Snakemake. Faça as seguintes mudanças no comando `snakemake`: Substitua a flag `--google-lifesciences` pela `--executor googlebatch`. Substitua todas as flags adicionais que tenham o prefixo `--google-lifesciences-` para usar o prefixo `--googlebatch-`.	Para saber mais sobre como usar o Batch com o Snakemake, consulte a documentação do Snakemake para o Batch.

A seguir

Para configurar o Batch para novos usuários e projetos, consulte Começar.
Para saber como executar cargas de trabalho usando o Batch, consulte Criar um job.