Créer des environnements Azure DevTest Labs à partir de modèles ARM

Dans cet article, vous allez apprendre à créer des environnements Azure DevTest Labs à partir de modèles Azure Resource Manager (ARM). Vous pouvez utiliser des environnements DevTest Labs pour approvisionner facilement et de manière cohérente des labos avec plusieurs machines virtuelles ou des ressources PaaS (Platform-as-a-Service). Vous pouvez adopter cette approche afin de créer un labo pour une application web multiniveau ou une batterie de serveurs SharePoint.

Les ressources d’un environnement DevTest Labs partagent le même cycle de vie, et vous pouvez les gérer ensemble. Vous pouvez suivre le coût des environnements de labo et des ressources PaaS de la même façon que vous effectuez le suivi des coûts des machines virtuelles de labo individuelles.

Vous pouvez configurer Azure DevTest Labs pour utiliser des modèles ARM provenant d’un dépôt GitHub public ou privé. Le diagramme suivant montre comment créer un environnement avec DevTest Labs à partir d’un modèle ARM dans un dépôt de modèles public ou personnalisé. La section sur les référentiels de modèles pour les labos décrit ce processus en détail.

Prérequis

• Il est utile d’avoir une expérience en matière de configuration des environnements de labo dans DevTest Labs. Si vous débutez avec les labos, commencez par passer en revue les instructions de la section Configurer les paramètres de l’environnement public. Vous devez comprendre comment configurer les dépôts de modèles, activer ou désactiver les environnements publics, et sélectionner des modèles pour créer des labos.

Limites

Il existe quelques limitations à garder à l’esprit lorsque vous créez des labos à partir de modèles ARM dans DevTest Labs :

• DevTest Labs ne prend pas en charge la fonctionnalité d’arrêt automatique de machine virtuelle pour les ressources PaaS créées à partir de modèles ARM.

• DevTest Labs n’évalue pas toutes les stratégies de labo lorsque vous déployez des modèles ARM. Les stratégies suivantes ne sont pas évaluées :

  • Nombre de machines virtuelles par utilisateur de labo
  • Nombre de machines virtuelles Premium par utilisateur
  • Nombre de bureaux Premium par utilisateur

  Supposez que vous avez une stratégie de labo qui autorise chaque utilisateur à créer un maximum de cinq machines virtuelles. Dans DevTest Labs, chaque utilisateur peut déployer un modèle d’environnement ARM qui crée des dizaines de machines virtuelles.

Créer des environnements à partir de modèles

Vous pouvez créer un environnement à partir du référentiel de modèles public Azure DevTest Labs ou ajouter un référentiel de modèles privé à votre labo.

Créez un environnement à partir d’un modèle en effectuant ces étapes :

1. Dans le portail Azure, accédez à votre ressource de labo DevTest Labs.

2. Dans la page Vue d’ensemble du labo, développez la section Mon labo dans le menu de gauche, puis sélectionnez Mes environnements.

3. Dans la page Mes environnements, sélectionnez Ajouter dans la barre d’outils.

4. Dans la page Choisir une base, sélectionnez le modèle d’environnement ARM à utiliser :

   

5. Dans le volet Ajouter, entrez un Nom d’environnement et configurez les autres paramètres.

   Le type et le nombre de paramètres sont uniques pour chaque modèle ARM. Un astérisque (*) rouge indique un paramètre obligatoire. Vous devez entrer des valeurs pour tous les paramètres obligatoires.

   Certaines valeurs de paramètres dans le fichier de modèle ARM (azuredeploy.parameters.json) produisent des champs de paramètres vides dans le volet Ajouter (aucune valeur par défaut). Ces valeurs de paramètres incluent GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEY et GEN-PASSWORD.

   

   Pour les paramètres de chaînes sécurisées comme les mots de passe, vous pouvez utiliser des secrets provenant d’Azure Key Vault. Pour savoir comment stocker des secrets dans un coffre de clés et comment les utiliser lorsque vous créez des ressources de labo, consultez Stocker des secrets dans Azure Key Vault.

