Criar ambientes de Azure DevTest Labs com base em modelos do ARM

Artigo
09/30/2023

Neste artigo, você aprenderá a criar ambientes Azure DevTest Labs a partir de modelos do ARM (Azure Resource Manager). Use ambientes do DevTest Labs para provisionar laboratórios de forma fácil e consistente com várias VMs (máquinas virtuais) ou recursos de PaaS (plataforma como serviço). Por exemplo, para criar um laboratório para um aplicativo Web de várias camadas ou um farm do SharePoint.

Os recursos em um ambiente compartilham o mesmo ciclo de vida e você pode gerenciá-los juntos. Você pode acompanhar o custo de ambientes de laboratório e recursos de PaaS, assim como controla os custos para VMs de laboratório individuais.

Configure o Azure DevTest Labs para usar modelos do ARM de um repositório Git público ou privado. Saiba mais sobre repositórios de modelos para laboratórios.

Se você quiser usar um modelo do ARM para criar um recurso de Azure DevTest Labs, consulte o Início Rápido: usar um modelo do ARM para criar um laboratório no DevTest Labs.

Limitações

Considere essas limitações ao criar laboratórios com base em modelos do ARM no DevTest Labs:

O desligamento automático de VM não se aplica aos recursos de PaaS.
Nem todas as políticas de laboratório são avaliadas ao implantar os modelos de ARM. As políticas que não são avaliadas incluem: o número de VMs por usuário do laboratório, o número de VMs Premium por usuário e o número de mesas Premium por usuário. Por exemplo, sua política de laboratório pode limitar os usuários a apenas cinco VMs cada. No entanto, um usuário pode implantar um modelo de ambiente do ARM que crie dezenas de VMs.

Criar ambientes com base em modelos

Crie um ambiente do repositório de modelo público do Azure DevTest Labs ou pode adicionar um repositório de modelo privado ao laboratório.

Saiba como configurar ambientes para seu laboratório. Por exemplo, como configurar os repositórios de modelo, habilitar ou desabilitar ambientes públicos e selecionar modelos específicos para a criação de laboratórios.

Para criar um ambiente a partir de um modelo:

No portal do Azure, selecione seu recurso de laboratório.
Na página Visã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 ser usado. Os modelos de ambiente disponíveis aparecem primeiro na lista de bases.
Na tela Adicionar, insira 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, insira valores para os campos de entrada que o modelo azuredeploy.parameters.json define como em branco ou padrão.
- Para parâmetros secure string, você pode usar segredos de Azure Key Vault. Para saber como armazenar segredos em um cofre de chaves e usá-los ao criar recursos de laboratório, consulte Store secrets in Azure Key Vault (Armazenar segredos no Azure Key Vault).
- Em arquivos de modelo ARM, GEN-UNIQUE, GEN-UNIQUE-[N], valores de parâmetro GEN-SSH-PUB-KEY e GEN-PASSWORD geram campos de entrada em branco para que os usuários insiram valores.
Selecione Adicionar para criar o ambiente.

O ambiente inicia o provisionamento imediatamente. Você pode ver o status de provisionamento em meus ambientes na página Visão geral do laboratório. O provisionamento de um ambiente pode levar muito tempo.
Depois que a criação do ambiente for concluída, expanda o ambiente em Meus ambientes para ver a lista de VMs e outros recursos provisionados pelo modelo.

A implantação cria um novo grupo de recursos para provisionar todos os recursos de ambiente definidos pelo modelo do ARM. Selecione o nome do ambiente em Meus ambientes para exibir 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 gerenciamento de configuração, agendas e políticas.

Repositórios de modelo de ambiente

Com o Azure DevTest Labs, você pode criar ambientes com base em modelos do ARM. Os modelos do ARM podem vir de duas fontes:

O Azure DevTest Labs tem um repositório de modelos do ARM público que inclui modelos de ambiente pré-criados para aplicativos Web do azure, um cluster de Service Fabric do Azure e propriedades do SharePoint de desenvolvimento. Os modelos têm parâmetros de entrada mínimos, para uma experiência de introdução perfeita com recursos de PaaS. Você pode usar os modelos de ambiente público no estado em que se encontram ou personalizá-los para atender às suas necessidades.
É possível armazenar modelos de ambiente em seus próprios repositórios do Git públicos ou privados e conectar esses repositórios ao seu laboratório para disponibilizar seus modelos para todos os usuários do laboratório.

