Bereitstellen von Linux-Computeknoten in Batch-Pools

Sie können Azure Batch verwenden, um Computeworkloads auf virtuellen Linux- und Windows-Computern parallel auszuführen. In diesem Artikel wird erläutert, wie Sie im Batchdienst mithilfe der Clientbibliotheken Batch Python und Azure.Compute.Batch Pools mit Linux-Computeknoten erstellen.

VM-Konfiguration

Wenn Sie einen Pool von Computeknoten in Batch erstellen, stehen Ihnen zwei Optionen zur Auswahl der Knotengröße und des Betriebssystems zur Verfügung: die Clouddienstkonfiguration und die Konfiguration des virtuellen Computers. Pools mit der Konfiguration virtueller Computer bestehen aus Azure-VMs, die entweder aus Linux- oder Windows-Images erstellt werden können. Wenn Sie einen Pool mit der VM-Konfiguration erstellen, geben Sie eine verfügbare Computeknotengröße, die auf dem Knoten zu installierende VM-Imagereferenz und die SKU des Batch-Knoten-Agents (ein auf jedem Knoten ausgeführtes Programm, das eine Schnittstelle zwischen dem Knoten und dem Batch-Dienst bereitstellt) an.

Imageverweis für virtuelle Maschinen

Der Batch-Dienst verwendet VM-Skalierungsgruppen, um Computeknoten in der VM-Konfiguration bereitzustellen. Sie können ein Image aus dem Azure Marktplatz angeben oder mithilfe von Azure Compute Gallery ein benutzerdefiniertes Image vorbereiten.

Beim Erstellen einer VM-Imagereferenz müssen Sie die folgenden Eigenschaften angeben:

Imagereferenzeigenschaft	Beispiel
Herausgeber	kanonisch
Angebot	0001-com-ubuntu-server-focal
SKU	20_04-lts
Version	Neueste

Tipp

Weitere Informationen zu diesen Eigenschaften und zum Angeben von Marketplace-Images finden Sie unter Suchen nach Linux-VM-Images im Azure Marketplace mit der Azure CLI. Beachten Sie, dass einige Marketplace-Images derzeit nicht mit Batch kompatibel sind.

Liste mit VM-Images

Nicht alle Marketplace-Images sind mit den derzeit verfügbaren Batch-Knoten-Agenten kompatibel. Um alle unterstützten Images für virtuelle Computer aus dem Marketplace für den Batch-Dienst sowie die zugehörigen Knoten-Agent-SKUs aufzulisten, verwenden Sie list_supported_images (Python), BatchClient.GetSupportedImagesAsync (Azure.Compute.Batch) oder die entsprechende API in einem SDK für eine andere Sprache.

Knoten-Agent-SKU

Der Batch-Knoten-Agent ist ein Programm, das auf jedem Knoten im Pool ausgeführt wird. Er stellt die Befehls- und Steuerungsschnittstelle zwischen dem Knoten und dem Batch-Dienst dar. Es gibt verschiedene Implementierungen des Knoten-Agents (SKUs) für verschiedene Betriebssysteme. Insbesondere beim Erstellen einer Konfiguration für einen virtuellen Computer legen Sie zuerst die VM-Imagereferenz und anschließend den Knoten-Agent fest, der auf dem Image installiert werden soll. In der Regel ist jede Knoten-Agent-SKU mit mehreren VM-Images kompatibel. Um die unterstützten Knoten-Agent-SKUs und Kompatibilitäten von VM-Images anzuzeigen, können Sie diesen Azure Batch CLI-Befehl verwenden:

az batch pool supported-images list

Weitere Informationen finden Sie unter Konto – Auflisten unterstützter Images – REST-API (Azure Batch Service) | Microsoft-Dokumentation.

Erstellen eines Linux-Pools: Batch Python

Der folgende Codeausschnitt zeigt ein Beispiel für die Erstellung eines Pools mit Ubuntu Server-Computeknoten mithilfe der Microsoft Azure Batch-Clientbibliothek für Python. Weitere Informationen zum Batch-Python-Modul finden Sie in der Referenzdokumentation.

Dieser Codeausschnitt erstellt eine BatchVmImageReference explizit und gibt jede seiner Eigenschaften an (Herausgeber, Angebot, SKU, Version). Im Produktionscode sollten Sie jedoch die Methode list_supported_images verwenden, um die verfügbaren Kombinationen aus Image und Knoten-Agent-SKU zur Laufzeit auszuwählen.

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

