Compartir a través de

Inicio rápido: Uso de .NET para crear un grupo de Batch y ejecutar un trabajo

En este inicio rápido se muestra cómo empezar a trabajar con Azure Batch mediante la ejecución de una aplicación de C# que usa la API de .NET de Azure Batch. La aplicación .NET:

  • Carga varios archivos de datos de entrada en un contenedor de blobs de Azure Storage para usarlos para el procesamiento de tareas de Batch.
  • Crea un grupo de dos máquinas virtuales (VM) o nodos de proceso que ejecutan Windows Server.
  • Crea un trabajo que ejecuta tareas en los nodos para procesar cada archivo de entrada mediante una línea de comandos de Windows.
  • Muestra los archivos de salida que devuelven las tareas.

Tras completar este artículo de inicio rápido, comprenderás los conceptos clave del servicio Batch y estarás listo para usar dicho servicio con cargas de trabajo más realistas y a mayor escala.

Prerrequisitos

Ejecución de la aplicación

Para completar este inicio rápido, descargue o clone la aplicación, proporcione los valores de la cuenta, compile y ejecute la aplicación y compruebe la salida.

Descarga o clonación de la aplicación

Descargue o clone la aplicación Guía rápida de Azure Batch .NET desde GitHub. Use el siguiente comando para clonar el repositorio de aplicaciones con un cliente de Git:

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

Proporcionar la información de la cuenta

La aplicación debe usar los nombres de cuenta de Batch y Storage, los valores de clave de cuenta y el punto de conexión de la cuenta de Batch. Puede obtener esta información desde Azure Portal, las API de Azure o las herramientas de línea de comandos.

Para obtener la información de la cuenta desde Azure Portal:

  1. En la barra de Azure Search, busque y seleccione el nombre de la cuenta de Batch.
  2. En la página de la cuenta de Batch, seleccione Claves en el panel de navegación izquierdo.
  3. En la página Claves , copie los valores siguientes:
  • Cuenta de Batch
  • Punto de conexión de cuenta
  • Clave de acceso principal
  • Nombre de la cuenta de almacenamiento
  • Key1

Vaya a la carpeta batch-dotnet-quickstart descargada y edite las cadenas de credenciales en Program.cs para proporcionar los valores que copió:

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

No se recomienda exponer las claves de cuenta en el origen de la aplicación para el uso de producción. Debe restringir el acceso a las credenciales y hacer referencia a ellas en el código mediante variables o un archivo de configuración. Es mejor almacenar claves de cuenta de Batch y Storage en Azure Key Vault.

Compilación y ejecución de la aplicación y visualización de la salida

Para ver el flujo de trabajo de Batch en acción, compile y ejecute la aplicación en Visual Studio. También puede usar la línea de comandos dotnet build y los comandos dotnet run.

En Visual Studio:

  1. Abra el archivo BatchDotNetQuickstart.sln , haga clic con el botón derecho en la solución en el Explorador de soluciones y seleccione Compilar. Si se le solicita, use el Administrador de paquetes NuGet para actualizar o restaurar paquetes NuGet.

  2. Una vez completada la compilación, seleccione BatchDotNetQuickstart en la barra de menús superior para ejecutar la aplicación.

El tiempo de ejecución típico con la configuración predeterminada es de aproximadamente cinco minutos. La configuración del nodo de grupo inicial tarda más tiempo. Para volver a ejecutar el trabajo, elimine el trabajo de la ejecución anterior, pero no elimine el pool de recursos. En un grupo preconfigurado, el trabajo se completa en unos segundos.

La aplicación devuelve un resultado similar al ejemplo siguiente:

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

Hay una pausa en Monitoring all tasks for 'Completed' state, timeout in 00:30:00... mientras se inician los nodos de ejecución del grupo. A medida que se crean las tareas, Batch las pone en cola para que se ejecuten en el grupo. Tan pronto como el primer nodo de proceso esté disponible, la primera tarea se ejecuta en el nodo. Puede supervisar el estado del nodo, la tarea y el trabajo desde la página de la cuenta de Batch en Azure Portal.

Una vez completada cada tarea, verá una salida similar a la del ejemplo siguiente:

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

Revisión del código

Revise el código para comprender los pasos del inicio rápido de .NET de Azure Batch.

