Skapa Azure DevTest Labs miljöer från ARM-mallar

Artikel
09/30/2023

I den här artikeln får du lära dig hur du skapar Azure DevTest Labs miljöer från ARM-mallar (Azure Resource Manager). Du kan använda DevTest Labs-miljöer för att enkelt och konsekvent etablera labb med flera virtuella datorer (VM) eller PaaS-resurser (plattform som en tjänst). Om du till exempel vill skapa ett labb för ett webbprogram med flera nivåer eller en SharePoint-servergrupp.

Resurser i en miljö delar samma livscykel och du kan hantera dem tillsammans. Du kan spåra kostnaden för labbmiljöer och PaaS-resurser, precis som du spårar kostnader för enskilda virtuella labbdatorer.

Du kan konfigurera Azure DevTest Labs att använda ARM-mallar från en offentlig eller privat Git-lagringsplats. Läs mer om malllagringsplatser för labb.

Om du vill använda en ARM-mall för att skapa en Azure DevTest Labs resurs kan du läsa Snabbstart: Använda en ARM-mall för att skapa ett labb i DevTest Labs.

Begränsningar

Tänk på dessa begränsningar när du skapar labb från ARM-mallar i DevTest Labs:

Automatisk avstängning av virtuell dator gäller inte för PaaS-resurser.
Alla labbprinciper utvärderas inte när du distribuerar ARM-mallar. Principer som inte utvärderas är: antal virtuella datorer per labbanvändare, antal virtuella premiumdatorer per användare och antal premiumdiskar per användare. Din labbprincip kan till exempel begränsa användarna till endast fem virtuella datorer vardera. En användare kan dock distribuera en ARM-miljömall som skapar dussintals virtuella datorer.

Skapa miljöer från mallar

Du kan skapa en miljö från Azure DevTest Labs offentliga malllagringsplatsen eller lägga till en privat malllagringsplats i labbet.

Lär dig hur du konfigurerar miljöer för ditt labb. Till exempel hur du konfigurerar malllagringsplatser, aktiverar eller inaktiverar offentliga miljöer och väljer specifika mallar för att skapa labb.

Så här skapar du en miljö från en mall:

I Azure Portal väljer du din labbresurs.
På sidan Översikt för labbet väljer du Lägg till i det översta verktygsfältet.
På sidan Välj en bas väljer du den ARM-miljömall som ska användas. De tillgängliga miljömallarna visas först i listan över baser.
På skärmen Lägg till anger du ett miljönamn och fyller i de andra indatafälten.

Antal och typ av indatafält definieras i ARM-mallen. Ange vid behov värden för indatafält som mallen azuredeploy.parameters.json-filen definierar som tom eller standard.
- För secure string parametrar kan du använda hemligheter från Azure Key Vault. Information om hur du lagrar hemligheter i ett nyckelvalv och använder dem när du skapar labbresurser finns i Lagra hemligheter i Azure Key Vault.
- I ARM-mallfiler genererar parametervärdena GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEYoch GEN-PASSWORD tomma indatafält så att användarna kan ange värden.
Välj Lägg till för att skapa miljön.

Miljön börjar etableras omedelbart. Du kan se etableringsstatusen under Mina miljöer på labbsidan Översikt . Det kan ta lång tid att etablera en miljö.
När miljön har skapats expanderar du miljön under Mina miljöer för att se listan över virtuella datorer och andra resurser som mallen har etablerat.

Distributionen skapar en ny resursgrupp för att etablera alla miljöresurser som ARM-mallen har definierat. Välj miljönamnet under Mina miljöer för att visa resursgruppen och alla resurser som mallen skapade.
Välj en virtuell miljödator för att se tillgängliga åtgärder för den virtuella datorn, till exempel hantering av konfiguration, scheman och principer.

Lagringsplatser för miljömallar

Med Azure DevTest Labs kan du skapa miljöer från ARM-mallar. ARM-mallarna kan komma från två källor:

Azure DevTest Labs har en offentlig ARM-malllagringsplats som innehåller förskapade miljömallar för Azure Web Apps, ett Azure Service Fabric-kluster och SharePoint-servergrupper för utveckling. Mallarna har minimala indataparametrar för att få en smidig komma igång-upplevelse med PaaS-resurser. Du kan använda de offentliga miljömallarna i sin egen takt eller anpassa dem efter dina behov.
Du kan lagra miljömallar på dina egna offentliga eller privata Git-lagringsplatser och ansluta dessa lagringsplatser till ditt labb för att göra mallarna tillgängliga för alla labbanvändare.

