Configurer des nœuds de calcul Linux dans des pools Batch

Vous pouvez utiliser Azure Batch pour exécuter des charges de travail de calcul parallèles sur les machines virtuelles Linux et Windows. Cet article explique comment créer des pools de nœuds de calcul Linux dans le service Batch à l’aide des Batch Python et Azure. Compute.Batch bibliothèques clientes.

Configuration de la machine virtuelle

Lorsque vous créez un pool de nœuds de calcul dans Batch, vous avez deux options pour sélectionner la taille du nœud et le système d’exploitation : Configuration des services cloud et Configuration de la machine virtuelle. Les pools de configuration de machine virtuelle sont composés de machines virtuelles Azure, qui peuvent être créées à partir d’images Linux ou Windows. Quand vous créez un pool avec une configuration de machine virtuelle, vous spécifiez une taille de nœud de calcul disponible, la référence d’image de machine virtuelle à installer sur les nœuds et la référence SKU de l’agent de nœud Batch (un programme qui s’exécute sur chaque nœud et fournit une interface entre le nœud et le service batch).

Référence d’image de machine virtuelle

Le service Batch utilise des groupes de machines virtuelles identiques pour fournir des nœuds de calcul dans la configuration de la machine virtuelle. Vous pouvez spécifier une image à partir de la Place de marché Azure ou utiliser l’Azure Compute Gallery pour préparer une image personnalisée.

Lorsque vous créez une référence d’image de machine virtuelle, vous devez spécifier les propriétés suivantes :

Propriété de référence d’image Exemple
Éditeur canonique
Offre 0001-com-ubuntu-server-focal
Référence (SKU) 20_04-lts
Version dernier

Conseil

Pour plus d’informations sur ces propriétés et sur la manière de spécifier des images de la Place de marché dans Rechercher des images de machine virtuelle Linux sur la Place de marché Microsoft Azure avec Azure CLI. Notez que certaines images Marketplace ne sont pas compatibles avec Batch pour le moment.

liste des images de machine virtuelle

Toutes les images du Marketplace ne sont pas compatibles avec les agents de nœud Batch actuellement disponibles. Pour répertorier toutes les images de machine virtuelle de la Place de marché prises en charge pour le service Batch et leurs références SKU d’agent de nœud correspondantes, utilisez list_supported_images (Python), BatchClient.GetSupportedImagesAsync (Azure. Compute.Batch), ou l’API correspondante dans un autre KIT SDK de langage.

Référence de l’agent de nœud

L’agent de nœud Batch est un programme qui s’exécute sur chacun des nœuds du pool. Il constitue l’interface de commande et de contrôle entre le nœud et le service Batch. Il existe différentes implémentations de l’agent de nœud, appelées SKU, pour différents systèmes d’exploitation. Essentiellement, lorsque vous créez une configuration de machine virtuelle, vous spécifiez d’abord la référence de l’image de la machine virtuelle, puis spécifiez l’agent de nœud à installer sur l’image. En règle générale, chaque référence d’agent de nœud est compatible avec plusieurs images de machine virtuelle. Pour afficher les références SKU de l’agent de nœud prises en charge et les compatibilités d’images de machine virtuelle, vous pouvez utiliser la commande CLI Azure Batch :

az batch pool supported-images list

Pour plus d’informations, vous pouvez vous référer à Account - List Supported Images - REST API (Azure Batch Service) | Microsoft Docs.

Création d’un pool Linux : Python Batch

L’extrait de code suivant offre un exemple d’utilisation de la bibliothèque cliente Microsoft Azure Batch pour Python pour créer un pool de nœuds de calcul de serveur Ubuntu. Pour plus d’informations sur le module Batch Python, consultez la documentation de référence.

Cet extrait de code crée explicitement un BatchVmImageReference et spécifie chacune de ses propriétés (éditeur, offre, référence SKU, version). Toutefois, dans un code de production, nous vous recommandons toutefois d’utiliser la méthode list_supported_images pour opérer une sélection parmi les combinaisons disponibles de références SKU d’image et de nœud d’agent au moment du runtime.

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

Comme mentionné précédemment, nous vous recommandons d’utiliser la méthode list_supported_images pour sélectionner dynamiquement parmi les combinaisons d’images de l’agent de nœud/place de marché actuellement prises en charge (plutôt que de créer explicitement un BatchVmImageReference ). L’extrait de code Python suivant illustre l’utilisation de cette méthode.

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

Création d’un pool Linux : .NET Batch

L’extrait de code suivant montre un exemple d’utilisation du Azure. Compute.Batch et Azure. ResourceManager.Batch bibliothèques clientes pour créer un pool de nœuds de calcul Ubuntu Server. Pour plus d’informations, consultez la documentation de référence.

L’extrait de code suivant utilise la méthode BatchClient.GetSupportedImages pour opérer une sélection dans la liste des combinaisons d’image de la Place de marché et de référence SKU d’agent de nœud actuellement prises en charge. Cette technique est recommandée car la liste des combinaisons prises en charge peut changer de temps à autre. En règle générale, les combinaisons prises en charge sont ajoutées.

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

Bien que l’extrait de code précédent utilise la méthode BatchClient.GetSupportedImages pour répertorier et sélectionner dynamiquement parmi les combinaisons de référenceS SKU de l’agent d’image et de nœud prises en charge (recommandé), vous pouvez également configurer une référence BatchVmImageReference explicitement :

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

Se connecter à des nœuds Linux via SSH

Pendant le développement ou lors de la résolution des problèmes, il peut s’avérer nécessaire de se connecter aux nœuds de votre pool. Contrairement aux nœuds de calcul Windows, vous ne pouvez pas utiliser le protocole RDP (Bureau à distance Protocol) pour se connecter à des nœuds Linux. Au lieu de cela, le service Batch autorise l’accès SSH sur chaque nœud de connexion à distance.

L’extrait de code Python suivant crée un utilisateur sur chaque nœud d’un pool, nécessaire à la connexion à distance. Il imprime ensuite les informations de connexion SSH pour chaque nœud.

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

Le résultat pour ce code ressemble à l’exemple suivant. Dans ce cas, le pool contient quatre nœuds 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

Au lieu d’un mot de passe, vous pouvez spécifier une clé publique SSH lorsque vous créez un utilisateur sur un nœud.

Dans le sdk Python, utilisez le paramètre ssh_public_key sur BatchNodeUserCreateOptions.

Dans .NET, utilisez la propriété BatchNodeUserCreateOptions.SshPublicKey.

Tarifs

Azure Batch est basé sur la technologie d’Azure Cloud Services et des machines virtuelles Azure. Le service Batch lui-même est proposé gratuitement, ce qui signifie que vous payez uniquement les ressources de calcul (et les coût associés qu’elles impliquent) que vos solutions Batch utilisent. Si vous sélectionnez la Configuration de la machine virtuelle, vous êtes facturé en fonction de la structure de tarification des machines virtuelles.

Si vous déployez des applications sur vos nœuds Batch à l’aide de packages d’application, vous êtes également facturé pour les ressources Stockage Azure que vos packages d’application consomment.

Étapes suivantes

  • Last updated on