Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
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 modernos de integración continua (CI) e implementación continua (CD) para compilar, implementar, probar y supervisar software. Estos procesos aceleran la entrega de tu software, lo que te permite centrarte en tu código en lugar de gestionar la infraestructura 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. En el ejemplo se crea una canalización de compilación y versión para implementar una infraestructura de Azure Batch y liberar 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:
Prerequisites
Para seguir los pasos de este artículo, necesita:
Una organización Azure DevOps y un proyecto de Azure DevOps con un repositorio de Azure Repos creado en la organización. Debe tener los roles de Administrador de 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 obtener más información, consulte Comprender 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, plantillas de ARM y Batch también admiten completamente el software y los nodos de Linux.
Descripción de las plantillas de ARM
Tres plantillas de funcionalidad, similares a unidades o módulos, implementan partes específicas de la funcionalidad. Después, una plantilla de solución de un extremo a otro implementa las plantillas de funcionalidad subyacentes. Esta estructura de plantilla vinculada permite probar y reutilizar individualmente cada plantilla de funcionalidad en todas las soluciones.
Para obtener información detallada sobre las plantillas, consulte la guía de referencia de plantillas de Resource Manager para Microsoft. Tipos de recursos de Batch.
Plantilla de cuenta de almacenamiento
Guarde el código siguiente como un archivo denominado 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 por lotes
Guarde el código siguiente como un archivo denominado batchAccount.json. Esta plantilla define una cuenta de Batch. La cuenta de Batch actúa como una plataforma para ejecutar aplicaciones entre 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 código siguiente como un archivo denominado 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 orquestador
Guarde el código siguiente como un archivo denominado deployment.json. Esta plantilla final actúa como orquestador para implementar las tres plantillas de funcionalidad 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 del repositorio.
Para el paquete de la aplicación, descargue y extraiga la versión de 64 bits de Windows de FFmpeg 4.3.1 y cárguela en la carpeta hpc-application de su repositorio.
Para la definición de compilación, guarde la siguiente definición como un archivo denominado hpc-app.build.yml y cárguelo en una carpeta de canalizaciones del 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:
- Carpeta arm-templates que contiene las plantillas de ARM.
- Carpeta hpc-application que contiene ffmpeg.
- Una carpeta pipelines que contiene el archivo YAML de definición de compilación para la canalización Build.
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.
Crear 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, prueba e implementación para la aplicación. En esta fase de una canalización, normalmente se ejecutan pruebas para validar el código y compilar partes del software. La cantidad y los tipos de pruebas, así como cualquier otra tarea que ejecutes, dependen de tu estrategia general de compilación y publicació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, a continuación, seleccione Nueva canalización.
En la pantalla ¿Dónde está tu código?, seleccione Azure Repos Git.
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 más información, consulte Definición de la canalización clásica.
En la pantalla Configurar la canalización, seleccione archivo YAML existente de Azure Pipelines.
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 de la definición de compilación en Azure Pipelines.
Nota:
Si usa una aplicación cliente para ejecutar la solución HPC, debe 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.
Crear la canalización de lanzamiento
Usa una canalización de lanzamiento de Azure Pipelines para implementar su 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 podría 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 como privados, pero acceda a ellos mediante un token de firma de acceso compartido (SAS).
En el ejemplo siguiente se muestra cómo implementar una infraestructura y una aplicación mediante plantillas de un blob de Azure Storage.
Configura la canalización
En su proyecto de Azure DevOps, seleccione Pipelines>Releases en el panel de navegación izquierdo.
En la pantalla siguiente, seleccione Nuevo>Nueva canalización de versión.
En la pantalla Seleccionar una plantilla, seleccione Trabajo vacío y, a continuación, 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. Anote el valor de Alias de origen, ya que lo necesitará para crear tareas en la definición de versión.
Selecciona 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 en el 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.
Name Value applicationStorageAccountName Nombre de la cuenta de almacenamiento que contiene los archivos binarios de la aplicación 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 para la aplicación Batch, con el formato: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^
/applications/<batchAccountApplicationName>.
Sustituya el marcador de posición<subscriptionId>por su identificador de suscripción de Azure, y los demás marcadores de posición por los valores que estableció para las demás variables de esta lista.batchApplicationVersion Versión semántica de la aplicación batch, en este caso 4.3.1. ubicación Región de Azure para los recursos que se implementarán. resourceGroupName Nombre del grupo de recursos en el que se van a implementar los recursos. storageAccountName Nombre de la cuenta de almacenamiento para almacenar las plantillas de ARM vinculadas. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Reemplace el marcador de posición<referenceNamepor el valor Nombre de referencia que configure en la sección Variables de salida del siguiente paso Azure File Copy.StorageContainerUri $(<referenceName>.StorageContainerUri). Sustituya el marcador de posición<referenceName>por el valor Nombre de referencia que haya configurado en la sección Variables de salida del paso Azure File Copy.
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.
Agregar tareas
Cree seis tareas para:
- Descargue los archivos ffmpeg comprimidos.
- Implemente una cuenta de almacenamiento para alojar las plantillas 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.
- Cargue el paquete de aplicación en la cuenta de Batch.
Para cada nueva tarea especificada en los pasos siguientes:
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.
Selecciona Agregar.
Cree las tareas de la manera siguiente:
Seleccione la tarea Descargar artefactos de canalización y establezca las siguientes propiedades:
- Nombre para mostrar: Escriba Descargar el paquete de la aplicación 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 independiente y el aislamiento del contenido, realice una cuenta de almacenamiento dedicada.
Seleccione la tarea Implementación de plantilla de ARM: ámbito del grupo de recursos y establezca las siguientes propiedades:
- Nombre para mostrar: Escriba Deploy storage account for ARM templates (Implementar cuenta de almacenamiento para plantillas de ARM).
- Conexión de Azure Resource Manager: Seleccione la suscripción de Azure adecuada.
- Suscripción: Seleccione la suscripción de Azure adecuada.
- Acción: seleccione Crear o actualizar el grupo de recursos.
-
Grupo de recursos: escriba
$(resourceGroupName). -
Ubicación: escriba
$(location). -
Plantilla: escriba
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Sustituya el marcador de posición<AzureRepoArtifactSourceAlias>por el alias Source del repositorio que anotó anteriormente. -
Invalidar 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 Azure File Copy devuelve el URI del contenedor de la cuenta de almacenamiento y el token SAS en una variable, para poder reutilizarlos en pasos posteriores.
Seleccione la tarea copia de archivos Azure y establezca las siguientes propiedades:
- Nombre para mostrar: Escriba AzureBlob File Copy.
-
Origen: Escriba
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Sustituya el marcador de posición<AzureRepoArtifactSourceAlias>por el alias Source del repositorio que anotó anteriormente. - Azure suscripción: seleccione la suscripción de Azure adecuada.
- Tipo de destino: seleccione Azure blob.
-
Cuenta de almacenamiento de RM: escriba
$(storageAccountName). - Nombre del contenedor: escriba plantillas.
- Nombre de referencia: expanda Variables de salida y escriba ffmpeg.
Nota:
Si este paso falla, asegúrese de que la organización de Azure DevOps tenga el rol Storage Blob Contributor en la cuenta de almacenamiento.
Implemente la plantilla ARM del orquestador para crear la cuenta de Batch y el pool. 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 ARM se encuentran en la sección de variables de la definición de versión y se establecieron a partir de la tarea AzureBlob File Copy.
Seleccione la tarea Implementación de 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: Seleccione la suscripción de Azure adecuada.
- Acción: seleccione Crear o actualizar el 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). -
Invalidar parámetros de plantilla: escriba
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Una práctica habitual es usar las 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 versión.
Llame a 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 una 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 en línea.
-
Script insertado: escriba
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Llame a 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 un 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 en línea.
-
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 permite controlar manualmente la versión del paquete insertada en Azure Batch.
Cree y ejecute la 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 activa, 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>.
Enumeración de las aplicaciones disponibles
az batch application list -g <resourceGroup> -n <batchAccount>
Compruebe que el pool 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 pool
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.