Usar o Azure Pipelines para criar e implantar uma solução HPC

2025-04-04

As ferramentas de DevOps do Azure podem automatizar a criação e o teste de soluções de computação de alto desempenho (HPC) do Azure Batch. O Azure Pipelines fornece modernos processos de integração contínua (CI) e implantação contínua (CD) para criar, implantar, testar e monitorar software. Esses processos aceleram a entrega do software, permitindo que você se concentre no código em vez de dar suporte à infraestrutura e às operações.

Este artigo mostra como configurar processos de CI/CD usando o Azure Pipelines com modelos do Azure Resource Manager (modelos ARM) para implantar soluções HPC no Azure Batch. O exemplo cria um pipeline de compilação e liberação para implantar uma infraestrutura de Lote do Azure e liberar um pacote de aplicativo. O diagrama a seguir mostra o fluxo geral de implantação, supondo que o código seja desenvolvido localmente:

Diagrama mostrando o fluxo de implantação no pipeline.

Pré-requisitos

Para seguir as etapas neste artigo, você precisa:

Uma organização do Azure DevOps e um projeto do Azure DevOps com um repositório do Azure Repos criado na organização. Você deve ter as funções de Administrador de Projeto, Administrador de Criação e Administrador de Liberação no projeto do Azure DevOps.
Uma assinatura ativa do Azure com Proprietário ou outra função que inclua habilidades de atribuição de função. Para obter mais informações, consulte Compreender as atribuições de função do Azure.
Uma compreensão básica do controle do código-fonte e da sintaxe do modelo ARM.

Preparar a solução

O exemplo neste artigo usa vários modelos ARM e um aplicativo de processamento de vídeo de código aberto existente, FFmpeg. Você pode copiar ou baixar esses recursos e enviá-los por push para o repositório do Azure Repos.

Importante

Este exemplo implanta software Windows em nós de lote baseados em Windows. Os Pipelines do Azure, os modelos ARM e o Batch também suportam totalmente o software e os nós Linux.

Compreender os modelos ARM

Três modelos de capacidade, semelhantes a unidades ou módulos, implementam partes específicas de funcionalidade. Em seguida, um modelo de solução de ponta a ponta implanta os modelos de capacidade subjacentes. Essa estrutura de modelo vinculado permite que cada modelo de capacidade seja testado individualmente e reutilizado em todas as soluções.

Diagrama mostrando uma estrutura de modelo vinculado usando modelos ARM.

Para obter informações detalhadas sobre os modelos, consulte o guia de referência de modelo do Gerenciador de Recursos para tipos de recursos Microsoft.Batch.

Modelo de conta de armazenamento

Salve o código a seguir como um arquivo chamado storageAccount.json. Este modelo define uma conta de Armazenamento do Azure, que é necessária para implantar o aplicativo na conta de lote.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "accountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Storage Account"
             }
         }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Storage/storageAccounts",
            "name": "[parameters('accountName')]",
            "sku": {
                "name": "Standard_LRS"
            },
            "apiVersion": "2018-02-01",
            "location": "[resourceGroup().location]",
            "properties": {}
        }
    ],
    "outputs": {
        "blobEndpoint": {
          "type": "string",
          "value": "[reference(resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))).primaryEndpoints.blob]"
        },
        "resourceId": {
          "type": "string",
          "value": "[resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))]"
        }
    }
}

Modelo de conta em lote

Salve o código a seguir como um arquivo chamado batchAccount.json. Este modelo define uma conta Batch. A conta Batch atua como uma plataforma para executar aplicativos em pools de nós.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "batchAccountName": {
           "type": "string",
           "metadata": {
                "description": "Name of the Azure Batch Account"
            }
        },
        "storageAccountId": {
           "type": "string",
           "metadata": {
                "description": "ID of the Azure Storage Account"
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "name": "[parameters('batchAccountName')]",
            "type": "Microsoft.Batch/batchAccounts",
            "apiVersion": "2017-09-01",
            "location": "[resourceGroup().location]",
            "properties": {
              "poolAllocationMode": "BatchService",
              "autoStorage": {
                  "storageAccountId": "[parameters('storageAccountId')]"
              }
            }
          }
    ],
    "outputs": {}
}

Modelo de agrupamento de lotes

