Dela via

Etablera Linux-beräkningsnoder i Batch-pooler

  • Artikel

Du kan använda Azure Batch för att köra parallella beräkningsarbetsbelastningar på både virtuella Linux- och Windows-datorer. Den här artikeln beskriver hur du skapar pooler med Linux-beräkningsnoder i Batch-tjänsten med hjälp av både Batch Python - och Batch .NET-klientbibliotek .

Konfiguration av virtuell dator

När du skapar en pool med beräkningsnoder i Batch har du två alternativ för att välja nodstorlek och operativsystem: Cloud Services Configuration och Virtual Machine Configuration. Konfigurationspooler för virtuella datorer består av virtuella Azure-datorer som kan skapas från linux- eller Windows-avbildningar. När du skapar en pool med Konfiguration av virtuell dator anger du en tillgänglig beräkningsnodstorlek, referensen för den virtuella datorns avbildning som ska installeras på noderna och Batch-nodagentens SKU (ett program som körs på varje nod och tillhandahåller ett gränssnitt mellan noden och Batch-tjänsten).

Referens för avbildning av virtuell dator

Batch-tjänsten använder VM-skalningsuppsättningar för att tillhandahålla beräkningsnoder i konfigurationen av virtuell dator. Du kan ange en avbildning från Azure Marketplace eller använda Azure Compute Gallery för att förbereda en anpassad avbildning.

När du skapar en referens för en virtuell datoravbildning måste du ange följande egenskaper:

Bildreferensegenskap Exempel
Publisher Canonical
Erbjudande UbuntuServer
SKU 20.04-LTS
Version senaste

Dricks

Du kan lära dig mer om de här egenskaperna och hur du anger Marketplace-avbildningar i Hitta virtuella Linux-avbildningar på Azure Marketplace med Azure CLI. Observera att vissa Marketplace-avbildningar för närvarande inte är kompatibla med Batch.

Lista över avbildningar av virtuella datorer

Alla Marketplace-avbildningar är inte kompatibla med de tillgängliga Batch-nodagenterna. Om du vill visa en lista över alla avbildningar av virtuella Marketplace-datorer som stöds för Batch-tjänsten och deras motsvarande nodagent-SKU:er använder du list_supported_images (Python), ListSupportedImages (Batch .NET) eller motsvarande API på ett annat språk-SDK.

Nodagent-SKU

Batch-nodagenten är ett program som körs på varje nod i poolen och tillhandahåller kommando- och kontrollgränssnittet mellan noden och Batch-tjänsten. Det finns olika implementeringar av nodagenten, så kallade SKU:er, för olika operativsystem. När du skapar en konfiguration av virtuell dator anger du först referensen för avbildningen av den virtuella datorn och anger sedan nodagenten som ska installeras på avbildningen. Vanligtvis är varje nodagent-SKU kompatibel med flera avbildningar av virtuella datorer. Om du vill visa nodagentens SKU:er och avbildningskompatibiliteter för virtuella datorer kan du använda Azure Batch CLI-kommandot:

az batch pool supported-images list

Mer information finns i Konto – Lista avbildningar som stöds – REST API (Azure Batch Service) | Microsoft Docs.

Skapa en Linux-pool: Batch Python

Följande kodfragment visar ett exempel på hur du använder Microsoft Azure Batch-klientbiblioteket för Python för att skapa en pool med Ubuntu Server-beräkningsnoder. Mer information om Batch Python-modulen finns i referensdokumentationen.

Det här kodfragmentet skapar en ImageReference explicit och anger var och en av dess egenskaper (utgivare, erbjudande, SKU, version). I produktionskoden rekommenderar vi dock att du använder metoden list_supported_images för att välja bland de tillgängliga SKU-kombinationerna för avbildnings- och nodagenten vid körning.

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

Som vi nämnde tidigare rekommenderar vi att du använder metoden list_supported_images för att dynamiskt välja bland de nodagent-/Marketplace-avbildningskombinationer som stöds (i stället för att uttryckligen skapa en ImageReference ). Följande Python-kodfragment visar hur du använder den här metoden.

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

Skapa en Linux-pool: Batch .NET

Följande kodfragment visar ett exempel på hur du använder Batch .NET-klientbiblioteket för att skapa en pool med Ubuntu Server-beräkningsnoder. Mer information om Batch .NET finns i referensdokumentationen.

Följande kodfragment använder metoden PoolOperations.ListSupportedImages för att välja från listan över marketplace-avbildnings- och nodagent-SKU-kombinationer som stöds för närvarande. Den här tekniken rekommenderas eftersom listan över kombinationer som stöds kan ändras då och då. Oftast läggs kombinationer som stöds till.

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

Även om det tidigare kodfragmentet använder metoden PoolOperations.istSupportedImages för att dynamiskt lista och välja bland SKU-kombinationer för avbildnings- och nodagenter som stöds (rekommenderas), kan du också konfigurera en ImageReference explicit:

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

Ansluta till Linux-noder med hjälp av SSH

Under utvecklingen eller under felsökningen kan du behöva logga in på noderna i poolen. Till skillnad från Windows-beräkningsnoder kan du inte använda RDP (Remote Desktop Protocol) för att ansluta till Linux-noder. I stället aktiverar Batch-tjänsten SSH-åtkomst på varje nod för fjärranslutning.

Följande Python-kodfragment skapar en användare på varje nod i en pool, vilket krävs för fjärranslutning. Den skriver sedan ut SSH-anslutningsinformationen (Secure Shell) för varje nod.

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

Den här koden har utdata som liknar följande exempel. I det här fallet innehåller poolen fyra Linux-noder.

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

I stället för ett lösenord kan du ange en offentlig SSH-nyckel när du skapar en användare på en nod.

I Python SDK använder du parametern ssh_public_key på ComputeNodeUser.

I .NET använder du egenskapen ComputeNodeUser.SshPublicKey .

Prissättning

Azure Batch bygger på Azure Cloud Services- och Azure Virtual Machines-teknik. Själva Batch-tjänsten erbjuds utan kostnad, vilket innebär att du endast debiteras för de beräkningsresurser (och tillhörande kostnader som medför) som dina Batch-lösningar förbrukar. När du väljer Konfiguration av virtuell dator debiteras du baserat på prisstrukturen för virtuella datorer.

Om du distribuerar program till dina Batch-noder med hjälp av programpaket debiteras du även för de Azure Storage-resurser som programpaketen förbrukar.

Nästa steg