Creare ambienti Azure DevTest Labs da modelli di Resource Manager

Articolo
09/30/2023

Questo articolo illustra come creare ambienti Azure DevTest Labs da modelli di Azure Resource Manager (ARM). È possibile usare gli ambienti DevTest Labs per eseguire facilmente e in modo coerente il provisioning dei lab con più macchine virtuali (VM) o risorse PaaS (Platform-as-a-Service). Ad esempio, per creare un lab per un'applicazione Web multilivello o una farm di SharePoint.

Le risorse in un ambiente condividono lo stesso ciclo di vita ed è possibile gestirle insieme. È possibile tenere traccia del costo degli ambienti lab e delle risorse PaaS, così come si tengono traccia dei costi per le singole macchine virtuali del lab.

È possibile configurare Azure DevTest Labs per usare i modelli di Resource Manager da un repository Git pubblico o privato. Altre informazioni sui repository di modelli per i lab.

Per usare un modello di Resource Manager per creare una risorsa Azure DevTest Labs, vedere Avvio rapido: Usare un modello di Resource Manager per creare un lab in DevTest Labs.

Limitazioni

Prendere in considerazione queste limitazioni quando si creano lab da modelli di Resource Manager in DevTest Labs:

L'arresto automatico della macchina virtuale non si applica alle risorse PaaS.
Non tutti i criteri lab vengono valutati quando si distribuiscono modelli di Resource Manager. I criteri non valutati includono: numero di macchine virtuali per utente lab, numero di macchine virtuali Premium per utente e numero di scrivanie Premium per utente. Ad esempio, i criteri lab potrebbero limitare gli utenti a soli cinque macchine virtuali. Tuttavia, un utente può distribuire un modello di ambiente ARM che crea decine di macchine virtuali.

Creare ambienti da modelli

È possibile creare un ambiente dal repository Azure DevTest Labs modello pubblico oppure aggiungere un repository di modelli privato al lab.

Informazioni su come configurare gli ambienti per il lab. Ad esempio, come configurare i repository dei modelli, abilitare o disabilitare gli ambienti pubblici e selezionare modelli specifici per la creazione di lab.

Per creare un ambiente da un modello:

Nella portale di Azure selezionare la risorsa lab.
Nella pagina Panoramica del lab selezionare Aggiungi nella barra degli strumenti superiore.
Nella pagina Scegliere una base selezionare il modello di ambiente ARM da usare. I modelli di ambiente disponibili vengono visualizzati per primi nell'elenco delle basi.
Nella schermata Aggiungi immettere un nome Ambiente e compilare gli altri campi di input.

Il numero e il tipo di campi di input sono definiti nel modello di Resource Manager. Se necessario, immettere i valori per i campi di input definiti dal file azuredeploy.parameters.json come predefinito o vuoto.
- Per secure string i parametri, è possibile usare i segreti di Azure Key Vault. Per informazioni su come archiviare i segreti in un insieme di credenziali delle chiavi e usarli durante la creazione di risorse lab, vedere Archiviare i segreti in Azure Key Vault.
- Nei file modello di Resource Manager i valori dei GEN-UNIQUEparametri , GEN-UNIQUE-[N], GEN-SSH-PUB-KEYe GEN-PASSWORD generano campi di input vuoti per gli utenti ai valori di input.
Selezionare Aggiungi per creare l'ambiente.

L'ambiente avvia immediatamente il provisioning. È possibile visualizzare lo stato del provisioning in Ambienti personali nella pagina Panoramica del lab. Il provisioning di un ambiente può richiedere molto tempo.
Al termine della creazione dell'ambiente, espandere l'ambiente in Ambienti personali per visualizzare l'elenco di macchine virtuali e altre risorse di cui è stato effettuato il provisioning.

La distribuzione crea un nuovo gruppo di risorse per effettuare il provisioning di tutte le risorse di ambiente definite dal modello di Resource Manager. Selezionare il nome dell'ambiente in Ambienti personali per visualizzare il gruppo di risorse e tutte le risorse create dal modello.
Selezionare una macchina virtuale dell'ambiente per visualizzare le azioni disponibili per la macchina virtuale, ad esempio la gestione della configurazione, delle pianificazioni e dei criteri.

Repository di modelli di ambiente

Con Azure DevTest Labs è possibile creare ambienti da modelli di Resource Manager. I modelli di Resource Manager possono provenire da due origini:

Azure DevTest Labs dispone di un repository di modelli di Resource Manager pubblico che include modelli di ambiente predefiniti per Azure App Web, un cluster di Azure Service Fabric e farm di SharePoint di sviluppo. I modelli hanno parametri di input minimi, per un'esperienza introduttiva uniforme con le risorse PaaS. È possibile usare i modelli di ambiente pubblico così come sono o personalizzarli in base alle proprie esigenze.
È possibile archiviare i modelli di ambiente nei repository Git pubblici o privati e connettere tali repository al lab per rendere disponibili i modelli a tutti gli utenti del lab.

