Esercizio - Gestire e distribuire applicazioni nei nodi di calcolo

10 minuti

L'API client di Azure Batch consente di controllare a livello di codice tutti i componenti di un account Azure Batch.

Continuando a migliorare l'app console dell'azienda, si aggiungeranno ora tutti i componenti necessari per convertire i video caricati nell'ultimo esercizio.

Importante

Per completare questo esercizio è necessaria una sottoscrizione di Azure propria e potrebbero essere applicati costi. Se non hai ancora una sottoscrizione di Azure, crea un account gratuito prima di iniziare.

Al termine di questo esercizio, si avrà un processo Batch funzionante in grado di convertire video MP4 in GIF animate. L'app aggiungerà un'operazione al pool esistente e avvierà le attività di conversione video.

Migliorare il codice usando il client batch

In Cloud Shell modificare il file Program.cs nell'editor:
```
code Program.cs
```
Aggiungere una costante a Program.cs per il JobId che useremo nel nostro processo batch.
```
private const string JobId = "WinFFmpegJob";
```

Sostituire queste righe nel metodo Main :

    var batchClient = BatchClient.Open(sharedKeyCredentials);

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

Con un blocco using per il 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);
}

Crea un lavoro

Aggiungere questo nuovo metodo, CreateJobAsync(), a Program.cs per creare e aggiungere un processo al 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();
}

Il codice precedente usa il client batch per creare un processo. Il metodo assegna l'ID lavoro specificato e le informazioni sul pool.

Aggiungere un'attività

Dopo la creazione del job, l'ultimo passaggio consiste nell'aggiungere un'attività al job. Aggiungere il metodo seguente, AddTaskAsync(), a 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;
}

Questo metodo finale esegue tutte le azioni complesse dell'app. Un'attività viene aggiunta al lavoro per ogni file caricato. L'attività ha il formato di un comando della shell. L'app (ffmpeg) è stata installata in ogni nodo in una posizione specifica perché è stato usato un pacchetto dell'applicazione. Il servizio Batch archivia tale posizione in una variabile di ambiente nel nodo in modo che sia accessibile tramite:

%AZ_BATCH_APP_PACKAGE_ffmpeg#3.4%

Usando questo approccio, è facile caricare e incrementare le versioni più recenti dell'app ffmpeg . Il comando esamina la cartella ZIP ed esegue:

ffmpeg.exe -i input-filename output-filename

Per ottenere prestazioni ottimali, le attività vengono aggiunte come elenco a batchClient.JobOperations.AddTaskAsync. Questa operazione è più efficiente rispetto all'esecuzione di una chiamata separata per ogni file.

Testare l'app console

Nell'editor di codice fare clic con il pulsante destro del mouse e scegliere Salva, quindi fare clic con il pulsante destro del mouse e scegliere Esci.
In Cloud Shell compilare ed eseguire l'app:
```
dotnet run
```

I messaggi seguenti vengono scritti nel terminale:

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'app console si chiude non appena ha aggiunto le attività. In Azure vengono creati pool, nodi, processi e attività. Non c'è alcun monitoraggio di ciò che accade nell'app poiché questa è stata chiusa. Per visualizzare lo stato corrente della conversione e controllare i risultati, tornare al portale di Azure.
Nel portale di Azure, selezionare l'account Batch che inizia cutify sulla Dashboard.
Il dashboard di salute viene visualizzato nella pagina Panoramica. Da qui è possibile controllare lo stato del processo in esecuzione corrente e del pool di nodi.
Nel menu a sinistra, selezionare Lavori in Funzionalità, quindi selezionare WinFFmpegJob. In questa pagina verrà visualizzato lo stato corrente delle attività.
Al termine delle attività, tornare all'account di archiviazione creato nel primo esercizio.
Nel menu a sinistra selezionare Contenitori in Archiviazione dati e quindi selezionare la cartella di output .
La cartella contiene i file gif animati convertiti. Scarica un file per controllare il video più carino di animali domestici.

Esercizio - Gestire e distribuire applicazioni nei nodi di calcolo

Migliorare il codice usando il client batch

Crea un lavoro

Aggiungere un'attività

Testare l'app console

Commenti e suggerimenti