Tips

Om du vill föreslå revisioner eller tillägg till de offentliga mallarna skickar du en pull-begäran mot den offentliga GitHub-malllagringsplatsen med öppen källkod.

Konfigurera offentliga miljöinställningar för ditt labb

Du kan konfigurera ditt labb för att aktivera användning av mallar från den offentliga malllagringsplatsen. Om du aktiverar den offentliga malllagringsplatsen för ett labb kan användarna snabbt skapa en miljö genom att välja dessa mallar direkt i Azure Portal, ungefär som när de skapar en virtuell dator i ett labb.

Dessutom kan du välja vilka mallar som ska vara tillgängliga för användare att skapa miljöer från.

Aktivera offentliga miljöer när du skapar ett labb

Så här aktiverar du åtkomst till lagringsplatsen för offentliga miljöer för ett labb när du skapar ett labb:

Välj fliken Grundläggande inställningar när du skapar en DevTest Labs-resurs.
Välj På i fältet Offentliga miljöer .

Aktivera eller inaktivera offentliga miljöer för befintliga labb

För befintliga labb eller labb som du skapar med en ARM-mall kanske offentliga miljöer inte är aktiverade. Så här aktiverar eller inaktiverar du lagringsplatsen för den offentliga miljön för befintliga labb:

I Azure Portal väljer du din labbresurs.
Välj Konfiguration och principer i det vänstra navigeringsfönstret.
Välj Offentliga miljöer under Baser för virtuella datorer i det vänstra navigeringsfönstret.
Välj Ja eller Nej för Aktivera offentliga miljöer för den här labbuppgiften för att aktivera eller inaktivera offentliga miljöer för labbet.
Välj Spara.

Välj tillgängliga offentliga miljömallar

När du aktiverar offentliga miljöer är alla miljömallar på lagringsplatsen tillgängliga för att skapa miljöer. Så här tillåter du endast specifika miljöer för ett labb:

I Azure Portal väljer du din labbresurs.
Välj Konfiguration och principer i det vänstra navigeringsfönstret.
Välj Offentliga miljöer under Baser för virtuella datorer i det vänstra navigeringsfönstret.
Avmarkera specifika miljöer i listan för att göra dem otillgängliga för labbanvändare och välj sedan Spara.

Konfigurera användarrättigheter för miljön

Som standard har labbanvändare rollen Läsare i miljöer och kan inte ändra miljöresurser. Användare kan till exempel inte stoppa eller starta resurser. Så här ger du labbanvändare rollen Deltagare så att de kan redigera miljöresurser:

I Azure Portal väljer du din labbresurs.
Välj Konfiguration och principer i det vänstra navigeringsfönstret.
Välj Labbinställningar i det vänstra navigeringsfönstret.
Under Miljöåtkomst>Användarrättigheter för resursgrupp väljer du Deltagare och sedan Spara.

Automatisera skapandet av miljön

Om du behöver skapa flera miljöer för utvecklings- eller testningsscenarier kan du automatisera miljödistributionen med Azure PowerShell eller Azure CLI.

Du kan använda Azure CLI-kommandot az deployment group create för att skapa miljöer. Mer information finns i Distribuera resurser med Resource Manager mallar och Azure CLI.

Labbägare och administratörer kan använda Azure PowerShell för att skapa virtuella datorer och miljöer från ARM-mallar.

Anteckning

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Se Installera Azure PowerShell för att komma igång. Information om hur du migrerar till Az PowerShell-modulen finns i artikeln om att migrera Azure PowerShell från AzureRM till Az.

Så här automatiserar du distributionen av ARM-miljömallar med Azure PowerShell:

Låt en ARM-miljömall checkas in på en Git-lagringsplats och lagringsplatsen läggs till i labbet.

Spara följande PowerShell-skript på datorn som deployenv.ps1. Det här skriptet anropar ARM-mallen för att skapa miljön i labbet.

#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."

Kör skriptet med dina egna värden för att ersätta exempelvärdena för:

SubscriptionId
LabName
ResourceGroupName
RepositoryName
TemplateName (mallmapp på Git-lagringsplatsen)
EnvironmentName

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