Skapa miljöer från ARM-mallar

Använd Azure DevTest Labs-miljöer för att enkelt och konsekvent tillhandahålla labb med flera virtuella maskiner (VM) och plattform som en tjänst (PaaS)-resurser. Den här artikeln beskriver hur du skapar DevTest Labs-miljöer från ARM-mallar (Azure Resource Manager ). Använd detta tillvägagångssätt för att skapa ett laboratorium för en flerskiktig webbapplikation, såsom en webbapp med en SQL-databasbackend.

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

Du kan konfigurera ett labb för att använda ARM-miljömallar från offentliga eller privata Git-malllagringsplatser. Följande diagram visar hur DevTest Labs använder en ARM-mall från en offentlig eller privat lagringsplats för att distribuera en miljö som innehåller virtuella datorer och andra resurser.

Diagram som visar hur du hämtar ARM-mallar från Git-lagringsplatser och använder dem för att distribuera miljöer med PaaS-resurser.

Förutsättningar

  • För att lägga till eller konfigurera malllagringsplatser för ett labb behöver du minst ha deltagarbehörigheter i labbet.
  • För att skapa DevTest Labs-miljöer från tillgängliga ARM-mallar, åtminstone DevTest User-behörigheter i labbet.
  • För att köra PowerShell-skriptet i Automatisera skapandet av miljön krävs Azure PowerShell med Az.Resources-modulen installerad.

Tilldela prenumerationsbehörigheter för mallutplacering

Om din organisation kräver prenumerationsbehörigheter för delegerad mallhantering, tilldela Azure Lab Services Contributor-rollen vid prenumerationsomfattningen.

Important

För att skapa miljöer i DevTest Labs behöver labbanvändare fortfarande minst DevTest User-behörigheter på labbet. Azure Lab Services Contributor-rollen ersätter inte DevTest Labs lab-nivåbehörigheter.

  1. Öppna din prenumeration i Azure-portalen.
  2. Välj Åtkomstkontroll (IAM)>Lägg till>Lägg till rolltilldelning.
  3. Sök efter och välj Azure Lab Services Contributor.
  4. Välj Nästa, välj användaren, gruppen eller tjänstehuvudpersonen, och välj sedan Granska + tilldela.

För åtkomst med minsta privilegium, använd en anpassad roll som endast inkluderar de behörigheter som krävs av din mall och labb-arbetsflöde istället för breda prenumerationsrättigheter.

Följande exempel på en anpassad roll begränsar tillgången till DevTest Labs miljöskapande och implementeringssynlighet. Lägg bara till de åtgärder som din mall kräver.

{
    "Name": "DevTest Labs Environment Template Deployer",
    "Description": "Create and read DevTest Labs environments from approved ARM templates.",
    "Actions": [
        "Microsoft.Authorization/*/read",
        "Microsoft.DevTestLab/labs/read",
        "Microsoft.DevTestLab/labs/EnsureCurrentUserProfile/action",
        "Microsoft.DevTestLab/labs/CreateEnvironment/action",
        "Microsoft.DevTestLab/labs/artifactSources/armTemplates/read",
        "Microsoft.DevTestLab/labs/policySets/EvaluatePolicies/action",
        "Microsoft.DevTestLab/labs/users/environments/read",
        "Microsoft.DevTestLab/labs/users/environments/write",
        "Microsoft.Resources/deployments/read",
        "Microsoft.Resources/deployments/operations/read",
        "Microsoft.Resources/subscriptions/resourceGroups/read"
    ],
    "NotActions": [],
    "DataActions": [],
    "NotDataActions": [],
    "AssignableScopes": [
        "/subscriptions/<subscription-id>"
    ]
}

Begränsningar

Miljöer som skapats från ARM-miljömallar i DevTest Labs har följande begränsningar:

  • Funktionen autoshutdown för virtuella datorer stöds inte.

  • Följande labbprinciper tillämpas inte eller utvärderas inte:

    • Antal virtuella datorer per labbanvändare
    • Antal premium-VM:ar per användare
    • Antal premiumdiskar per användare

    Även om labbprincipen till exempel bara tillåter varje användare att skapa högst fem virtuella datorer kan användaren distribuera en ARM-miljömall som skapar dussintals virtuella datorer.

