Criar ambientes com base em modelos do ARM

Use ambientes Azure DevTest Labs para provisionar laboratórios de forma fácil e consistente com múltiplas máquinas virtuais (VMs) e recursos de plataforma como serviço (PaaS). Este artigo descreve como criar ambientes do DevTest Labs com base em modelos do ARM (Azure Resource Manager ). Use essa abordagem para criar um laboratório para uma aplicação web multinível, como um aplicativo web com um backend de banco de dados SQL.

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

Você pode configurar um laboratório para usar modelos de ambiente arm de repositórios de modelos git públicos ou privados. O diagrama a seguir mostra como o DevTest Labs usa um modelo arm de um repositório público ou privado para implantar um ambiente que contém VMs e outros recursos.

Pré-requisitos

Para adicionar ou configurar repositórios de modelo para um laboratório, é necessário ter pelo menos permissões de Colaborador no laboratório.
Para criar ambientes do DevTest Labs a partir dos modelos ARM disponíveis, é necessário ter pelo menos as permissões de DevTest User no laboratório.
Para executar o script do PowerShell na criação do ambiente do Automate, é necessário que o Azure PowerShell tenha o módulo Az.Resources instalado.

Atribuir permissões de assinatura para implantação de templates

Se sua organização exigir permissões no escopo da assinatura para o gerenciamento delegado de modelos, atribua a função de Contribuidor do Azure Lab Services no escopo da assinatura.

Importante

Para criar ambientes no DevTest Labs, os usuários do laboratório ainda precisam ter, no mínimo, as permissões de DevTest User no laboratório. A função de Contribuidor do Azure Lab Services não substitui as permissões em nível de laboratório do DevTest Labs.

No portal do Azure, abra sua assinatura.
Selecione Controle de acesso (IAM)>Adicionar>Adicionar atribuição de função.
Procure e selecione Azure Lab Services Contributor.
Selecione Próximo, escolha usuário, grupo ou principal de serviço, e então selecione Revisar + atribuir.

Para acesso com privilégio mínimo, use uma função personalizada que inclua apenas as permissões necessárias para seu modelo e fluxo de trabalho do laboratório, em vez de permissões amplas em toda a assinatura.

O exemplo de função personalizada a seguir limita o acesso à criação de ambientes do DevTest Labs e à visibilidade da implantação. Adicione apenas as ações que seu modelo exige.

{
    "Name": "DevTest Labs Environment Template Deployer",
    "Description": "Create and read DevTest Labs environments from approved ARM templates.",
    "Actions": [
        "Microsoft.Authorization/*/read",
        "Microsoft.DevTestLab/labs/read",
        "Microsoft.DevTestLab/labs/EnsureCurrentUserProfile/action",
        "Microsoft.DevTestLab/labs/CreateEnvironment/action",
        "Microsoft.DevTestLab/labs/artifactSources/armTemplates/read",
        "Microsoft.DevTestLab/labs/policySets/EvaluatePolicies/action",
        "Microsoft.DevTestLab/labs/users/environments/read",
        "Microsoft.DevTestLab/labs/users/environments/write",
        "Microsoft.Resources/deployments/read",
        "Microsoft.Resources/deployments/operations/read",
        "Microsoft.Resources/subscriptions/resourceGroups/read"
    ],
    "NotActions": [],
    "DataActions": [],
    "NotDataActions": [],
    "AssignableScopes": [
        "/subscriptions/<subscription-id>"
    ]
}

Limitações

Os ambientes criados a partir de modelos de ambiente do ARM no DevTest Labs têm as seguintes limitações:

Não há suporte para o recurso de desligamento automático para VMs.
As seguintes políticas de laboratório não são impostas ou avaliadas:
- Número de VMs por usuário do laboratório
- Número de VMs premium por usuário
- Número de discos premium por usuário
Por exemplo, mesmo que a política de laboratório permita que cada usuário crie no máximo cinco VMs, o usuário poderá implantar um modelo de ambiente do ARM que cria dezenas de VMs.

Configurar repositórios de modelo para laboratórios

Você pode configurar seu laboratório para usar modelos de ambiente arm do repositório de modelos do ARM público do DevTest Labs e de outros repositórios Git públicos ou privados. Quando você habilita o acesso do laboratório a um repositório de templates, os usuários do laboratório podem criar rapidamente ambientes selecionando templates no portal do Azure.

O repositório público de modelos ARM do DevTest Labs inclui modelos de ambiente pré-escritos, como Web App com SQL Database e exemplos de cluster do Azure Service Fabric. Para uma experiência de introdução suave com recursos de PaaS, os modelos têm parâmetros de entrada mínimos.

Você pode usar os modelos de ambiente público no estado em que se encontram ou personalizá-los para atender às suas necessidades. Você também pode sugerir revisões ou adições a um modelo público enviando uma solicitação de pull para o repositório de modelo público de GitHub.

Você também pode armazenar modelos de ambiente em outros repositórios Git públicos ou privados e adicionar esses repositórios ao seu laboratório para disponibilizar os modelos a todos os usuários do laboratório. Para obter instruções, consulte Armazenar modelos ARM em repositórios Git e Adicionar repositórios de modelos aos laboratórios.

Definir configurações de ambiente público

Você pode habilitar o acesso de laboratório ao repositório de modelos públicos do DevTest Labs para um laboratório novo ou existente. Ao habilitar o acesso ao repositório, você pode selecionar quais modelos de ambiente disponibilizar aos usuários do laboratório.

Configurar o acesso ao ambiente público para um novo laboratório