Suggerimento

Per suggerire revisioni o aggiunte ai modelli pubblici, inviare una richiesta pull al repository di modelli pubblici di GitHub open source.

Configurare le impostazioni dell'ambiente pubblico per il lab

È possibile configurare il lab per abilitare l'uso dei modelli dal repository di modelli pubblici. Se si abilita il repository di modelli pubblici per un lab, gli utenti possono quindi creare rapidamente un ambiente selezionando questi modelli direttamente nel portale di Azure, in modo analogo a come creano una macchina virtuale in un lab.

È anche possibile selezionare i modelli da cui gli utenti possono creare ambienti.

Abilitare gli ambienti pubblici quando si crea un lab

Per abilitare l'accesso al repository dell'ambiente pubblico per un lab quando si crea un lab:

Selezionare la scheda Impostazioni di base quando si crea una risorsa DevTest Labs.
Selezionare Sì nel campo Ambienti pubblici .

Abilitare o disabilitare gli ambienti pubblici per i lab esistenti

Per i lab esistenti o i lab creati con un modello di Resource Manager, è possibile che gli ambienti pubblici non siano abilitati. Per abilitare o disabilitare il repository dell'ambiente pubblico per i lab esistenti:

Nella portale di Azure selezionare la risorsa lab.
Selezionare Configurazione e criteri nel riquadro di spostamento a sinistra.
Selezionare Ambienti pubblici in Basi macchina virtuale nel riquadro di spostamento a sinistra.
Selezionare Sì o No per Abilita ambienti pubblici per questo lab per abilitare o disabilitare gli ambienti pubblici per il lab.
Selezionare Salva.

Selezionare i modelli di ambiente pubblico disponibili

Quando si abilitano gli ambienti pubblici, tutti i modelli di ambiente nel repository sono disponibili per la creazione di ambienti. Per consentire solo ambienti specifici per un lab:

Nella portale di Azure selezionare la risorsa lab.
Selezionare Configurazione e criteri nel riquadro di spostamento a sinistra.
Selezionare Ambienti pubblici in Basi macchina virtuale nel riquadro di spostamento a sinistra.
Deselezionare ambienti specifici dall'elenco per renderli non disponibili per gli utenti del lab e quindi selezionare Salva.

Configurare i diritti utente dell'ambiente

Per impostazione predefinita, gli utenti del lab hanno il ruolo Lettore negli ambienti e non possono modificare le risorse dell'ambiente. Ad esempio, gli utenti non possono arrestare o avviare le risorse. Per assegnare agli utenti del lab il ruolo Collaboratore per consentire loro di modificare le risorse dell'ambiente:

Nella portale di Azure selezionare la risorsa lab.
Selezionare Configurazione e criteri nel riquadro di spostamento a sinistra.
Selezionare Impostazioni lab nel riquadro di spostamento a sinistra.
In Dirittiutente del gruppo di risorsedi accesso all'ambiente> selezionare Collaboratore e quindi Selezionare Salva.

Automatizzare la creazione dell'ambiente

Se è necessario creare più ambienti per scenari di sviluppo o test, è possibile automatizzare la distribuzione dell'ambiente con Azure PowerShell o l'interfaccia della riga di comando di Azure.

È possibile usare il comando dell'interfaccia della riga di comando di Azure az deployment group create per creare ambienti. Per altre informazioni, vedere Distribuire le risorse con i modelli di Azure Resource Manager e l'interfaccia della riga di comando di Azure.

I proprietari e gli amministratori dei lab possono usare Azure PowerShell per creare macchine virtuali e ambienti da modelli di Resource Manager.

Nota

È consigliabile usare il modulo Azure Az PowerShell per interagire con Azure. Per iniziare, vedere Installare Azure PowerShell. Per informazioni su come eseguire la migrazione al modulo AZ PowerShell, vedere Eseguire la migrazione di Azure PowerShell da AzureRM ad Az.

Per automatizzare la distribuzione dei modelli di ambiente ARM con Azure PowerShell:

Disporre di un modello di ambiente ARM archiviato in un repository Git e il repository aggiunto al lab.

Salvare lo script di PowerShell seguente nel computer come deployenv.ps1. Questo script chiama il modello di Resource Manager per creare l'ambiente nel lab.

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

Eseguire lo script usando i propri valori per sostituire i valori di esempio per:

SubscriptionId
LabName
ResourceGroupName
RepositoryName
TemplateName (cartella modello nel repository Git)
EnvironmentName

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