Share via

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 in de Batch-service maakt met behulp van zowel de Batch Python - als Batch .NET-clientbibliotheken .

Configuratie van virtuele machine

Wanneer u een pool met rekenknooppunten in Batch maakt, hebt u twee opties waaruit u de grootte en het besturingssysteem van het knooppunt kunt selecteren: Cloud Services Configuration en Virtual Machine Configuration. Virtuele-machineconfiguratiegroepen bestaan uit Virtuele Azure-machines, die kunnen worden gemaakt op basis van Linux- of Windows-installatiekopieën. Wanneer u een pool maakt met configuratie van virtuele machines, geeft u een beschikbare rekenknooppuntgrootte op, de verwijzing naar de installatiekopieën van de virtuele machine op de knooppunten 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 in de configuratie van de virtuele machine te bieden. U kunt een installatiekopieën opgeven vanuit Azure Marketplace 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
Aanbieden UbuntuServer
SKU 20.04-LTS
Versie nieuwste

Tip

Meer informatie over deze eigenschappen en het opgeven van Marketplace-installatiekopieën in Installatiekopieën voor Virtuele Linux-machines zoeken in 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 opdracht-en-beheerinterface 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 in wezen eerst de verwijzing naar de installatiekopieën van de virtuele machine op en geeft u vervolgens de knooppuntagent op die moet worden geïnstalleerd op de installatiekopieën. Normaal gesproken is elke knooppuntagent-SKU compatibel met meerdere installatiekopieën van virtuele machines. Als u de ondersteunde knooppuntagent-SKU's en compatibiliteitsproblemen met installatiekopieën van virtuele machines wilt weergeven, kunt u de Azure Batch CLI-opdracht gebruiken:

az batch pool supported-images list

Voor meer informatie kunt u verwijzen naar Account - Lijst met ondersteunde installatiekopieën - REST API (Azure Batch Service) | 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. Raadpleeg de referentiedocumentatie voor meer informatie over de Batch Python-module.

Met dit fragment maakt u expliciet een ImageReference en geeft u elk van de eigenschappen op (uitgever, aanbieding, SKU, versie). In productiecode raden we u echter aan om tijdens runtime de list_supported_images methode te gebruiken om een keuze te maken uit de beschikbare combinaties van installatiekopieën en knooppuntagentagenten.

# 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 in de momenteel ondersteunde knooppuntagent/Marketplace-installatiekopiecombinaties (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 het gebruik van de Batch .NET-clientbibliotheek om een pool met Ubuntu Server-rekenknooppunten te maken. Raadpleeg 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 momenteel ondersteunde Combinaties van Marketplace-installatiekopieën en knooppuntagentagents. 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 het vorige codefragment gebruikmaakt van de methode PoolOperations.istSupportedImages om dynamisch een lijst te maken en te selecteren uit ondersteunde combinaties van installatiekopieën en knooppuntagentagenten (aanbevolen), kunt u ook expliciet een ImageReference 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 is het mogelijk nodig om u aan te melden 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 gepaard gaan) die uw Batch-oplossingen verbruiken. Wanneer u Virtual Machine Configuration kiest, worden er kosten in rekening gebracht op basis van de prijsstructuur van virtuele machines.

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

  • Verken de Python-codevoorbeelden in de GitHub-opslagplaats azure-batch-samples om te zien hoe u algemene Batch-bewerkingen uitvoert, zoals pool, taak en het maken van taken. De README die bij de Python-voorbeelden hoort, bevat informatie over het installeren van de vereiste pakketten.
  • Meer informatie over het gebruik van Azure Spot-VM's met Batch.