Konfigurera malllagringsplatser för labb

Du kan konfigurera ditt labb att använda ARM-miljömallar från den offentliga ARM-malllagringsplatsen DevTest Labs och från andra offentliga eller privata Git-lagringsplatser. När du aktiverar labbåtkomst till ett mallarkiv kan labbanvändare snabbt skapa miljöer genom att välja mallar i Azure-portalen.

DevTest Labs publika ARM-mallarkiv inkluderar förförfattade miljömallar såsom Web App with SQL Database och Azure Service Fabric-klusterexempel. För en smidig komma igång-upplevelse med PaaS-resurser har mallarna minimala indataparametrar.

Du kan använda mallarna för den offentliga miljön som de är eller anpassa dem efter dina behov. Du kan också föreslå revisioner eller tillägg till en offentlig mall genom att skicka en pull-begäran mot den offentliga GitHub-malllagringsplatsen.

Du kan också lagra miljömallar i andra offentliga eller privata Git-lagringsplatser och lägga till dessa lagringsplatser i labbet för att göra mallarna tillgängliga för alla labbanvändare. Anvisningar finns i Lagra ARM-mallar i Git-lagringsplatser och Lägg till malllagringsplatser i labb.

Konfigurera inställningar för offentlig miljö

Du kan aktivera labbåtkomst till den offentliga Malllagringsplatsen för DevTest Labs för ett nytt eller befintligt labb. När du aktiverar åtkomst till lagringsplatsen kan du välja vilka miljömallar som ska vara tillgängliga för labbanvändare.

Konfigurera åtkomst till offentlig miljö för ett nytt labb

Om du vill konfigurera åtkomst till lagringsplatsen för offentliga miljöer när du skapar ett nytt labb anger du alternativet Offentliga miljöer till På eller Av på fliken Grundläggande inställningar. Det här alternativet är inställt på På som standard.

Skärmbild som visar hur du aktiverar lagringsplatser för offentliga miljöer för ett labb under labbskapandeprocessen.

Konfigurera offentlig miljöåtkomst för ett befintligt labb

Så här aktiverar eller inaktiverar du åtkomst till offentliga miljöer för ett befintligt labb:

  1. På sidan Översikt i Azure-portalen för ditt labb väljer du Konfiguration och principer under Inställningar i den vänstra navigeringsmenyn.

  2. På sidan Konfiguration och principer expanderar du Baser för virtuella datorer i den vänstra menyn och väljer Offentliga miljöer.

  3. På sidan Offentliga miljöer anger du alternativet Aktivera offentliga miljöer för den här labbuppgiften till Ja eller Nej.

    Skärmbild som visar hur du aktiverar alla offentliga miljölagringsplatser för en befintlig labbresurs.

  4. Välj Spara.

Välj tillgängliga offentliga miljömallar

När du aktiverar lagringsplatsen för den offentliga miljön för ett labb är alla miljömallar på lagringsplatsen tillgängliga för dina labbanvändare som standard. Du kan välja att inaktivera åtkomst till valda mallar. De inaktiverade mallarna visas inte längre i listan över miljöer som användare kan skapa.

Så här tillåter du inte åtkomst till specifika miljömallar:

  1. Avmarkera kryssrutorna bredvid de miljöer som du vill inaktivera på sidan Konfiguration och policies>Bas för virtuella datorer>Offentliga miljöer i ditt labbs Azure-portal.

  2. Välj Spara.

Skärmbild som visar hur du avmarkerar offentliga miljölagringsplatser för ett labb för att inaktivera åtkomst för användare.

Konfigurera användarbehörigheter för miljön

