Utiliser Azure Pipelines pour générer et déployer une solution HPC

Azure DevOps outils peuvent automatiser la création et le test Azure Batch solutions HPC (High Performance Computing). Azure Pipelines fournit des processus modernes d’intégration continue (CI) et de déploiement continu (CD) pour créer, déployer, tester et surveiller des logiciels. Ces processus accélèrent la livraison de vos 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 de 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 libérer un package d’application. Le diagramme suivant illustre le flux de déploiement général, en supposant que le code est développé localement :

Prerequisites

Pour suivre les étapes décrites dans cet article, vous avez besoin des éléments suivants :

• Une organisation Azure DevOps et un projet Azure DevOps avec un dépôt Azure Repos créé dans l’organisation. Vous devez disposer des rôles Administrateur du projet, Administrateur de build et Administrateur des mises en production dans le projet Azure DevOps.

• Un abonnement actif Azure avec propriétaire ou un autre rôle qui inclut des capacités d’attribution de rôle. Pour plus d’informations, consultez Comprendre Azure attributions de rôles.

• Compréhension de base de la syntaxe du contrôle de code source et du modèle ARM.

Préparer 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 (push) à votre dépôt Azure Repos.

Comprendre les modèles ARM

Trois modèles de fonctionnalité, similaires aux unités ou aux modules, implémentent des éléments de fonctionnalité spécifiques. Un modèle de solution de bout en bout déploie ensuite les modèles de capacité sous-jacents. Cette structure de modèle lié permet à chaque modèle de fonctionnalité d’être testé et réutilisé individuellement entre les solutions.

Pour obtenir 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 sous la forme d’un fichier nommé storageAccount.json. Ce modèle définit un compte stockage Azure, qui est nécessaire pour déployer l’application sur 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 sous la forme d’un fichier nommé batchAccount.json. Ce modèle définit un compte Batch. Le compte Batch agit comme une plateforme pour exécuter des applications sur 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 groupe Batch

Enregistrez le code suivant sous la forme d’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 d’orchestrateur

Enregistrez le code suivant sous la forme d’un fichier nommé deployment.json. Ce modèle final agit en tant qu’orchestrateur pour déployer les trois modèles de fonctionnalité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 dépôt Azure Repos.

1. Chargez les quatre modèles ARM dans un dossier arm-templates dans votre dépôt.

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

3. Pour la définition de build, enregistrez la définition suivante sous la forme d’un fichier nommé hpc-app.build.yml, puis chargez-la 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'
   

Une fois que vous avez terminé de configurer votre référentiel, la structure de dossiers doit comporter les sections principales suivantes :

• Dossier arm-templates qui contient les modèles ARM.
• Dossier hpc-application qui contient ffmpeg.
• Un dossier pipelines qui contient le fichier YAML de définition de build pour le pipeline de génération.

Créer le pipeline Azure

Après avoir configuré le référentiel de code source, utilisez Azure Pipelines pour implémenter un pipeline de génération, de test et de déploiement pour votre application. Dans cette phase 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 les types de tests, ainsi que les autres tâches que vous exécutez, dépendent de votre stratégie globale de génération 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.

1. Dans votre projet Azure DevOps, sélectionnez Pipelines dans le volet de navigation gauche, puis sélectionnez Nouveau pipeline.

2. Dans l’écran Où se trouve votre code écran, sélectionnez Azure Repos Git.

   

3. Dans l’écran Sélectionner un référentiel , sélectionnez votre dépôt.

   Note

   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.

4. Dans l’écran Configurer votre pipeline, sélectionnez Existant Azure Pipelines fichier YAML.

5. Dans l’écran Sélectionner un fichier YAML existant , sélectionnez le fichier hpc-app.build.yml dans votre référentiel, puis sélectionnez Continuer.

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

   

7. Vous pouvez afficher en direct l’état d’avancement de la build en direct. Pour afficher les résultats de build, sélectionnez l’exécution appropriée à partir de votre définition de build dans Azure Pipelines.

   

