Démarrage rapide : Utiliser .NET pour créer un pool Batch et exécuter un travail

2025-04-17

Ce guide de démarrage rapide vous montre comment commencer à utiliser Azure Batch en exécutant une application C# qui utilise l’API .NET Azure Batch. L’application .NET :

Charge plusieurs fichiers de données d’entrée dans un conteneur blob Azure Storage à utiliser pour le traitement des tâches Batch.
Crée un pool de deux machines virtuelles ou nœuds de calcul exécutant Windows Server.
Crée un travail qui exécute des tâches sur les nœuds pour traiter chaque fichier d’entrée à l’aide d’une ligne de commande Windows.
Affiche les fichiers de sortie retournés par les tâches.

À l’issue de ce démarrage rapide, vous maîtriserez les principaux concepts du service Batch et serez prêt à utiliser Batch avec des charges de travail plus réalistes à plus grande échelle.

Conditions préalables

Un compte Azure avec un abonnement actif. Si vous n’en avez pas, créez un compte gratuitement.
Un compte Batch et un compte Stockage Azure lié. Vous pouvez créer les comptes à l’aide de l’une des méthodes suivantes : Azure CLI | portail Azure | Bicep | modèle ARM | Terraform.
Visual Studio 2019 ou version ultérieure, ou .NET 6.0 ou version ultérieure, pour Linux ou Windows.

Exécuter l’application

Pour suivre ce guide de démarrage rapide, vous téléchargez ou clonez l’application, fournissez les valeurs de votre compte, générez et exécutez l’application, puis vérifiez la sortie.

Télécharger ou cloner l’application

Téléchargez ou clonez l’application de démarrage rapide Azure Batch .NET à partir de GitHub. Utilisez la commande suivante pour cloner le dépôt d’application avec un client Git :

git clone https://github.com/Azure-Samples/batch-dotnet-quickstart.git

Fournissez les informations de votre compte

L’application doit utiliser vos noms de compte Batch et de stockage, les valeurs de clé de compte et le point de terminaison du compte Batch. Vous pouvez obtenir ces informations à partir du portail Azure, des API Azure ou des outils en ligne de commande.

Pour obtenir des informations sur votre compte à partir du portail Azure :

Dans la barre recherche Azure, recherchez et sélectionnez le nom de votre compte Batch.
Sur la page de votre compte Batch, sélectionnez Clés dans le volet de navigation de gauche.
Sur la page Clés, copiez les valeurs suivantes :

Compte Batch
Point de terminaison de compte
Clé d’accès primaire
Nom du compte de stockage
Key1

Accédez à votre dossier batch-dotnet-quickstart téléchargé et modifiez les chaînes d'identifiants dans Program.cs pour fournir les valeurs que vous avez copiées :

// Batch account credentials
private const string BatchAccountName = "<batch account>";
private const string BatchAccountKey  = "<primary access key>";
private const string BatchAccountUrl  = "<account endpoint>";

// Storage account credentials
private const string StorageAccountName = "<storage account name>";
private const string StorageAccountKey  = "<key1>

Important

L’exposition des clés de compte dans la source de l’application n’est pas recommandée pour l’utilisation en production. Vous devez restreindre l’accès aux informations d’identification et y faire référence dans votre code à l’aide de variables ou d’un fichier de configuration. Il est préférable de stocker les clés de compte Batch et de stockage dans Azure Key Vault.

Générer et exécuter l’application et afficher la sortie

Pour afficher le flux de travail Batch en action, générez et exécutez l’application dans Visual Studio. Vous pouvez également utiliser les commandes en ligne de commande dotnet build et dotnet run.

Dans Visual Studio :

Ouvrez le fichier BatchDotNetQuickstart.sln , cliquez avec le bouton droit sur la solution dans l’Explorateur de solutions, puis sélectionnez Générer. Si vous y êtes invité, utilisez le Gestionnaire de package NuGet pour mettre à jour ou restaurer des packages NuGet.
Une fois la build terminée, sélectionnez BatchDotNetQuickstart dans la barre de menus supérieure pour exécuter l’application.

Le temps d’exécution classique avec la configuration par défaut est d’environ cinq minutes. La configuration initiale du nœud de pool prend le plus de temps. Pour réexécuter la tâche, supprimez la tâche de la dernière exécution, mais ne supprimez pas le pool. Sur un pool préconfiguré, le travail se termine en quelques secondes.

