Guida introduttiva: Usare .NET per creare un pool di Batch ed eseguire un processo

Articolo
10/18/2023

Questa guida introduttiva illustra come iniziare a usare Azure Batch eseguendo un'app C# che usa l'API .NET di Azure Batch. App .NET:

Carica diversi file di dati di input in un contenitore BLOB Archiviazione di Azure da usare per l'elaborazione di attività batch.
Crea un pool di due macchine virtuali (VM) o nodi di calcolo che eseguono Windows Server.
Crea un processo che esegue attività sui nodi per elaborare ogni file di input usando una riga di comando di Windows.
Visualizza i file di output restituiti dalle attività.

Dopo aver completato questa guida introduttiva, si conoscono i concetti chiave del servizio Batch e si è pronti per l'uso di Batch con carichi di lavoro su larga scala più realistici.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Se non si dispone di un account, crearne uno gratuitamente.
Un account Batch con un account Archiviazione di Azure collegato. È possibile creare gli account usando uno dei metodi seguenti: l'interfaccia della riga di comando di Azure portale di Azure | Modello arm | Di | Azure | Terraform.
Visual Studio 2019 o versione successiva o .NET 6.0 o versione successiva per Linux o Windows.

Eseguire l'app

Per completare questa guida introduttiva, scaricare o clonare l'app, specificare i valori dell'account, compilare ed eseguire l'app e verificare l'output.

Scaricare o clonare l'app

Scaricare o clonare l'app di avvio rapido di Azure Batch .NET da GitHub. Usare il comando seguente per clonare il repository dell'app con un client Git:

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

Specificare le informazioni sull'account

L'app deve usare i nomi di account Batch e Archiviazione, i valori delle chiavi dell'account e l'endpoint dell'account Batch. È possibile ottenere queste informazioni dai portale di Azure, dalle API di Azure o dagli strumenti da riga di comando.

Per ottenere le informazioni sull'account dal portale di Azure:

Nella barra di Ricerca di Azure cercare e selezionare il nome dell'account Batch.
Nella pagina Account Batch selezionare Chiavi nel riquadro di spostamento a sinistra.
Nella pagina Chiavi copiare i valori seguenti:

Account Batch
Endpoint dell'account
Chiave di accesso primaria
Nome account di archiviazione
Key1

Passare alla cartella batch-dotnet-quickstart scaricata e modificare le stringhe delle credenziali in Program.cs per specificare i valori copiati:

// 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>

Importante

L'esposizione delle chiavi dell'account nell'origine dell'app non è consigliata per l'utilizzo di produzione. È consigliabile limitare l'accesso alle credenziali e farvi riferimento nel codice usando variabili o un file di configurazione. È consigliabile archiviare Batch e Archiviazione chiavi dell'account in Azure Key Vault.

Compilare ed eseguire l'app e visualizzare l'output

Per visualizzare il flusso di lavoro batch in azione, compilare ed eseguire l'applicazione in Visual Studio. È anche possibile usare la riga dotnet build di comando e dotnet run i comandi.

In Visual Studio:

Aprire il file BatchDotNetQuickstart.sln, fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni e scegliere Compila. Se richiesto, usare nuGet Gestione pacchetti per aggiornare o ripristinare i pacchetti NuGet.
Al termine della compilazione, selezionare BatchDotNetQuickstart nella barra dei menu superiore per eseguire l'app.

Il tempo di esecuzione tipico con la configurazione predefinita è di circa cinque minuti. La configurazione iniziale del nodo del pool richiede più tempo. Per rieseguire il processo, eliminare il processo dall'esecuzione precedente, ma non eliminare il pool. In un pool preconfigurato, il processo viene completato in pochi secondi.

L'app restituisce un output simile all'esempio seguente:

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...

Si verifica una pausa durante Monitoring all tasks for 'Completed' state, timeout in 00:30:00... l'avvio dei nodi di calcolo del pool. Durante la creazione delle attività, Batch li accoda per l'esecuzione nel pool. Non appena è disponibile il primo nodo di calcolo, la prima attività viene eseguita nel nodo. È possibile monitorare lo stato del nodo, dell'attività e del processo dalla pagina dell'account Batch nel portale di Azure.

Al termine di ogni attività, viene visualizzato un output simile all'esempio seguente:

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:
...

Esaminare il codice

