Provisionar os nós de computação do Linux em pools do Lote

Artigo
05/24/2023

Você pode usar o Lote do Azure para executar cargas de trabalho de computação paralelas em máquinas virtuais do Linux e do Windows. Este artigo fornece detalhes sobre como criar pools de nós de computação do Linux no serviço do Lote usando as bibliotecas de cliente Python do Lote e .NET do Lote.

Configuração de Máquina Virtual

Ao criar um pool de nós de computação no Lote, você tem duas opções das quais pode selecionar o tamanho do nó e o sistema operacional: Configuração de Serviços de Nuvem e Configuração de Máquina Virtual. Os pools de Configuração de Máquina Virtual são compostos de VMs do Azure, que podem ser criadas usando imagens do Linux ou do Windows. Ao criar um pool com a Configuração de Máquina Virtual, você especifica um tamanho de nó de computação disponível, a referência de imagem de máquina virtual a ser instalada nos nós e o SKU do agente de nó de lote (um programa que é executado em cada nó e fornece uma interface entre o nó e o serviço de lote).

Referência da imagem da máquina virtual

O serviço de Lote usa Conjuntos de Dimensionamento de Máquinas Virtuais para fornecer nós de computação na Configuração de máquina virtual. Você pode especificar uma imagem do Azure Marketplace ou usar a Galeria de Computação do Azure para preparar uma imagem personalizada.

Ao criar uma referência de imagem de máquina virtual, você deve especificar as seguintes propriedades:

Propriedade de referência de imagem	Exemplo
Publicador	canonical
Oferta	0001-com-ubuntu-server-focal
SKU	20_04-lts
Versão	mais recente

Dica

Você pode saber mais sobre essas propriedades e como especificar imagens do Marketplace em Localizar imagens de VM do Linux no Azure Marketplace com a CLI do Azure. Observe que nem todas as imagens do Marketplace são compatíveis com o serviço do Lote no momento.

imagens da Lista de máquinas virtuais

Nem todas as imagens do Marketplace são compatíveis com os agentes de nó atualmente de Lote disponíveis. Para listar todas as imagens de máquina virtual do Marketplace com suporte para o serviço do Lote e seus SKUs de agentes de nó correspondentes, use list_supported_images (Python), ListSupportedImages (.NET do Lote) ou a API correspondente em outro SDK de linguagem.

SKU do agente do nó

O agente do nó do Lote é um programa executado em cada nó no pool e fornece a interface de comando e controle entre o nó e o serviço do Lote. Há diferentes implementações do agente do nó, conhecido como SKUs, para diferentes sistemas operacionais. Essencialmente, ao criar uma Configuração de Máquina Virtual, você primeiro especifica a referência de imagem de máquina virtual e depois especifica o agente do nó a instalar na imagem. Normalmente, cada SKU do agente do nó é compatível com várias imagens de máquina virtual. Para exibir as compatibilidades de imagem da máquina virtual e as SKUs do agente de nó com suporte, você pode usar o comando CLI do Lote do Azure:

az batch pool supported-images list

Para obter mais informações, você pode consultar Conta – Listar imagens com suporte – API REST (serviço do Lote do Azure) | Microsoft Docs.

Crie um pool do Linux: Python no Lote

O snippet de código a seguir mostra um exemplo de como usar a Biblioteca de cliente do Lote do Microsoft Azure para Python para criar um pool de nós de computação do Ubuntu Server. Para obter mais detalhes sobre o módulo Python do Lote, confira a documentação de referência.

Esse snippet de código cria explicitamente um ImageReference e especifica cada uma das propriedades (publicador, oferta, SKU, versão). No entanto, no código de produção, recomendamos usar o método list_supported_images para selecionar uma das combinações disponíveis de SKU do agente do nó e imagem no runtime.

# Import the required modules from the
# Azure Batch Client Library for Python
import azure.batch.batch_service_client as batch
import azure.batch.batch_auth as batchauth
import azure.batch.models as batchmodels

# Specify Batch account credentials
account = "<batch-account-name>"
key = "<batch-account-key>"
batch_url = "<batch-account-url>"

