Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Azure DevOps strumenti possono automatizzare la compilazione e il test Azure Batch soluzioni HPC (High Performance Computing). Azure Pipelines fornisce processi di integrazione continua (CI) e distribuzione continua (CD) moderni per la compilazione, la distribuzione, il test e il monitoraggio del software. Questi processi accelerano la distribuzione del software, consentendo di concentrarsi sul codice invece di supportare l'infrastruttura e le operazioni.
Questo articolo illustra come configurare i processi CI/CD usando Azure Pipelines con modelli di Azure Resource Manager (modelli arm) per distribuire soluzioni HPC in Azure Batch. L'esempio crea una pipeline di compilazione e versione per distribuire un'infrastruttura Azure Batch e rilasciare un pacchetto dell'applicazione. Il diagramma seguente mostra il flusso di distribuzione generale, presupponendo che il codice venga sviluppato in locale:
Prerequisiti
Per seguire i passaggi descritti in questo articolo, è necessario:
Un'organizzazione Azure DevOps e un progetto di Azure DevOps con un repository Azure Repos creato nell'organizzazione. Devi disporre dei ruoli Amministratore progetto, Amministratore compilazione e Amministratore release nel progetto Azure DevOps.
Una sottoscrizione di Azure attiva con Owner o un altro ruolo che includa le autorizzazioni per assegnare ruoli. Per altre informazioni, vedere Comprendere le assegnazioni di ruolo di Azure.
Conoscenza di base della sintassi del controllo del codice sorgente e del modello arm.
Preparare la soluzione
L'esempio in questo articolo usa diversi modelli arm e un'applicazione di elaborazione video open source esistente, FFmpeg. È possibile copiare o scaricare queste risorse ed eseguirne il push nel repository Azure Repos.
Importante
Questo esempio distribuisce software Windows su nodi Batch basati su Windows. Azure Pipelines, i modelli arm e Batch supportano anche completamente software e nodi Linux.
Informazioni sui modelli ARM
Tre modelli di funzionalità, simili a unità o moduli, implementano parti di funzionalità specifiche. Un modello di soluzione end-to-end distribuisce quindi i modelli di funzionalità sottostanti. Questa struttura di modelli collegati consente di testare e riutilizzare singolarmente ogni modello di funzionalità tra soluzioni.
Per informazioni dettagliate sui modelli, vedere la guida di riferimento ai modelli di Resource Manager per i tipi di risorsa Microsoft.Batch.
Modello di account di archiviazione
Salvare il codice seguente come file denominato storageAccount.json. Questo modello definisce un account Archiviazione di Azure, necessario per distribuire l'applicazione nell'account 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'))]"
}
}
}
Modello di account Batch
Salvare il codice seguente come file denominato batchAccount.json. Questo modello definisce un account Batch. L'account Batch funge da piattaforma per l'esecuzione di applicazioni tra pool di nodi.
{
"$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": {}
}
Modello di pool di Batch
Salvare il codice seguente come file denominato batchAccountPool.json. Questo modello crea un pool di nodi e nodi nell'account 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": {}
}
Modello di orchestratore
Salvare il codice seguente come file denominato deployment.json. Questo modello finale funge da agente di orchestrazione per distribuire i tre modelli di funzionalità sottostanti.
{
"$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": {}
}
Configurare il repository
Carica i modelli ARM, l'app FFmpeg e un file YAML di definizione della build nel repository di Azure Repos.
Carica i quattro modelli ARM nella cartella arm-templates del tuo repository.
Per il pacchetto dell'applicazione, scaricare ed estrarre la versione Windows a 64 bit di FFmpeg 4.3.1 e caricarla in una cartella hpc-application nel repository.
Per la definizione di compilazione, salvare la definizione seguente come file denominato hpc-app.build.yml e caricarlo in una cartella pipelines nel repository.
# 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'
Al termine della configurazione del repository, la struttura di cartelle deve avere le sezioni principali seguenti:
- Una cartella arm-templates che contiene i modelli ARM.
- Una cartella hpc-application che contiene ffmpeg.
- Una cartella pipelines che contiene il file YAML di definizione della build per la Build pipeline.
Annotazioni
Questa struttura codebase di esempio dimostra che è possibile archiviare il codice dell'applicazione, dell'infrastruttura e della pipeline nello stesso repository.
Creare la pipeline di Azure
Dopo aver configurato il repository del codice sorgente, usare Azure Pipelines per implementare una pipeline di compilazione, test e distribuzione per l'applicazione. In questa fase di una pipeline vengono in genere eseguiti test per convalidare il codice e compilare parti del software. Il numero e i tipi di test e qualsiasi altra attività eseguita dipendono dalla strategia complessiva di compilazione e rilascio.
Creazione della pipeline di compilazione
In questa sezione viene creata una pipeline di compilazione YAML per lavorare con il software ffmpeg eseguito nell'account Batch.
Nel progetto Azure DevOps selezionare Pipeline nel riquadro di spostamento a sinistra e quindi selezionare Nuova pipeline.
Nella schermata Dove si trova il tuo codice, selezionare Azure Repos Git.
Nella schermata Seleziona un repository, seleziona il tuo repository.
Annotazioni
È anche possibile creare una pipeline di compilazione usando una finestra di progettazione visiva. Nella pagina Nuova pipeline selezionare Usa l'editor classico. È possibile usare un modello YAML nella finestra di progettazione visiva. Per altre informazioni, vedere Definire la pipeline classica.
Nella schermata Configura la pipeline selezionare File YAML Azure Pipelines esistente.
Nella schermata Selezionare un file YAML esistente selezionare il file hpc-app.build.yml dal repository e quindi selezionare Continua.
Nella schermata Rivedi la pipeline YAML esaminare la configurazione della compilazione e quindi selezionare Esegui oppure selezionare il cursore a discesa accanto a Esegui e selezionare Salva. Questo modello abilita l'integrazione continua, quindi la compilazione viene attivata automaticamente quando un nuovo commit nel repository soddisfa le condizioni impostate nella compilazione.
È possibile visualizzare gli aggiornamenti dello stato di avanzamento della compilazione in tempo reale. Per visualizzare i risultati della compilazione, selezionare l'esecuzione appropriata dalla definizione di compilazione in Azure Pipelines.
Annotazioni
Se si usa un'applicazione client per eseguire la soluzione HPC, è necessario creare una definizione di compilazione separata per tale applicazione. Per le guide pratiche, vedere la documentazione Azure Pipelines.
Creare la pipeline di rilascio
Si utilizza una pipeline di rilascio di Azure Pipelines per distribuire l'applicazione e l'infrastruttura sottostante. Le pipeline di rilascio consentono la distribuzione continua e automatizzano il processo di rilascio. Esistono diversi passaggi per distribuire l'applicazione e l'infrastruttura sottostante.
I modelli collegati per questa soluzione devono essere accessibili da un endpoint HTTP o HTTPS pubblico. Questo endpoint può essere un repository GitHub, un account Archiviazione BLOB di Azure o un'altra posizione di archiviazione. Per garantire che gli artefatti del modello caricati rimangano sicuri, tenerli in modalità privata, ma accedervi usando una forma di token di firma di accesso condiviso .To ensure that the upload template artifacts remain secure, hold them in a private mode, but access them by using some form of shared access signature (SAS).
L'esempio seguente illustra come distribuire un'infrastruttura e un'applicazione usando modelli da un BLOB Archiviazione di Azure.
Configurare la pipeline
Nel progetto Azure DevOps, seleziona Pipelines>Versioni nella barra di spostamento a sinistra.
Nella schermata successiva selezionare Nuova>Nuova pipeline di versione.
Nella schermata Seleziona un modello selezionare Processo vuoto e quindi chiudere la schermata Fase .
Selezionare Nuova pipeline di versione nella parte superiore della pagina e rinominare la pipeline in un elemento pertinente per la pipeline, ad esempio Distribuisci Azure Batch + Pool.
Nella sezione Artefatti selezionare Aggiungi.
Nella schermata Aggiungi un artefatto selezionare Compila e quindi selezionare la pipeline di compilazione per ottenere l'output per l'applicazione HPC.
Annotazioni
È possibile creare un alias di origine o accettare l'impostazione predefinita. Prendi nota del valore alias di origine, poiché ti serve per creare attività nella definizione della versione.
Seleziona Aggiungi.
Nella pagina della pipeline selezionare Aggiungi accanto ad Artefatti per creare un collegamento a un altro artefatto, il repository Azure Repos. Questo collegamento è necessario per accedere ai modelli ARM nel tuo repository. I modelli ARM non richiedono la compilazione, quindi non è necessario farli passare attraverso una pipeline di compilazione.
Annotazioni
Prendere nota anche del valore dell'alias di origine da usare in un secondo momento.
Selezionare la scheda Variabili . Creare le variabili seguenti nella pipeline in modo da non dover immettere nuovamente le stesse informazioni in più attività.
Nome Value applicationStorageAccountName Nome dell'account di archiviazione per contenere i file binari dell'applicazione HPC. batchAccountApplicationName Nome dell'applicazione nell'account Batch. batchAccountName Nome dell'account Batch. batchAccountPoolName Nome per il pool di macchine virtuali (VM) per eseguire l'elaborazione. batchApplicationId ID univoco per l'applicazione Batch, nel formato: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^
/applications/<batchAccountApplicationName>.
Sostituisci il segnaposto<subscriptionId>con l'ID della sottoscrizione Azure e gli altri segnaposto con i valori specificati per le altre variabili in questo elenco.batchApplicationVersion Versione semantica dell'applicazione Batch, in questo caso 4.3.1. ubicazione Area geografica di Azure per le risorse da distribuire. resourceGroupName Nome del gruppo di risorse in cui distribuire le risorse. storageAccountName Nome dell'account di archiviazione che conterrà i modelli ARM collegati. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Sostituisci il segnaposto<referenceNamecon il valore Nome di riferimento che configuri nella sezione Variabili di output del passaggio Azure File Copy seguente.StorageContainerUri $(<referenceName>.StorageContainerUri). Sostituire il<referenceName>segnaposto con il valore del nome di riferimento configurato nella sezione Variabili di output del passaggio copia file Azure.
Selezionare la scheda Attività, quindi selezionare Processo dell'agente.
Nella schermata Processo dell'agente, in Pool di agenti, seleziona Azure Pipelines.
In Specifica dell'agente, selezionare windows-latest.
Aggiungere attività
Creare sei attività per:
- Scarica i file ffmpeg compressi.
- Distribuisci un account di archiviazione per ospitare i modelli ARM annidati.
- Copiare i modelli ARM nell'account di archiviazione.
- Distribuisci l'account Batch e le dipendenze richieste.
- Creare un'applicazione nell'account Batch.
- Caricare il pacchetto dell'applicazione nell'account Batch.
Per ogni nuova attività specificata dai passaggi seguenti:
Seleziona l'icona + accanto a Processo dell'agente nel riquadro sinistro.
Cercare e selezionare l'attività specificata nel riquadro destro.
Aggiungere o selezionare le proprietà per configurare l'attività.
Seleziona Aggiungi.
Creare le attività come indicato di seguito:
Seleziona l'attività Scarica gli artefatti della pipeline e imposta le proprietà seguenti:
- Nome visualizzato: immetti Scarica ApplicationPackage nell'agente.
- Nome dell'artefatto: immetti hpc-application.
-
Directory di destinazione: Inserire
$(System.DefaultWorkingDirectory).
Crea un account di archiviazione di Azure per archiviare i modelli ARM. È possibile usare un account di archiviazione esistente, ma per supportare questo esempio autonomo e l'isolamento del contenuto, creare un account di archiviazione dedicato.
Selezionare l'attività Distribuzione del modello ARM: ambito Gruppo di risorse e impostare le proprietà seguenti:
- Nome visualizzato: Immetti Distribuisci account di archiviazione per modelli ARM).
- Connessione di Azure Resource Manager: Selezionare la sottoscrizione di Azure appropriata.
- Sottoscrizione: Selezionare la sottoscrizione Azure appropriata.
- Azione: selezionare Crea o aggiorna gruppo di risorse.
-
Gruppo di risorse: immettere
$(resourceGroupName). -
Percorso: immettere
$(location). -
Modello: immettere
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Sostituisci il segnaposto<AzureRepoArtifactSourceAlias>con l'alias del repository Source che hai annotato in precedenza. -
Esegui l'override dei parametri modello: inserire
-accountName $(storageAccountName).
Carica gli artefatti dal controllo del codice sorgente nell'account di archiviazione. Parte di questa attività Azure File Copy scrive l'URI del contenitore dell'account di archiviazione e il token SAS in una variabile, in modo che possano essere riutilizzati nelle fasi successive.
Selezionare l'attività Copia file Azure e impostare le proprietà seguenti:
- Nome visualizzato: Immetti Copia file BLOB di Azure.
-
Fonte: Immettere
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Sostituisci il segnaposto<AzureRepoArtifactSourceAlias>con l'alias del repository Source che hai annotato in precedenza. - sottoscrizione Azure: selezionare la sottoscrizione Azure appropriata.
- Tipo di destinazione: selezionare Azure BLOB.
-
Account di archiviazione RM: immettere
$(storageAccountName). - Nome contenitore: immettere i modelli.
- Nome riferimento: espandere Variabili di output, quindi immettere ffmpeg.
Annotazioni
Se questo passaggio non riesce, assicurati che l'organizzazione Azure DevOps abbia il ruolo Collaboratore BLOB di archiviazione nell'account di archiviazione.
Distribuisci il modello ARM dell'orchestratore per creare l'account Batch e il pool. Questo modello include i parametri per l'URI del contenitore dell'account di archiviazione e il token di firma di accesso condiviso. Le variabili necessarie nel modello ARM sono contenute nella sezione delle variabili della definizione della versione e sono state impostate dall'attività AzureBlob File Copy.
Selezionare l'attività Distribuzione del modello ARM: ambito Gruppo di risorse e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Deploy Azure Batch (Distribuisci Azure Batch).
- Connessione di Azure Resource Manager: Selezionare la sottoscrizione Azure appropriata.
- Sottoscrizione: Selezionare la sottoscrizione Azure appropriata.
- Azione: selezionare Crea o aggiorna gruppo di risorse.
-
Gruppo di risorse: immettere
$(resourceGroupName). -
Percorso: immettere
$(location). - Posizione del modello: Seleziona l'URL del file.
-
Collegamento al modello: Immetti
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken). -
Esegui l'override dei parametri modello: inserire
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Una pratica comune prevede l'uso di attività di Azure Key Vault. Se l'entità servizio connessa alla sottoscrizione Azure ha un set di criteri di accesso appropriato, può scaricare i segreti da Key Vault e usarla come variabile nella pipeline. Il nome del segreto viene impostato con il valore associato. Ad esempio, è possibile fare riferimento a un segreto di sshPassword con $(sshPassword) nella definizione di versione.
Chiamare interfaccia della riga di comando di Azure per creare un'applicazione in Azure Batch.
Selezionare l'attività interfaccia della riga di comando di Azure e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Crea applicazione in Azure Batch account.
- Connessione di Azure Resource Manager: Selezionare la sottoscrizione Azure appropriata.
- Tipo di script: selezionare PowerShell Core.
- Posizione script: seleziona script inline.
-
Script inline: immetti
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Chiamare interfaccia della riga di comando di Azure per caricare i pacchetti associati nell'applicazione, in questo caso i file ffmpeg.
Selezionare l'attività interfaccia della riga di comando di Azure e impostare le proprietà seguenti:
- Nome visualizzato: Immetti Carica pacchetto nell'account Azure Batch.
- Connessione di Azure Resource Manager: Selezionare la sottoscrizione Azure appropriata.
- Tipo di script: selezionare PowerShell Core.
- Posizione script: seleziona script inline.
-
Script inline: immetti
az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Sostituisci il segnaposto<AzureBuildArtifactSourceAlias>con l'alias dell'origine della compilazione che hai annotato in precedenza.
Annotazioni
Il numero di versione del pacchetto dell'applicazione è impostato su una variabile. La variabile consente di sovrascrivere le versioni precedenti del pacchetto e di controllare manualmente la versione del pacchetto inserita in Azure Batch.
Creare ed eseguire la versione
Al termine della creazione di tutti i passaggi, selezionare Salva nella parte superiore della pagina della pipeline e quindi selezionare OK.
Selezionare Crea versione nella parte superiore della pagina.
Per visualizzare lo stato di rilascio live, selezionare il collegamento nella parte superiore della pagina che indica che la versione è stata creata.
Per visualizzare l'output del log generato dall'agente, passa il puntatore sulla fase e quindi seleziona il pulsante Log.
Testare l'ambiente
Dopo aver configurato l'ambiente, verificare che i test seguenti vengano eseguiti correttamente. Sostituire i segnaposto con i valori del gruppo di risorse e dell'account Batch.
Connetti l'account Batch
Connettersi al nuovo account di Azure Batch usando l'interfaccia della riga di comando di Azure da un prompt dei comandi.
- Accedere all'account Azure con
az logine seguire le istruzioni per l'autenticazione. - Autenticare l'account Batch con
az batch account login -g <resourceGroup> -n <batchAccount>.
Elencare le applicazioni disponibili
az batch application list -g <resourceGroup> -n <batchAccount>
Verificare che il pool sia valido
az batch pool list
Nell'output del comando, annotare il valore di currentDedicatedNodes da utilizzare per la regolazione nel test successivo.
Ridimensionare il pool
Eseguire il comando seguente per ridimensionare il pool in modo che siano disponibili nodi di calcolo per il test di processi e attività. Sostituisci il segnaposto <poolName> con il valore del nome del tuo pool e il segnaposto <targetNumber> con un numero maggiore di currentDedicatedNodes nell'output del comando precedente. Controllare lo stato eseguendo il az batch pool list comando fino al completamento del ridimensionamento e visualizza il numero di nodi di destinazione.
az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>
Passaggi successivi
Consulta queste esercitazioni per imparare a interagire con un account Batch mediante una semplice applicazione.