Démarrage rapide : utiliser .NET pour créer un pool Batch, puis 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 Azure Batch .NET. L’application .NET :

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

Prérequis

• Compte Azure avec un abonnement actif. Si vous n’en avez pas un, 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 effectuer ce démarrage rapide, téléchargez ou clonez l’application, fournissez les valeurs des comptes, compilez, puis exécutez l’application, puis vérifiez la sortie.

Télécharger ou cloner l’application

Téléchargez ou clonez l’application Azure Batch .NET Quickstart depuis GitHub. Utilisez la commande ci-dessous pour cloner le référentiel d’application avec un client Git :

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

Fournir les informations sur les comptes

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

Pour obtenir les informations sur vos comptes à partir du portail Azure :

1. Dans la barre recherche Azure, recherchez et sélectionnez le nom de votre compte Batch.
2. Sur la page de votre compte Batch, sélectionnez Clés dans le volet de navigation de gauche.
3. 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é, puis modifiez les chaînes d’informations d’identification 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>

Compiler, puis exécuter l’application, puis afficher la sortie

Pour afficher le flux de travail Batch en action, compilez, puis exécutez l’application. Vous pouvez également utiliser la ligne de commande dotnet build et les commandes dotnet run.

Dans Visual Studio :

1. Ouvrez le fichier BatchDotNetQuickstart.sln, cliquez avec le bouton droit sur la solution dans Explorateur de solutions, puis sélectionnez Compiler. Si vous y êtes invité, utilisez le Gestionnaire de package NuGet pour mettre à jour ou restaurer des packages NuGet.

2. Une fois la compilation terminée, sélectionnez BatchDotNetQuickstart dans la barre de menus supérieure pour exécuter l’application.

Le temps d’exécution standard avec la configuration par défaut est d’environ cinq minutes. La configuration initial des nœuds du pool prend le plus de temps. Pour réexécuter le travail, supprimez-le de l’exécution précédente mais ne supprimez pas le pool. Sur un pool préconfiguré, le travail se termine en quelques secondes.

L’application retourne un résultat semblable à 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 des nœuds, des tâches et des travaux à 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 de l’application Azure Batch .NET Quickstart.

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

1. Pour interagir avec le compte de stockage, l’application utilise la bibliothèque de client Azure Storage Blob 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;
   

2. L’application utilise la référence blobServiceClient pour créer un conteneur dans le compte de stockage, ainsi que pour charger des fichiers de données dans le conteneur. Les fichiers de 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));
   }
   

3. L’application crée un objet BatchClient pour créer, puis gérer des pools, des travaux et des tâches. 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, la taille de machine virtuelle et la configuration du pool. L’objet VirtualMachineConfiguration suivant spécifie une référence ImageReference sur une image Windows Server publiée dans la Place de marché. Batch prend en charge une large plage d’images Windows Server et Linux dans la Place de marché, ainsi que les images de machines virtuelles personnalisées.

L’élément PoolNodeCount et la taille de machine virtuelle PoolVMSize sont des constantes définies. L’application crée un pool de deux nœuds de taille 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 soumet 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éation d’un travail Batch

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

L’application utilise la méthode BatchClient.JobOperations.CreateJob pour créer un travail sur votre pool. La méthode Commit soumet le travail au service Batch. Dans un premier temps, le travail n’a aucune tâche.

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. L’application crée une liste d’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 se trouve là où vous spécifiez votre application ou votre script.

La ligne de commande dans le 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, puis vérifier qu’elles se terminent. Lorsque chaque tâche s’exécute correctement, sa sortie s’écrit dans stdout.txt. L’application utilise ensuite la propriété CloudTask.ComputeNodeInformation pour afficher le fichier stdout.txt de 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 créé et vous donne la possibilité de supprimer le travail et le pool Azure Batch. Les pools et les nœuds entraînent des frais pendant l’exécution des nœuds, même s’ils n’exécutent pas de travaux. Si vous n’avez plus besoin du pool, supprimez-le.

Quand 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, entrez 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, des nœuds, un travail et des tâches Batch. 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 Azure Batch avec des charges de travail plus réalistes à plus grande échelle. Si vous souhaitez en savoir plus sur Azure Batch et parcourir une charge de travail parallèle avec une application réelle, veuillez passer au didacticiel .NET Batch.