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

Z tego artykułu dowiesz się, jak tworzyć środowiska usługi 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). Możesz użyć tego podejścia do utworzenia laboratorium dla wielowarstwowej aplikacji internetowej lub farmy programu SharePoint.

Zasoby w środowisku usługi DevTest Labs współdzielą ten sam cykl życia i można nimi zarządzać razem. Możesz śledzić koszty środowisk laboratoryjnych i zasobów PaaS w taki sam sposób, jak śledzenie kosztów poszczególnych maszyn wirtualnych laboratorium.

Usługę Azure DevTest Labs można skonfigurować do używania szablonów usługi ARM z publicznego lub prywatnego repozytorium GitHub. Na poniższym diagramie pokazano, jak utworzyć środowisko za pomocą usługi DevTest Labs z szablonu usługi ARM w publicznym lub niestandardowym repozytorium szablonów. W sekcji Repozytoria szablonów dla laboratoriów szczegółowo opisano ten proces.

Wymagania wstępne

• Warto mieć doświadczenie w konfigurowaniu środowisk laboratoryjnych w usłudze DevTest Labs. Jeśli dopiero zaczynasz pracę z laboratoriami, zapoznaj się z instrukcjami w sekcji Konfigurowanie ustawień środowiska publicznego. Musisz zrozumieć, jak skonfigurować repozytoria szablonów, włączyć lub wyłączyć środowiska publiczne, a następnie wybrać szablony do tworzenia laboratoriów.

Ograniczenia

Podczas tworzenia laboratoriów z szablonów usługi ARM w usłudze DevTest Labs należy pamiętać o kilku ograniczeniach:

• Usługa DevTest Labs nie obsługuje funkcji automatycznego zamykania maszyny wirtualnej dla zasobów PaaS utworzonych na podstawie szablonów usługi ARM.

• Usługa DevTest Labs nie ocenia wszystkich zasad laboratorium podczas wdrażania szablonów usługi ARM. Następujące zasady nie są oceniane:

  • Liczba maszyn wirtualnych na użytkownika laboratorium
  • Liczba maszyn wirtualnych w warstwie Premium na użytkownika
  • Liczba biurków w warstwie Premium na użytkownika

  Załóżmy, że masz zasady laboratorium, które umożliwiają każdemu użytkownikowi utworzenie maksymalnie pięciu maszyn wirtualnych. W usłudze DevTest Labs każdy użytkownik może wdrożyć szablon środowiska ARM, który tworzy dziesiątki maszyn wirtualnych.

Tworzenie środowisk na podstawie szablonów

Środowisko można utworzyć z publicznego repozytorium szablonów usługi Azure DevTest Labs lub dodać prywatne repozytorium szablonów do laboratorium.

Utwórz środowisko na podstawie szablonu, wykonując następujące kroki:

1. W witrynie Azure Portal przejdź do zasobu laboratorium DevTest Labs.

2. Na stronie Przegląd laboratorium rozwiń sekcję Moje laboratorium w menu po lewej stronie i wybierz pozycję Moje środowiska.

3. Na stronie Moje środowiska wybierz pozycję Dodaj na pasku narzędzi.

4. Na stronie Wybieranie bazy wybierz szablon środowiska arm do użycia:

   

5. W okienku Dodawanie wprowadź nazwę środowiska i skonfiguruj inne ustawienia parametrów.

   Typ i liczba parametrów są unikatowe dla każdego szablonu usługi ARM. Czerwona gwiazdka (*) wskazuje wymagane ustawienie. Musisz wprowadzić wartości dla wszystkich wymaganych ustawień.

   Niektóre wartości parametrów w pliku szablonu usługi ARM (azuredeploy.parameters.json) generują puste pola ustawień w okienku Dodawanie (bez wartości domyślnej). Te wartości parametrów obejmują GEN-UNIQUE, , GEN-UNIQUE-[N]GEN-SSH-PUB-KEYi GEN-PASSWORD.

   

   W przypadku parametrów bezpiecznego ciągu , takich jak hasła, 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 laboratorium, zobacz Przechowywanie wpisów tajnych w usłudze Azure Key Vault.