L’application retourne une sortie similaire à l’exemple suivant :

Sample start: 11/16/2022 4:02:54 PM

Container [input] created.
Uploading file taskdata0.txt to container [input]...
Uploading file taskdata1.txt to container [input]...
Uploading file taskdata2.txt to container [input]...
Creating pool [DotNetQuickstartPool]...
Creating job [DotNetQuickstartJob]...
Adding 3 tasks to job [DotNetQuickstartJob]...
Monitoring all tasks for 'Completed' state, timeout in 00:30:00...

Il y a une pause dans Monitoring all tasks for 'Completed' state, timeout in 00:30:00... au moment où les nœuds de calcul du pool démarrent. À mesure que les tâches sont créées, Batch les met en file d’attente pour qu’elles s’exécutent sur le pool. Dès que le premier nœud de calcul est disponible, la première tâche s’exécute sur le nœud. Vous pouvez surveiller l’état du nœud, de la tâche et du travail à partir de la page de votre compte Batch dans le portail Azure.

Une fois chaque tâche terminée, vous voyez une sortie similaire à l’exemple suivant :

Printing task output.
Task: Task0
Node: tvm-2850684224_3-20171205t000401z
Standard out:
Batch processing began with mainframe computers and punch cards. Today it still plays a central role...
stderr:
...

Vérifier le code

Passez en revue le code pour comprendre les étapes du guide de démarrage rapide Azure Batch .NET.

Créer des clients de service et charger des fichiers de ressources

Pour interagir avec le compte de stockage, l’application utilise la bibliothèque de client Stockage Blobs Azure pour .NET afin de créer un BlobServiceClient.

var sharedKeyCredential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
string blobUri = "https://" + storageAccountName + ".blob.core.windows.net";

var blobServiceClient = new BlobServiceClient(new Uri(blobUri), sharedKeyCredential);
return blobServiceClient;

L’application utilise la blobServiceClient référence pour créer un conteneur dans le compte de stockage et charger des fichiers de données dans le conteneur. Les fichiers dans le stockage sont définis en tant qu’objets Batch ResourceFile que Batch peut télécharger ultérieurement sur les nœuds de calcul.
```
List<string> inputFilePaths = new()
{
    "taskdata0.txt",
    "taskdata1.txt",
    "taskdata2.txt"
};

var inputFiles = new List<ResourceFile>();

foreach (var filePath in inputFilePaths)
{
    inputFiles.Add(UploadFileToContainer(containerClient, inputContainerName, filePath));
}
```
L’application crée un objet BatchClient pour créer et gérer des pools, des travaux et des tâches Batch. Le client Batch utilise l’authentification par clé partagée. Batch prend également en charge l’authentification Microsoft Entra.
```
var cred = new BatchSharedKeyCredentials(BatchAccountUrl, BatchAccountName, BatchAccountKey);

 using BatchClient batchClient = BatchClient.Open(cred);
...
```

Créer un pool de nœuds de calcul

Pour créer un pool Batch, l’application utilise la méthode BatchClient.PoolOperations.CreatePool pour définir le nombre de nœuds, de taille de machine virtuelle et de configuration du pool. L’objet VirtualMachineConfiguration suivant spécifie une ImageReference pour une image Marketplace Windows Server. Batch prend en charge un large éventail d’images de système d’exploitation windows Server et Linux Marketplace, et prend également en charge les images de machine virtuelle personnalisées.

La PoolNodeCount et la taille de VM PoolVMSize sont des constantes définies. L’application crée un pool de deux nœuds Standard_A1_v2. Cette taille offre un bon compromis entre performance et coût dans ce guide de démarrage rapide.

La méthode Commit envoie le pool au service Batch.


private static VirtualMachineConfiguration CreateVirtualMachineConfiguration(ImageReference imageReference)
{
    return new VirtualMachineConfiguration(
        imageReference: imageReference,
        nodeAgentSkuId: "batch.node.windows amd64");
}

private static ImageReference CreateImageReference()
{
    return new ImageReference(
        publisher: "MicrosoftWindowsServer",
        offer: "WindowsServer",
        sku: "2016-datacenter-smalldisk",
        version: "latest");
}

