Usar Azure Pipelines para compilar e implementar una solución HPC
Las herramientas de Azure DevOps pueden automatizar la compilación y las pruebas de soluciones de informática de alto rendimiento (HPC) de Azure Batch. Azure Pipelines proporciona procesos de integración continua (CI) e implementación continua (CD) para compilar, implementar, probar y supervisar software. Estos procesos aceleran la entrega de software, lo que permite centrarse en el código, más que en la infraestructura de soporte y las operaciones.
En este artículo se muestra cómo configurar procesos de CI/CD mediante Azure Pipelines con plantillas de Azure Resource Manager (plantillas de ARM) para implementar soluciones de HPC en Azure Batch. El ejemplo crea una canalización de compilación y versión para implementar una infraestructura de Azure Batch y lanzar un paquete de aplicación. En el diagrama siguiente se muestra el flujo de implementación general, suponiendo que el código se desarrolla localmente:
Requisitos previos
Para seguir los pasos de este artículo, necesita:
Una organización de Azure DevOps y un proyecto de Azure DevOps con un repositorio de Azure Repos creado en la organización. Debe tener roles de Administrador del proyecto, Administrador de compilación y Administrador de versiones en el proyecto de Azure DevOps.
Una suscripción de Azure activa con Propietario u otro rol que incluya capacidades de asignación de roles. Para más información, consulte Descripción de las asignaciones de roles de Azure.
Conocimientos básicos sobre el control de código fuente y la sintaxis de la plantilla de ARM.
Preparación de la solución
En el ejemplo de este artículo se usan varias plantillas de ARM y una aplicación de procesamiento de vídeo de código abierto existente, FFmpeg. Puede copiar o descargar estos recursos e insertarlos en el repositorio de Azure Repos.
Importante
En este ejemplo se implementa software de Windows en nodos de Batch basados en Windows. Azure Pipelines, las plantillas de ARM y Batch también admiten completamente el software y los nodos de Linux.
Conocimientos básicos sobre las plantillas de ARM
Las plantillas de capacidad, de forma similar a las unidades o los módulos, implementan funcionalidades específicas. A continuación, una plantilla de solución de un extremo a otro implementa las plantillas de funcionalidad subyacentes. Esta estructura de plantillas vinculadas permite que cada plantilla de funcionalidad se pueda probar y reutilizar individualmente en las soluciones.
Para obtener información detallada sobre las plantillas, consulte la Guía de referencia de plantillas de Resource Manager para los tipos de recursos de Microsoft.Batch.
Plantilla de cuenta de almacenamiento
Guarde el siguiente código como un archivo llamado storageAccount.json. Esta plantilla define una cuenta de Azure Storage, que es necesaria para implementar la aplicación en la cuenta de Batch.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"accountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Storage Account"
}
}
},
"variables": {},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"name": "[parameters('accountName')]",
"sku": {
"name": "Standard_LRS"
},
"apiVersion": "2018-02-01",
"location": "[resourceGroup().location]",
"properties": {}
}
],
"outputs": {
"blobEndpoint": {
"type": "string",
"value": "[reference(resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))).primaryEndpoints.blob]"
},
"resourceId": {
"type": "string",
"value": "[resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))]"
}
}
}
Plantilla de cuenta de Batch
Guarde el siguiente código como un archivo llamado batchAccount.json. Esta plantilla define una cuenta de Batch. La cuenta de Batch actúa como plataforma donde ejecutar aplicaciones en grupos de nodos.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"batchAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account"
}
},
"storageAccountId": {
"type": "string",
"metadata": {
"description": "ID of the Azure Storage Account"
}
}
},
"variables": {},
"resources": [
{
"name": "[parameters('batchAccountName')]",
"type": "Microsoft.Batch/batchAccounts",
"apiVersion": "2017-09-01",
"location": "[resourceGroup().location]",
"properties": {
"poolAllocationMode": "BatchService",
"autoStorage": {
"storageAccountId": "[parameters('storageAccountId')]"
}
}
}
],
"outputs": {}
}
Plantilla de grupo de Batch
Guarde el siguiente código como un archivo llamado batchAccountPool.json. Esta plantilla crea un grupo de nodos y nodos en la cuenta de Batch.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"batchAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account"
}
},
"batchAccountPoolName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account Pool"
}
}
},
"variables": {},
"resources": [
{
"name": "[concat(parameters('batchAccountName'),'/', parameters('batchAccountPoolName'))]",
"type": "Microsoft.Batch/batchAccounts/pools",
"apiVersion": "2017-09-01",
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "MicrosoftWindowsServer",
"offer": "WindowsServer",
"sku": "2022-datacenter",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64"
}
},
"vmSize": "Standard_D2s_v3"
}
}
],
"outputs": {}
}
Plantilla de Orchestrator
Guarde el siguiente código como un archivo llamado deployment.json. La plantilla final actúa como un orquestador, al implementar las tres plantillas de capacidad subyacentes.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"StorageContainerUri": {
"type": "string",
"metadata": {
"description": "URI of the Blob Storage Container containing the Azure Resource Manager templates"
}
},
"StorageContainerSasToken": {
"type": "string",
"metadata": {
"description": "The SAS token of the container containing the Azure Resource Manager templates"
}
},
"applicationStorageAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Storage Account"
}
},
"batchAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account"
}
},
"batchAccountPoolName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account Pool"
}
}
},
"variables": {},
"resources": [
{
"apiVersion": "2017-05-10",
"name": "storageAccountDeployment",
"type": "Microsoft.Resources/deployments",
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/storageAccount.json', parameters('StorageContainerSasToken'))]",
"contentVersion": "1.0.0.0"
},
"parameters": {
"accountName": {"value": "[parameters('applicationStorageAccountName')]"}
}
}
},
{
"apiVersion": "2017-05-10",
"name": "batchAccountDeployment",
"type": "Microsoft.Resources/deployments",
"dependsOn": [
"storageAccountDeployment"
],
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccount.json', parameters('StorageContainerSasToken'))]",
"contentVersion": "1.0.0.0"
},
"parameters": {
"batchAccountName": {"value": "[parameters('batchAccountName')]"},
"storageAccountId": {"value": "[reference('storageAccountDeployment').outputs.resourceId.value]"}
}
}
},
{
"apiVersion": "2017-05-10",
"name": "poolDeployment",
"type": "Microsoft.Resources/deployments",
"dependsOn": [
"batchAccountDeployment"
],
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccountPool.json', parameters('StorageContainerSasToken'))]",
"contentVersion": "1.0.0.0"
},
"parameters": {
"batchAccountName": {"value": "[parameters('batchAccountName')]"},
"batchAccountPoolName": {"value": "[parameters('batchAccountPoolName')]"}
}
}
}
],
"outputs": {}
}
Configuración del repositorio
Cargue las plantillas de ARM, la aplicación FFmpeg y un archivo de definición de compilación de YAML en el repositorio de Azure Repos.
Cargue las cuatro plantillas de ARM en una carpeta arm-templates en su repositorio.
Para el paquete de aplicación, descargue y extraiga la versión de Windows de 64 bits de FFmpeg 4.3.1 y cárguelo en una carpeta hpc-application en su repositorio.
Para la definición de compilación, guarde la definición siguiente como un archivo denominado hpc-app.build.yml y cárguelo en una carpeta canalizaciones en su repositorio.
# To publish an application into Batch, you need to # first zip the file, and then publish an artifact, so # you can take the necessary steps in your release pipeline. steps: # First, zip up the files required in the Batch account. # For this instance, those are the ffmpeg files. - task: ArchiveFiles@2 displayName: 'Archive applications' inputs: rootFolderOrFile: hpc-application includeRootFolder: false archiveFile: '$(Build.ArtifactStagingDirectory)/package/$(Build.BuildId).zip' # Publish the zip file, so you can use it as part # of your Release pipeline later. - task: PublishPipelineArtifact@0 inputs: artifactName: 'hpc-application' targetPath: '$(Build.ArtifactStagingDirectory)/package'
Cuando haya terminado de configurar el repositorio, la estructura de carpetas debe tener las secciones principales siguientes:
- Una carpeta arm-templates que contiene las plantillas de ARM.
- Una carpeta hpc-application que contiene ffmpeg.
- Una carpeta canalizaciones que contiene el archivo de definición de compilación de YAML para la canalización de compilación.
Nota:
En esta estructura de código base de ejemplo se muestra que puede almacenar código de aplicación, infraestructura y canalización en el mismo repositorio.
Creación de la canalización de Azure
Después de configurar el repositorio de código fuente, use Azure Pipelines para implementar una canalización de compilación y una prueba e implementación para la aplicación. En esta fase de la canalización se suelen ejecutar pruebas para validar el código y compilar fragmentos del software. La cantidad y los tipos de pruebas, así como cualquier otra tarea que ejecute, dependerán de la estrategia general de compilación y versión.
Creación de la canalización de compilación
En esta sección, creará una canalización de compilación de YAML para trabajar con el software ffmpeg que se ejecuta en la cuenta de Batch.
En el proyecto de Azure DevOps, seleccione Canalizaciones en el panel de navegación izquierdo y, después, Nueva canalización.
En la pantalla ¿Dónde está el código?, seleccione Git de Azure Repos.
En la pantalla Seleccionar un repositorio, seleccione su repositorio.
Nota:
También puede crear una canalización de compilación mediante un diseñador visual. En la página Nueva canalización, seleccione Usar el editor clásico. Puede usar una plantilla YAML en el diseñador visual. Para obtener más información, consulte Definir la canalización clásica.
En la pantalla Configure su canalización, seleccione Archivo YAML de Azure Pipelines existente.
En la pantalla Seleccionar un archivo YAML existente, seleccione el archivo hpc-app.build.yml del repositorio y, a continuación, seleccione Continuar.
En la pantalla Revisar la canalización YAML, revise la configuración de compilación y, a continuación, seleccione Ejecutar o seleccione el símbolo de intercalación desplegable junto a Ejecutar y seleccione Guardar. Esta plantilla habilita la integración continua, por lo que la compilación se desencadena automáticamente cuando una nueva confirmación en el repositorio cumple las condiciones establecidas en la compilación.
Puede ver las actualizaciones del progreso de la compilación en directo. Para ver los resultados de la compilación, seleccione la ejecución adecuada en la definición de compilación en Azure Pipelines.
Nota:
Si usa una aplicación cliente para ejecutar la solución HPC, deberá crear una definición de compilación independiente para esa aplicación. Para obtener guías paso a paso, consulte la documentación de Azure Pipelines.
Creación de la Canalización de versión
Use una Canalización de versión de Azure Pipelines para implementar la aplicación y la infraestructura subyacente. Las canalizaciones de versión habilitan CD y automatizan el proceso de versión. Hay varios pasos para implementar la aplicación y la infraestructura subyacente.
Las plantillas vinculadas para esta solución deben ser accesibles desde un punto de conexión HTTP o HTTPS público. Este punto de conexión puede ser un repositorio de GitHub, una cuenta de Azure Blob Storage u otra ubicación de almacenamiento. Para asegurarse de que los artefactos de plantilla cargados permanezcan seguros, manténgalos en modo privado, pero acceda a ellos mediante algún tipo de token de firma de acceso compartido (SAS).
En el siguiente ejemplo se muestra cómo implementar una infraestructura y aplicaciones con plantillas de un blob Azure Storage.
Configuración de la canalización
En la página del proyecto de Azure DevOps, seleccione Canalizaciones>Versiones en el menú de navegación de la izquierda.
En la pantalla siguiente, seleccione Nueva>Nueva canalización de versión.
En la pantalla Seleccionar una plantilla, seleccione Trabajo vacío y cierre la pantalla Fase.
Seleccione Nueva canalización de versión en la parte superior de la página y cambie el nombre de la canalización a algo relevante para la canalización, como Implementar Azure Batch + Grupo.
En la sección Artefactos, seleccione Agregar.
En la pantalla Agregar un artefacto, seleccione Compilar y, a continuación, seleccione la Canalización de compilación para obtener la salida de la aplicación HPC.
Nota:
Puede crear un Alias de origen o aceptar el valor predeterminado. Tome nota del valor de Alias de origen, ya que lo necesita para crear tareas en la definición de versión.
Seleccione Agregar.
En la página de canalización, seleccione Agregar junto a Artefactos para crear un vínculo a otro artefacto, el repositorio de Azure Repos. Este vínculo es necesario para acceder a las plantillas de ARM del repositorio. Las plantillas de ARM no necesitan compilación, por lo que no es necesario insertarlas a través de una canalización de compilación.
Nota:
Tenga en cuenta de nuevo el valor del alias de origen que se usará más adelante.
Seleccione la pestaña Variables. Cree las siguientes variables en la canalización para que no tenga que volver a escribir la misma información en varias tareas.
Nombre Value applicationStorageAccountName Nombre de la cuenta de almacenamiento para que contenga los archivos binarios de la aplicación de HPC. batchAccountApplicationName Nombre de la aplicación en la cuenta de Batch. batchAccountName Nombre de la cuenta de Batch. batchAccountPoolName Nombre del grupo de máquinas virtuales (VM) para realizar el procesamiento. batchApplicationId Identificador único de la aplicación de Batch, con el formato: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^/applications/<batchAccountApplicationName>.
Reemplace el marcador de posición<subscriptionId>por el identificador de suscripción de Azure y los demás marcadores de posición por los valores establecidos para las otras variables de esta lista.batchApplicationVersion Versión semántica de la aplicación de Batch, en este caso 4.3.1. ubicación Región de Azure para los recursos que se van a implementar. resourceGroupName Nombre del grupo de recursos en el que se van a implementar los recursos. storageAccountName Nombre de la cuenta de almacenamiento para contener las plantillas de ARM vinculadas. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Reemplace el<referenceNamemarcador de posición por el valor de Nombre de referencia que configure en la sección Variables de salida del siguiente paso de copia de archivos de Azure.StorageContainerUri $(<referenceName>.StorageContainerUri). Reemplace el<referenceName>marcador de posición por el valor de Nombre de referencia que configure en la sección Variables de salida del paso de copia de archivos de Azure.
Seleccione la pestaña Tareas y, a continuación, seleccione Trabajo del Agente.
En la pantalla Trabajo del agente, en Grupo de agentes, seleccione Azure Pipelines.
En Especificación del agente, seleccione windows-latest.
Adición de tareas
Cree seis tareas para:
- Descargar los archivos ffmpeg comprimidos.
- Implementar una cuenta de almacenamiento para hospedar las plantillas de ARM anidadas.
- Copie las plantillas de ARM en la cuenta de almacenamiento.
- Implemente la cuenta de Batch y las dependencias necesarias.
- Cree una aplicación en la cuenta de Batch.
- Actualizar el paquete de aplicación a la cuenta de Batch.
Para cada nueva tarea que especifiquen los siguientes pasos:
Seleccione el + símbolo situado junto al Trabajo del agente en el panel izquierdo.
Busque y seleccione la tarea especificada en el panel derecho.
Agregue o seleccione las propiedades para configurar la tarea.
Seleccione Agregar.
Cree las tareas de la siguiente manera:
Agregue la tarea Descargar artefacto de canalización y establezca las siguientes propiedades:
- Nombre para mostrar: escriba Descargar ApplicationPackage en el agente.
- Nombre del artefacto: escriba hpc-application.
- Directorio de destino: escriba
$(System.DefaultWorkingDirectory).
Cree una cuenta de Azure Storage para almacenar las plantillas de ARM. Puede usar una cuenta de almacenamiento existente, pero para admitir este ejemplo autónomo, y de cara al aislamiento de contenido, cree una cuenta de almacenamiento dedicada.
Seleccione la tarea Implementación de la plantilla de ARM: ámbito del grupo de recursos y establezca las siguientes propiedades:
- Nombre para mostrar: escriba Implementar cuenta de almacenamiento para plantillas de ARM.
- Conexión de Azure Resource Manager: seleccione la suscripción de Azure adecuada.
- Suscripción de Azure: seleccione la suscripción de Azure adecuada.
- Acción: seleccione Creación o actualización del grupo de recursos.
- Grupo de recursos: escriba
$(resourceGroupName). - Ubicación: escriba
$(location). - Plantilla: escriba
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Reemplace el marcador de posición<AzureRepoArtifactSourceAlias>por el alias de origen del repositorio que anotó anteriormente. - Reemplazar parámetros de plantilla: Escriba
-accountName $(storageAccountName).
Cargue los artefactos desde el control de código fuente en la cuenta de almacenamiento. Parte de esta tarea de copia de archivos de Azure genera el identificador URI del contenedor de la cuenta de almacenamiento y el token de SAS en una variable, por lo que se pueden reutilizar en pasos posteriores.
Seleccione la tarea Copia de archivos de Azure y establezca las siguientes propiedades:
- Nombre para mostrar: escriba Copia de archivos de AzureBlob.
- En Origen: escriba
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Reemplace el marcador de posición<AzureRepoArtifactSourceAlias>por el alias de origen del repositorio que anotó anteriormente. - Suscripción de Azure: seleccione la suscripción de Azure adecuada.
- Tipo de destino: seleccione Blob de Azure.
- Cuenta de almacenamiento del Administrador de recursos: escriba
$(storageAccountName). - Nombre del contenedor: escriba plantillas.
- Nombre de referencia: expanda Variables de salida y escriba ffmpeg.
Nota:
Si se produce un error en este paso, asegúrese de que la organización de Azure DevOps tiene el rol de Colaborador de Blob almacenamiento en la cuenta de almacenamiento.
Implemente la plantilla de ARM del orquestador para crear la cuenta y el grupo de Batch. Esta plantilla incluye parámetros para el URI del contenedor de la cuenta de almacenamiento y el token de SAS. Las variables necesarias en la plantilla de ARM se mantienen en la sección variables de la definición de versión y se establecieron desde la tarea de copia de archivos de AzureBlob.
Seleccione la tarea Implementación de la plantilla de ARM: ámbito del grupo de recursos y establezca las siguientes propiedades:
- Nombre para mostrar: Escriba Implementar Azure Batch.
- Conexión de Azure Resource Manager: seleccione la suscripción de Azure adecuada.
- Suscripción de Azure: seleccione la suscripción de Azure adecuada.
- Acción: seleccione Creación o actualización del grupo de recursos.
- Grupo de recursos: escriba
$(resourceGroupName). - Ubicación: escriba
$(location). - Ubicación de la plantilla: seleccione la Dirección URL del archivo.
- Vínculo de plantilla: escriba
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken). - Reemplazar parámetros de plantilla: Escriba
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Una práctica habitual es usar tareas de Azure Key Vault. Si la entidad de servicio conectada a su suscripción de Azure tiene establecido un conjunto de directivas de acceso adecuado, esta puede descargar secretos de Azure Key Vault y usarlos como una variable en la canalización. El nombre del secreto se establece con el valor asociado. Por ejemplo, podría hacer referencia a un secreto de sshPassword con $(sshPassword) en la definición de la versión.
Llame a la CLI de Azure para crear una aplicación en Azure Batch.
Seleccione la tarea CLI de Azure y establezca las siguientes propiedades:
- Nombre para mostrar: escriba Crear la aplicación en la cuenta de Azure Batch.
- Conexión de Azure Resource Manager: seleccione la suscripción de Azure adecuada.
- Tipo de script: seleccione PowerShell Core.
- Ubicación del script: seleccione Script insertado.
- Script insertado: escriba
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Llame a la CLI de Azure para cargar paquetes asociados en la aplicación, en este caso los archivos ffmpeg.
Seleccione la tarea CLI de Azure y establezca las siguientes propiedades:
- Nombre para mostrar: escriba Cargar el paquete en la cuenta de Azure Batch.
- Conexión de Azure Resource Manager: seleccione la suscripción de Azure adecuada.
- Tipo de script: seleccione PowerShell Core.
- Ubicación del script: seleccione Script insertado.
- Script insertado: escriba
az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Reemplace el marcador de posición<AzureBuildArtifactSourceAlias>por el alias de origen del compilador que anotó anteriormente.
Nota
El número de versión del paquete de aplicación se establece en una variable. La variable permite sobrescribir versiones anteriores del paquete y controlar manualmente la versión del paquete insertado en Azure Batch.
Creación y ejecución de una versión
Cuando termine de crear todos los pasos, seleccione Guardar en la parte superior de la página de canalización y, a continuación, seleccione Aceptar.
Seleccione Crear versión en la parte superior de la página.
Para ver el estado de la versión en directo, seleccione el vínculo situado en la parte superior de la página que indica que se ha creado la versión.
Para ver la salida del registro del agente, mantenga el puntero sobre la fase y, a continuación, seleccione el botón Registros.
Prueba del entorno
Una vez configurado el entorno, confirme que las siguientes pruebas se ejecutan correctamente. Reemplace los marcadores de posición por el grupo de recursos y los valores de la cuenta de Batch.
Conexión a la cuenta de Batch
Conecte la nueva cuenta de Batch mediante la CLI de Azure desde un símbolo del sistema.
- Inicie sesión en su cuenta de Azure con
az loginy siga las instrucciones para autenticarse. - Autentique la cuenta de Batch con
az batch account login -g <resourceGroup> -n <batchAccount>.
Mostrar las aplicaciones disponibles
az batch application list -g <resourceGroup> -n <batchAccount>
Comprobar que el grupo es válido
az batch pool list
En la salida del comando, anote el valor de currentDedicatedNodes para ajustarlo en la prueba siguiente.
Cambiar el tamaño del grupo
Ejecute el siguiente comando para cambiar el tamaño del grupo para que haya nodos de proceso disponibles para las pruebas de trabajos y tareas. Reemplace el <poolName> marcador de posición por el valor del nombre del grupo y el <targetNumber> marcador de posición por un número mayor que el de la currentDedicatedNodes salida del comando anterior. Compruebe el estado ejecutando el az batch pool list comando hasta que se complete el cambio de tamaño y muestre el número de nodos de destino.
az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>
Pasos siguientes
Consulte estos tutoriales para aprender a interactuar con una cuenta de Batch a través de una aplicación sencilla.