Exercice - Gérer et déployer des applications sur des nœuds de calcul - Training

10 minutes

L’API du client Azure Batch vous permet de contrôler par programmation tous les composants d’un compte Azure Batch.

Pour poursuivre l’amélioration de l’application de votre entreprise, vous allez maintenant ajouter tous les composants nécessaires pour convertir les vidéos que vous avez chargées au cours de l’exercice précédent.

Important

Vous avez besoin de votre propre abonnement Azure pour exécuter cet exercice et des frais pourraient vous être facturés. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

À la fin de cet exercice, vous disposerez d’un processus Batch opérationnel capable de convertir des vidéos MP4 en images GIF animées. L’application ajoutera un travail au pool existant, puis ajoutera et démarrera les tâches de conversion vidéo.

Améliorer le code à l’aide du client Batch

Dans Cloud Shell, modifiez le fichier Program.cs dans l’éditeur :
```
code Program.cs
```
Ajoutez une constante à Program.cs pour le JobId que nous allons utiliser dans notre travail Batch :
```
private const string JobId = "WinFFmpegJob";
```

Remplacez les lignes suivantes de la méthode Main :

    var batchClient = BatchClient.Open(sharedKeyCredentials);

    // Create the Batch pool, which contains the compute nodes that execute tasks.
    await CreateBatchPoolAsync(batchClient, PoolId);

Avec un bloc using pour le batchClient :

using (BatchClient batchClient = BatchClient.Open(sharedKeyCredentials))
{
    // Create the Batch pool, which contains the compute nodes that execute the tasks.
    await CreateBatchPoolAsync(batchClient, PoolId);

    // Create the job that runs the tasks.
    await CreateJobAsync(batchClient, JobId, PoolId);

    // Create a collection of tasks and add them to the Batch job.
    await AddTasksAsync(batchClient, JobId, inputFiles, outputContainerSasUrl);
}

Créer un travail

Ajoutez cette nouvelle méthode, CreateJobAsync(), à Program.cs pour créer un travail et l’ajouter au pool :

private static async Task CreateJobAsync(BatchClient batchClient, string jobId, string poolId)
{
        Console.WriteLine("Creating job [{0}]...", jobId);

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

        await job.CommitAsync();
}

Le code ci-dessus utilise le client Batch pour créer un travail. La méthode affecte l’ID de la tâche donnée et des informations sur le pool.

Ajouter une tâche

Une fois le travail créé, la dernière étape consiste à ajouter une tâche au travail. Ajoutez la méthode suivante, AddTaskAsync(), à Program.cs :

private static async Task<List<CloudTask>> AddTasksAsync(BatchClient batchClient, string jobId, List<ResourceFile> inputFiles, string outputContainerSasUrl)
{
    Console.WriteLine("Adding {0} tasks to job [{1}]...", inputFiles.Count, jobId);

    // Create a collection to hold the tasks added to the job
    List<CloudTask> tasks = new List<CloudTask>();

    for (int i = 0; i < inputFiles.Count; i++)
    {
        // Assign a task ID for each iteration
        string taskId = String.Format("Task{0}", i);

        // Define task command line to convert the video format from MP4 to animated GIF using ffmpeg.
        // Note that ffmpeg syntax specifies the format as the file extension of the input file
        // and the output file respectively. In this case inputs are MP4.
        string appPath = String.Format("%AZ_BATCH_APP_PACKAGE_{0}#{1}%", appPackageId, appPackageVersion);
        string inputMediaFile = inputFiles[i].FilePath;
        string outputMediaFile = String.Format("{0}{1}",
            System.IO.Path.GetFileNameWithoutExtension(inputMediaFile),
            ".gif");

        // This is the dos command built by using the ffmpeg application package, the paths from the input container
        string taskCommandLine = String.Format("cmd /c {0}\\ffmpeg-3.4-win64-static\\bin\\ffmpeg.exe -i {1} {2}", appPath, inputMediaFile, outputMediaFile);

        // Create a cloud task (with the task ID and command line) and add it to the task list
        CloudTask task = new CloudTask(taskId, taskCommandLine);
        task.ResourceFiles = new List<ResourceFile> { inputFiles[i] };

        // Task output file will be uploaded to the output container in Storage.
        List<OutputFile> outputFileList = new List<OutputFile>();
        OutputFileBlobContainerDestination outputContainer = new OutputFileBlobContainerDestination(outputContainerSasUrl);
        OutputFile outputFile = new OutputFile(outputMediaFile,
                                                new OutputFileDestination(outputContainer),
                                                new OutputFileUploadOptions(OutputFileUploadCondition.TaskSuccess));
        outputFileList.Add(outputFile);
        task.OutputFiles = outputFileList;
        tasks.Add(task);
    }

    // Call BatchClient.JobOperations.AddTask() to add the tasks as a collection rather than making a
    // separate call for each. Bulk task submission helps to ensure efficient underlying API
    // calls to the Batch service.
    await batchClient.JobOperations.AddTaskAsync(jobId, tasks);

    return tasks;
}

