Utilisez Azure Pipelines pour générer et déployer une solution HPC
Les outils Azure DevOps peuvent automatiser la génération et le test des solutions de calcul haute performance (HPC) Azure Batch. Azure Pipelines propose des processus modernes d’intégration continue (CI) et de déploiement continu (CD) pour générer, déployer, tester et surveiller les logiciels. Ces processus accélèrent la livraison des logiciels, ce qui vous permet de vous concentrer sur votre code plutôt que de prendre en charge l’infrastructure et les opérations.
Cet article explique comment configurer des processus CI/CD à l’aide d’Azure Pipelines avec des modèles AZURE Resource Manager (modèles ARM) pour déployer des solutions HPC sur Azure Batch. L’exemple crée un pipeline de build et de mise en production pour déployer une infrastructure Azure Batch et mettre en production un package d’application. Le diagramme suivant montre le flux de déploiement général, en supposant que le code est développé localement :
Prérequis
Pour suivre les étapes décrites dans cet article, vous devez :
Un organisation Azure DevOps et un projet Azure DevOps avec un référentielAzure Repos créé dans l’organisation. Vous devez disposer des rôles Administrateur de projet, Administrateur de build et Administrateur de mise en production dans le projet Azure DevOps.
Un abonnement Azure actif avec Propriétaire ou un autre rôle qui inclut des capacités d’attribution de rôle. Pour plus d’informations, consultez Comprendre les attributions de rôles Azure.
Une compréhension de base du contrôle de code source et de la syntaxe de modèle ARM.
Préparez la solution
L’exemple de cet article utilise plusieurs modèles ARM et une application de traitement vidéo open source existante, FFmpeg. Vous pouvez copier ou télécharger ces ressources et les envoyer à votre référentiel Azure Repos.
Important
Cet exemple déploie des logiciels Windows sur des nœuds Batch Windows. Azure Pipelines, les modèles ARM et Batch prennent également entièrement en charge les logiciels et les nœuds Linux.
Comprenez les modèles ARM
Trois modèles de capacités, semblables à des unités ou des modules, mettent en œuvre des éléments spécifiques de fonctionnalité. Un modèle de solution de bout en bout déploie ensuite les modèles de capacité sous-jacents. Cette structure de modèles liés permet de tester individuellement chaque modèle de capacité et de le réutiliser dans les différentes solutions.
Pour des informations détaillées sur les modèles, consultez le Guide de référence des modèles Resource Manager pour les types de ressources Microsoft.Batch.
Modèle de compte de stockage
Enregistrez le code suivant dans un fichier nommé storageAccount.json. Ce modèle définit un compte de stockage Azure, qui est nécessaire pour déployer l’application dans le compte 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'))]"
}
}
}
Modèle de compte Batch
Enregistrez le code suivant dans un fichier nommé batchAccount.json. Ce modèle définit un compte Batch. Le compte Batch agit comme une plateforme permettant d’exécuter des applications à travers des pools de nœuds.
{
"$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": {}
}
Modèle de pool Batch
Enregistrez le code suivant dans un fichier nommé batchAccountPool.json. Ce modèle crée un pool de nœuds et des nœuds dans le compte 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": {}
}
Modèle Orchestrator
Enregistrez le code suivant dans un fichier nommé deployment.json. Ce dernier modèle fait office d’orchestrateur pour déployer les trois modèles de capacités sous-jacents.
{
"$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": {}
}
Configurer votre référentiel
Chargez les modèles ARM, l’application FFmpeg et un fichier de définition de build YAML dans votre référentiel Azure Repos.
Chargez les quatre modèles ARM dans un dossier arm-templates dans votre référentiel.
Pour le package d’application, téléchargez et extrayez la version Windows 64 bits de FFmpeg 4.3.1, puis chargez-la dans un dossier hpc-application dans votre référentiel.
Pour la définition de build, enregistrez la définition suivante en tant que nom de fichier hpc-app.build.yml, puis téléchargez-le dans un dossier pipelines dans votre référentiel.
# 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'
Lorsque vous avez terminé de configurer votre référentiel, la structure du dossier doit comporter les sections principales suivantes :
- Un dossier arm-templates qui contient les modèles ARM.
- Un dossier hpc-application qui contient ffmpeg.
- Un dossier pipelines qui contient le fichier de définition de build YAML pour le pipeline de build.
Notes
Cet exemple de structure codebase montre que vous pouvez stocker du code d’application, d’infrastructure et de pipeline dans le même référentiel.
Créez le pipeline Azure
Après avoir configuré le référentiel de code source, utilisez Azure Pipelines pour implémenter un pipeline de build, de test et de déploiement pour votre application. À ce stade d’un pipeline, vous exécutez généralement des tests pour valider le code et générer des éléments du logiciel. Le nombre et le type de tests, ainsi que les autres tâches que vous exécutez, dépendent de votre stratégie globale de build et de mise en production.
Créez le pipeline de build
Dans cette section, vous créez un pipeline de build YAML pour utiliser le logiciel ffmpeg qui s’exécute dans le compte Batch.
Dans votre projet Azure DevOps, sélectionnez Pipelines dans la navigation de gauche, puis sélectionnez Nouveau pipeline.
Dans l’écran Où se trouve votre code ?, sélectionnez Azure Repos Git.
Dans l’écran Sélectionner un référentiel, sélectionnez votre référentiel.
Notes
Vous pouvez également créer un pipeline de build à l’aide d’un concepteur visuel. Dans la page Nouveau pipeline, sélectionnez Utiliser l’éditeur classique. Vous pouvez utiliser un modèle YAML dans le concepteur visuel. Pour plus d’informations, consultez Définir votre pipeline classique.
Dans l’écran Configurer votre pipeline, sélectionnez Fichier YAML Azure Pipelines existant.
Dans l’écran Sélectionner un fichier YAML existant, sélectionnez le fichier hpc-app.build.yml à partir de votre référentiel, puis sélectionnez Continuer.
Dans l’écran Passer en revue votre pipeline YAML, passez en revue la configuration de la build, puis sélectionnez Exécuter, ou sélectionnez la liste déroulante en regard de Exécuter et sélectionnez Enregistrer. Ce modèle permet l’intégration continue, de sorte que la build se déclenche automatiquement lorsqu’une nouvelle validation dans le référentiel remplit les conditions définies dans la build.
Vous pouvez afficher en direct l’état d’avancement de la build en direct. Pour afficher les résultats de la build, sélectionnez l’exécution appropriée à partir de votre définition de build dans Azure Pipelines.
Notes
Si vous utilisez une application cliente pour exécuter votre solution HPC, vous devez créer une définition de build distincte pour cette application. Pour obtenir des guides pratiques, consultez la documentation Azure Pipelines.
Créez le pipeline de mise en production
Vous utilisez un Pipeline de mise en production Azure Pipelines pour déployer votre application et votre infrastructure sous-jacente. Les pipelines de mise en production activent le CD et automatisent votre processus de mise en production. Il existe plusieurs étapes pour déployer votre application et votre infrastructure sous-jacente.
Les modèles liés pour cette solution doivent être accessibles à partir d’un point de terminaison HTTP ou HTTPS public. Ce point de terminaison peut être un référentiel GitHub, un compte de stockage Blob Azure ou un autre emplacement de stockage. Pour vous assurer que les artefacts de modèle téléchargés restent sécurisés, conservez-les en mode privé, mais accédez-y en utilisant une forme de jeton de signature d’accès partagé (SAS).
L’exemple suivant montre comment déployer une infrastructure et une application en utilisant des modèles à partir d’un blob de stockage Azure.
Configurer le pipeline
Dans votre projet Azure DevOps, sélectionnez Pipelines>Mise en production dans la navigation de gauche.
Dans l’écran suivant, sélectionnez Nouveau>Nouveau pipeline de mise en production.
Dans l’écran Sélectionner un modèle, sélectionnez Travail vide, puis fermez l’écran Index.
Sélectionnez Nouveau pipeline de mise en production en haut de la page et renommez le pipeline en quelque chose de pertinent pour votre pipeline, par exemple Déployer Azure Batch + Pool.
Dans la section Artefacts, sélectionnez Ajouter.
Dans l’écran Ajouter un artefact, sélectionnez Build, puis sélectionnez votre pipeline de build pour obtenir la sortie de l’application HPC.
Notes
Vous pouvez créer un Alias source ou accepter la valeur par défaut. Notez la valeur de l’Alias source, car vous en avez besoin pour créer des tâches dans la définition de mise en production.
Sélectionnez Ajouter.
Dans la page du pipeline, sélectionnez Ajouter en regard de Artefacts pour créer un lien vers un autre artefact, votre référentiel Azure Repos. Ce lien est nécessaire pour accéder aux modèles ARM dans votre référentiel. Les modèles ARM n’ont pas besoin de compilation. Vous n’avez donc pas besoin de les envoyer via un pipeline de build.
Notes
Notez à nouveau la valeur de l’Alias source à utiliser ultérieurement.
Sélectionnez l’onglet Variables. Créez les variables suivantes dans votre pipeline afin de ne pas avoir à entrer à nouveau les mêmes informations dans plusieurs tâches.
Nom Valeur applicationStorageAccountName Nom du compte de stockage pour contenir les fichiers binaires de l’application HPC. batchAccountApplicationName Nom de l’application dans le compte Batch. batchAccountName Nom du compte Batch. batchAccountPoolName Nom du pool de machines virtuelles à traiter. batchApplicationId ID unique de l’application Batch, au format : /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^
/applications/<batchAccountApplicationName>.
Remplacez l’espace réservé<subscriptionId>par votre ID d’abonnement Azure et les autres espaces réservés par les valeurs que vous avez définies pour les autres variables de cette liste.batchApplicationVersion Version sémantique de votre application Batch, dans ce cas 4.3.1. location Région Azure pour les ressources à déployer. resourceGroupName Nom du groupe de ressources dans lequel déployer des ressources. storageAccountName Nom du compte de stockage pour contenir les modèles ARM liés. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Remplacez l’espace réservé<referenceNamepar la valeur du Nom de référence que vous configurez dans la section Variables de sortie de l’étape de Copie de fichier Azure suivante.StorageContainerUri $(<referenceName>.StorageContainerUri). Remplacez l’espace réservé<referenceName>par la valeur du Nom de référence que vous configurez dans la section Variables de sortie de l’étape de Copie de fichier Azure.
Sélectionnez l’onglet Tâches, puis sélectionnez Travail de l’agent.
Dans l’écran Travail de l’agent, sous Pool d’agents, sélectionnez Azure Pipelines.
Sous Spécification de l’agent, sélectionnez windows-latest.
Ajouter des tâches
Créez six tâches pour :
- Téléchargez les fichiers ffmpeg compressés.
- Déployez un compte de stockage pour héberger les modèles ARM imbriqués.
- Copiez les modèles ARM dans le compte de stockage.
- Déployez le compte Batch et les dépendances requises.
- Créez une application dans le compte Batch.
- Téléchargez le dossier de candidature sur le compte Batch.
Pour chaque nouvelle tâche que les étapes suivantes spécifient :
Sélectionnez le symbole + en regard de Tâche de l’agent dans le volet gauche.
Recherchez et sélectionnez la tâche spécifiée dans le volet droit.
Ajoutez ou sélectionnez les propriétés pour configurer la tâche.
Sélectionnez Ajouter.
Créez les tâches comme suit :
Sélectionnez la tâche Télécharger les artefacts de pipeline et définissez les propriétés suivantes :
- Nom d’affichage : entrez Télécharger ApplicationPackage sur l’agent.
- Nom de l’artefact : entrez hpc-application.
-
Répertoire de destination : entrez
$(System.DefaultWorkingDirectory).
Créez un compte de stockage Azure pour stocker vos modèles ARM. Vous pouvez utiliser un compte de stockage existant, mais pour appuyer cet exemple autonome et l’isolation du contenu, créez un compte de stockage dédié.
Sélectionnez la tâche Template deployment ARM : Étendue du groupe de ressources, puis définissez les propriétés suivantes :
- Nom d’affichage : Entrez Déployer le compte de stockage pour les modèles ARM.
- Connexion Azure Resource Manager : sélectionnez l’abonnement Azure approprié.
- Abonnement : sélectionnez l’abonnement Azure approprié.
- Action : sélectionnez Créer ou mettre à jour un groupe de ressources.
-
Groupe de ressources : entrez
$(resourceGroupName). -
Emplacement : entrez
$(location). -
Modèle : entrez
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Remplacez l’espace réservé<AzureRepoArtifactSourceAlias>par l’alias source du référentiel que vous avez noté précédemment. -
Remplacer les paramètres du modèle : entrez
-accountName $(storageAccountName).
Téléchargez les artefacts du contrôle de code source dans le compte de stockage. Une partie de cette tâche de copie de fichier Azure génère l’URI du conteneur de compte de stockage et le jeton SAP vers une variable, afin qu’ils puissent être réutilisés dans les étapes ultérieures.
Sélectionnez la tâche Copie de fichier Azure et définissez les propriétés suivantes :
- Nom d’affichage : entrez Copie de fichier AzureBlob.
-
Source : entrez
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Remplacez l’espace réservé<AzureRepoArtifactSourceAlias>par l’alias source du référentiel que vous avez noté précédemment. - Abonnement Azure : sélectionnez l’abonnement Azure approprié.
- Type de destination : sélectionnez Blob Azure.
-
Compte de stockage RM : entrez
$(storageAccountName). - Nom du conteneur : entrez modèles.
- Nom de référence : développez Variables de sortie, puis entrez ffmpeg.
Notes
Si cette étape échoue, vérifiez que votre organisation Azure DevOps a le rôle Contributeur de blob de stockage dans le compte de stockage.
Déployez le modèle ARM d’orchestrateur pour créer le compte et le pool Batch. Ce modèle comprend des paramètres d’URI du Conteneur de compte de stockage et de jeton SAS. Les variables requises dans le modèle ARM sont conservées dans la section variables de la définition de mise en production et ont été définies à partir de la tâche de copie de fichier AzureBlob.
Sélectionnez la tâche Template deployment ARM : Étendue du groupe de ressources, puis définissez les propriétés suivantes :
- Nom d’affichage : entrez Déployer Azure Batch.
- Connexion Azure Resource Manager : sélectionnez l’abonnement Azure approprié.
- Abonnement : sélectionnez l’abonnement Azure approprié.
- Action : sélectionnez Créer ou mettre à jour un groupe de ressources.
-
Groupe de ressources : entrez
$(resourceGroupName). -
Emplacement : entrez
$(location). - Emplacement du modèle : sélectionnez l’URL du fichier.
-
Lien de modèle : entrez
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken). -
Remplacer les paramètres du modèle : entrez
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Une pratique courante consiste à utiliser les tâches Azure Key Vault. Si le principal de service connecté à votre abonnement Azure dispose d’une stratégie d’accès appropriée, il peut télécharger des secrets à partir de Key Vault et être utilisé comme variable dans votre pipeline. Le nom de la clé secrète est défini avec la valeur associée. Par exemple, vous pouvez référencer un secret de sshPassword avec $(sshPassword) dans la définition de la mise en production.
Appelez Azure CLI pour créer une application dans Azure Batch.
Sélectionnez la tâche Azure CLI et définissez les propriétés suivantes :
- Nom d’affichage : entrez Créer une application dans le compte Azure Batch.
- Connexion Azure Resource Manager : sélectionnez l’abonnement Azure approprié.
- Type de script : sélectionnez PowerShell Core.
- Emplacement du script : sélectionnez Script inclus.
-
Script inclus : entrez
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Appelez Azure CLI pour charger les packages associés dans l’application, dans ce cas les fichiers ffmpeg.
Sélectionnez la tâche Azure CLI et définissez les propriétés suivantes :
- Nom d’affichage : entrez Charger le package dans le compte Azure Batch.
- Connexion Azure Resource Manager : sélectionnez l’abonnement Azure approprié.
- Type de script : sélectionnez PowerShell Core.
- Emplacement du script : sélectionnez Script inclus.
-
Script inclus : entrez
az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Remplacez l’espace réservé<AzureBuildArtifactSourceAlias>par l’alias source de la build que vous avez noté précédemment.
Notes
Le numéro de version du package d’application est défini sur une variable. Cette variable permet de remplacer les versions précédentes du package et de contrôler manuellement la version du package envoyée à Azure Batch.
Créez et exécutez la mise en production
Lorsque vous avez terminé de créer toutes les étapes, sélectionnez Enregistrer en haut de la page du pipeline, puis sélectionnez OK.
Sélectionnez Créer une mise en production en haut de la page.
Pour afficher les statut de mise en production en direct, sélectionnez le lien en haut de la page indiquant que la mise en production a été créée.
Pour afficher la sortie du journal à partir de l’agent, passez le curseur sur l’index, puis sélectionnez le bouton Journaux.
Test de l’environnement
Une fois l’environnement configuré, vérifiez que les tests suivants s’exécutent correctement. Remplacez les espaces réservés par vos valeurs de groupe de ressources et de compte Batch.
Connectez-vous au compte Batch
Connectez-vous au nouveau compte Batch en utilisant Azure CLI à partir d’une invite de commande.
- Connectez-vous à votre compte Azure avec
az loginet suivez les instructions pour vous effectuer l’authentification. - Authentifiez le compte Batch avec
az batch account login -g <resourceGroup> -n <batchAccount>.
Répertorier les applications disponibles
az batch application list -g <resourceGroup> -n <batchAccount>
Vérifiez que le pool est valide
az batch pool list
Dans la sortie de commande, notez la valeur de currentDedicatedNodes à ajuster dans le test suivant.
Redimensionner le pool
Exécutez la commande suivante pour redimensionner le pool afin qu’il y ait des nœuds de calcul disponibles pour les tests de travaux et de tâches. Remplacez l’espace réservé <poolName> par la valeur du nom de votre pool et l’espace réservé <targetNumber> par un nombre supérieur à la valeur currentDedicatedNodes de la sortie de la commande précédente. Vérifiez l’état en exécutant la commande az batch pool list jusqu’à ce que le redimensionnement se termine et affiche le nombre cible de nœuds.
az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>
Étapes suivantes
Pour savoir comment interagir avec un compte Batch par l’intermédiaire d’une application simple, consultez ces tutoriels.