Aprovisionar nós de computação do Linux em conjuntos do Batch

  • Artigo

Pode utilizar Azure Batch para executar cargas de trabalho de computação paralelas em máquinas virtuais do Linux e do Windows. Este artigo detalha como criar conjuntos de nós de computação do Linux no serviço Batch com as bibliotecas de cliente Batch Python e Batch .NET .

Configuração da Máquina Virtual

Quando cria um conjunto de nós de computação no Batch, tem duas opções para selecionar o tamanho do nó e o sistema operativo: Serviços Cloud Configuração e Configuração da Máquina Virtual. Os conjuntos de Configuração de Máquinas Virtuais são compostos por VMs do Azure, que podem ser criadas a partir de imagens do Linux ou do Windows. Quando cria um conjunto com a Configuração da Máquina Virtual, especifica um tamanho de nó de computação disponível, a referência de imagem da máquina virtual a instalar nos nós e o SKU do agente do nó do Batch (um programa que é executado em cada nó e fornece uma interface entre o nó e o serviço Batch).

Referência de imagem de máquina virtual

O serviço Batch utiliza conjuntos de dimensionamento de máquinas virtuais para fornecer nós de computação na Configuração da Máquina Virtual. Pode especificar uma imagem do Azure Marketplace ou utilizar a Galeria de Computação do Azure para preparar uma imagem personalizada.

Quando cria uma referência de imagem de máquina virtual, tem de especificar as seguintes propriedades:

Propriedade de referência de imagem Exemplo
Publisher Canónico
Oferta UbuntuServer
SKU 20.04-LTS
Versão mais recente

Dica

Pode saber mais sobre estas propriedades e como especificar imagens do Marketplace em Localizar imagens de VM do Linux no Azure Marketplace com a CLI do Azure. Tenha em atenção 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ós do Batch atualmente disponíveis. Para listar todas as imagens de máquinas virtuais do Marketplace suportadas para o serviço Batch e os skUs do agente de nó correspondentes, utilize list_supported_images (Python), ListSupportedImages (Batch .NET) ou a API correspondente noutro SDK de idioma.

SKU do agente do nó

O agente de nó do Batch é um programa que é executado em cada nó no conjunto e fornece a interface de comando e controlo entre o nó e o serviço Batch. Existem diferentes implementações do agente de nó, conhecido como SKUs, para diferentes sistemas operativos. Essencialmente, quando cria uma Configuração de Máquina Virtual, primeiro especifica a referência de imagem da máquina virtual e, em seguida, especifica o agente de nó a instalar na imagem. Normalmente, cada SKU de agente de nó é compatível com várias imagens de máquina virtual. Para ver os SKUs do agente de nó suportados e as compatibilidades de imagem de máquina virtual, pode utilizar o comando Azure Batch CLI:

az batch pool supported-images list

Para obter mais informações, pode consultar Conta – Listar Imagens Suportadas – API REST (serviço Azure Batch) | Microsoft Docs.

Criar um conjunto do Linux: Batch Python

O fragmento de código seguinte mostra um exemplo de como utilizar a Biblioteca de Clientes do Microsoft Azure Batch para Python para criar um conjunto de nós de computação do Ubuntu Server. Para obter mais detalhes sobre o módulo Do Batch Python, veja a documentação de referência.

Este fragmento cria explicitamente uma ImageReference e especifica cada uma das respetivas propriedades (publicador, oferta, SKU, versão). No código de produção, no entanto, recomendamos que utilize o método list_supported_images para selecionar a partir das combinações de SKU da imagem e do agente do nó disponíveis 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="UbuntuServer",
    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)

Conforme mencionado anteriormente, recomendamos que utilize o método list_supported_images para selecionar dinamicamente a partir das combinações de imagens do agente de nó/Marketplace atualmente suportadas (em vez de criar explicitamente uma ImageReference ). O fragmento python seguinte mostra como utilizar este 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() == "ubuntuserver" 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 conjunto do Linux: Batch .NET

O fragmento de código seguinte mostra um exemplo de como utilizar a biblioteca de cliente .NET do Batch para criar um conjunto de nós de computação do Ubuntu Server. Para obter mais detalhes sobre o Batch .NET, veja a documentação de referência.

O fragmento de código seguinte utiliza o método PoolOperations.ListSupportedImages para selecionar a partir da lista de combinações de SKU de agente de nós e imagem do Marketplace atualmente suportadas. Esta técnica é recomendada porque a lista de combinações suportadas pode mudar de vez em quando. Normalmente, são adicionadas combinações suportadas.

// 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 == "UbuntuServer" &&
        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 fragmento anterior utilize o método PoolOperations.istSupportedImages para listar e selecionar dinamicamente a partir de combinações de SKU de imagem e agente de nó suportadas (recomendado), também pode configurar explicitamente uma ImageReference :

ImageReference imageReference = new ImageReference(
    publisher: "Canonical",
    offer: "UbuntuServer",
    sku: "20.04-LTS",
    version: "latest");

Ligar a nós do Linux com SSH

Durante o desenvolvimento ou durante a resolução de problemas, poderá considerar necessário iniciar sessão nos nós do conjunto. Ao contrário dos nós de computação do Windows, não pode utilizar o Protocolo RDP (Remote Desktop Protocol) para ligar a nós do Linux. Em vez disso, o serviço Batch ativa o acesso SSH em cada nó para ligação remota.

O fragmento de código Python seguinte cria um utilizador em cada nó num conjunto, o que é necessário para a ligação remota. Em seguida, imprime as informações de ligação de shell segura (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á um resultado semelhante ao seguinte exemplo. Neste caso, o conjunto 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 palavra-passe, pode especificar uma chave pública SSH quando cria um utilizador num nó.

No SDK python, utilize o parâmetro ssh_public_key em ComputeNodeUser.

No .NET, utilize a propriedade ComputeNodeUser.SshPublicKey .

Preços

Azure Batch baseia-se na tecnologia do Azure Serviços Cloud e do Azure Máquinas Virtuais. O próprio serviço Batch é oferecido sem custos, o que significa que só lhe são cobrados os recursos de computação (e os custos associados que as suas soluções do Batch consomem). Quando seleciona Configuração de Máquina Virtual, é cobrado com base na estrutura de preços Máquinas Virtuais.

Se implementar aplicações nos nós do Batch com pacotes de aplicações, também lhe serão cobrados os recursos do Armazenamento do Azure que os pacotes de aplicações consomem.

Passos seguintes