Tworzenie środowisk Azure DevTest Labs na podstawie szablonów usługi ARM

Artykuł
09/30/2023

Z tego artykułu dowiesz się, jak tworzyć środowiska Azure DevTest Labs na podstawie szablonów usługi Azure Resource Manager (ARM). Za pomocą środowisk DevTest Labs można łatwo i spójnie aprowizować laboratoria z wieloma maszynami wirtualnymi lub zasobami Typu platforma jako usługa (PaaS). Aby na przykład utworzyć laboratorium dla wielowarstwowej aplikacji internetowej lub farmy programu SharePoint.

Zasoby w środowisku współużytkują ten sam cykl życia i można nimi zarządzać razem. Możesz śledzić koszty środowisk laboratoryjnych i zasobów PaaS, podobnie jak w przypadku śledzenia kosztów poszczególnych maszyn wirtualnych laboratorium.

Można skonfigurować Azure DevTest Labs do używania szablonów usługi ARM z publicznego lub prywatnego repozytorium Git. Dowiedz się więcej o repozytoriach szablonów dla laboratoriów.

Jeśli chcesz użyć szablonu usługi ARM do utworzenia zasobu Azure DevTest Labs, zobacz Szybki start: tworzenie laboratorium w usłudze DevTest Labs przy użyciu szablonu usługi ARM.

Ograniczenia

Podczas tworzenia laboratoriów na podstawie szablonów usługi ARM w usłudze DevTest Labs należy wziąć pod uwagę następujące ograniczenia:

Automatyczne zamykanie maszyny wirtualnej nie ma zastosowania do zasobów PaaS.
Nie wszystkie zasady laboratorium są oceniane podczas wdrażania szablonów usługi ARM. Zasady, które nie są oceniane, obejmują: liczbę maszyn wirtualnych na użytkownika laboratorium, liczbę maszyn wirtualnych w warstwie Premium na użytkownika i liczbę biurków w warstwie Premium na użytkownika. Na przykład zasady laboratorium mogą ograniczać użytkowników tylko do pięciu maszyn wirtualnych za sztukę. Użytkownik może jednak wdrożyć szablon środowiska ARM, który tworzy dziesiątki maszyn wirtualnych.

Tworzenie środowisk na podstawie szablonów

Możesz utworzyć środowisko z repozytorium szablonów publicznych Azure DevTest Labs lub dodać prywatne repozytorium szablonów do laboratorium.

Dowiedz się, jak skonfigurować środowiska na potrzeby laboratorium. Na przykład sposób konfigurowania repozytoriów szablonów, włączania lub wyłączania środowisk publicznych oraz wybierania określonych szablonów do tworzenia laboratoriów.

Aby utworzyć środowisko na podstawie szablonu:

W Azure Portal wybierz zasób laboratorium.
Na stronie Przegląd laboratorium wybierz pozycję Dodaj na górnym pasku narzędzi.
Na stronie Wybieranie podstawy wybierz szablon środowiska usługi ARM do użycia. Dostępne szablony środowiska są wyświetlane jako pierwsze na liście baz.
Na ekranie Dodawanie wprowadź nazwę środowiska i wypełnij inne pola wejściowe.

Liczba i typ pól wejściowych są definiowane w szablonie usługi ARM. W razie potrzeby wprowadź wartości pól wejściowych, które plik azuredeploy.parameters.json szablonu definiuje jako puste lub domyślne.
- W przypadku secure string parametrów można użyć wpisów tajnych z usługi Azure Key Vault. Aby dowiedzieć się, jak przechowywać wpisy tajne w magazynie kluczy i używać ich podczas tworzenia zasobów laboratoryjnych, zobacz Przechowywanie wpisów tajnych w usłudze Azure Key Vault.
- W plikach szablonów usługi ARM wartości parametrów GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEYi GEN-PASSWORD generują puste pola wejściowe dla użytkowników do wartości wejściowych.
Wybierz pozycję Dodaj , aby utworzyć środowisko.

Środowisko rozpoczyna aprowizację natychmiast. Stan aprowizacji można wyświetlić w obszarze Moje środowiska na stronie Przegląd laboratorium. Aprowizowanie środowiska może zająć dużo czasu.
Po zakończeniu tworzenia środowiska rozwiń środowisko w obszarze Moje środowiska, aby wyświetlić listę maszyn wirtualnych i innych zasobów aprowizowania szablonu.

Wdrożenie tworzy nową grupę zasobów, aby aprowizować wszystkie zasoby środowiska zdefiniowane przez szablon usługi ARM. Wybierz nazwę środowiska w obszarze Moje środowiska , aby wyświetlić grupę zasobów i wszystkie zasoby utworzone przez szablon.
Wybierz maszynę wirtualną środowiska, aby wyświetlić dostępne akcje dla maszyny wirtualnej, takie jak zarządzanie konfiguracją, harmonogramami i zasadami.

Repozytoria szablonów środowiska

Za pomocą Azure DevTest Labs można tworzyć środowiska na podstawie szablonów usługi ARM. Szablony usługi ARM mogą pochodzić z dwóch źródeł:

Azure DevTest Labs ma publiczne repozytorium szablonów usługi ARM, które zawiera wstępnie utworzone szablony środowiska dla usługi Azure Web Apps, klastra usługi Azure Service Fabric i farmy programistyczne programu SharePoint. Szablony mają minimalne parametry wejściowe, aby bezproblemowo rozpocząć pracę z zasobami PaaS. Możesz użyć szablonów środowiska publicznego zgodnie z potrzebami lub dostosować je do własnych potrzeb.
Szablony środowiska można przechowywać we własnych publicznych lub prywatnych repozytoriach Git i połączyć te repozytoria z laboratorium , aby udostępnić szablony wszystkim użytkownikom laboratorium.

