Guia de início rápido: use o .NET para criar um pool de lotes e executar um trabalho

Este início rápido mostra como começar a usar o Azure Batch executando uma aplicação C# que utiliza a API .NET do Azure Batch. O aplicativo .NET:

Carrega vários ficheiros de dados de entrada num contentor de blobs de armazenamento do Azure para usar no processamento de tarefas em lote.
Cria um pool de duas máquinas virtuais (VMs), ou nós de computação, executando o Windows Server.
Cria um trabalho que executa tarefas nos nós para processar cada arquivo de entrada usando uma linha de comando do Windows.
Exibe os ficheiros de saída que as tarefas retornam.

Depois de concluir este início rápido, você entende os principais conceitos do serviço Batch e está pronto para usar o Batch com cargas de trabalho mais realistas e de maior escala.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta gratuitamente.
Uma conta de lote com uma conta de Armazenamento do Azure vinculada. Você pode criar as contas usando qualquer um dos seguintes métodos: CLI do Azure | Azure portal | Bicep | modelo ARM Terraform | .
Visual Studio 2019 ou posterior, ou .NET 6.0 ou posterior, para Linux ou Windows.

Executar o aplicativo

Para concluir este início rápido, baixe ou clone o aplicativo, forneça os valores da sua conta, crie e execute o aplicativo e verifique a saída.

Baixe ou clone o aplicativo

Baixe ou clone o aplicativo Azure Batch .NET Quickstart do GitHub. Use o seguinte comando para clonar o repositório de aplicativos com um cliente Git:

git clone https://github.com/Azure-Samples/batch-dotnet-quickstart.git

Forneça as informações da sua conta

A aplicação precisa utilizar os nomes das contas de Processamento em Lote e Armazenamento, os valores das chaves de conta e o endpoint da conta de Processamento em Lote. Você pode obter essas informações do portal do Azure, APIs do Azure ou ferramentas de linha de comando.

Para obter as informações da sua conta a partir do portal do Azure:

Na barra de Pesquisa do Azure, procure e selecione o nome da sua conta de lote.

Conta de processamento em lote
Ponto final da conta
Nome da conta de armazenamento
ID da subscrição
Nome do grupo de recursos

Navegue até a pasta batch-dotnet-quickstart baixada e edite as cadeias de caracteres de credenciais no Program.cs para fornecer os valores copiados:

// Batch account credentials
const string BatchAccountName = "<batch account>";
const string BatchAccountUrl  = "<account endpoint>";

// Azure Resource Manager credentials for the Batch account
const string SubscriptionId    = "<subscription ID>";
const string ResourceGroupName = "<resource group name>";

// Storage account credentials
const string StorageAccountName = "<storage account name>";

Criar e executar o aplicativo e exibir a saída

Para ver o fluxo de trabalho em lote em ação, crie e execute o aplicativo no Visual Studio. Você também pode usar os comandos da linha de dotnet build e dotnet run.

No Visual Studio:

Abra o arquivo BatchDotNetQuickstart.sln , clique com o botão direito do mouse na solução no Gerenciador de Soluções e selecione Compilar. Se solicitado, use o Gerenciador de Pacotes NuGet para atualizar ou restaurar pacotes NuGet.
Quando a compilação for concluída, selecione BatchDotNetQuickstart na barra de menu superior para executar o aplicativo.

O tempo de execução típico com a configuração padrão é de aproximadamente cinco minutos. A configuração inicial do nó do pool é a que leva mais tempo. Para executar novamente o trabalho, exclua-o da execução anterior, mas não exclua o pool. Em um pool pré-configurado, o trabalho é concluído em poucos segundos.

O aplicativo retorna uma saída semelhante ao exemplo a seguir:

Sample start: 11/16/2022 4:02:54 PM

Container [input] created.
Uploading file taskdata0.txt to container [input]...
Uploading file taskdata1.txt to container [input]...
Uploading file taskdata2.txt to container [input]...
Creating pool [DotNetQuickstartPool]...
Creating job [DotNetQuickstartJob]...
Adding 3 tasks to job [DotNetQuickstartJob]...
Monitoring all tasks for 'Completed' state, timeout in 00:30:00...

