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: Azure CLI | 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.
Na página da conta Batch, selecione Chaves no menu da esquerda.
Na página Chaves, copie os seguintes valores:

Conta de processamento em lote
Ponto final da conta
Chave de acesso primária
Nome da conta de armazenamento
Chave1

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
private const string BatchAccountName = "<batch account>";
private const string BatchAccountKey  = "<primary access key>";
private const string BatchAccountUrl  = "<account endpoint>";

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

Importante

A exposição de chaves de conta na origem do aplicativo não é recomendada para uso em Produção. Você deve restringir o acesso às credenciais e consultá-las em seu código usando variáveis ou um arquivo de configuração. É melhor armazenar chaves de conta de lote e armazenamento no Cofre de Chaves do Azure.

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 Azure Storage Blobs para .NET para criar um BlobServiceClient.

var sharedKeyCredential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
string blobUri = "https://" + storageAccountName + ".blob.core.windows.net";

var blobServiceClient = new BlobServiceClient(new Uri(blobUri), sharedKeyCredential);
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));
}
```
O aplicativo cria um objeto BatchClient para criar e gerenciar pools de lotes, trabalhos e tarefas. O cliente Batch usa autenticação de chave compartilhada. O Batch também suporta a autenticação Microsoft Entra.
```
var cred = new BatchSharedKeyCredentials(BatchAccountUrl, BatchAccountName, BatchAccountKey);

 using BatchClient batchClient = BatchClient.Open(cred);
...
```

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

Para criar um pool de lotes, o aplicativo usa o método BatchClient.PoolOperations.CreatePool para definir o número de nós, o tamanho da VM e a configuração do pool. O seguinte objeto VirtualMachineConfiguration especifica um ImageReference para uma imagem do 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.

O método Commit envia o pool para o serviço Batch.


private static VirtualMachineConfiguration CreateVirtualMachineConfiguration(ImageReference imageReference)
{
    return new VirtualMachineConfiguration(
        imageReference: imageReference,
        nodeAgentSkuId: "batch.node.windows amd64");
}

private static ImageReference CreateImageReference()
{
    return new ImageReference(
        publisher: "MicrosoftWindowsServer",
        offer: "WindowsServer",
        sku: "2016-datacenter-smalldisk",
        version: "latest");
}

private static void CreateBatchPool(BatchClient batchClient, VirtualMachineConfiguration vmConfiguration)
{
    try
    {
        CloudPool pool = batchClient.PoolOperations.CreatePool(
            poolId: PoolId,
            targetDedicatedComputeNodes: PoolNodeCount,
            virtualMachineSize: PoolVMSize,
            virtualMachineConfiguration: vmConfiguration);

        pool.Commit();
    }
...

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 o método BatchClient.JobOperations.CreateJob para criar uma tarefa no seu pool. O método Commit envia o trabalho para o serviço Batch. Inicialmente o trabalho não tem tarefas.

try
{
    CloudJob job = batchClient.JobOperations.CreateJob();
    job.Id = JobId;
    job.PoolInformation = new PoolInformation { PoolId = PoolId };

    job.Commit();
}
...

Criar tarefas

O Batch fornece várias maneiras de implantar aplicativos e scripts em nós de computação. Este aplicativo cria uma lista de objetos de entrada do 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. Em seguida, o aplicativo adiciona cada tarefa ao trabalho com o método AddTask , que enfileira a tarefa para ser executada 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);

    var task = new CloudTask(taskId, taskCommandLine)
    {
        ResourceFiles = new List<ResourceFile> { inputFiles[i] }
    };
    tasks.Add(task);
}

batchClient.JobOperations.AddTask(JobId, tasks);

Ver resultado das tarefas

O aplicativo cria um TaskStateMonitor para monitorar as tarefas e garantir que elas sejam concluídas. Quando cada tarefa é executada com êxito, sua saída grava emstdout.txt. Em seguida, o aplicativo usa a propriedade CloudTask.ComputeNodeInformation para exibir o arquivo stdout.txt para cada tarefa concluída.

foreach (CloudTask task in completedtasks)
{
    string nodeId = String.Format(task.ComputeNodeInformation.ComputeNodeId);
    Console.WriteLine("Task: {0}", task.Id);
    Console.WriteLine("Node: {0}", nodeId);
    Console.WriteLine("Standard out:");
    Console.WriteLine(task.GetNodeFile(Constants.StandardOutFileName).ReadAsString());
}

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

Feedback

Esta página foi útil?

Last updated on 2025-04-08