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

Article
09/30/2023

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). Par exemple, pour créer un labo pour une application web multiniveau ou une batterie de serveurs SharePoint.

Les ressources d’un environnement 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 référentiel Git public ou privé. En savoir plus sur les référentiels de modèles pour les labos.

Si vous souhaitez utiliser un modèle ARM pour créer une ressource Azure DevTest Labs, consultez Démarrage rapide : Utiliser un modèle ARM pour créer un lab dans DevTest Labs.

Limites

Tenez compte des limitations suivantes lorsque vous créez des labos à partir de modèles ARM dans DevTest Labs :

L’arrêt automatique des machines virtuelles ne s’applique pas aux ressources PaaS.
Toutes les stratégies de labo ne sont pas évaluées au moment du déploiement de modèles ARM. Les stratégies non évaluées incluent : le nombre de machines virtuelles par utilisateur de labo, le nombre de machines virtuelles Premium par utilisateur ainsi que le nombre de bureaux Premium par utilisateur. Par exemple, votre stratégie de labo peut limiter les utilisateurs à seulement cinq machines virtuelles. Toutefois, un 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.

Découvrez comment configurer des environnements pour votre labo. Par exemple, comment configurer les référentiels de modèles, activer ou désactiver des environnements publics et sélectionner des modèles spécifiques pour la création de labos.

Pour créer un environnement à partir d’un modèle :

Dans le portail Azure, sélectionnez votre ressource de labo.
Dans la page Vue d’ensemble du labo, sélectionnez Ajouter dans la barre d’outils supérieure.
Dans la page Choisir une base, sélectionnez le modèle d’environnement ARM à utiliser. Les modèles d’environnements disponibles apparaissent en premier dans la liste des bases.
Dans l’écran Ajouter, entrez un Nom d’environnement et renseignez les autres champs d’entrée.

Le nombre et le type des champs d’entrée sont définis dans le modèle ARM. Si nécessaire, entrez les valeurs des champs d’entrée que le fichier de modèle azuredeploy.parameters.json définit comme étant vides ou par défaut.
- Pour les paramètres de secure string, vous pouvez utiliser les secrets d’Azure Key Vault. Pour savoir comment stocker des secrets dans un coffre de clés et comment les utiliser au moment de la création de ressources de labo, consultez Stocker les secrets dans Azure Key Vault.
- Dans les fichiers de modèles ARM, les valeurs de paramètre GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEY et GEN-PASSWORD génèrent des champs d’entrée vides qui permettent aux utilisateurs d’entrer des valeurs.
Sélectionnez Ajouter pour créer l’environnement.

L’environnement démarre immédiatement le provisionnement. Vous pouvez voir l’état de provisionnement sous Mes environnements dans la page Vue d’ensemble du labo. Le provisionnement d’un environnement peut prendre beaucoup de temps.
Une fois l’environnement créé, développez-le sous Mes environnements pour voir la liste des machines virtuelles et des autres ressources provisionnées par le modèle.

Le déploiement crée un groupe de ressources pour provisionner toutes les ressources d’environnement définies par le modèle ARM. Sélectionnez le nom de l’environnement sous Mes environnements pour voir le groupe de ressources et toutes les ressources créées par le modèle.
Sélectionnez une machine virtuelle d’environnement pour voir les actions disponibles relatives à celle-ci, par exemple la gestion de la configuration, les planifications et les stratégies.

Référentiels de modèles d’environnement

Avec Azure DevTest Labs, vous pouvez créer des environnements à partir de modèles ARM. Les modèles ARM peuvent provenir de deux sources :

Azure 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, pour 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 stocker les modèles d’environnements dans vos propres référentiels Git publics ou privés, et connecter ces dépôts à votre labo pour mettre vos modèles à disposition de tous les utilisateurs de labo.

Conseil

Pour suggérer des révisions ou des ajouts aux modèles publics, soumettez une demande de tirage (pull request) au référentiel de modèles publics GitHub open source.

Configurer les paramètres d’environnement public pour votre labo

Vous pouvez configurer votre labo pour activer l’utilisation de modèles à partir du référentiel de modèles public. Si vous activez le référentiel de modèles public pour un labo, les utilisateurs peuvent créer rapidement un environnement 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.

Activer les environnements publics quand vous créez un labo

Pour activer l’accès au référentiel d’environnement public pour un labo lorsque vous créez un labo :

Sélectionnez l’onglet Paramètres de base lorsque vous créez une ressource DevTest Labs.
Sélectionnez Activé dans le champ Environnements publics.

Activer ou désactiver les environnements publics de 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. Pour activer ou désactiver le dépôt d’environnements publics pour des labos existants :

Dans le portail Azure, sélectionnez votre ressource de labo.
Sélectionnez Configuration et stratégies dans le volet de navigation de gauche.
Sélectionnez Environnements publics sous Bases de machine virtuelle dans le volet de navigation de gauche.
Sélectionnez Oui ou Non pour Activer les environnements publics pour ce labo, afin d’activer ou de désactiver les environnements publics pour le labo.
Sélectionnez Enregistrer.

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

Quand vous activez les environnements publics, tous les modèles d’environnements du dépôt sont disponibles pour la création d’environnements. Pour autoriser uniquement des environnements spécifiques pour un labo :

Dans le portail Azure, sélectionnez votre ressource de labo.
Sélectionnez Configuration et stratégies dans le volet de navigation de gauche.
Sélectionnez Environnements publics sous Bases de machine virtuelle dans le volet de navigation de gauche.
Désélectionnez des environnements spécifiques dans la liste pour les rendre indisponibles pour les utilisateurs du labo, puis sélectionnez Enregistrer.

Configurer les droits de l’utilisateur de l’environnement

Par défaut, les utilisateurs de labo ont le rôle Lecteur dans les environnements. Ils ne peuvent donc pas changer les ressources d’environnement. Par exemple, les utilisateurs ne peuvent pas arrêter ou démarrer les ressources. Pour attribuer le rôle Contributeur aux utilisateurs de labo afin qu’ils puissent modifier les ressources d’environnement :

Dans le portail Azure, sélectionnez votre ressource de labo.
Sélectionnez Configuration et stratégies dans le volet de navigation de gauche.
Sélectionnez Paramètres de labo dans le volet gauche de navigation.
Sous Accès de l’environnement>Droits utilisateur du groupe de ressources, sélectionnez Contributeur, puis Enregistrer.

Automatiser la création d’environnements

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.

Vous pouvez utiliser la commande Azure CLI az deployment group create pour créer des environnements. Pour plus d’informations, consultez Déployer des ressources à l’aide de modèles Resource Manager et d’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.

Notes

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

Pour automatiser le déploiement de modèles d’environnements ARM avec Azure PowerShell :

Archivez un modèle d’environnement ARM dans un dépôt Git, puis ajoutez le dépôt au labo.

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 Git repository)
[string] [Parameter(Mandatory=$true)] $TemplateName,

# Name of the environment to create in the lab
[string] [Parameter(Mandatory=$true)] $EnvironmentName,

# The parameters to be passed 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 will be "-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 that has the 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 the 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 the 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."

Exécutez le script à l’aide de vos propres valeurs afin de remplacer les exemples de valeurs pour :

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

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