Créer 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 Stockage Blob Azure ou un autre emplacement de stockage. Pour vous assurer que les artefacts de modèle chargés restent sécurisés, maintenez-les en mode privé, mais accédez-y à l’aide d’un certain type de jeton de signature d’accès partagé (SAP).

L’exemple suivant montre comment déployer une infrastructure et une application à l’aide de modèles à partir d’un objet blob stockage Azure.

Configurer le pipeline

1. Dans votre projet Azure DevOps, sélectionnez Pipelines Releases> dans le volet de navigation gauche.

2. Dans l’écran suivant, sélectionnez Nouveau>pipeline de mise en production.

3. Dans l’écran Sélectionner un modèle , sélectionnez Travail vide, puis fermez l’écran Étape .

4. Sélectionnez Nouveau pipeline de mise en production en haut de la page et renommez le pipeline en fonction de votre pipeline, par exemple Déployer Azure Batch + Pool.

   

5. Dans la section Artefacts , sélectionnez Ajouter.

6. Dans l’écran Ajouter un artefact , sélectionnez Générer , puis sélectionnez votre pipeline de build pour obtenir la sortie de l’application HPC.

   Note

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

   

7. Cliquez sur Ajouter.

8. Sur la page du pipeline, sélectionnez Ajouter en regard de Artifacts pour créer un lien vers un autre artefact : votre dépôt Azure Repos. Ce lien est requis 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.

   Note

   Notez à nouveau la valeur de l’alias source à utiliser ultérieurement.

   

9. Sélectionnez l’onglet Variables . Créez les variables suivantes dans votre pipeline afin que vous n’ayez pas besoin de reentérer 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	Identifiant unique de l’application Batch, de la forme : /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^ /providers/Microsoft.Batch/batchAccounts/<batchAccountName>^ /applications/<batchAccountApplicationName> Remplacez l’espace <subscriptionId> réservé par votre ID d’abonnement Azure et les autres espaces réservés par les valeurs que vous définissez pour les autres variables de cette liste.
   batchApplicationVersion	Version sémantique de votre application Batch, dans ce cas 4.3.1.
   emplacement	Région Azure dans laquelle les ressources seront déployées.
   resourceGroupName	Nom du groupe de ressources dans lequel déployer des ressources.
   nomDuCompteDeStockage	Nom du compte de stockage pour contenir les modèles ARM liés.
   StorageContainerSasToken	$(<referenceName>.StorageContainerSasToken) Remplacez l’espace <referenceName réservé par la valeur de nom de référence que vous configurez dans la section Variables de sortie de l’étape de copie de fichier suivante Azure.
   StorageContainerUri	$(<referenceName>.StorageContainerUri) Remplacez l’espace <referenceName> réservé par la valeur de nom de référence que vous configurez dans la section Variables de sortie de l’étape Azure Copie de fichiers.

   

10. Sélectionnez l’onglet Tâches , puis sélectionnez Travail de l’agent.

11. Dans l’écran du travail de l’agent, sous Pool d’agents, sélectionnez Azure Pipelines.

12. 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.
• Chargez le package d’application sur le compte Batch.

Pour chaque nouvelle tâche que les étapes suivantes spécifient :

1. Sélectionnez le symbole + à côté de tâche Agent dans le volet de gauche.

2. Recherchez et sélectionnez la tâche spécifiée dans le volet droit.

3. Ajoutez ou sélectionnez les propriétés pour configurer la tâche.

4. Cliquez sur Ajouter.

   

Créez les tâches comme suit :

1. 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 Agent.
   • Nom de l’artefact : entrez hpc-application.
   • Répertoire de destination : Entrez $(System.DefaultWorkingDirectory).