Salve o código a seguir como um arquivo chamado batchAccountPool.json. Este template cria um pool de nós de computação e nós na conta Batch.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "batchAccountName": {
           "type": "string",
           "metadata": {
                "description": "Name of the Azure Batch Account"
           }
        },
        "batchAccountPoolName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Batch Account Pool"
             }
         }
    },
    "variables": {},
    "resources": [
        {
            "name": "[concat(parameters('batchAccountName'),'/', parameters('batchAccountPoolName'))]",
            "type": "Microsoft.Batch/batchAccounts/pools",
            "apiVersion": "2017-09-01",
            "properties": {
                "deploymentConfiguration": {
                    "virtualMachineConfiguration": {
                        "imageReference": {
                            "publisher": "MicrosoftWindowsServer",
                            "offer": "WindowsServer",
                            "sku": "2022-datacenter",
                            "version": "latest"
                        },
                        "nodeAgentSkuId": "batch.node.windows amd64"
                    }
                },
                "vmSize": "Standard_D2s_v3"
            }
          }
    ],
    "outputs": {}
}

Modelo de orquestrador

Salve o código a seguir como um arquivo chamado deployment.json. Este modelo final atua como um orquestrador para implantar os três modelos de capacidade subjacentes.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "StorageContainerUri": {
           "type": "string",
           "metadata": {
                "description": "URI of the Blob Storage Container containing the Azure Resource Manager templates"
            }
        },
        "StorageContainerSasToken": {
           "type": "string",
           "metadata": {
                "description": "The SAS token of the container containing the Azure Resource Manager templates"
            }
        },
        "applicationStorageAccountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Storage Account"
            }
         },
        "batchAccountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Batch Account"
            }
         },
         "batchAccountPoolName": {
             "type": "string",
             "metadata": {
                  "description": "Name of the Azure Batch Account Pool"
              }
          }
    },
    "variables": {},
    "resources": [
        {
            "apiVersion": "2017-05-10",
            "name": "storageAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/storageAccount.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "accountName": {"value": "[parameters('applicationStorageAccountName')]"}
                }
            }
        },
        {
            "apiVersion": "2017-05-10",
            "name": "batchAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "dependsOn": [
                "storageAccountDeployment"
            ],
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccount.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "batchAccountName": {"value": "[parameters('batchAccountName')]"},
                    "storageAccountId": {"value": "[reference('storageAccountDeployment').outputs.resourceId.value]"}
                }
            }
        },
        {
            "apiVersion": "2017-05-10",
            "name": "poolDeployment",
            "type": "Microsoft.Resources/deployments",
            "dependsOn": [
                "batchAccountDeployment"
            ],
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccountPool.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "batchAccountName": {"value": "[parameters('batchAccountName')]"},
                    "batchAccountPoolName": {"value": "[parameters('batchAccountPoolName')]"}
                }
            }
        }
    ],
    "outputs": {}
}

Configurar o repositório

Carregue os modelos ARM, o aplicativo FFmpeg e um arquivo de definição de compilação YAML em seu repositório do Azure Repos.

Carregue os quatro modelos ARM para uma pasta arm-templates no repositório.
Para o pacote de aplicativos, baixe e extraia a versão Windows de 64 bits do FFmpeg 4.3.1 e carregue-a para uma pasta de aplicativos hpc em seu repositório.

Para a definição de compilação, salve a seguinte definição como um arquivo chamado hpc-app.build.yml e carregue-a para uma pasta de pipelines em seu repositório.

# To publish an application into Batch, you need to
# first zip the file, and then publish an artifact, so
# you can take the necessary steps in your release pipeline.
steps:
# First, zip up the files required in the Batch account.
# For this instance, those are the ffmpeg files.
- task: ArchiveFiles@2
  displayName: 'Archive applications'
  inputs:
    rootFolderOrFile: hpc-application
    includeRootFolder: false
    archiveFile: '$(Build.ArtifactStagingDirectory)/package/$(Build.BuildId).zip'
# Publish the zip file, so you can use it as part
# of your Release pipeline later.
- task: PublishPipelineArtifact@0
  inputs:
    artifactName: 'hpc-application'
    targetPath: '$(Build.ArtifactStagingDirectory)/package'

Quando terminar de configurar o repositório, a estrutura de pastas deverá ter as seguintes seções principais:

Uma pasta arm-templates que contém os modelos ARM.
Uma pasta hpc-application que contém ffmpeg.
Uma pasta pipelines que contém o ficheiro de definição YAML para o pipeline de Build.

Captura de tela da estrutura do repositório.

Observação

Este exemplo de estrutura de base de código demonstra que você pode armazenar código de aplicativo, infraestrutura e pipeline no mesmo repositório.