Há uma pausa em Monitoring all tasks for 'Completed' state, timeout in 00:30:00... enquanto os nós de computação do pool são iniciados. À medida que as tarefas são criadas, o Batch as enfileira para serem executadas no pool. Assim que o primeiro nó de computação estiver disponível, a primeira tarefa será executada no nó. Você pode monitorar o estado do nó, da tarefa e do trabalho na página da sua conta do Batch no portal do Azure.

Após a conclusão de cada tarefa, você verá uma saída semelhante ao exemplo a seguir:

Printing task output.
Task: Task0
Node: tvm-2850684224_3-20171205t000401z
Standard out:
Batch processing began with mainframe computers and punch cards. Today it still plays a central role...
stderr:
...

Reveja o código

Revise o código para entender as etapas no Guia de início rápido do Azure Batch .NET.

Criar clientes de serviço e carregar arquivos de recursos

Para interagir com a conta de armazenamento, a aplicação utiliza a biblioteca de cliente Armazenamento do Azure Blobs para .NET para criar um BlobServiceClient.

string blobUri = "https://" + storageAccountName + ".blob.core.windows.net";

var blobServiceClient = new BlobServiceClient(new Uri(blobUri), new DefaultAzureCredential());
return blobServiceClient;

O aplicativo usa a blobServiceClient referência para criar um contêiner na conta de armazenamento e carregar arquivos de dados para o contêiner. Os arquivos em armazenamento são definidos como objetos Batch ResourceFile que Batch pode baixar posteriormente para os nós de computação.
```
List<string> inputFilePaths = new()
{
    "taskdata0.txt",
    "taskdata1.txt",
    "taskdata2.txt"
};

var inputFiles = new List<ResourceFile>();

foreach (var filePath in inputFilePaths)
{
    inputFiles.Add(UploadFileToContainer(containerClient, inputContainerName, filePath));
}
```
A aplicação cria um objeto BatchClient a partir do Azure. Compute.Batch biblioteca para criar e gerir trabalhos e tarefas em lote. O cliente Batch utiliza autenticação Microsoft Entra.
```
BatchClient batchClient = new BatchClient(new Uri(BatchAccountUrl), new DefaultAzureCredential());
...
```

A aplicação também utiliza a biblioteca Azure.ResourceManager.Batch para gerir a conta do Batch e os respetivos conjuntos. Cria um ArmClient e obtém uma referência BatchAccountResource para a conta Batch usando o ID de subscrição, nome do grupo de recursos e nome da conta Batch.

ArmClient armClient = new ArmClient(new DefaultAzureCredential());

ResourceIdentifier batchAccountIdentifier = BatchAccountResource.CreateResourceIdentifier(
    SubscriptionId,
    ResourceGroupName,
    BatchAccountName);

BatchAccountResource batchAccount = armClient.GetBatchAccountResource(batchAccountIdentifier);

Criar um conjunto de nós de computação

Para criar um pool Batch, a aplicação utiliza o método BatchAccountPoolCollection.CreateOrUpdateAsync para definir o número de nós, o tamanho da VM e a configuração do pool. O objeto seguinte BatchVmConfiguration especifica um BatchImageReference para uma imagem Windows Server Marketplace. O Batch suporta uma ampla gama de imagens do sistema operacional Windows Server e Linux Marketplace e também suporta imagens de VM personalizadas.

O tamanho PoolNodeCount e VM PoolVMSize são constantes definidas. O aplicativo cria um pool de dois nós Standard_A1_v2. Este tamanho oferece um bom equilíbrio entre desempenho e custo para este início rápido.

BatchImageReference imageReference = new BatchImageReference()
{
    Publisher = "MicrosoftWindowsServer",
    Offer = "WindowsServer",
    Sku = "2016-datacenter-smalldisk",
    Version = "latest"
};