private static void CreateBatchPool(BatchClient batchClient, VirtualMachineConfiguration vmConfiguration)
{
    try
    {
        CloudPool pool = batchClient.PoolOperations.CreatePool(
            poolId: PoolId,
            targetDedicatedComputeNodes: PoolNodeCount,
            virtualMachineSize: PoolVMSize,
            virtualMachineConfiguration: vmConfiguration);

        pool.Commit();
    }
...

Créer une tâche par lots

Un travail Batch est un regroupement logique d’une ou plusieurs tâches. Le travail inclut des paramètres communs aux tâches, tels que la priorité et le pool sur lequel exécuter des tâches.

L'application utilise la méthode BatchClient.JobOperations.CreateJob pour créer un job dans votre pool. La méthode Commit envoie le travail au service Batch. Au début, le travail n’a pas de tâches.

try
{
    CloudJob job = batchClient.JobOperations.CreateJob();
    job.Id = JobId;
    job.PoolInformation = new PoolInformation { PoolId = PoolId };

    job.Commit();
}
...

Créer des tâches

Azure Batch fournit plusieurs façons de déployer des applications et des scripts sur des nœuds de calcul. Cette application crée une liste des objets CloudTask d’entrée ResourceFile. Chaque tâche traite un fichier d’entrée à l’aide d’une propriété CommandLine . La ligne de commande Batch est l’emplacement où vous spécifiez votre application ou votre script.

La ligne de commande du code suivant exécute la commande Windows type pour afficher les fichiers d’entrée. Ensuite, l’application ajoute chaque tâche au travail avec la méthode AddTask , qui met en file d’attente la tâche à exécuter sur les nœuds de calcul.

for (int i = 0; i < inputFiles.Count; i++)
{
    string taskId = String.Format("Task{0}", i);
    string inputFilename = inputFiles[i].FilePath;
    string taskCommandLine = String.Format("cmd /c type {0}", inputFilename);

    var task = new CloudTask(taskId, taskCommandLine)
    {
        ResourceFiles = new List<ResourceFile> { inputFiles[i] }
    };
    tasks.Add(task);
}

batchClient.JobOperations.AddTask(JobId, tasks);

Afficher la sortie des tâches

L’application crée un TaskStateMonitor pour surveiller les tâches et s’assurer qu’elles se terminent. Lorsque chaque tâche s’exécute correctement, elle envoie sa sortie vers stdout.txt. L’application utilise ensuite la propriété CloudTask.ComputeNodeInformation pour afficher le fichier stdout.txt pour chaque tâche terminée.

foreach (CloudTask task in completedtasks)
{
    string nodeId = String.Format(task.ComputeNodeInformation.ComputeNodeId);
    Console.WriteLine("Task: {0}", task.Id);
    Console.WriteLine("Node: {0}", nodeId);
    Console.WriteLine("Standard out:");
    Console.WriteLine(task.GetNodeFile(Constants.StandardOutFileName).ReadAsString());
}

Nettoyer les ressources

L’application supprime automatiquement le conteneur de stockage qu’elle crée et vous donne la possibilité de supprimer le pool et le travail Batch. Les pools et les nœuds engendrent des frais tant que les nœuds sont en fonctionnement, même s'ils n'exécutent pas de tâches. Si vous n’avez plus besoin du pool, supprimez-le.

Lorsque vous n’avez plus besoin de votre compte Batch et de votre compte de stockage, vous pouvez supprimer le groupe de ressources qui les contient. Dans le portail Azure, sélectionnez Supprimer le groupe de ressources en haut de la page du groupe de ressources. Dans l’écran Supprimer un groupe de ressources, saisissez le nom du groupe de ressources concerné, puis sélectionnez Supprimer.

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez exécuté une application qui utilise l’API Batch .NET pour créer un pool Batch, des nœuds, un travail et des tâches. Le travail a chargé des fichiers de ressources dans un conteneur de stockage, exécuté des tâches sur les nœuds et affiché la sortie des nœuds.

Maintenant que vous maîtrisez les concepts clés du service Batch, vous êtes prêt à utiliser Batch avec des charges de travail plus réalistes et à plus grande échelle. Pour en savoir plus sur Azure Batch et parcourir une charge de travail parallèle avec une application réelle, passez au didacticiel Batch .NET.

Traiter une charge de travail parallèle avec .NET