Dica

Para sugerir revisões ou adições aos modelos públicos, envie uma solicitação de pull para o repositório de modelo público de GitHub de código-fonte aberto.

Definir configurações de ambiente público para seu laboratório

Configure seu laboratório para habilitar o uso de modelos do repositório de modelos público. Se você habilitar o repositório de modelos público para um laboratório, os usuários poderão criar rapidamente um ambiente selecionando esses modelos diretamente no portal do Azure, semelhante à forma como eles criam uma VM em um laboratório.

Além disso, você pode selecionar de quais modelos estão disponíveis para os usuários criarem ambientes.

Habilitar ambientes públicos ao criar um laboratório

Para habilitar o acesso ao repositório de ambiente público para um laboratório ao criar um laboratório:

Selecione a guia Configurações Básicas ao criar um recurso do DevTest Labs.
Selecione Ativado no campo Ambientes públicos.

Habilitar ou desabilitar ambientes públicos para laboratórios existentes

Para laboratórios existentes ou laboratórios criados com um modelo do ARM, os ambientes públicos podem não estar habilitados. Para habilitar ou desabilitar o repositório de ambiente público para laboratórios existentes:

No portal do Azure, selecione seu recurso de laboratório.
Selecione Configuração e políticas no painel de navegação esquerdo.
Selecione Ambientes públicos em Bases da máquina virtual no painel de navegação à esquerda.
Selecione Sim ou Não para Habilitar ambientes públicos para este laboratório, para habilitar ou desabilitar ambientes públicos para o laboratório.
Selecione Salvar.

Selecionar modelos de ambiente público disponíveis

Ao habilitar ambientes públicos, todos os modelos de ambiente no repositório estarão disponíveis para a criação de ambientes. Para permitir apenas ambientes específicos para um laboratório:

No portal do Azure, selecione seu recurso de laboratório.
Selecione Configuração e políticas no painel de navegação esquerdo.
Selecione Ambientes públicos em Bases da máquina virtual no painel de navegação à esquerda.
Desmarque ambientes específicos da lista para torná-los indisponíveis para os usuários do laboratório e selecione Salvar.

Configurar direitos de usuário de ambiente

Por padrão, os usuários do laboratório têm a função de Leitor nos ambientes e não podem alterar os recursos do ambiente. Por exemplo, os usuários não podem parar nem iniciar recursos. Para fornecer à função Colaborador dos usuários do laboratório para permitir que eles editem os recursos do ambiente:

No portal do Azure, selecione seu recurso de laboratório.
Selecione Configuração e políticas no painel de navegação esquerdo.
Selecione Configurações do laboratório na navegação à esquerda.
Em Direitos de usuário do grupo de recursos> de acesso ao ambiente, selecione Colaborador e, em seguida, selecione salvar.

Automatizar a criação do ambiente

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

Você pode usar o comando da CLI do Azure o grupo de implantação AZ Create para criar ambientes. Para obter mais informações, veja Implantar recursos com modelos do Resource Manager e a CLI do Azure.

Os proprietários e os administradores do laboratório podem usar o Azure PowerShell para criar VMs e ambientes de modelos do ARM.

Observação

Recomendamos que você use o módulo Az PowerShell do Azure para interagir com o Azure. Confira Instalar o Azure PowerShell para começar. Para saber como migrar para o módulo Az PowerShell, confira Migrar o Azure PowerShell do AzureRM para o Az.

Para automatizar a implantação do modelo de ambiente ARM com o Azure PowerShell:

Ter um modelo de ambiente do ARM com check-in em um repositório Gite o repositório adicionado ao laboratório.

Salve o script do PowerShell a seguir em seu computador como deployenv.ps1. Esse 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 usando seus próprios valores para substituir os valores de exemplo para:

SubscriptionId
LabName
ResourceGroupName
RepositoryName
TemplateName(pasta de modelo 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"