Para configurar o acesso ao repositório de ambiente público ao criar um novo laboratório, na guia Configurações Básicas , defina a opção Ambientes públicos como Ativar ou Desativar. Essa opção é definida como Ativada por padrão.

Configurar o acesso ao ambiente público para um laboratório existente

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

Na página Visão geral do portal do Azure para seu laboratório, selecione Configuração e políticas em Configurações no menu de navegação à esquerda.
Na página Configuração e políticas , expanda as bases de máquinas virtuais no menu à esquerda e selecione Ambientes públicos.
Na página Ambientes Públicos , defina a opção Habilitar Ambientes Públicos para esta opção de laboratório como Sim ou Não.
Clique em Salvar.

Selecionar modelos de ambiente público disponíveis

Quando você habilita o repositório de ambiente público para um laboratório, todos os modelos de ambiente no repositório ficam disponíveis para os usuários do laboratório por padrão. Você pode optar por desabilitar o acesso aos modelos selecionados. Os modelos desabilitados não aparecem mais na lista de ambientes que os usuários podem criar.

Para não permitir o acesso a modelos de ambiente específicos:

Na página do portal do Azure Configurações e políticas>Bases de máquina virtual>, e Ambientes públicos, desmarque as caixas de seleção ao lado dos ambientes que você quer desabilitar.
Clique em Salvar.

Configurar permissões de usuário do ambiente

Por padrão, os usuários do laboratório recebem o papel de Leitor nos ambientes que criam. Os leitores não podem parar, iniciar ou modificar recursos de ambiente, como servidores SQL ou bancos de dados. Para permitir que os usuários do laboratório editem recursos em seus ambientes, conceda a eles o papel de Contribuinte no grupo de recursos do ambiente.

Na página Visão geral do portal do Azure para seu laboratório, selecione Configuração e políticas em Configurações no menu de navegação à esquerda.
Na página Configuração e políticas , expanda Configurações no menu à esquerda e selecione As configurações do Laboratório.
Na página Configurações do Laboratório em Acesso ao Ambiente, defina a opção direitos de usuário do grupo de recursos como Colaborador.
Clique em Salvar.

Criar ambientes com base em modelos

Se você configurar seu laboratório para usar repositórios de templates públicos ou privados, pode criar um ambiente selecionando um template ARM disponível. Siga estas etapas para criar um ambiente a partir de um modelo.

Na página Visão geral do portal do Azure para seu laboratório, selecione Meus ambientes em Meu Laboratório no menu de navegação à esquerda.
Na página Meus ambientes , selecione Adicionar.
Na página Escolher uma base , selecione Aplicativo Web com Banco de Dados SQL.
No painel de Adicionar , insira o nome de um Ambiente e configure as outras configurações de parâmetros para o aplicativo web e os recursos do banco de dados SQL.
- Cada modelo de ambiente arm inclui parâmetros exclusivos. Ao adicionar um ambiente, você deve inserir valores para todos os parâmetros necessários, indicados por asteriscos vermelhos.
- Alguns valores de parâmetro em um arquivo de modelo ARM azuredeploy.parameters.json produzem campos de configuração em branco sem nenhum valor padrão no painel Adicionar. Esses valores incluem GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEYe GEN-PASSWORD.
- Você pode usar segredos do Azure Key Vault para parâmetros de cadeia de caracteres seguros , como senhas. Para obter mais informações, consulte Armazenar segredos no Azure Key Vault.
Selecione Adicionar. O ambiente inicia o provisionamento imediatamente.

O processo de provisionamento de um ambiente pode levar muito tempo. O tempo total depende do número de instâncias de serviço, VMs e outros recursos que o DevTest Labs cria como parte do ambiente de laboratório.

Você pode monitorar o status de provisionamento na página Meus ambientes . Selecione Atualizar na barra de ferramentas para atualizar o modo de exibição de página e verificar o status atual. Enquanto o provisionamento estiver em andamento, o status do ambiente será Criando. Após o provisionamento ser concluído, o status será alterado para Pronto.

A implantação cria um novo grupo de recursos para provisionar todos os recursos de ambiente definidos pelo modelo do ARM. Selecione o ambiente na lista Meus ambientes para exibir o grupo de recursos e todos os recursos que o modelo criou.

Selecione um recurso na lista para ver propriedades e ações disponíveis.

Automatize a criação de ambientes

Se você precisar criar vários ambientes para cenários de desenvolvimento ou teste, poderá usar o Azure PowerShell ou a CLI do Azure para automatizar a implantação de ambiente de modelos do ARM. As etapas a seguir mostram como automatizar a implantação do modelo de ambiente do ARM usando o comando do Azure PowerShell New-AzResource .

Você também pode automatizar a implantação usando o comando az deployment group create da CLI do Azure. Para obter mais informações, confira Implantar recursos com modelos do ARM e a CLI do Azure.

Armazene o modelo de ambiente do ARM em um repositório Git e adicione o repositório ao seu 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 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."

Para usar o script, execute o comando a seguir. Atualize os espaços reservados no comando com seus próprios valores de laboratório.

.\DeployLabEnvironment.ps1 `
    -SubscriptionId "<Subscription ID>" `
    -LabName "<LabName>" `
    -ResourceGroupName "<LabResourceGroupName>" `
    -RepositoryName "<TemplateRepoName>" `
    -TemplateName "<TemplateFolderName>" `
    -EnvironmentName "<EnvironmentName>"

Comentários

Esta página foi útil?

Last updated on 2026-07-15