Porada

Aby zasugerować poprawki lub dodatki do szablonów publicznych, prześlij żądanie ściągnięcia do publicznego repozytorium szablonów github typu open source.

Konfigurowanie ustawień środowiska publicznego dla laboratorium

Możesz skonfigurować laboratorium, aby umożliwić korzystanie z szablonów z repozytorium szablonów publicznych. Jeśli włączysz repozytorium szablonów publicznych dla laboratorium, użytkownicy będą mogli szybko utworzyć środowisko, wybierając te szablony bezpośrednio w Azure Portal, podobnie jak w przypadku tworzenia maszyny wirtualnej w laboratorium.

Ponadto można wybrać szablony dostępne dla użytkowników w celu utworzenia środowisk.

Włączanie środowisk publicznych podczas tworzenia laboratorium

Aby włączyć dostęp do repozytorium środowiska publicznego dla laboratorium podczas tworzenia laboratorium:

Wybierz kartę Ustawienia podstawowe podczas tworzenia zasobu usługi DevTest Labs.
Wybierz pozycję Włączone w polu Środowiska publiczne .

Włączanie lub wyłączanie środowisk publicznych dla istniejących laboratoriów

W przypadku istniejących laboratoriów lub laboratoriów utworzonych za pomocą szablonu usługi ARM środowiska publiczne mogą nie być włączone. Aby włączyć lub wyłączyć repozytorium środowiska publicznego dla istniejących laboratoriów:

W Azure Portal wybierz zasób laboratorium.
Wybierz pozycję Konfiguracja i zasady w obszarze nawigacji po lewej stronie.
Wybierz pozycję Środowiska publiczne w obszarze Podstawy maszyn wirtualnych w obszarze nawigacji po lewej stronie.
Wybierz opcję Tak lub Nie dla opcji Włącz środowiska publiczne dla tego laboratorium, aby włączyć lub wyłączyć środowiska publiczne dla laboratorium.
Wybierz pozycję Zapisz.

Wybieranie dostępnych szablonów środowisk publicznych

Po włączeniu środowisk publicznych wszystkie szablony środowiska w repozytorium są dostępne do tworzenia środowisk. Aby zezwolić tylko na określone środowiska dla laboratorium:

W Azure Portal wybierz zasób laboratorium.
Wybierz pozycję Konfiguracja i zasady w obszarze nawigacji po lewej stronie.
Wybierz pozycję Środowiska publiczne w obszarze Podstawy maszyn wirtualnych w obszarze nawigacji po lewej stronie.
Usuń zaznaczenie określonych środowisk z listy, aby uniemożliwić ich użytkownikom laboratorium, a następnie wybierz pozycję Zapisz.

Konfigurowanie praw użytkownika środowiska

Domyślnie użytkownicy laboratorium mają rolę Czytelnik w środowiskach i nie mogą zmieniać zasobów środowiska. Na przykład użytkownicy nie mogą zatrzymywać ani uruchamiać zasobów. Aby nadać użytkownikom laboratorium rolę Współautor , aby umożliwić im edytowanie zasobów środowiska:

W Azure Portal wybierz zasób laboratorium.
Wybierz pozycję Konfiguracja i zasady w obszarze nawigacji po lewej stronie.
Wybierz pozycję Ustawienia laboratorium w obszarze nawigacji po lewej stronie.
W obszarzeUprawnienia użytkownikagrupy zasobów dostępu do> środowiska wybierz pozycję Współautor, a następnie wybierz pozycję Zapisz.

Automatyzowanie tworzenia środowiska

Jeśli musisz utworzyć wiele środowisk na potrzeby scenariuszy programowania lub testowania, możesz zautomatyzować wdrażanie środowiska za pomocą Azure PowerShell lub interfejsu wiersza polecenia platformy Azure.

Do tworzenia środowisk można użyć polecenia interfejsu wiersza polecenia platformy Azure az deployment group create . Aby uzyskać więcej informacji, zobacz Wdrażanie zasobów przy użyciu szablonów Resource Manager i interfejsu wiersza polecenia platformy Azure.

Właściciele laboratoriów i administratorzy mogą używać Azure PowerShell do tworzenia maszyn wirtualnych i środowisk na podstawie szablonów usługi ARM.

Uwaga

Zalecamy korzystanie z modułu Azure Az programu PowerShell do interakcji z platformą Azure. Zobacz Instalowanie programu Azure PowerShell, aby rozpocząć. Aby dowiedzieć się, jak przeprowadzić migrację do modułu Az PowerShell, zobacz Migracja programu Azure PowerShell z modułu AzureRM do modułu Az.

Aby zautomatyzować wdrażanie szablonu środowiska usługi ARM przy użyciu Azure PowerShell:

Zaewidencjonuj szablon środowiska usługi ARM w repozytorium Git i repozytorium dodane do laboratorium.

Zapisz następujący skrypt programu PowerShell na komputerze jakodeployenv.ps1. Ten skrypt wywołuje szablon usługi ARM w celu utworzenia środowiska w laboratorium.

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

Uruchom skrypt, używając własnych wartości, aby zastąpić przykładowe wartości:

SubscriptionId
LabName
ResourceGroupName
RepositoryName
TemplateName (folder szablonu w repozytorium Git)
EnvironmentName

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