Criar ambientes de Azure DevTest Labs a partir de modelos do ARM

Artigo
09/30/2023

Neste artigo, vai aprender a criar ambientes de Azure DevTest Labs a partir de modelos do Azure Resource Manager (ARM). Pode utilizar ambientes do DevTest Labs para aprovisionar laboratórios de forma fácil e consistente com várias máquinas virtuais (VMs) ou recursos paaS (plataforma como serviço). Por exemplo, para criar um laboratório para uma aplicação Web de várias camadas ou um farm do SharePoint.

Os recursos num ambiente partilham o mesmo ciclo de vida e pode geri-los em conjunto. Pode controlar o custo dos ambientes de laboratório e dos recursos PaaS, assim como controlar os custos das VMs de laboratório individuais.

Pode configurar Azure DevTest Labs para utilizar modelos do ARM a partir de um repositório Git público ou privado. Saiba mais sobre os repositórios de modelos para laboratórios.

Se quiser utilizar um modelo do ARM para criar um recurso Azure DevTest Labs, veja Início Rápido: utilizar um modelo do ARM para criar um laboratório no DevTest Labs.

Limitações

Considere estas limitações quando criar laboratórios a partir de modelos do ARM no DevTest Labs:

O encerramento automático da VM não se aplica aos recursos PaaS.
Nem todas as políticas de laboratório são avaliadas quando implementa modelos do ARM. As políticas que não são avaliadas incluem: número de VMs por utilizador de laboratório, número de VMs premium por utilizador e número de suportes premium por utilizador. Por exemplo, a política de laboratório pode limitar os utilizadores a apenas cinco VMs cada. No entanto, um utilizador pode implementar um modelo de ambiente arm que cria dezenas de VMs.

Criar ambientes a partir de modelos

Pode criar um ambiente a partir do Azure DevTest Labs repositório de modelos públicos ou pode adicionar um repositório de modelo privado ao seu laboratório.

Saiba como configurar ambientes para o laboratório. Por exemplo, como configurar os repositórios de modelos, ativar ou desativar ambientes públicos e selecionar modelos específicos para criar laboratórios.

Para criar um ambiente a partir de um modelo:

Na portal do Azure, selecione o recurso de laboratório.
Na página Descrição Geral do laboratório, selecione Adicionar na barra de ferramentas superior.
Na página Escolher uma base , selecione o modelo de ambiente arm a utilizar. Os modelos de ambiente disponíveis são apresentados primeiro na lista de bases.
No ecrã Adicionar , introduza um Nome do ambiente e preencha os outros campos de entrada.

O número e o tipo de campos de entrada são definidos no modelo do ARM. Conforme necessário, introduza valores para campos de entrada que o ficheiro azuredeploy.parameters.json do modelo define como em branco ou predefinido.
- Para secure string parâmetros, pode utilizar segredos do Azure Key Vault. Para saber como armazenar segredos num cofre de chaves e utilizá-los ao criar recursos de laboratório, veja Armazenar segredos no Azure Key Vault.
- Nos ficheiros de modelo do ARM, os GEN-UNIQUEvalores dos parâmetros , GEN-UNIQUE-[N], GEN-SSH-PUB-KEYe GEN-PASSWORD geram campos de entrada em branco para os utilizadores introduzirem valores.
Selecione Adicionar para criar o ambiente.

O ambiente começa a ser aprovisionado imediatamente. Pode ver o estado de aprovisionamento em Os meus ambientes na página Descrição Geral do laboratório. O aprovisionamento de um ambiente pode demorar muito tempo.
Assim que a criação do ambiente estiver concluída, expanda o ambiente em Os meus ambientes para ver a lista de VMs e outros recursos que o modelo aprovisionou.

A implementação cria um novo grupo de recursos para aprovisionar todos os recursos de ambiente que o modelo do ARM definiu. Selecione o nome do ambiente em Os meus ambientes para ver o grupo de recursos e todos os recursos que o modelo criou.
Selecione uma VM de ambiente para ver as ações disponíveis para a VM, como a gestão de configurações, agendas e políticas.

Repositórios de modelos de ambiente

Com Azure DevTest Labs, pode criar ambientes a partir de modelos do ARM. Os modelos do ARM podem ser provenientes de duas origens:

Azure DevTest Labs tem um repositório de modelo do ARM público que inclui modelos de ambiente pré-criados para o Azure Aplicações Web, um cluster do Azure Service Fabric e farms do SharePoint de desenvolvimento. Os modelos têm parâmetros de entrada mínimos, para uma experiência de introdução suave com recursos PaaS. Pode utilizar os modelos de ambiente público tal como estão ou personalizá-los de acordo com as suas necessidades.
Pode armazenar modelos de ambiente nos seus próprios repositórios Git públicos ou privados e ligar esses repositórios ao seu laboratório para disponibilizar os seus modelos a todos os utilizadores do laboratório.

Dica

Para sugerir revisões ou adições aos modelos públicos, submeta um pedido Pull no repositório de modelos públicos do GitHub open source.

Configurar as definições de ambiente público para o laboratório

Pode configurar o laboratório para ativar a utilização de modelos a partir do repositório de modelos públicos. Se ativar o repositório de modelos públicos para um laboratório, os utilizadores podem criar rapidamente um ambiente ao selecionar estes modelos diretamente no portal do Azure, de forma semelhante à forma como criam uma VM num laboratório.

Além disso, pode selecionar a partir dos modelos que estão disponíveis para os utilizadores criarem ambientes.

Ativar ambientes públicos quando cria um laboratório

Para ativar o acesso ao repositório de ambiente público para um laboratório quando cria um laboratório:

Selecione o separador Definições Básicas quando criar um recurso do DevTest Labs.
Selecione Ativado no campo Ambientes públicos .

Ativar ou desativar ambientes públicos para laboratórios existentes

Para laboratórios existentes ou laboratórios que cria com um modelo do ARM, os ambientes públicos podem não estar ativados. Para ativar ou desativar o repositório de ambiente público para laboratórios existentes:

Na portal do Azure, selecione o recurso de laboratório.
Selecione Configuração e políticas no painel de navegação esquerdo.
Selecione Ambientes públicos em Bases de máquinas virtuais no painel de navegação esquerdo.
Selecione Sim ou Não para Ativar Ambientes Públicos para este laboratório, para ativar ou desativar ambientes públicos para o laboratório.
Selecione Guardar.

Selecionar modelos de ambiente público disponíveis

Quando ativa ambientes públicos, todos os modelos de ambiente no repositório estão disponíveis para criar ambientes. Para permitir apenas ambientes específicos para um laboratório:

Na portal do Azure, selecione o recurso de laboratório.
Selecione Configuração e políticas no painel de navegação esquerdo.
Selecione Ambientes públicos em Bases de máquinas virtuais no painel de navegação esquerdo.
Desselecione ambientes específicos da lista para torná-los indisponíveis para os utilizadores do laboratório e, em seguida, selecione Guardar.

Configurar direitos de utilizador do ambiente

Por predefinição, os utilizadores de laboratório têm a função Leitor em ambientes e não podem alterar os recursos do ambiente. Por exemplo, os utilizadores não podem parar ou iniciar recursos. Para atribuir aos utilizadores do laboratório a função Contribuidor para permitir que editem recursos de ambiente:

Na portal do Azure, selecione o recurso de laboratório.
Selecione Configuração e políticas no painel de navegação esquerdo.
Selecione Definições do laboratório no painel de navegação esquerdo.
Em Acesso ao ambiente>Direitos de utilizador do grupo de recursos, selecione Contribuidor e, em seguida, selecione Guardar.

Automatizar a criação do ambiente

Se precisar de criar vários ambientes para cenários de desenvolvimento ou teste, pode automatizar a implementação do ambiente com Azure PowerShell ou a CLI do Azure.

Pode utilizar o comando da CLI do Azure az deployment group create para criar ambientes. Para obter mais informações, veja Deploy resources with Resource Manager templates and Azure CLI (Implementar recursos com modelos de Resource Manager e a CLI do Azure).

Os proprietários e administradores do laboratório podem utilizar Azure PowerShell para criar VMs e ambientes a partir de modelos do ARM.

Nota

Recomendamos que utilize o módulo Azure Az PowerShell para interagir com o Azure. Veja Instalar o Azure PowerShell para começar. Para saber como migrar para o módulo do Az PowerShell, veja Migrar o Azure PowerShell do AzureRM para o Az.

Para automatizar a implementação de modelos de ambiente do ARM com Azure PowerShell:

Peça a um modelo de ambiente arm para dar entrada num repositório Git e o repositório adicionado ao laboratório.

Guarde o seguinte script do PowerShell no seu computador como deployenv.ps1. Este script chama o modelo do ARM para criar o ambiente no laboratório.

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

Execute o script com os seus próprios valores para substituir os valores de exemplo para:

SubscriptionId
LabName
ResourceGroupName
RepositoryName
TemplateName (pasta de modelos no repositório Git)
EnvironmentName

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