Cette dernière méthode effectue toutes les actions complexes de l’application. Une tâche est ajoutée au travail pour chaque fichier chargé. La tâche prend la forme d’une commande d’interpréteur de commandes. Étant donné que nous avons utilisé un package d’application, l’application ffmpeg est installée sur chaque nœud à un emplacement spécifique. Le service Batch stocke cet emplacement dans une variable d’environnement sur le nœud pour qu’il soit accessible avec :

%AZ_BATCH_APP_PACKAGE_ffmpeg#3.4%

Grâce à cette approche, il est facile de charger et d’incrémenter les nouvelles versions de l’application ffmpeg. La commande examine le dossier zip, puis exécute ce qui suit :

ffmpeg.exe -i input-filename output-filename

Pour optimiser les performances, les tâches sont ajoutées sous forme de liste à batchClient.JobOperations.AddTaskAsync. Cela est plus efficace que d’effectuer un appel distinct pour chaque fichier.

Tester l’application console

Dans l’éditeur de code, cliquez avec le bouton droit et sélectionnez Enregistrer, puis cliquez avec le bouton droit et sélectionnez Quitter.
Dans Cloud Shell, générez et exécutez l’application :
```
dotnet run
```

Les messages suivants sont écrits dans le terminal :

Creating container [input].
Creating container [output].
Uploading file ~\cutifypets\InputFiles\3.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\2.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\4.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\1.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\5.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\6.mp4 to container [input]...
Creating pool [WinFFmpegPool]...
Creating job [WinFFmpegJob]...
Adding 6 tasks to job [WinFFmpegJob]...

L’application console se ferme aussitôt les tâches ajoutées. Dans Azure, le pool, les nœuds, les travaux et les tâches sont créés. Aucun moniteur ne supervise ce qui se passe dans l’application puisque celle-ci est fermée. Pour afficher l’état actuel de la conversion et vérifier les résultats, revenez au portail Azure.
Dans le portail Azure, sélectionnez le compte Batch commençant par cutify sur le Tableau de bord.
Le tableau de bord Intégrité apparaît dans la page Vue d’ensemble. À partir de là, vous pouvez vérifier l’état du travail en cours d’exécution et du pool de nœuds.
Dans le menu de gauche, sélectionnez Travaux sous Fonctionnalités, puis sélectionnez WinFFmpegJob. Cette page vous montre l’état actuel des tâches.
Une fois les tâches terminées, revenez au compte de stockage que vous avez créé dans le premier exercice.
Dans le menu de gauche, sélectionnez Conteneurs sous Stockage de données, puis sélectionnez le dossier output.
Le dossier contient les fichiers des images GIF animées converties. Téléchargez un fichier pour vérifier la vidéo de l’animal le plus adorable.

Continuer

Exercice - Gérer et déployer des applications sur des nœuds de calcul

Améliorer le code à l’aide du client Batch

Créer un travail

Ajouter une tâche

Tester l’application console

Commentaires