Criar o pipeline do Azure

Depois de configurar o repositório de código-fonte, use o Azure Pipelines para implementar um pipeline de compilação, teste e implantação para seu aplicativo. Neste estágio de um pipeline, você normalmente executa testes para validar o código e criar partes do software. O número e os tipos de testes, bem como quaisquer outras tarefas executadas, dependem da sua estratégia geral de compilação e lançamento.

Criar o pipeline de compilação de software

Nesta seção, você cria um pipeline de construção YAML para trabalhar com o software ffmpeg que é executado na conta Batch.

No seu projeto do Azure DevOps, selecione Pipelines na navegação à esquerda e, em seguida, selecione Novo pipeline.
Na tela Onde está seu código , selecione Azure Repos Git.
Na tela Selecione um repositório , selecione seu repositório.

Observação

Você também pode criar um pipeline de build utilizando um designer visual. Na página Novo pipeline, selecione Usar o editor clássico. Você pode usar um modelo YAML no designer visual. Para obter mais informações, consulte Definir o seu pipeline clássico.
No ecrã Configurar o seu pipeline, selecione Ficheiro YAML Existente do Azure Pipelines.
Na tela Selecione um arquivo YAML existente , selecione o arquivo hpc-app.build.yml no repositório e selecione Continuar.
No ecrã Revisar o YAML do pipeline, reveja a configuração de compilação e selecione Executar, ou selecione a seta de menu ao lado de Executar e selecione Salvar. Esse modelo permite a integração contínua, de modo que a compilação é acionada automaticamente quando uma nova confirmação no repositório atende às condições definidas na compilação.
Você pode ver atualizações ao vivo do progresso da compilação. Para ver os resultados da compilação, selecione a execução apropriada na sua definição de compilação no Azure Pipelines.

Observação

Se você usar um aplicativo cliente para executar sua solução HPC, precisará criar uma definição de compilação separada para esse aplicativo. Para obter guias de instruções, consulte a documentação do Azure Pipelines .

Criar o pipeline de lançamento

Você usa um pipeline do Azure Pipelines Release para implantar seu aplicativo e a infraestrutura subjacente. Os pipelines de liberação habilitam o CD e automatizam seu processo de lançamento. Há várias etapas para implantar seu aplicativo e a infraestrutura subjacente.

Os modelos vinculados para esta solução devem ser acessíveis a partir de um endpoint HTTP ou HTTPS público. Este endpoint pode ser um repositório GitHub, uma conta Azure Blob Storage ou outro local de armazenamento. Para garantir que os artefatos de modelo carregados permaneçam seguros, mantenha-os em um modo privado, mas acesse-os usando alguma forma de token de assinatura de acesso compartilhado (SAS).

O exemplo a seguir demonstra como implantar uma infraestrutura e um aplicativo usando modelos de um blob de Armazenamento do Azure.

Configurar o pipeline

Em seu projeto de DevOps do Azure, selecione Pipelines>Releases na navegação à esquerda.
Na próxima tela, selecione Novo>pipeline de lançamento.
No ecrã Selecione um modelo, selecione Tarefa vazia e feche o ecrã Etapa.
Selecione Novo pipeline de lançamento na parte superior da página e renomeie o pipeline para algo relevante para o seu pipeline, como Implementar Azure Batch + Pool.
Na seção Artefatos , selecione Adicionar.
No ecrã Adicionar um artefacto, selecione Compilação e, em seguida, selecione o seu pipeline de Compilação para obter a saída para a aplicação HPC.

Observação

Você pode criar um alias de origem ou aceitar o padrão. Anote o valor do alias de origem , pois você precisa dele para criar tarefas na definição de versão.
Selecione Adicionar.
Na página de pipeline, selecione Adicionar ao lado de Artefatos para criar um link para outro artefato, que é o seu repositório no Azure Repos. Este link é necessário para acessar os modelos ARM em seu repositório. Os modelos ARM não precisam de compilação, portanto, você não precisa enviá-los por um pipeline de compilação.

Observação

Observe novamente o valor do alias de origem a ser usado mais tarde.

Selecione a guia Variáveis . Crie as seguintes variáveis em seu pipeline para não precisar reinserir as mesmas informações em várias tarefas.