Som standard tilldelas labbanvändare läsarrollen i miljöer de skapar. Läsare kan inte stoppa, starta eller ändra miljöresurser som SQL-servrar eller databaser. För att låta labbanvändare redigera resurser i sina miljöer, ge dem rollen som bidragsgivare i resursgruppen för deras miljö.

  1. På sidan Översikt i Azure-portalen för ditt labb väljer du Konfiguration och principer under Inställningar i den vänstra navigeringsmenyn.

  2. På sidan Konfiguration och principer expanderar du Inställningar på den vänstra menyn och väljer Labbinställningar.

  3. På sidan Labbinställningar under Miljöåtkomst anger du alternativet Resursgruppsanvändares rättigheter till Deltagare.

  4. Välj Spara.

Skärmbild som visar hur du anger behörigheter för rollen Deltagare för labbanvändare i DevTest Labs.

Skapa miljöer från mallar

Om du konfigurerar ditt labb att använda publika eller privata mallarkiv kan du skapa en miljö genom att välja en tillgänglig ARM-mall. Följ de här stegen för att skapa en miljö från en mall.

  1. På sidan Översikt i Azure-portalen för ditt labb väljer du Mina miljöer under Mitt labb i den vänstra navigeringsmenyn.

  2. På sidan Mina miljöer väljer du Lägg till.

  3. På sidan Välj en bas , välj Webbapp med SQL-databas.

    Skärmdump som visar webbapp med SQL-databas vald från tillgängliga miljömallar i Azure DevTest Labs.

  4. I panelen Lägg till , ange ett miljönamn och konfigurera de andra parameterinställningarna för webbappen och SQL-databasresurserna.

    Skärmdump som visar att man väljer webbapp med SQL-databas och anger miljöinställningar i Azure DevTest Labs.

    • Varje ARM-miljömall innehåller unika parametrar. När du lägger till en miljö måste du ange värden för alla obligatoriska parametrar, som anges med röda asterisker.
    • Vissa parametervärden i en azuredeploy.parameters.json ARM-mallfil skapar tomma inställningsfält utan standardvärde i fönstret Lägg till . Dessa värden inkluderar GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEYoch GEN-PASSWORD.
    • Du kan använda hemligheter från Azure Key Vault för säkra strängparametrar som lösenord. Mer information finns i Lagra hemligheter i Azure Key Vault.

  5. Välj Lägg till. Etableringen av miljön påbörjas omedelbart.

Det kan ta lång tid att etablera en miljö. Den totala tiden beror på antalet tjänstinstanser, virtuella datorer och andra resurser som DevTest Labs skapar som en del av labbmiljön.

Du kan övervaka tilldelningsstatusen på sidan Mina miljöer. Välj Uppdatera i verktygsfältet för att uppdatera sidvyn och kontrollera aktuell status. Medan etablering pågår är miljöstatusen Skapa. När provisioneringen har slutförts ändras statusen till Ready.

Skärmbild som visar hur du ser etableringsstatus för labbmiljön.

Distribueringen skapar en ny resursgrupp för att tillhandahålla alla miljöresurserna som ARM-mallen definierat. Välj miljön i listan Mina miljöer för att visa resursgruppen och alla resurser som mallen skapade.

Välj en resurs i listan för att se egenskaper och tillgängliga åtgärder.

Automatisera skapandet av miljöer

Om du behöver skapa flera miljöer för utvecklings- eller testscenarier kan du använda Azure PowerShell eller Azure CLI för att automatisera miljödistributionen från ARM-mallar. Följande steg visar hur du automatiserar distributionen av ARM-miljömallar med hjälp av Azure PowerShell-kommandot New-AzResource .

Du kan också automatisera distributionen med hjälp av kommandot Azure CLI az deployment group create . Mer information finns i Distribuera resurser med ARM-mallar och Azure CLI.

  1. Lagra ARM-miljömallen på en Git-lagringsplats och lägg till lagringsplatsen i labbet.

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

  3. Kör följande kommando för att använda skriptet. Uppdatera platshållarna i kommandot med dina egna labbvärden.

    .\DeployLabEnvironment.ps1 `
    -SubscriptionId "<Subscription ID>" `
    -LabName "<LabName>" `
    -ResourceGroupName "<LabResourceGroupName>" `
    -RepositoryName "<TemplateRepoName>" `
    -TemplateName "<TemplateFolderName>" `
    -EnvironmentName "<EnvironmentName>"

Relaterat innehåll

  • Last updated on