6. Wybierz pozycję Dodaj , aby utworzyć środowisko. Środowisko rozpoczyna aprowizację natychmiast.

   Uwaga

   Proces aprowizacji środowiska może zająć dużo czasu. Łączny czas zależy od liczby wystąpień usługi, maszyn wirtualnych i innych zasobów tworzonych przez usługę DevTest Labs w ramach środowiska laboratoryjnego.

7. Aby monitorować stan aprowizacji, wróć do strony Moje środowiska dla laboratorium:

   

   Podczas aprowizacji stan środowiska to Tworzenie. Po zakończeniu aprowizacji stan zmieni się na Gotowy. Możesz wybrać pozycję Odśwież na pasku narzędzi, aby zaktualizować widok strony i sprawdzić bieżący stan.

8. Gdy środowisko jest gotowe, możesz rozwinąć środowisko na liście Moje środowiska, aby wyświetlić maszyny wirtualne aprowidowane przez szablon:

   

9. Wdrożenie tworzy nową grupę zasobów, aby aprowizować wszystkie zasoby środowiska zdefiniowane przez szablon usługi ARM. Wybierz nazwę środowiska na liście Moje środowiska , aby wyświetlić grupę zasobów i wszystkie zasoby utworzone przez szablon:

   

10. Wybierz maszynę wirtualną środowiska na liście, aby wyświetlić dostępne akcje dla maszyny wirtualnej, takie jak zarządzanie konfiguracją, harmonogramami i zasadami:

    

Eksplorowanie repozytoriów szablonów

Szablony usługi ARM do tworzenia środowisk w usłudze DevTest Labs są dostępne z dwóch źródeł:

• Usługa DevTest Labs ma publiczne repozytorium szablonów usługi ARM, które zawiera wstępnie uwierzytelnione szablony środowiska dla usługi Azure Web Apps, klastra usługi Azure Service Fabric i programowania farm 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. Możesz również zasugerować poprawki lub dodatki do szablonu publicznego, przesyłając żądanie ściągnięcia do publicznego repozytorium szablonów usługi GitHub.

• Szablony środowisk można przechowywać we własnych publicznych lub prywatnych repozytoriach GitHub i dodawać te repozytoria do laboratorium, aby udostępnić szablony wszystkim użytkownikom laboratorium .

Konfigurowanie ustawień środowiska publicznego

Laboratorium można skonfigurować tak, aby umożliwić korzystanie z szablonów z repozytorium GitHub szablonu publicznego. Po włączeniu publicznego repozytorium szablonów dla laboratorium użytkownicy mogą szybko utworzyć środowisko laboratoryjne, wybierając te szablony bezpośrednio w witrynie Azure Portal, podobnie jak w przypadku tworzenia maszyny wirtualnej w laboratorium. Ponadto możesz wybrać, które szablony są dostępne dla użytkowników w celu tworzenia środowisk laboratoryjnych.

Ustawianie dostępu do środowiska publicznego dla nowego laboratorium

Skonfiguruj dostęp do repozytorium środowiska publicznego dla nowego laboratorium, wykonując następujące kroki:

1. Podczas tworzenia zasobu usługi DevTest Labs wybierz kartę Ustawienia podstawowe.

2. Ustaw opcję Środowiska publiczne na Włączone:

   

Ustawianie dostępu do środowiska publicznego 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. Możesz kontrolować dostęp do repozytoriów środowiska publicznego dla dowolnego istniejącego laboratorium za pomocą opcji Włącz środowiska publiczne dla tego laboratorium .

Wykonaj następujące kroki, aby włączyć lub wyłączyć dostęp do repozytorium środowiska publicznego dla dowolnego istniejącego laboratorium:

1. W witrynie Azure Portal przejdź do zasobu laboratorium DevTest Labs, w którym chcesz ustawić dostęp do środowiska publicznego.

2. Na stronie Przegląd laboratorium rozwiń sekcję Ustawienia w menu po lewej stronie, a następnie wybierz pozycję Konfiguracja i zasady.

3. Na stronie Konfiguracja i zasady rozwiń sekcję Podstawy maszyny wirtualnej w menu po lewej stronie i wybierz pozycję Środowiska publiczne.