Wie bereits erwähnt, empfehlen wir die Verwendung der list_supported_images-Methode , um dynamisch aus den derzeit unterstützten Knoten-Agent/Marketplace-Imagekombinationen auszuwählen (anstatt eine BatchVmImageReference explizit zu erstellen). Der folgende Python-Ausschnitt veranschaulicht die Verwendung dieser Methode.

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

Erstellen eines Linux-Pools: Batch .NET

Der folgende Codeausschnitt zeigt ein Beispiel für die Verwendung des Azure. Compute.Batch und Azure. ResourceManager.Batch Clientbibliotheken zum Erstellen eines Pools von Ubuntu Server-Computeknoten. Weitere Informationen finden Sie in der Referenzdokumentation.

Der folgende Codeausschnitt verwendet die BatchClient.GetSupportedImages-Methode , um aus der Liste der derzeit unterstützten Marketplace-Image- und Knoten-Agent-SKU-Kombinationen auszuwählen. Diese Vorgehensweise wird empfohlen, da sich die Liste mit den unterstützten Kombinationen von Zeit zu Zeit ändern kann. In den meisten Fällen werden unterstützte Kombinationen hinzugefügt.

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

Obwohl der vorherige Codeausschnitt die BatchClient.GetSupportedImages-Methode verwendet, um dynamisch eine Liste und Auswahl aus unterstützten Bild- und Knoten-Agent-SKU-Kombinationen (empfohlen) durchzuführen, können Sie auch eine BatchVmImageReference explizit konfigurieren:

BatchImageReference imageReference = new BatchImageReference()
{
    Publisher = "canonical",
    Offer = "0001-com-ubuntu-server-focal",
    Sku = "20_04-lts",
    Version = "latest"
};

Herstellen einer Verbindung mit Linux-Knoten über SSH

Während der Entwicklung oder bei der Fehlerbehebung ist es unter Umständen erforderlich, sich bei den Knoten im Pool anzumelden. Im Gegensatz zu Windows-Computeknoten können Sie das Remotedesktopprotokoll (RDP) nicht für die Herstellung einer Verbindung mit Linux-Knoten verwenden. Stattdessen ermöglicht der Batch-Dienst den SSH-Zugriff auf jeden Knoten zum Herstellen einer Remoteverbindung.

Mit dem folgenden Python-Codeausschnitt wird ein Benutzer für jeden Knoten eines Pools erstellt, der für eine Remoteverbindung erforderlich ist. Anschließend werden die SSH-Verbindungsinformationen (Secure Shell) für die einzelnen Knoten ausgegeben.

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

Die Ausgabe dieses Codes sieht in etwa wie im folgenden Beispiel aus. In diesem Fall enthält der Pool vier Linux-Knoten.

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

Anstelle eines Kennworts können Sie einen öffentlichen SSH-Schlüssel festlegen, wenn Sie einen Benutzer auf einem Knoten erstellen.

Verwenden Sie im Python SDK den Parameter ssh_public_key für BatchNodeUserCreateOptions.

Verwenden Sie in .NET die Eigenschaft BatchNodeUserCreateOptions.SshPublicKey.

Preise

Azure Batch basiert auf der Technologie von Azure Cloud Services und von Azure Virtual Machines. Der Batch-Dienst selbst wird kostenlos angeboten, d. h. dass Ihnen nur die Computeressourcen (und die damit verbundenen Kosten) in Rechnung gestellt werden, die Ihre Batch-Lösungen beanspruchen. Wenn Sie sich für die VM-Konfiguration entscheiden, erfolgt die Abrechnung auf der Grundlage der Preisstruktur unter Virtuelle Computer – Preise.

Wenn Sie Anwendungen mit Anwendungspaketen auf Ihren Batch-Knoten bereitstellen, werden auch die von Ihren Anwendungspaketen genutzten Azure Storage-Ressourcen in Rechnung gestellt.

Nächste Schritte

Sehen Sie sich die Python-Codebeispiele im GitHub-Repository azure-batch-samples an, um zu erfahren, wie Sie allgemeine Batch-Vorgänge wie die Erstellung von Pools, Aufträgen und Aufgaben ausführen. Die jeweils zu den Python-Beispielen gehörende INFODATEI enthält Details zur Installation der erforderlichen Pakete.
Erfahren Sie mehr über die Verwendung von Azure Spot-VMs mit Batch.

Feedback

War diese Seite hilfreich?

Last updated on 2026-05-26