# Pool settings
pool_id = "LinuxNodesSamplePoolPython"
vm_size = "STANDARD_D2_V3"
node_count = 1

# Initialize the Batch client
creds = batchauth.SharedKeyCredentials(account, key)
config = batch.BatchServiceClientConfiguration(creds, batch_url)
client = batch.BatchServiceClient(creds, batch_url)

# Create the unbound pool
new_pool = batchmodels.PoolAddParameter(id=pool_id, vm_size=vm_size)
new_pool.target_dedicated = node_count

# Configure the start task for the pool
start_task = batchmodels.StartTask()
start_task.run_elevated = True
start_task.command_line = "printenv AZ_BATCH_NODE_STARTUP_DIR"
new_pool.start_task = start_task

# Create an ImageReference which specifies the Marketplace
# virtual machine image to install on the nodes
ir = batchmodels.ImageReference(
    publisher="canonical",
    offer="0001-com-ubuntu-server-focal",
    sku="20_04-lts",
    version="latest")

# Create the VirtualMachineConfiguration, specifying
# the VM image reference and the Batch node agent
# to install on the node
vmc = batchmodels.VirtualMachineConfiguration(
    image_reference=ir,
    node_agent_sku_id="batch.node.ubuntu 20.04")

# Assign the virtual machine configuration to the pool
new_pool.virtual_machine_configuration = vmc

# Create pool in the Batch service
client.pool.add(new_pool)

Como mencionamos anteriormente, recomendamos usar o método list_supported_images para selecionar dinamicamente entre as combinações de imagens do agente do nó/Marketplace com suporte no momento (em vez de criar uma ImageReference explicitamente). O snippet de código Python a seguir mostra como usar esse método.

# Get the list of supported images from the Batch service
images = client.account.list_supported_images()

# Obtain the desired image reference
image = None
for img in images:
  if (img.image_reference.publisher.lower() == "canonical" and
        img.image_reference.offer.lower() == "0001-com-ubuntu-server-focal" and
        img.image_reference.sku.lower() == "20_04-lts"):
    image = img
    break

if image is None:
  raise RuntimeError('invalid image reference for desired configuration')

# Create the VirtualMachineConfiguration, specifying the VM image
# reference and the Batch node agent to be installed on the node
vmc = batchmodels.VirtualMachineConfiguration(
    image_reference=image.image_reference,
    node_agent_sku_id=image.node_agent_sku_id)

Crie um pool do Linux: .NET no Lote

O snippet de código a seguir mostra um exemplo de como usar a biblioteca de cliente .NET do Lote para criar um pool de nós de computação do Ubuntu Server. Para obter mais detalhes sobre o .NET do Lote, confira a documentação de referência.

O snippet de código a seguir usa o método PoolOperations.ListSupportedImages para fazer a seleção na lista de combinações de SKU do agente do nó e imagem do Marketplace com suporte no momento. Essa técnica é recomendável porque a lista de combinações com suporte pode ser alterada periodicamente. Os mais comum é que combinações com suporte sejam adicionadas.

// Pool settings
const string poolId = "LinuxNodesSamplePoolDotNet";
const string vmSize = "STANDARD_D2_V3";
const int nodeCount = 1;

// Obtain a collection of all available node agent SKUs.
// This allows us to select from a list of supported
// VM image/node agent combinations.
List<ImageInformation> images =
    batchClient.PoolOperations.ListSupportedImages().ToList();

// Find the appropriate image information
ImageInformation image = null;
foreach (var img in images)
{
    if (img.ImageReference.Publisher == "canonical" &&
        img.ImageReference.Offer == "0001-com-ubuntu-server-focal" &&
        img.ImageReference.Sku == "20_04-lts")
    {
        image = img;
        break;
    }
}

// Create the VirtualMachineConfiguration for use when actually
// creating the pool
VirtualMachineConfiguration virtualMachineConfiguration =
    new VirtualMachineConfiguration(image.ImageReference, image.NodeAgentSkuId);

// Create the unbound pool object using the VirtualMachineConfiguration
// created above
CloudPool pool = batchClient.PoolOperations.CreatePool(
    poolId: poolId,
    virtualMachineSize: vmSize,
    virtualMachineConfiguration: virtualMachineConfiguration,
    targetDedicatedComputeNodes: nodeCount);

