Provisionar nós de computação Linux em pools de lotes

Artigo
10/16/2024

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

Configuração da Máquina Virtual

Ao criar um pool de nós de computação em lote, você tem duas opções para 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 por VMs do Azure, que podem ser criadas a partir de imagens do Linux ou do Windows. Ao criar um pool com a Configuração da Máquina Virtual, você especifica um tamanho de nó de computação disponível, a referência de imagem da máquina virtual a ser instalada nos nós e a SKU do agente do nó em lote (um programa que é executado em cada nó e fornece uma interface entre o nó e o serviço em lote).

Referência de imagem de máquina virtual

O serviço Batch usa conjuntos de dimensionamento de máquina virtual para fornecer nós de computação na Configuração da 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
Publisher	canônico
Oferecer	0001-com-ubuntu-servidor-focal
SKU	20_04-lts
Versão	mais recente

Gorjeta

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 algumas imagens do Marketplace não são atualmente compatíveis com o Batch.

Lista de imagens de máquinas virtuais

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

SKU do agente do nó

O agente do nó Batch é um programa executado em cada nó do pool e fornece a interface de comando e controle entre o nó e o serviço Batch. Existem diferentes implementações do agente de 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, em seguida, especifica o agente de nó a ser instalado na imagem. Normalmente, cada SKU do agente de nó é compatível com várias imagens de máquina virtual. Para exibir as SKUs do agente de nó com suporte e as compatibilidades de imagem de máquina virtual, você pode usar o comando Azure Batch CLI:

az batch pool supported-images list

Para obter mais informações, consulte Conta - Listar imagens suportadas - API REST (Azure Batch Service) | Documentos Microsoft.

Criar um pool Linux: Batch Python

O trecho de código a seguir mostra um exemplo de como usar a Biblioteca de Cliente em 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 Batch Python, consulte a documentação de referência.

Este trecho cria um ImageReference explicitamente e especifica cada uma de suas propriedades (editor, oferta, SKU, versão). No código de produção, no entanto, recomendamos que você use o método list_supported_images para selecionar entre as combinações de SKU do agente de imagem e nó disponíveis em tempo de execução.

# 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 mencionado anteriormente, recomendamos o uso do método list_supported_images para selecionar dinamicamente as combinações de imagem do agente de nó com suporte no momento (em vez de criar um ImageReference explicitamente). O trecho 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)

Criar um pool Linux: Batch .NET

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

O trecho de código a seguir usa o método PoolOperations.ListSupportedImages para selecionar na lista de combinações de SKU de agente de nó e imagem do Marketplace atualmente suportadas. Esta técnica é recomendada, porque a lista de combinações suportadas pode mudar de tempos em tempos. Mais comumente, as combinações suportadas são 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 trecho anterior use o método PoolOperations.istSupportedImages para listar e selecionar dinamicamente as combinações de SKU do agente de nó e imagem suportadas (recomendado), você também pode configurar um ImageReference explicitamente:

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

Conecte-se a nós Linux usando SSH

Durante o desenvolvimento ou durante a solução de problemas, você pode achar necessário entrar nos nós do seu pool. Ao contrário dos nós de computação do Windows, você não pode usar o protocolo RDP (Remote Desktop Protocol) para se conectar aos nós do Linux. Em vez disso, o serviço Batch permite o acesso SSH em cada nó para conexão remota.

O trecho de código Python a seguir cria um usuário em cada nó de um pool, que é necessário para conexão remota. Em seguida, ele imprime as informações de conexão do shell seguro (SSH) 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))

Este código terá uma saída semelhante ao exemplo a seguir. Nesse caso, o pool contém quatro nós 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 Python SDK, use o parâmetro ssh_public_key em ComputeNodeUser.

No .NET, use a propriedade ComputeNodeUser.SshPublicKey .

Preços

O Azure Batch baseia-se nos Serviços de Nuvem do Azure e na tecnologia de Máquinas Virtuais do Azure. O serviço Batch em si é oferecido sem nenhum custo, o que significa que você é cobrado apenas pelos recursos de computação (e custos associados que isso implica) que suas soluções Batch consomem. Ao escolher Configuração de Máquina Virtual, você será cobrado com base na estrutura de preços das Máquinas Virtuais.

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

Próximos passos

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

Partilhar via