Nome	Valor
applicationStorageAccountName	Nome da conta de armazenamento para armazenar os binários do aplicativo HPC.
batchAccountApplicationName	Nome do aplicativo na conta Batch.
batchAccountName	Nome da conta Batch.
batchAccountPoolName	Nome para o pool de máquinas virtuais (VMs) para fazer o processamento.
batchApplicationId	Identificador exclusivo para a aplicação Batch, no formato: `/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^` `/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^` `/applications/<batchAccountApplicationName>`. Substitua o marcador de posição `<subscriptionId>` pela sua ID de subscrição Azure e os outros marcadores de posição pelos valores definidos para as outras variáveis nesta lista.
batchApplicationVersion	Versão semântica do seu aplicativo Batch, neste caso 4.3.1.
localização	Região do Azure para os recursos a serem implementados.
resourceGroupName	Nome do grupo de recursos no qual implantar recursos.
storageAccountName	Nome da conta de armazenamento para armazenar os modelos ARM vinculados.
StorageContainerSasToken	`$(<referenceName>.StorageContainerSasToken)`. Substitua o espaço reservado `<referenceName` pelo valor Nome de referência que você configura na seção Variáveis de Saída da seguinte etapa de Cópia de Arquivo do Azure .
URI do Contentor de Armazenamento	`$(<referenceName>.StorageContainerUri)`. Substitua o espaço reservado `<referenceName>` pelo valor Nome de referência que você configura na seção Variáveis de Saída da etapa Cópia de Arquivo do Azure.

Captura de tela mostrando variáveis definidas para a versão do Azure Pipelines.

Selecione a guia Tarefas e, em seguida, selecione Trabalho do agente.
Na tela Trabalho do Agente , em Pool de agentes, selecione Pipelines do Azure.
Em Especificação do agente, selecione windows-latest.

Adicionar tarefas

Crie seis tarefas para:

Baixe os arquivos ffmpeg compactados.
Implemente uma conta de armazenamento para alojar os modelos ARM aninhados.
Copie os modelos ARM para a conta de armazenamento.
Implemente a conta de Batch e as dependências necessárias.
Crie um aplicativo na conta Batch.
Carregue o pacote do aplicativo para a conta Batch.

Para cada nova tarefa especificada pelas etapas a seguir:

Selecione o + símbolo ao lado de Trabalho do agente no painel esquerdo.
Procure e selecione a tarefa especificada no painel direito.
Adicione ou selecione as propriedades para configurar a tarefa.
Selecione Adicionar.

Crie as tarefas da seguinte maneira:

Selecione a tarefa Descarregar Artefactos da Pipeline e defina as seguintes propriedades:
- Nome para exibição: insira Baixar Pacote de Aplicação para Agente.
- Nome do artefato: digite hpc-application.
- Diretório de destino: Digite $(System.DefaultWorkingDirectory).
Crie uma conta de Armazenamento do Azure para armazenar seus modelos ARM. Você pode usar uma conta de armazenamento existente, mas para dar suporte a esse exemplo autônomo e isolamento de conteúdo, crie uma conta de armazenamento dedicada.

Selecione a tarefa Implantação do modelo ARM: escopo do Grupo de Recursos e defina as seguintes propriedades:
- Nome para exibição: Insira Implantar conta de armazenamento para modelos ARM.
- Conexão do Azure Resource Manager: selecione a assinatura apropriada do Azure.
- Subscrição: Selecione a assinatura apropriada do Azure.
- Ação: Selecione Criar ou atualizar grupo de recursos.
- Grupo de recursos: Digite $(resourceGroupName).
- Localização: Digite $(location).
- Modelo: Digite $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Substitua o espaço reservado <AzureRepoArtifactSourceAlias> pelo alias de origem do repositório que você anotou anteriormente.
- Substituir parâmetros do modelo: insira -accountName $(storageAccountName).
Carregue os artefatos do controle do código-fonte para a conta de armazenamento. Parte desta tarefa de Cópia de Arquivo do Azure gera o URI do contêiner de armazenamento e o token SAS para uma variável, para que possam ser reutilizados em etapas posteriores.

Selecione a tarefa Cópia de Arquivo do Azure e defina as seguintes propriedades:
- Nome para exibição: Insira AzureBlob File Copy.
- Fonte: Digite $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Substitua o espaço reservado <AzureRepoArtifactSourceAlias> pelo alias de origem do repositório que você anotou anteriormente.
- Subscrição do Azure: Selecione a assinatura apropriada do Azure.
- Tipo de destino: Selecione Azure Blob.
- Conta de armazenamento RM: Digite $(storageAccountName).
- Nome do contêiner: insira os modelos.
- Nome de referência: expanda Variáveis de saída e insira ffmpeg.
Observação