2. Créez un compte stockage Azure pour stocker vos modèles ARM. Vous pouvez utiliser un compte de stockage existant, mais pour prendre en charge cet exemple autonome et l’isolation du contenu, créez un compte de stockage dédié.

   Sélectionnez la tâche Déploiement de modèle ARM : portée 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.
   • Azure Resource Manager connexion : 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 : Saisissez $(resourceGroupName).
   • Emplacement : Entrée $(location).
   • Modèle : Saisissez $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Remplacez l’espace réservé <AzureRepoArtifactSourceAlias> par l’alias Source du dépôt que vous avez noté précédemment.
   • Remplacer les paramètres du modèle : Entrez -accountName $(storageAccountName).

3. 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 fichiers Azure génère l’URI du conteneur de compte de stockage et le jeton SAP vers une variable, afin qu’elles puissent être réutilisées dans les étapes ultérieures.

   Sélectionnez la tâche de copie de fichiers Azure, puis définissez les propriétés suivantes :

   • Nom d’affichage : Entrez AzureBlob File Copy.
   • Source: Entrez $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Remplacez l’espace réservé <AzureRepoArtifactSourceAlias> par l’alias Source du dépôt que vous avez noté précédemment.
   • abonnement Azure : sélectionnez l’abonnement Azure approprié.
   • Type de destination : sélectionnez Azure blob.
   • Compte de stockage RM : Entrez $(storageAccountName).
   • Nom du conteneur : entrez des modèles.
   • Nom de référence : Développez les variables de sortie, puis entrez ffmpeg.

   Note

   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.

4. Déployez le modèle ARM de l’orchestrateur pour créer le compte Batch et le pool. Ce modèle inclut des paramètres pour l’URI du conteneur de compte de stockage et le jeton SAP. 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 fichiers AzureBlob.

   Sélectionnez la tâche Déploiement de modèle ARM : portée Groupe de ressources, puis définissez les propriétés suivantes :

   • Nom d’affichage: Entrez Deploy 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 : Saisissez $(resourceGroupName).
   • Emplacement : Entrée $(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 des tâches Azure Key Vault. Si le principal de service connecté à votre abonnement Azure dispose d’un jeu de stratégies d’accès approprié, il peut télécharger des secrets à partir de Key Vault et être utilisé comme variable dans votre pipeline. Le nom du secret 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 version.

5. Appelez Azure CLI pour créer une application dans Azure Batch.

   Sélectionnez la tâche Azure CLI, puis définissez les propriétés suivantes :

   • Nom d’affichage : Saisissez 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 un script inline.
   • Script en ligne : Saisissez az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).

6. 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, puis définissez les propriétés suivantes :

   • Nom d’affichage : Saisissez 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 un script inline.
   • Script en ligne : Saisissez 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.

   Note

   Le numéro de version du package d’application est défini sur une variable. La 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

1. Lorsque vous avez terminé de créer toutes les étapes, sélectionnez Enregistrer en haut de la page de pipeline, puis sélectionnez OK.

2. Sélectionnez Créer une version en haut de la page.

3. Pour afficher l’état de la version en temps réel, sélectionnez le lien en haut de la page indiquant que la version a été créée.

4. Pour afficher la sortie du journal à partir de l’agent, passez le curseur sur l’index, puis sélectionnez le bouton Journaux.

   

Tester l’environnement

Une fois l’environnement configuré, vérifiez que les tests suivants s’exécutent correctement. Remplacez les espaces réservés par les valeurs de votre groupe de ressources et de votre compte Batch.

Se connecter au compte Batch

Connectez-vous au nouveau compte Batch à l’aide d’Azure CLI depuis une invite de commandes.

1. Connectez-vous à votre compte Azure avec az login et suivez les instructions pour vous authentifier.
2. 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érifier que le pool est valide

az batch pool list

Dans la sortie de commande, notez la valeur de currentDedicatedNodes pour l’ajuster lors du 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 tâche et de travail. 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 à currentDedicatedNodes dans la sortie de la commande précédente. Vérifiez l’état en exécutant la az batch pool list commande 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

Consultez ces tutoriels pour découvrir comment interagir avec un compte Batch via une application simple.

• Exécuter une charge de travail parallèle avec Azure Batch à l’aide de l’API Python
• Exécuter une charge de travail parallèle avec Azure Batch à l’aide de l’API .NET