6. Sélectionnez Ajouter pour créer l’environnement. L’environnement démarre immédiatement le provisionnement.

   Remarque

   Le processus d’approvisionnement d’un environnement peut prendre beaucoup de temps. La durée totale dépend du nombre d’instances de service et de machines virtuelles et des autres ressources créées par DevTest Labs dans le cadre de l’environnement de labo.

7. Pour surveiller l’état d’approvisionnement, revenez à la page Mes environnements du labo :

   

   Pendant que l’approvisionnement est en cours, l’état de l’environnement est Création en cours. Une fois l’approvisionnement terminé, l’état prend la valeur Prêt. Vous pouvez sélectionner Actualiser dans la barre d’outils pour mettre à jour l’affichage de la page et vérifier l’état actuel.

8. Lorsque l’environnement est prêt, vous pouvez le développer dans la liste Mes environnements pour afficher les machines virtuelles approvisionnées par le modèle :

   

9. Le déploiement crée un groupe de ressources pour approvisionner toutes les ressources d’environnement définies par le modèle ARM. Sélectionnez le nom de l’environnement dans la liste Mes environnements pour afficher le groupe de ressources et toutes les ressources créées par le modèle :

   

10. Sélectionnez une machine virtuelle d’environnement dans la liste pour voir les actions disponibles relatives à celle-ci, par exemple la gestion de la configuration, les planifications et les stratégies :

    

Explorer les dépôts de modèles

Les modèles ARM pour la création d’environnements dans DevTest Labs sont disponibles à partir de deux sources :

• DevTest Labs dispose d’un dépôt de modèles ARM public qui comprend des modèles d’environnement précréés pour Azure Web Apps, un cluster Azure Service Fabric ainsi que des batteries de serveurs SharePoint de développement. Les modèles ont des paramètres d’entrée minimaux afin de faciliter l’expérience de prise en main des ressources PaaS. Vous pouvez utiliser les modèles d’environnements publics en l’état, ou les personnaliser selon vos besoins. Vous pouvez également suggérer des révisions ou des ajouts à un modèle public en soumettant une demande de tirage (pull request) au dépôt de modèles publics GitHub.

• Vous pouvez stocker des modèles d’environnements dans vos propres dépôts GitHub publics ou privés, et ajouter ces dépôts à votre labo pour mettre vos modèles à disposition de tous les utilisateurs de labo.

Configurer les paramètres d’environnement public

Vous pouvez configurer votre labo pour activer l’utilisation de modèles à partir du dépôt GitHub de modèles public. Lorsque vous activez le dépôt de modèles public pour un labo, les utilisateurs peuvent créer rapidement un environnement de labo en sélectionnant ces modèles directement dans le portail Azure, de la même façon qu’ils créent une machine virtuelle dans un labo. En outre, vous pouvez sélectionner les modèles à partir desquels les utilisateurs peuvent créer des environnements de labo.

Définir l’accès à l’environnement public pour le nouveau labo

Configurez l’accès au dépôt d’environnement public pour un nouveau labo en effectuant ces étapes :

1. Pendant le processus de création d’une ressource DevTest Labs, sélectionnez l’onglet Paramètres de base.

2. Affectez la valeur Activé à l’option Environnements publics :

   

Définir l’accès à l’environnement public pour les labos existants

Pour les labos existants ou les labos que vous créez avec un modèle ARM, les environnements publics peuvent ne pas être activés. Vous pouvez contrôler l’accès aux dépôts d’environnements publics pour n’importe quel labo existant avec l’option Activer les environnements publics pour ce lab.

Effectuez ces étapes pour activer ou désactiver l’accès au dépôt d’environnement public pour tout labo existant :

1. Dans le portail Azure, accédez à la ressource de labo DevTest Labs où vous souhaitez définir l’accès à l’environnement public.

2. Dans la page Vue d’ensemble de votre labo, développez la section Paramètres dans le menu de gauche, puis sélectionnez Configuration et stratégies.

3. Dans la page Configuration et stratégies, développez la section Bases de machine virtuelle dans le menu de gauche, puis sélectionnez Environnements publics.

4. Dans la page Environnements publics, affectez la valeur Oui à l’option Activer les environnements publics pour ce lab :

   

5. Cliquez sur Enregistrer.

