Partager via

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

  • Article

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 de bibliothèques clientes Batch Python et Batch .NET.

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 de l’image de la 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
Serveur de publication canonical
Offre 0001-com-ubuntu-server-focal
Référence (SKU) 20_04-lts
Version latest

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 de la Place de marché ne sont pas compatibles avec les agents de nœud Batch actuellement disponibles. Pour répertorier la liste de toutes les images de machine virtuelle de la Place de marché prises en charge pour le service Batch et les références SKU des agents de nœud correspondants, utilisez list_supported_images (Python), ListSupportedImages (Batch.NET) ou l’API correspondante dans le Kit de développement logiciel (SDK) pour l’autre langue.

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 pour différents systèmes d’exploitation, connues sous le nom de références. 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 paramètre ImageReference 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
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="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 = 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)

Comme nous l’avons indiqué, nous vous recommandons d’utiliser la méthode list_supported_images afin d’opérer une sélection de manière dynamique parmi les combinaisons d’image d’agent de nœud/marketplace actuellement prises en charge (au lieu de créer explicitement une ImageReference). L’extrait de code Python suivant illustre l’utilisation de cette méthode.

# 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() == "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 = batchmodels.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 offre un exemple d’utilisation de la bibliothèque cliente Batch .NET pour créer un pool de nœuds de calcul de serveur Ubuntu. Pour plus d’informations sur Batch .NET, consultez la documentation de référence.

L’extrait de code suivant utilise la méthode PoolOperations.ListSupportedImages 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<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 == "0001-com-ubuntu-server-focal" &&
        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();

Bien que l’extrait de code ci-dessus utilise la méthode PoolOperations.istSupportedImages pour répertorier et sélectionner de manière dynamique des combinaisons d’images et de références SKU d’agent de nœud prises en charge (recommandé), vous pouvez également configurer explicitement ImageReference :

ImageReference imageReference = new ImageReference(
    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 (Remote Desktop 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
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))

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 ComputeNodeUser.

Dans .NET, utilisez la propriété ComputeNodeUser.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