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

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 stockage Azure à 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.

Compte Batch
Point de terminaison de compte
Nom du compte de stockage
ID d’abonnement
Nom du groupe de ressources

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
const string BatchAccountName = "<batch account>";
const string BatchAccountUrl  = "<account endpoint>";

// Azure Resource Manager credentials for the Batch account
const string SubscriptionId    = "<subscription ID>";
const string ResourceGroupName = "<resource group name>";

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

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.

string blobUri = "https://" + storageAccountName + ".blob.core.windows.net";

var blobServiceClient = new BlobServiceClient(new Uri(blobUri), new DefaultAzureCredential());
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 à partir de la bibliothèque Azure.Compute.Batch pour créer et gérer des travaux par lots et des tâches. Le client Batch utilise l’authentification Microsoft Entra.
```
BatchClient batchClient = new BatchClient(new Uri(BatchAccountUrl), new DefaultAzureCredential());
...
```

L’application utilise également la bibliothèque Azure.ResourceManager.Batch pour gérer le compte Batch et ses pools. Il crée un ArmClient et obtient une référence BatchAccountResource pour le compte Batch à l’aide de l’ID d’abonnement, du nom du groupe de ressources et du nom du compte Batch.

ArmClient armClient = new ArmClient(new DefaultAzureCredential());

ResourceIdentifier batchAccountIdentifier = BatchAccountResource.CreateResourceIdentifier(
    SubscriptionId,
    ResourceGroupName,
    BatchAccountName);

BatchAccountResource batchAccount = armClient.GetBatchAccountResource(batchAccountIdentifier);

Créer un pool de nœuds de calcul

Pour créer un pool Batch, l’application utilise la méthode BatchAccountPoolCollection.CreateOrUpdateAsync pour définir le nombre de nœuds, de taille de machine virtuelle et de configuration du pool. L’objet BatchVmConfiguration suivant spécifie une BatchImageReference sur une image de la Place de marché 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.

BatchImageReference imageReference = new BatchImageReference()
{
    Publisher = "MicrosoftWindowsServer",
    Offer = "WindowsServer",
    Sku = "2016-datacenter-smalldisk",
    Version = "latest"
};

BatchVmConfiguration vmConfiguration = new BatchVmConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.windows amd64");

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = PoolVMSize,
    DeploymentConfiguration = new BatchDeploymentConfiguration() { VmConfiguration = vmConfiguration },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        FixedScale = new BatchAccountFixedScaleSettings() { TargetDedicatedNodes = PoolNodeCount }
    }
};

await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, PoolId, poolData);

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 BatchClient.CreateJobAsync pour créer une tâche dans votre pool. Au début, le travail n’a pas de tâches.

BatchJobCreateOptions job = new BatchJobCreateOptions(JobId, new BatchPoolInfo() { PoolId = PoolId });
await batchClient.CreateJobAsync(job);

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 d’objets 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 les tâches au travail avec BatchClient.CreateTasksAsync, qui met en file d’attente les tâches à 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);

    BatchTaskCreateOptions task = new BatchTaskCreateOptions(taskId, taskCommandLine)
    {
        ResourceFiles = { inputFiles[i] }
    };
    tasks.Add(task);
}

await batchClient.CreateTasksAsync(JobId, tasks);

Afficher la sortie des tâches

L’application attend que les tâches se terminent. Lorsque chaque tâche s’exécute correctement, elle envoie sa sortie vers stdout.txt. L’application utilise ensuite la propriété BatchTask.NodeInfo pour afficher le fichier stdout.txt pour chaque tâche terminée.

await foreach (BatchTask task in batchClient.GetTasksAsync(JobId))
{
    string nodeId = task.NodeInfo?.NodeId ?? "<unknown>";
    Console.WriteLine("Task: {0}", task.Id);
    Console.WriteLine("Node: {0}", nodeId);
    Console.WriteLine("Standard out:");
    BinaryData stdout = await batchClient.GetTaskFileAsync(JobId, task.Id, "stdout.txt");
    Console.WriteLine(stdout.ToString());
}

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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-05-20