4. Na stronie Środowiska publiczne ustaw opcję Włącz środowiska publiczne dla tego laboratorium na wartość Tak:

   

5. Wybierz pozycję Zapisz.

Wybieranie dostępnych szablonów środowisk publicznych

Po ustawieniu opcji Włącz środowiska publiczne dla tego laboratorium w celu kontrolowania dostępu do środowisk publicznych dla laboratorium wszystkie szablony środowiska są domyślnie zaznaczone. Ustawienie opcji zezwala lub nie zezwala na dostęp do wszystkich środowisk na podstawie wybranego wyboru. Możesz użyć pól wyboru na liście, aby określić środowiska, do których użytkownicy mogą uzyskiwać dostęp.

Wykonaj następujące kroki, aby zezwolić na dostęp tylko do określonych środowisk dla laboratorium:

1. Na stronie Środowiska publiczne ustaw opcję Włącz środowiska publiczne dla tego laboratorium na wartość Tak.

2. Usuń zaznaczenie określonych środowisk na liście, aby uczynić je niedostępnymi dla użytkowników laboratorium:

   

3. Wybierz pozycję Zapisz.

Konfigurowanie praw użytkownika środowiska

Domyślnie użytkownicy laboratorium mają przypisaną rolę Czytelnik w repozytoriach środowiska publicznego. Nie mogą zmieniać zasobów środowiska i nie mogą zatrzymywać ani uruchamiać zasobów.

Wykonaj następujące kroki, aby przyznać użytkownikom laboratorium rolę Współautor i umożliwić im edytowanie zasobów środowiska:

1. W witrynie Azure Portal przejdź do zasobu laboratorium DevTest Labs, w którym chcesz dostosować przypisania ról użytkownika.

2. Na stronie Przegląd laboratorium rozwiń sekcję Ustawienia w menu po lewej stronie, a następnie wybierz pozycję Konfiguracja i zasady.

3. Na stronie Konfiguracja i zasady rozwiń sekcję Ustawienia w menu po lewej stronie i wybierz pozycję Ustawienia laboratorium.

4. Na stronie Ustawienia laboratorium ustaw opcję Uprawnienia użytkownika grupy zasobów dostęp do>środowiska na Wartość Współautor:

   

5. Wybierz pozycję Zapisz.

Zautomatyzuj tworzenie środowiska

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

Właściciele laboratoriów i administratorzy mogą używać programu Azure PowerShell do tworzenia maszyn wirtualnych i środowisk na podstawie szablonów usługi ARM. Wdrożenie można również zautomatyzować za pomocą interfejsu wiersza polecenia platformy Azure przy użyciu polecenia az deployment group create w celu utworzenia środowisk. Aby uzyskać więcej informacji, zobacz Wdrażanie zasobów przy użyciu szablonów usługi ARM i interfejsu wiersza polecenia platformy Azure.

Uwaga

Do interakcji z platformą Azure zalecamy używanie modułu Azure Az w programie PowerShell. Aby rozpocząć, zobacz Instalowanie programu Azure PowerShell. Aby dowiedzieć się, jak przeprowadzić migrację do modułu Az PowerShell, zobacz Migracja programu Azure PowerShell z modułu AzureRM do modułu Az.

Zautomatyzuj wdrażanie szablonu środowiska arm przy użyciu programu Azure PowerShell, wykonując następujące kroki:

1. Zapisz szablon środowiska ARM w repozytorium GitHub.

2. Dodaj repozytorium szablonów usługi ARM usługi GitHub do laboratorium.

3. Zapisz następujący skrypt programu PowerShell na komputerze przy użyciu nazwy pliku deployenv.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 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."
   

4. Zaktualizuj następujące symbole zastępcze w skrycie przy użyciu własnych wartości laboratorium:

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

   Poniższy fragment kodu pokazuje, jak uruchomić skrypt z przykładowymi wartościami parametrów:

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

5. Uruchom skrypt.

Powiązana zawartość

• Tworzenie maszyn wirtualnych usługi DevTest Labs przy użyciu szablonów usługi ARM
• Repozytorium szablonów publicznego środowiska ARM w witrynie GitHub
• Galeria szablonów szybkiego startu platformy Azure w usłudze GitHub