BatchVmConfiguration vmConfiguration = new BatchVmConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.windows amd64");

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = PoolVMSize,
    DeploymentConfiguration = new BatchDeploymentConfiguration() { VmConfiguration = vmConfiguration },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        FixedScale = new BatchAccountFixedScaleSettings() { TargetDedicatedNodes = PoolNodeCount }
    }
};

await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, PoolId, poolData);

Criar um trabalho em lote

Um trabalho em lote é um agrupamento lógico de uma ou mais tarefas. O trabalho inclui configurações comuns às tarefas, como prioridade e o pool no qual executar tarefas.

A aplicação usa BatchClient.CreateJobAsync para criar um trabalho no seu pool. Inicialmente o trabalho não tem tarefas.

BatchJobCreateOptions job = new BatchJobCreateOptions(JobId, new BatchPoolInfo() { PoolId = PoolId });
await batchClient.CreateJobAsync(job);

Criar tarefas

O Batch fornece várias maneiras de implantar aplicativos e scripts em nós de computação. Esta aplicação cria uma lista de objetos de entrada ResourceFile. Cada tarefa processa um arquivo de entrada usando uma propriedade CommandLine . A linha de comando Lote é onde você especifica seu aplicativo ou script.

A linha de comando no código a seguir executa o comando do Windows type para exibir os arquivos de entrada. Depois, a aplicação adiciona as tarefas ao trabalho com o BatchClient.CreateTasksAsync, que coloca as tarefas em fila para serem executadas nos nós de computação.

for (int i = 0; i < inputFiles.Count; i++)
{
    string taskId = String.Format("Task{0}", i);
    string inputFilename = inputFiles[i].FilePath;
    string taskCommandLine = String.Format("cmd /c type {0}", inputFilename);

    BatchTaskCreateOptions task = new BatchTaskCreateOptions(taskId, taskCommandLine)
    {
        ResourceFiles = { inputFiles[i] }
    };
    tasks.Add(task);
}

await batchClient.CreateTasksAsync(JobId, tasks);

Ver resultado das tarefas

A aplicação espera que as tarefas sejam concluídas. Quando cada tarefa é executada com êxito, sua saída grava emstdout.txt. A aplicação utiliza depois a propriedade BatchTask.NodeInfo para mostrar o ficheiro stdout.txt de cada tarefa concluída.

await foreach (BatchTask task in batchClient.GetTasksAsync(JobId))
{
    string nodeId = task.NodeInfo?.NodeId ?? "<unknown>";
    Console.WriteLine("Task: {0}", task.Id);
    Console.WriteLine("Node: {0}", nodeId);
    Console.WriteLine("Standard out:");
    BinaryData stdout = await batchClient.GetTaskFileAsync(JobId, task.Id, "stdout.txt");
    Console.WriteLine(stdout.ToString());
}

Limpeza de recursos

A aplicação elimina automaticamente o contentor de armazenamento que cria e oferece a opção de eliminar o pool de Batch e o trabalho. Pools e nós acumulam custos enquanto os nós estão ativos, mesmo que não estejam a executar trabalhos. Se você não precisar mais do pool, exclua-o.

Quando você não precisar mais de sua conta de lote e conta de armazenamento, poderá excluir o grupo de recursos que as contém. No portal do Azure, selecione Excluir grupo de recursos na parte superior da página do grupo de recursos. No ecrã "Eliminar um grupo de recursos", introduza o nome do grupo de recursos e, em seguida, selecione "Eliminar".

Próximos passos

Neste início rápido, executaste uma aplicação que utiliza a API .NET Batch para criar um pool Batch, nós, um trabalho e tarefas. O trabalho carregou ficheiros de recursos num contentor de armazenamento, executou tarefas nos nós e exibiu o resultado dos nós.

Agora que você entende os principais conceitos do serviço Batch, está pronto para usar o Batch com cargas de trabalho mais realistas e de maior escala. Para saber mais sobre o Azure Batch e percorrer uma carga de trabalho paralela com um aplicativo do mundo real, continue para o tutorial do Batch .NET.

Processar uma carga de trabalho paralela com o .NET

Comentários

Esta página foi útil?

Last updated on 2026-05-19