Eseguire il provisioning di nodi di calcolo Linux nei pool di Batch

  • Articolo

È possibile usare Azure Batch per eseguire carichi di lavoro di calcolo paralleli in macchine virtuali Linux e Windows. Questo articolo illustra in dettaglio come creare pool di nodi di calcolo Linux nel servizio Batch usando le librerie client Batch Python e Batch .NET.

Configurazione macchina virtuale

Quando si crea un pool di nodi di calcolo in Batch, sono disponibili due opzioni per la selezione delle dimensioni e del sistema operativo del nodo: la configurazione di servizi cloud e la configurazione della macchina virtuale. I pool di configurazione della macchina virtuale sono costituiti da macchine virtuali di Azure, che possono essere create da immagini Linux o Windows. Quando si crea un pool con configurazione macchina virtuale, si specifica una dimensione del nodo di calcolo disponibile, il riferimento all'immagine della macchina virtuale da installare nei nodi e lo SKU dell'agente del nodo Batch (un programma che viene eseguito in ogni nodo e fornisce un'interfaccia tra il nodo e il servizio Batch).

Riferimento all'immagine della macchina virtuale

Il servizio Batch usa set di scalabilità di macchine virtuali per fornire nodi di calcolo nella configurazione macchina virtuale. È possibile specificare un'immagine dal Azure Marketplace oppure usare La raccolta di calcolo di Azure per preparare un'immagine personalizzata.

Quando si crea un riferimento all'immagine di macchina virtuale, è necessario specificare le proprietà seguenti:

Proprietà di riferimento dell'immagine Esempio
Editore Canonical
Offerta UbuntuServer
SKU 20.04-LTS
Versione più recenti

Suggerimento

Per altre informazioni su queste proprietà e su come specificare immagini del Marketplace in Trovare immagini di macchine virtuali Linux nella Azure Marketplace con l'interfaccia della riga di comando di Azure. Si noti che alcune immagini del Marketplace non sono attualmente compatibili con Batch.

Elenco di immagini di macchine virtuali

Non tutte le immagini del Marketplace sono compatibili con gli agenti del nodo Batch attualmente disponibili. Per elencare tutte le immagini della macchina virtuale Marketplace supportate per il servizio Batch e gli SKU dell'agente del nodo corrispondenti, usare list_supported_images (Python), ListSupportedImages (Batch .NET) o l'API corrispondente in un altro SDK del linguaggio.

SKU dell'agente del nodo

L'agente del nodo Batch è un programma che viene eseguito in ogni nodo nel pool e fornisce l'interfaccia di comando e controllo tra il nodo e il servizio Batch. Sono disponibili diverse implementazioni dell'agente del nodo, definite SKU, per sistemi operativi diversi. Quando si crea una configurazione della macchina virtuale, è essenzialmente necessario specificare prima di tutto il riferimento all'immagine della macchina virtuale e quindi l'agente del nodo da installare nell'immagine. Ogni SKU dell'agente del nodo è in genere compatibile con più immagini di macchina virtuale. Per visualizzare gli SKU dell'agente di nodi supportati e le compatibilità delle immagini delle macchine virtuali, è possibile usare il comando Azure Batch interfaccia della riga di comando:

az batch pool supported-images list

Per altre informazioni, è possibile fare riferimento a Account - Elencare immagini supportate - API REST (Azure Batch Servizio) | Microsoft Docs.

Creare un pool Linux: Batch Python

Il frammento di codice seguente illustra un esempio su come usare la libreria client di Microsoft Azure Batch per Python per creare un pool di nodi di calcolo Ubuntu Server. Per altre informazioni sul modulo Batch Python, visualizzare la documentazione di riferimento.

Questo frammento di codice crea in modo esplicito una classe ImageReference e ne specifica tutte le proprietà (editore, offerta, SKU, versione). Nel codice di produzione, tuttavia, è consigliabile usare il metodo list_supported_images per selezionare le combinazioni di SKU dell'agente dell'immagine e del nodo disponibili in fase di esecuzione.

# 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)

Come accennato in precedenza, è consigliabile usare il metodo list_supported_images per selezionare dinamicamente le combinazioni di immagini dell'agente del nodo/Marketplace attualmente supportate anziché creare un'immagine ImageReference in modo esplicito. Il frammento di codice Python seguente illustra come usare questo metodo.

# 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)

Creare un pool Linux: Batch .NET

Il frammento di codice seguente illustra un esempio di come usare la libreria client Batch .NET per creare un pool di nodi di calcolo Ubuntu Server. Per altre informazioni su Batch .NET, visualizzare la documentazione di riferimento.

Il frammento di codice seguente usa il metodo PoolOperations.ListSupportedImages per selezionare dall'elenco delle combinazioni di SKU dell'agente del Marketplace attualmente supportate. Questa tecnica è consigliata, perché l'elenco di combinazioni supportate può cambiare da un momento all'altro. in genere a causa dell'aggiunta di altre combinazioni supportate.

// 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();

Anche se il frammento di codice precedente usa il metodo PoolOperations.istSupportedImages per elencare dinamicamente e selezionare le combinazioni di SKU dell'agente di immagine e nodo supportate (consigliato), è anche possibile configurare un imageReference in modo esplicito:

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

Connettersi a nodi Linux tramite SSH

Durante lo sviluppo o la risoluzione dei problemi potrebbe essere necessario accedere ai nodi del pool. A differenza dei nodi di calcolo di Windows, non è possibile usare Remote Desktop Protocol (RDP) per connettersi ai nodi Linux. Il servizio Batch consente invece l'accesso SSH in ogni nodo per la connessione remota.

Il frammento di codice Python seguente crea un utente in ogni nodo in un pool, necessario per la connessione remota, quindi stampa le informazioni di connessione Secure Shell (SSH) per ogni nodo.

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))

Questo codice avrà un output simile all'esempio seguente. In questo caso, il pool contiene quattro nodi 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

Invece di una password, è possibile specificare una chiave pubblica SSH durante la creazione di un utente in un nodo.

In Python SDK usare il parametro ssh_public_key in ComputeNodeUser.

In .NET usare la proprietà ComputeNodeUser.SshPublicKey .

Prezzi

Azure Batch è basato sulla tecnologia di Servizi cloud di Azure e di Macchine virtuali di Azure. Il servizio Batch è gratuito, vengono quindi addebitate solo le risorse di calcolo usate dalle soluzioni Batch e i costi associati che comportano. Scegliendo la configurazione della macchina virtuale, i costi verranno addebitati in base alla struttura dei prezzi di Macchine virtuali.

Se si distribuiscono applicazioni ai nodi Batch tramite pacchetti dell'applicazione, vengono inoltre addebitati i costi per le risorse di Archiviazione di Azure utilizzate dai pacchetti dell'applicazione.

Passaggi successivi