Creación de clientes de servicio y carga de archivos de recursos

  1. Para interactuar con la cuenta de almacenamiento, la aplicación usa la biblioteca cliente de Blobs de Azure Storage para .NET para crear 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. La aplicación usa la blobServiceClient referencia para crear un contenedor en la cuenta de almacenamiento y cargar archivos de datos en el contenedor. Los archivos del almacenamiento se definen como objetos ResourceFile de Batch que Batch puede descargar posteriormente en los nodos de proceso.

    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. La aplicación crea un objeto BatchClient para crear y administrar grupos, trabajos y tareas de Batch. El cliente de Batch usa la autenticación de clave compartida. Batch también admite la autenticación de Microsoft Entra.

    var cred = new BatchSharedKeyCredentials(BatchAccountUrl, BatchAccountName, BatchAccountKey);

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

Crear un grupo de nodos de cómputo

Para crear un grupo de Batch, la aplicación usa el método BatchClient.PoolOperations.CreatePool para establecer el número de nodos, tamaño de máquina virtual y configuración del grupo. El siguiente objeto VirtualMachineConfiguration especifica una imageReference en una imagen de Marketplace de Windows Server. Batch admite una amplia gama de imágenes del sistema operativo Windows Server y Linux Marketplace y también admite imágenes de máquina virtual personalizadas.

Las constantes definidas son PoolNodeCount y el tamaño de la máquina virtual PoolVMSize. La aplicación crea un grupo de dos nodos Standard_A1_v2. Este tamaño ofrece un buen equilibrio de rendimiento frente al costo de este inicio rápido.

El método Commit envía el grupo al servicio 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();
    }
...

Creación de un trabajo de Batch

Un trabajo de Batch es una agrupación lógica de una o varias tareas. El trabajo incluye valores comunes para las tareas, como la prioridad y el grupo en el que se ejecutan las tareas.

La aplicación usa el método BatchClient.JobOperations.CreateJob para crear un trabajo en el grupo. El método Commit envía el trabajo al servicio Batch. Inicialmente, el trabajo no tiene tareas.

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

    job.Commit();
}
...

Crear tareas

Batch proporciona varias formas de implementar aplicaciones y scripts en nodos de proceso. Esta aplicación crea una lista de CloudTask objetos de entrada ResourceFile. Cada tarea procesa un archivo de entrada mediante una propiedad CommandLine . La línea de comandos de Batch es donde se especifica la aplicación o el script.

La línea de comandos del código siguiente ejecuta el comando de Windows type para mostrar los archivos de entrada. A continuación, la aplicación agrega cada tarea al trabajo con el método AddTask , que pone en cola la tarea para ejecutarse en los nodos de proceso.

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

Visualización de la salida de la tarea

La aplicación crea un TaskStateMonitor para supervisar las tareas y asegurarse de que se completan. Cuando cada tarea se ejecuta correctamente, su salida escribe en stdout.txt. A continuación, la aplicación usa la propiedad CloudTask.ComputeNodeInformation para mostrar el archivo stdout.txt para cada tarea completada.

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

Limpieza de recursos

La aplicación elimina automáticamente el contenedor de almacenamiento que crea y ofrece la opción de eliminar el grupo y el trabajo de Batch. Los grupos y nodos incurren en cargos mientras se ejecutan los nodos, incluso si no ejecutan trabajos. Si ya no necesita el grupo, elimínelo.

Cuando ya no necesite la cuenta de Batch y la cuenta de almacenamiento, puede eliminar el grupo de recursos que los contiene. En Azure Portal, seleccione Eliminar grupo de recursos en la parte superior de la página del grupo de recursos. En la pantalla Eliminar un grupo de recursos , escriba el nombre del grupo de recursos y seleccione Eliminar.

Pasos siguientes

En este inicio rápido, ha ejecutado una aplicación que usa la API de .NET de Batch para crear un grupo, nodos, trabajos y tareas de Batch. El trabajo cargó archivos de recursos en un contenedor de almacenamiento, ejecutó tareas en los nodos y mostró la salida de los nodos.

Ahora que conoces los conceptos clave del servicio Batch, ya estás listo para usar Batch con cargas de trabajo más realistas y a mayor escala. Para más información sobre Azure Batch y recorrer una carga de trabajo paralela con una aplicación real, continúe con el tutorial de .NET de Batch.

Procesamiento de una carga de trabajo paralela con .NET

  • Last updated on