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

Pode usar o Azure Batch para executar cargas de cálculo paralelas em máquinas virtuais Linux e Windows. Este artigo descreve detalhadamente como criar conjuntos de nós de computação Linux no serviço Batch, utilizando as bibliotecas de cliente Batch Python e Azure.Compute.Batch.

Configuração da Máquina Virtual

Quando cria um conjunto de nós de computação em Batch, tem duas opções para selecionar o tamanho do nó e o sistema operativo: Configuração de Serviços Cloud e Configuração de Máquina Virtual. Os pools de Configuração de Máquinas Virtuais são compostos por VMs Azure, que podem ser criadas a partir de imagens Linux ou Windows. Quando cria um pool com Configuração de Máquina Virtual, especifica o tamanho disponível do nó de computação, a referência da imagem da máquina virtual a ser instalada nos nós e o SKU do agente de nó Batch (um programa que corre 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 escala de máquinas virtuais para fornecer nós de computação na Configuração da Máquina Virtual. Pode especificar uma imagem a partir do Azure Marketplace, ou usar a Azure Compute Gallery para preparar uma imagem personalizada.

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

Propriedade de referência da imagem Example
Publisher canónico
Oferta 0001-com-ubuntu-server-focal
SKU 20_04-lts
Versão mais recente

Sugestão

Pode aprender mais sobre estas propriedades e como especificar imagens do Marketplace em Encontrar imagens de VM Linux no Azure Marketplace com o CLI do Azure. Note 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 Batch disponíveis atualmente. Para listar todas as imagens de máquinas virtuais do Marketplace suportadas para o serviço Batch e os respetivos SKUs de agente de nó, use list_supported_images (Python), BatchClient.GetSupportedImagesAsync (Azure.Compute.Batch) ou a API correspondente no SDK de outra linguagem.

SKU do agente de nó

O programa agente de nó Batch executa-se em cada nó do pool 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 operacionais. Basicamente, quando crias uma Configuração de Máquina Virtual, primeiro especificas a referência da imagem da máquina virtual e depois especificas o agente de nó a instalar na imagem. Normalmente, cada SKU de agente de nó é compatível com múltiplas imagens de máquinas virtuais. Para visualizar os SKUs de agente de nó suportados e as compatibilidades de imagem de máquinas virtuais, pode usar o comando Azure Batch CLI:

az batch pool supported-images list

Para mais informação, pode consultar Account - List Supported Images - REST API (Azure Batch Service) | Microsoft Docs.

Criar um "pool" Linux: Batch Python

O seguinte excerto de código mostra um exemplo de como usar a Microsoft Azure Batch Client Library para Python para criar um pool de nós de computação do Ubuntu Server. Para mais detalhes sobre o módulo Batch Python, consulte a documentação de referência.

Este excerto cria explicitamente uma BatchVmImageReference e especifica cada uma das suas 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 entre as combinações disponíveis de SKU de imagem e de agente de nó durante a execução.

# Import the required modules from the
# Azure Batch Client Library for Python
from azure.batch import BatchClient, models
from azure.core.credentials import AzureNamedKeyCredential

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

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

# Initialize the Batch client
creds = AzureNamedKeyCredential(account, key)
client = BatchClient(endpoint=account_endpoint, credential=creds)

# Configure the start task for the pool
start_task = models.BatchStartTask(
    command_line="printenv AZ_BATCH_NODE_STARTUP_DIR",
    user_identity=models.UserIdentity(
        auto_user=models.AutoUserSpecification(
            elevation_level=models.ElevationLevel.ADMIN,
            scope=models.AutoUserScope.POOL,
        )
    ),
)

# Create an ImageReference which specifies the Marketplace
# virtual machine image to install on the nodes
ir = models.BatchVmImageReference(
    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 = models.VirtualMachineConfiguration(
    image_reference=ir,
    node_agent_sku_id="batch.node.ubuntu 20.04")

# Create the unbound pool
new_pool = models.BatchPoolCreateOptions(
    id=pool_id,
    vm_size=vm_size,
    target_dedicated_nodes=node_count,
    virtual_machine_configuration=vmc,
    start_task=start_task,
)

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

Como mencionado anteriormente, recomendamos usar o método list_supported_images para selecionar dinamicamente entre as combinações de agente de nó/imagem do Marketplace atualmente suportadas (em vez de criar explicitamente uma BatchVmImageReference ). O seguinte excerto em Python mostra como usar este método.

# Get the list of supported images from the Batch service
images = list(client.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 = models.VirtualMachineConfiguration(
    image_reference=image.image_reference,
    node_agent_sku_id=image.node_agent_sku_id)

Criar um pool Linux: Batch .NET

O seguinte excerto de código mostra um exemplo de como usar o Azure. Compute.Batch e Azure. ResourceManager.Batch bibliotecas clientes para criar um conjunto de nós de computação do Ubuntu Server. Para mais detalhes, consulte a documentação de referência.

O seguinte excerto de código utiliza o método BatchClient.GetSupportedImages para selecionar da lista de combinações de SKU de imagem do Marketplace e agente de nó atualmente suportadas. Esta técnica é recomendada, pois a lista de combinações suportadas pode mudar de tempos a tempos. Mais frequentemente, 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<BatchSupportedImage> images = new List<BatchSupportedImage>();
await foreach (BatchSupportedImage img in batchClient.GetSupportedImagesAsync())
{
    images.Add(img);
}

// Find the appropriate image information
BatchSupportedImage 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 BatchVmConfiguration for use when actually creating the pool.
// Note that the data-plane discovery uses Azure.Compute.Batch.BatchVmImageReference
// but the ARM pool data type uses Azure.ResourceManager.Batch.Models.BatchImageReference.
BatchVmConfiguration vmConfiguration = new BatchVmConfiguration(
    imageReference: new BatchImageReference()
    {
        Publisher = image.ImageReference.Publisher,
        Offer = image.ImageReference.Offer,
        Sku = image.ImageReference.Sku,
        Version = image.ImageReference.Version
    },
    nodeAgentSkuId: image.NodeAgentSkuId);

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = vmSize,
    DeploymentConfiguration = new BatchDeploymentConfiguration() { VmConfiguration = vmConfiguration },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        FixedScale = new BatchAccountFixedScaleSettings() { TargetDedicatedNodes = nodeCount }
    }
};

// Commit the pool to the Batch service via Azure.ResourceManager.Batch.
await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, poolId, poolData);