Sélectionner les modèles d’environnements publics disponibles

Lorsque vous définissez l’option Activer les environnements publics pour ce lab pour contrôler l’accès aux environnements publics de votre labo, tous les modèles d’environnements sont sélectionnés par défaut. Le paramètre autorise ou interdit l’accès à tous les environnements en fonction de votre sélection. Vous pouvez utiliser les cases de sélection dans la liste pour spécifier les environnements auxquels vos utilisateurs peuvent accéder.

Effectuez ces étapes pour autoriser l’accès uniquement à des environnements spécifiques pour le labo :

1. Dans la page Environnements publics, affectez la valeur Oui à l’option Activer les environnements publics pour ce lab.

2. Désélectionnez des environnements spécifiques dans la liste pour les rendre inaccessibles aux utilisateurs de labo :

   

3. Cliquez sur Enregistrer.

Configurer les droits de l’utilisateur de l’environnement

Par défaut, les utilisateurs de labo ont le rôle Lecteur dans les dépôts d’environnements publics. Ils ne peuvent pas modifier les ressources d’environnement, et ne peuvent pas arrêter ni démarrer des ressources.

Effectuez les étapes suivantes pour accorder aux utilisateurs de labo le rôle Contributeur et les autoriser à modifier les ressources de l’environnement :

1. Dans le portail Azure, accédez à la ressource de labo DevTest Labs où vous souhaitez ajuster les affectations de rôles utilisateur.

2. Dans la page Vue d’ensemble de votre labo, développez la section Paramètres dans le menu de gauche, puis sélectionnez Configuration et stratégies.

3. Dans la page Configuration et stratégies, développez la section Paramètres dans le menu de gauche, puis sélectionnez Paramètres de labo.

4. Dans la page Paramètres de labo, définissez l’option Accès de l’environnement>Droits utilisateur du groupe de ressources sur Contributeur :

   

5. Cliquez sur Enregistrer.

Automatiser la création d’un environnement

Si vous devez créer plusieurs environnements pour des scénarios de développement ou de test, vous pouvez automatiser le déploiement d’environnements avec Azure PowerShell ou Azure CLI.

Les propriétaires et administrateurs de labos peuvent utiliser Azure PowerShell pour créer des machines virtuelles et des environnements à partir de modèles ARM. Vous pouvez également automatiser le déploiement via Azure CLI en utilisant la commande az deployment group create pour créer des environnements. Pour plus d’informations, consultez Déployer des ressources à l’aide de modèles ARM et d’Azure CLI.

Remarque

Nous vous recommandons d’utiliser le module Azure Az PowerShell pour interagir avec Azure. Pour bien démarrer, consultez Installer Azure PowerShell. Pour savoir comment migrer vers le module Az PowerShell, consultez Migrer Azure PowerShell depuis AzureRM vers Az.

Automatisez le déploiement de modèles d’environnements ARM avec Azure PowerShell en effectuant les étapes suivantes :

1. Stockez le modèle d’environnement ARM dans un dépôt GitHub.

2. Ajoutez le dépôt de modèles ARM GitHub à votre labo.