// Commit the pool to the Batch service
await pool.CommitAsync();

Embora o snippet de código anterior use o método PoolOperations.istSupportedImages para relacionar e selecionar dinamicamente dentre as combinações de SKU do agente do nó e imagem com suporte (recomendado), você também pode configurar uma ImageReference explicitamente:

ImageReference imageReference = new ImageReference(
    publisher: "canonical",
    offer: "0001-com-ubuntu-server-focal",
    sku: "20_04-lts",
    version: "latest");

Conectar-se a nós do Linux usando SSH

Durante o desenvolvimento ou durante a solução de problemas, talvez seja necessário entrar nos nós em seu pool. Ao contrário dos nós de computação do Windows, não é possível usar o protocolo RDP para se conectar aos nós do Linux. Em vez disso, o serviço do Lote habilita acesso do SSH em cada nó para a conexão remota.

O snippet de código Python a seguir cria um usuário em cada nó em um pool, requerido para conexão remota. Ele imprime as informações de conexão SSH (secure shell) para cada nó.

import datetime
import getpass
import azure.batch.batch_service_client as batch
import azure.batch.batch_auth as batchauth
import azure.batch.models as batchmodels

# Specify your own account credentials
batch_account_name = ''
batch_account_key = ''
batch_account_url = ''

# Specify the ID of an existing pool containing Linux nodes
# currently in the 'idle' state
pool_id = ''

# Specify the username and prompt for a password
username = 'linuxuser'
password = getpass.getpass()

# Create a BatchClient
credentials = batchauth.SharedKeyCredentials(
    batch_account_name,
    batch_account_key
)
batch_client = batch.BatchServiceClient(
    credentials,
    base_url=batch_account_url
)

# Create the user that will be added to each node in the pool
user = batchmodels.ComputeNodeUser(username)
user.password = password
user.is_admin = True
user.expiry_time = \
    (datetime.datetime.today() + datetime.timedelta(days=30)).isoformat()

# Get the list of nodes in the pool
nodes = batch_client.compute_node.list(pool_id)

# Add the user to each node in the pool and print
# the connection information for the node
for node in nodes:
    # Add the user to the node
    batch_client.compute_node.add_user(pool_id, node.id, user)

    # Obtain SSH login information for the node
    login = batch_client.compute_node.get_remote_login_settings(pool_id,
                                                                node.id)

    # Print the connection info for the node
    print("{0} | {1} | {2} | {3}".format(node.id,
                                         node.state,
                                         login.remote_login_ip_address,
                                         login.remote_login_port))

Esse código terá uma saída semelhante ao exemplo a seguir. Nesse caso, o pool contém quatro nós do Linux.

Password:
tvm-1219235766_1-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50000
tvm-1219235766_2-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50003
tvm-1219235766_3-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50002
tvm-1219235766_4-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50001

Em vez de uma senha, você pode especificar uma chave pública SSH ao criar um usuário em um nó.

No SDK do Python, use o parâmetro ssh_public_key em ComputeNodeUser.

No .NET, use a propriedade ComputeNodeUser.SshPublicKey.

Preços

O Lote do Azure baseia-se na tecnologia de Serviços de Nuvem do Azure e Máquinas Virtuais do Azure. O serviço de Lote em si é oferecido sem custos, o que significa que você é cobrado apenas pelos recursos de computação (e os custos associados envolvidos) que as soluções do Lote consomem. Ao escolher a Configuração da Máquina Virtual, você é cobrado com base na estrutura de Preços das Máquinas Virtuais.

Se você implantar aplicativos para os nós do Lote usando pacotes de aplicativos, você também será cobrado pelos recursos de Armazenamento do Azure que consomem seus pacotes de aplicativos.

Próximas etapas

Explore os exemplos de código Python no repositório azure-batch-samples do GitHub para ver como executar as operações comuns do Lote, como criação de pool, trabalho e tarefa. O LEIAME que acompanha os exemplos do Python apresenta detalhes sobre como instalar os pacotes necessários.
Saiba mais sobre como usar VMs Spot do Azure com o Lote.

Compartilhar via