Esaminare il codice per comprendere i passaggi della guida introduttiva di Azure Batch .NET.

Creare client di servizio e caricare file di risorse

Per interagire con l'account di archiviazione, l'app usa la libreria client Archiviazione di Azure BLOB per .NET per creare 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'app usa il blobServiceClient riferimento per creare un contenitore nell'account di archiviazione e caricare i file di dati nel contenitore. I file nell'archiviazione vengono definiti come oggetti Batch ResourceFile che Batch può scaricare in un secondo momento nei nodi di calcolo.

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'app crea un oggetto BatchClient per creare e gestire pool, processi e attività di Batch. Il client Batch usa l'autenticazione con chiave condivisa. Batch supporta anche l'autenticazione di Microsoft Entra.
```
var cred = new BatchSharedKeyCredentials(BatchAccountUrl, BatchAccountName, BatchAccountKey);

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

Creare un pool di nodi di calcolo

Per creare un pool di Batch, l'app usa il metodo BatchClient.PoolOperations.CreatePool per impostare il numero di nodi, dimensioni della macchina virtuale e configurazione del pool. L'oggetto VirtualMachineConfiguration seguente specifica un oggetto ImageReference a un'immagine di Windows Server Marketplace. Batch supporta un'ampia gamma di immagini del sistema operativo Windows Server e Linux Marketplace e supporta anche immagini di macchine virtuali personalizzate.

Le dimensioni PoolVMSize della PoolNodeCount macchina virtuale e sono costanti definite. L'app crea un pool di due nodi Standard_A1_v2. Questa dimensione offre un buon equilibrio tra prestazioni e costi per questa guida introduttiva.

Il metodo Commit invia il pool al servizio 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();
    }
...

Creare un processo Batch

Un processo Batch è un gruppo logico di una o più attività. Il processo include impostazioni comuni alle attività, ad esempio priorità e pool in cui eseguire le attività.

L'app usa il metodo BatchClient.JobOperations.CreateJob per creare un processo nel pool. Il metodo Commit invia il processo al servizio Batch. Inizialmente il processo è privo di attività.

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

    job.Commit();
}
...

Creare attività

Batch offre diversi modi per distribuire app e script nei nodi di calcolo. Questa app crea un elenco di oggetti di input ResourceFile CloudTask. Ogni attività elabora un file di input usando una proprietà CommandLine . La riga di comando di Batch consente di specificare l'app o lo script.

La riga di comando nel codice seguente esegue il comando di Windows type per visualizzare i file di input. L'app aggiunge quindi ogni attività al processo con il metodo AddTask , che accoda l'attività da eseguire nei nodi di calcolo.

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);

Visualizzare l'output dell'attività

L'app crea un TaskStateMonitor per monitorare le attività e assicurarsi che vengano completate. Quando ogni attività viene eseguita correttamente, l'output scrive in stdout.txt. L'app usa quindi la proprietà CloudTask.ComputeNodeInformation per visualizzare il file stdout.txt per ogni attività completata.

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());
}

Pulire le risorse

L'app elimina automaticamente il contenitore di archiviazione creato e consente di scegliere se eliminare il processo e il pool di Batch. I pool e i nodi comportano addebiti durante l'esecuzione dei nodi, anche se non eseguono processi. Se il pool non è più necessario, eliminarlo.

Quando l'account Batch e l'account di archiviazione non sono più necessari, è possibile eliminare il gruppo di risorse che li contiene. Nella portale di Azure selezionare Elimina gruppo di risorse nella parte superiore della pagina del gruppo di risorse. Nella schermata Elimina un gruppo di risorse immettere il nome del gruppo di risorse e quindi selezionare Elimina.

Passaggi successivi

In questa guida introduttiva è stata eseguita un'app che usa l'API Batch .NET per creare un pool, nodi, processi e attività di Batch. Il processo caricava i file di risorse in un contenitore di archiviazione, eseguiva attività sui nodi e visualizzava l'output dei nodi.

Dopo aver compreso i concetti chiave del servizio Batch, è possibile usare Batch con carichi di lavoro più realistici e su larga scala. Per altre informazioni su Azure Batch e per un carico di lavoro parallelo con un'applicazione reale, continuare con l'esercitazione su Batch .NET.

Elaborare un carico di lavoro parallelo con .NET