3. Enregistrez le script PowerShell suivant sur votre ordinateur sous le nom deployenv.ps1. Ce script appelle le modèle ARM pour créer l’environnement dans le labo.

   #Requires -Module Az.Resources
   
   [CmdletBinding()]
   
   param (
   # ID of the Azure subscription for the lab
   [string] [Parameter(Mandatory=$true)] $SubscriptionId,
   
   # Name of the lab in which to create the environment
   [string] [Parameter(Mandatory=$true)] $LabName,
   
   # Name of the template repository connected to the lab
   [string] [Parameter(Mandatory=$true)] $RepositoryName,
   
   # Name of the template (folder name in the GitHub repository)
   [string] [Parameter(Mandatory=$true)] $TemplateName,
   
   # Name of the environment to create in the lab
   [string] [Parameter(Mandatory=$true)] $EnvironmentName,
   
   # The parameters to pass to the template. Each parameter is prefixed with "-param_".
   # For example, if the template has a parameter named "TestVMName" with a value of "MyVMName",
   # the string in $Params is "-param_TestVMName MyVMName".
   # This convention allows the script to dynamically handle different templates.
   [Parameter(ValueFromRemainingArguments=$true)]
       $Params
   )
   
   # Sign in to Azure, or comment out this statement to completely automate environment creation.
   Connect-AzAccount
   
   # Select the subscription for your lab.  
   Set-AzContext -SubscriptionId $SubscriptionId | Out-Null
   
   # Get the user ID to use later in the script.
   $UserId = $((Get-AzADUser -UserPrincipalName ((Get-AzContext).Account).Id).Id)
   
   # Get the lab location.
   $lab = Get-AzResource -ResourceType "Microsoft.DevTestLab/labs" -Name $LabName
   if ($lab -eq $null) { throw "Unable to find lab $LabName in subscription $SubscriptionId." }
   
   # Get information about the repository connected to your lab.
   $repository = Get-AzResource -ResourceGroupName $lab.ResourceGroupName `
       -ResourceType 'Microsoft.DevTestLab/labs/artifactsources' `
       -ResourceName $LabName `
       -ApiVersion 2016-05-15 `
       | Where-Object { $RepositoryName -in ($_.Name, $_.Properties.displayName) } `
       | Select-Object -First 1
   if ($repository -eq $null) { throw "Unable to find repository $RepositoryName in lab $LabName." }
   
   # Get information about the ARM template base for the environment.
   $template = Get-AzResource -ResourceGroupName $lab.ResourceGroupName `
       -ResourceType "Microsoft.DevTestLab/labs/artifactSources/armTemplates" `
       -ResourceName "$LabName/$($repository.Name)" `
       -ApiVersion 2016-05-15 `
       | Where-Object { $TemplateName -in ($_.Name, $_.Properties.displayName) } `
       | Select-Object -First 1
   if ($template -eq $null) { throw "Unable to find template $TemplateName in lab $LabName." }
   
   # Build the template parameters by using parameter names and values.
   $parameters = Get-Member -InputObject $template.Properties.contents.parameters -MemberType NoteProperty | Select-Object -ExpandProperty Name
   $templateParameters = @()
   
   # Extract the custom parameters from $Params and format them as name/value pairs.
   $Params | ForEach-Object {
       if ($_ -match '^-param_(.*)' -and $Matches[1] -in $parameters) {
           $name = $Matches[1]                
       } elseif ( $name ) {
           $templateParameters += @{ "name" = "$name"; "value" = "$_" }
           $name = $null #reset name variable
       }
   }
   
   # Create an object to hold the necessary template properties.
   $templateProperties = @{ "deploymentProperties" = @{ "armTemplateId" = "$($template.ResourceId)"; "parameters" = $templateParameters }; }
   
   # Deploy the environment in your lab by using the New-AzResource command.
   New-AzResource -Location $Lab.Location `
       -ResourceGroupName $lab.ResourceGroupName `
       -Properties $templateProperties `
       -ResourceType 'Microsoft.DevTestLab/labs/users/environments' `
       -ResourceName "$LabName/$UserId/$EnvironmentName" `
       -ApiVersion '2016-05-15' -Force
   
   Write-Output "Environment $EnvironmentName completed."
   

4. Mettez à jour les espaces réservés suivants dans le script avec vos propres valeurs de labo :

   • SubscriptionId
   • LabName
   • ResourceGroupName
   • RepositoryName
   • TemplateName (dossier de modèles dans le dépôt GitHub)
   • EnvironmentName

   L’extrait de code suivant montre comment exécuter le script avec des exemples de valeurs de paramètres :

   ./deployenv.ps1 -SubscriptionId "000000000-0000-0000-0000-0000000000000" -LabName "mydevtestlab" -ResourceGroupName "mydevtestlabRG000000" -RepositoryName "myRepository" -TemplateName "ARM template folder name" -EnvironmentName "myNewEnvironment"
   

5. Exécutez le script.

Contenu connexe

• Utiliser des modèles ARM pour créer des machines virtuelles DevTest Labs
• Dépôt de modèles d’environnements ARM publics sur GitHub
• Galerie de modèles de démarrage rapide Azure sur GitHub