Exercício – criar um pool de nós de computação para executar nossos trabalhos

Concluído

Para executar um trabalho do Lote, precisamos adicionar um pool à nossa conta do Lote. Um pool contém nós de computação, que são os mecanismos que executam o trabalho do Lote. Você especifica o número, tamanho e sistema operacional dos nós no momento da criação. Neste exercício, você modificará o aplicativo de console que criou no exercício anterior para adicionar um pool à sua conta do Lote.

Sua empresa deseja controlar os custos do aplicativo e solicitou que você use um número fixo de nós.

Importante

É preciso ter uma assinatura do Azure para fazer esse exercício, e isso pode gerar encargos. Caso ainda não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar.

Adicionar configurações para seu novo pool

1. No Cloud Shell, edite o arquivo Program.cs no editor:

   code Program.cs
   

2. Adicione as seguintes propriedades à classe Program em Program.cs:

   private const string PoolId = "WinFFmpegPool";
   private const int DedicatedNodeCount = 0;
   private const int LowPriorityNodeCount = 3;
   private const string PoolVMSize = "STANDARD_D2_v2";
   private const string appPackageId = "ffmpeg";
   private const string appPackageVersion = "3.4";
   

   As configurações acima serão usadas no código para criar o pool. Observando cada variável, podemos explicá-las desta maneira:

   • PoolId: O nome que nosso código usa para referenciar o pool de outras chamadas de cliente do Lote.
   • LowPriorityNodeCount: Você criará um pool com três VMs (máquinas virtuais) de baixa prioridade.
   • PoolVMSize: As VMs serão STANDARD_A1_v2, o que fornece aos nós 1 CPU, 2 GB de RAM e 10 GB de armazenamento SSD.
   • appPackageId: O nome do pacote do aplicativos a ser usado naqueles nós que você criar.
   • appPackageVersion: A versão do aplicativo a ser usado nos nós que você criar.

Atualizar o método Main() para dar suporte a chamadas assíncronas

Tornaremos várias chamadas para serviços de nuvem assíncronas, portanto, a primeira coisa a fazer é tornar Main assíncrono. Com o .NET do C# versão 7.1 e posteriores, métodos Main assíncronos em aplicativos de console são compatíveis.

1. Altere o aplicativo de console para permitir chamadas de método assíncronas, o que é feito adicionando primeiro a biblioteca System.Threading.Tasks.

   using System.Threading.Tasks;
   using System.Collections.Generic; // Also add generics to allow the app to use Lists
   

2. Em seguida, atualize a assinatura Main do método da seguinte maneira:

   static async Task Main(string[] args)
   

Criar um pool

1. Adicione o novo método a seguir à classe Program para criar um pool do Lote. O método :

   • Criará um objeto de referência de imagem para armazenar as configurações para os nós a serem adicionados ao pool.
   • Usa a referência de imagem para criar um objeto VirtualMachineConfiguration.
   • Cria um pool não acoplado usando as propriedades declaradas anteriormente e o VirtualMachineConfiguration.
   • Adicionará uma referência de pacote de aplicativos ao pool.
   • Cria o pool no Azure.
   • Usa dois parâmetros, batchClient e PoolId.

     private static async Task CreateBatchPoolAsync(BatchClient batchClient, string poolId)
       {
           CloudPool pool = null;
           Console.WriteLine("Creating pool [{0}]...", poolId);
   
           // Create an image reference object to store the settings for the nodes to be added to the pool
           ImageReference imageReference = new ImageReference(
                   publisher: "MicrosoftWindowsServer",
                   offer: "WindowsServer",
                   sku: "2012-R2-Datacenter-smalldisk",
                   version: "latest");
   
           // Use the image reference to create a VirtualMachineConfiguration object
           VirtualMachineConfiguration virtualMachineConfiguration =
           new VirtualMachineConfiguration(
               imageReference: imageReference,
               nodeAgentSkuId: "batch.node.windows amd64");
   
           try
           {
               // Create an unbound pool. No pool is actually created in the Batch service until we call
               // CloudPool.CommitAsync(). This CloudPool instance is therefore considered "unbound," and we can
               // modify its properties.
               pool = batchClient.PoolOperations.CreatePool(
                   poolId: poolId,
                   targetDedicatedComputeNodes: DedicatedNodeCount,
                   targetLowPriorityComputeNodes: LowPriorityNodeCount,
                   virtualMachineSize: PoolVMSize,
                   virtualMachineConfiguration: virtualMachineConfiguration);  
   
               // Specify the application and version to install on the compute nodes
               pool.ApplicationPackageReferences = new List<ApplicationPackageReference>
               {
                   new ApplicationPackageReference
                   {
                   ApplicationId = appPackageId,
                   Version = appPackageVersion
                   }
               };
   
               // Create the pool
               await pool.CommitAsync();
           }
           catch (BatchException be)
           {
               // Accept the specific error code PoolExists as that is expected if the pool already exists
               if (be.RequestInformation?.BatchError?.Code == BatchErrorCodeStrings.PoolExists)
               {
                   Console.WriteLine("The pool [{0}] already existed when we tried to create it", poolId);
               }
               else
               {
                   throw; // Any other exception is unexpected
               }
           }
       }  
   

2. Chamará CreateBatchPoolAsync do nosso método Main. O método Main agora deve ser conforme demonstrado a seguir:

   static async Task Main(string[] args)
   {
       // Read the environment variables to allow the app to connect to the Azure Batch account
       batchAccountUrl = Environment.GetEnvironmentVariable(envVarBatchURI);
       batchAccountName = Environment.GetEnvironmentVariable(envVarBatchName);
       batchAccountKey = Environment.GetEnvironmentVariable(envVarKey);
   
       // Show the user the batch the app is attaching to
       Console.WriteLine("URL: {0}, Name: {1}, Key: {2}", batchAccountUrl, batchAccountName, batchAccountKey);
   
       // The batch client requires a BatchSharedKeyCredentials object to open a connection
       var sharedKeyCredentials = new BatchSharedKeyCredentials(batchAccountUrl, batchAccountName, batchAccountKey);
       var batchClient = BatchClient.Open(sharedKeyCredentials);
   
       // Create the Batch pool, which contains the compute nodes that execute tasks.
       await CreateBatchPoolAsync(batchClient, PoolId);
   }
   

Testar o aplicativo

1. No editor de código, clique com o botão direito do mouse, selecione Salvar e, em seguida, clique com o botão direito do mouse e selecione Sair.

2. No Cloud Shell, compile e execute o aplicativo com o seguinte comando:

   dotnet run
   

3. O aplicativo levará alguns minutos para ser executado e você deverá obter a seguinte saída:

   URL: <your batch account url, Name: <your batch name>, Key: <your batch key>
   Creating pool [WinFFmpegPool]...
   

Lembre-se de que cada nó é uma VM executando o Windows Server 2012, com apenas uma CPU e 2 GB de RAM. Leva tempo para o Lote transferir essas imagens de VM do Windows da Máquina Virtual do Azure Marketplace, criar a rede e a infraestrutura de VM e, finalmente, iniciar cada nó. Essa é a parte mais demorada da maioria das soluções de Lote. Um fluxo de trabalho típico do Lote não limpa o pool e seus nós.