Se esta etapa falhar, verifique se sua organização do Azure DevOps tem a função de Colaborador de Blob de Armazenamento na conta de armazenamento.
Implante o modelo ARM do orchestrator para criar a conta e o pool do Batch. Este modelo inclui parâmetros para o URI do contêiner de conta de armazenamento e o token SAS. As variáveis necessárias no modelo ARM são mantidas na seção variáveis da definição de versão e foram definidas a partir da tarefa AzureBlob File Copy.

Selecione a tarefa Implantação do modelo ARM: escopo do Grupo de Recursos e defina as seguintes propriedades:
- Nome para exibição: Introduza Deploy Azure Batch.
- Conexão do Azure Resource Manager: Selecione a assinatura apropriada do Azure.
- Subscrição: Selecione a assinatura apropriada do Azure.
- Ação: Selecione Criar ou atualizar grupo de recursos.
- Grupo de recursos: Digite $(resourceGroupName).
- Localização: Digite $(location).
- Local do modelo: selecione o URL do arquivo.
- Link do modelo: Digite $(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken).
- Substituir parâmetros do modelo: insira -StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Uma prática comum é usar tarefas do Azure Key Vault. Se a entidade de serviço conectada à sua assinatura do Azure tiver um conjunto de políticas de acesso apropriado, ela poderá baixar segredos do Cofre da Chave e ser usada como uma variável em seu pipeline. O nome do segredo é definido com o valor associado. Por exemplo, você pode fazer referência a um segredo de sshPassword com $(sshPassword) na definição de versão.
Chame a CLI do Azure para criar uma aplicação no Azure Batch.

Selecione a tarefa CLI do Azure e defina as seguintes propriedades:
- Nome de exibição: Insira Criar aplicação na conta do Azure Batch.
- Conexão do Azure Resource Manager: Selecione a assinatura apropriada do Azure.
- Tipo de script: Selecione PowerShell Core.
- Local do script: Selecione Script embutido.
- Script Inline: insira az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Chame a CLI do Azure para carregar pacotes associados ao aplicativo, neste caso os arquivos ffmpeg.

Selecione a tarefa CLI do Azure e defina as seguintes propriedades:
- Nome para exibição: Insira Carregar pacote para a conta do Azure Batch.
- Conexão do Azure Resource Manager: Selecione a assinatura apropriada do Azure.
- Tipo de script: Selecione PowerShell Core.
- Local do script: Selecione Script embutido.
- Script Inline: insira az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Substitua o marcador de posição <AzureBuildArtifactSourceAlias> pelo alias Build Source que anotaste anteriormente.
Observação

O número da versão do pacote do aplicativo é definido como uma variável. A variável permite substituir versões anteriores do pacote e permite controlar manualmente a versão do pacote enviada por push para o Azure Batch.

Criar e executar o lançamento

Quando terminar de criar todas as etapas, selecione Salvar na parte superior da página do pipeline e, em seguida, selecione OK.
Selecione Criar versão na parte superior da página.
Para ver o status da versão ao vivo, selecione o link na parte superior da página que diz que a versão foi criada.
Para exibir a saída de log do agente, coloque o cursor sobre a fase e selecione o botão Logs.

Testar o ambiente

Depois que o ambiente estiver configurado, confirme se os testes a seguir são executados com êxito. Substitua os marcadores de posição pelos valores do grupo de recursos e da conta Batch.

Conectar-se à conta do Batch

Conecte-se à nova conta Batch usando a CLI do Azure na linha de comandos.

Inicie sessão na sua conta do Azure com az login e siga as instruções para autenticar.
Autentique a conta Batch com az batch account login -g <resourceGroup> -n <batchAccount>.

Listar os aplicativos disponíveis

az batch application list -g <resourceGroup> -n <batchAccount>

Verifique se a piscina é válida

az batch pool list

Na saída do comando, observe o valor de currentDedicatedNodes a ser ajustado no próximo teste.

Redimensionar a piscina

Execute o comando a seguir para redimensionar o pool de forma a que haja nodos de computação disponíveis para testes de trabalho e tarefa. Substitua o marcador <poolName> pelo valor do nome do pool e o marcador <targetNumber> por um número maior do que o currentDedicatedNodes da saída do comando anterior. Verifique o status executando o az batch pool list comando até que o redimensionamento seja concluído e mostre o número de nós de destino.

az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>

Próximos passos

Veja estes tutoriais para saber como interagir com uma conta Batch através de uma aplicação simples.