Embora o excerto de código anterior utilize o método BatchClient.GetSupportedImages para listar e selecionar dinamicamente combinações suportadas de SKU de imagem e do agente de nó (recomendado), também pode configurar explicitamente uma BatchVmImageReference:

BatchImageReference imageReference = new BatchImageReference()
{
    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 resolução de problemas, pode ser necessário fazer login nos nós do seu pool. Ao contrário dos nós de computação do Windows, não pode usar o Protocolo de Ambiente de Trabalho Remoto (RDP) para se ligar a nós Linux. Em vez disso, o serviço Batch permite o acesso SSH em cada nó para ligação remota.

O seguinte excerto de código Python cria um utilizador em cada nó de um pool, o que é necessário para a ligação remota. Depois, imprime a informação de ligação secure shell (SSH) para cada nó.

import datetime
import getpass
from azure.batch import BatchClient, models
from azure.core.credentials import AzureNamedKeyCredential

# 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 = AzureNamedKeyCredential(
    batch_account_name,
    batch_account_key
)
batch_client = BatchClient(
    endpoint=batch_account_url,
    credential=credentials
)

# Create the user that will be added to each node in the pool
user = models.BatchNodeUserCreateOptions(
    name=username,
    password=password,
    is_admin=True,
    expiry_time=(datetime.datetime.utcnow() + datetime.timedelta(days=30)),
)

# Get the list of nodes in the pool
nodes = batch_client.list_nodes(pool_id=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.create_node_user(pool_id=pool_id, node_id=node.id, user=user)

    # Obtain SSH login information for the node
    login = batch_client.get_node_remote_login_settings(pool_id=pool_id,
                                                        node_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 seguinte. Neste 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 palavra-passe, pode especificar uma chave pública SSH quando cria um utilizador num nó.

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

No .NET, utilize a propriedade BatchNodeUserCreateOptions.SshPublicKey.

Preços

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

Se implantar aplicações nos seus nós do Batch usando pacotes de aplicações, também é cobrado pelos recursos do Armazenamento do Azure que os seus pacotes de aplicações consomem.

Próximos passos

  • Last updated on