Linux-rekenknooppunten inrichten in Batch-pools

  • Artikel

U kunt Azure Batch gebruiken om parallelle rekenworkloads uit te voeren op virtuele Linux- en Windows-machines. In dit artikel wordt beschreven hoe u pools met Linux-rekenknooppunten maakt in de Batch-service met behulp van zowel de Batch Python - als Batch .NET-clientbibliotheken .

Configuratie van virtuele machines

Wanneer u een pool met rekenknooppunten maakt in Batch, hebt u twee opties om de knooppuntgrootte en het besturingssysteem te selecteren: Cloud Services Configuratie en Configuratie van virtuele machines. Virtuele-machineconfiguratiepools bestaan uit Azure-VM's, die kunnen worden gemaakt op basis van Linux- of Windows-installatiekopieën. Wanneer u een pool maakt met Virtual Machine Configuration, geeft u een beschikbare rekenknooppuntgrootte op, de verwijzing naar de installatiekopieën van de virtuele machine die op de knooppunten moet worden geïnstalleerd en de Batch-knooppuntagent-SKU (een programma dat op elk knooppunt wordt uitgevoerd en een interface biedt tussen het knooppunt en de Batch-service).

Naslaginformatie over installatiekopieën van virtuele machines

De Batch-service maakt gebruik van virtuele-machineschaalsets om rekenknooppunten te bieden in de configuratie van virtuele machines. U kunt een installatiekopieën uit de Azure Marketplace opgeven of de Azure Compute Gallery gebruiken om een aangepaste installatiekopieën voor te bereiden.

Wanneer u een verwijzing naar de installatiekopieën van een virtuele machine maakt, moet u de volgende eigenschappen opgeven:

Afbeeldingsreferentieeigenschap Voorbeeld
Publisher Canonical
Aanbieding UbuntuServer
SKU 20.04-LTS
Versie meest recente

Tip

Meer informatie over deze eigenschappen en het opgeven van Marketplace-installatiekopieën vindt u in Installatiekopieën voor Linux-VM's zoeken in de Azure Marketplace met de Azure CLI. Houd er rekening mee dat sommige Marketplace-installatiekopieën momenteel niet compatibel zijn met Batch.

Lijst met installatiekopieën van virtuele machines

Niet alle Marketplace-installatiekopieën zijn compatibel met de momenteel beschikbare Batch-knooppuntagents. Als u alle ondersteunde installatiekopieën van virtuele Marketplace-machines voor de Batch-service en de bijbehorende knooppuntagent-SKU's wilt weergeven, gebruikt u list_supported_images (Python), ListSupportedImages (Batch .NET) of de bijbehorende API in een andere taal-SDK.

Knooppuntagent-SKU

De Batch-knooppuntagent is een programma dat wordt uitgevoerd op elk knooppunt in de pool en biedt de command-and-control-interface tussen het knooppunt en de Batch-service. Er zijn verschillende implementaties van de knooppuntagent, ook wel SKU's genoemd, voor verschillende besturingssystemen. Wanneer u een virtuele-machineconfiguratie maakt, geeft u eerst de verwijzing naar de installatiekopieën van de virtuele machine op en geeft u vervolgens de knooppuntagent op die op de installatiekopieën moet worden geïnstalleerd. Normaal gesproken is elke knooppuntagent-SKU compatibel met meerdere installatiekopieën van virtuele machines. Als u de ondersteunde knooppuntagent-SKU's en compatibiliteit van vm-installatiekopieën wilt weergeven, kunt u de opdracht Azure Batch CLI gebruiken:

az batch pool supported-images list

Raadpleeg Account - Lijst met ondersteunde installatiekopieën - REST API (Azure Batch Service) voor meer informatie | Microsoft Docs.

Een Linux-pool maken: Batch Python

In het volgende codefragment ziet u een voorbeeld van het gebruik van de Microsoft Azure Batch-clientbibliotheek voor Python om een pool met Ubuntu Server-rekenknooppunten te maken. Bekijk de referentiedocumentatie voor meer informatie over de Batch Python-module.

Met dit fragment wordt expliciet een ImageReference gemaakt en worden alle eigenschappen (uitgever, aanbieding, SKU, versie) opgegeven. In productiecode raden we u echter aan de methode list_supported_images te gebruiken om tijdens runtime te kiezen uit de beschikbare combinaties van installatiekopieën en knooppuntagents.

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

Zoals eerder vermeld, raden we u aan de methode list_supported_images te gebruiken om dynamisch te selecteren uit de momenteel ondersteunde combinaties van knooppuntagent-/Marketplace-installatiekopieën (in plaats van expliciet een ImageReference te maken). In het volgende Python-fragment ziet u hoe u deze methode gebruikt.

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

Een Linux-pool maken: Batch .NET

In het volgende codefragment ziet u een voorbeeld van hoe u de Batch .NET-clientbibliotheek gebruikt om een pool met Ubuntu Server-rekenknooppunten te maken. Bekijk de referentiedocumentatie voor meer informatie over Batch .NET.

In het volgende codefragment wordt de methode PoolOperations.ListSupportedImages gebruikt om een keuze te maken uit de lijst met ondersteunde combinaties van marketplace-installatiekopieën en knooppuntagentSKU's. Deze techniek wordt aanbevolen, omdat de lijst met ondersteunde combinaties van tijd tot tijd kan veranderen. Meestal worden ondersteunde combinaties toegevoegd.

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

Hoewel in het vorige fragment de methode PoolOperations.istSupportedImages wordt gebruikt om dynamisch een lijst weer te geven en een keuze te maken uit ondersteunde combinaties van installatiekopieën en knooppuntagents (aanbevolen), kunt u ook een ImageReference expliciet configureren:

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

Verbinding maken met Linux-knooppunten met behulp van SSH

Tijdens de ontwikkeling of tijdens het oplossen van problemen moet u zich mogelijk aanmelden bij de knooppunten in uw pool. In tegenstelling tot Windows-rekenknooppunten kunt u Remote Desktop Protocol (RDP) niet gebruiken om verbinding te maken met Linux-knooppunten. In plaats daarvan schakelt de Batch-service SSH-toegang in op elk knooppunt voor externe verbinding.

Met het volgende Python-codefragment maakt u een gebruiker op elk knooppunt in een pool. Dit is vereist voor externe verbinding. Vervolgens worden de SSH-verbindingsgegevens (Secure Shell) voor elk knooppunt afgedrukt.

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

Deze code heeft uitvoer die vergelijkbaar is met het volgende voorbeeld. In dit geval bevat de pool vier Linux-knooppunten.

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

In plaats van een wachtwoord kunt u een openbare SSH-sleutel opgeven wanneer u een gebruiker op een knooppunt maakt.

Gebruik in de Python SDK de parameter ssh_public_key op ComputeNodeUser.

Gebruik in .NET de eigenschap ComputeNodeUser.SshPublicKey .

Prijzen

Azure Batch is gebaseerd op Azure Cloud Services- en Azure Virtual Machines-technologie. De Batch-service zelf wordt gratis aangeboden, wat betekent dat er alleen kosten in rekening worden gebracht voor de rekenresources (en de bijbehorende kosten die met zich meebrengen) die uw Batch-oplossingen verbruiken. Wanneer u Virtuele machineconfiguratie kiest, worden er kosten in rekening gebracht op basis van de Virtual Machines prijsstructuur.

Als u toepassingen implementeert op uw Batch-knooppunten met behulp van toepassingspakketten, worden er ook kosten in rekening gebracht voor de Azure Storage-resources die uw toepassingspakketten gebruiken.

Volgende stappen