Criar ambientes do Azure DevTest Labs a partir de modelos ARM

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

Os recursos em um ambiente DevTest Labs 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 da mesma forma que controla os custos de VMs de laboratório individuais.

Você pode configurar o Azure DevTest Labs para usar modelos ARM de um repositório GitHub público ou privado. O diagrama a seguir mostra como criar um ambiente com o DevTest Labs a partir de um modelo ARM em um repositório de modelos público ou personalizado. A seção repositórios de modelos para laboratórios descreve esse processo em detalhes.

Nota

Os Ambientes de Implantação do Azure (ADE) são altamente recomendados para a criação de ambientes. O ADE permite que os desenvolvedores implantem rapidamente a infraestrutura de aplicativos usando modelos baseados em projetos, garantindo ambientes consistentes e seguros para suas equipes de desenvolvimento.

Para saber mais sobre os Ambientes de Implantação do Azure, consulte a documentação dos Ambientes de Implantação do Azure.

Pré-requisitos

• É útil ter experiência na configuração de ambientes de laboratório no DevTest Labs. Se você é novo no trabalho com laboratórios, comece revisando as instruções na seção Configurar configurações de ambiente público. Você precisa entender como configurar repositórios de modelos, habilitar ou desabilitar ambientes públicos e selecionar modelos para criar laboratórios.

Limitações

Há algumas limitações a ter em mente ao criar laboratórios a partir de modelos ARM no DevTest Labs:

• O DevTest Labs não suporta o recurso de desligamento automático da máquina virtual (VM) para recursos PaaS criados a partir de modelos ARM.

• O DevTest Labs não avalia todas as políticas de laboratório quando você implanta modelos ARM. As seguintes políticas não são avaliadas:

  • Número de VMs por usuário de laboratório
  • Número de VMs premium por usuário
  • Número de mesas premium por usuário

  Suponha que você tenha uma política de laboratório que permita que cada usuário crie no máximo cinco VMs. No DevTest Labs, cada usuário pode implantar um modelo de ambiente ARM que cria dezenas de VMs.

Criar ambientes a partir de modelos

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

Crie um ambiente a partir de um modelo seguindo estas etapas:

1. No portal do Azure, vá para seu recurso de laboratório do DevTest Labs.

2. Na página Visão geral do laboratório, expanda a seção Meu laboratório no menu à esquerda e selecione Meus ambientes.

3. Na página Meus ambientes, selecione Adicionar na barra de ferramentas.

4. Na página Escolha uma base, selecione o modelo de ambiente ARM a ser usado:

   

5. No painel Adicionar, insira um Nome do ambiente e defina as outras configurações de parâmetro.

   O tipo e o número de parâmetros são exclusivos para cada modelo ARM. Um asterisco vermelho (*) indica uma configuração necessária. Você deve inserir valores para todas as configurações necessárias.

   Alguns valores de parâmetro no arquivo de modelo ARM (azuredeploy.parameters.json) produzem campos de configuração em branco no painel Adicionar (sem valor padrão). Esses valores de parâmetro incluem GEN-UNIQUE, GEN-UNIQUE-[N], GEN-SSH-PUB-KEY, e GEN-PASSWORD.

   

   Para parâmetros de cadeia de caracteres seguros, como senhas, você pode usar segredos do Cofre de Chaves do Azure. Para saber como armazenar segredos em um cofre de chaves e usá-los ao criar recursos de laboratório, consulte Armazenar segredos no Cofre de Chaves do Azure.

6. Selecione Adicionar para criar o ambiente. O ambiente começa a provisionar imediatamente.

   Nota

   O processo para provisionar 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.

7. Para monitorar o status de provisionamento, retorne à página Meus ambientes do laboratório:

   

   Enquanto o provisionamento está em andamento, o status do ambiente está sendo criado. Após a conclusão do provisionamento, o status muda para Pronto. Você pode selecionar Atualizar na barra de ferramentas para atualizar a exibição de página e verificar o status atual.

8. Quando o ambiente estiver pronto, você poderá expandi-lo na lista Meus ambientes para ver as VMs provisionadas pelo modelo:

   

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

   

10. Selecione uma VM de ambiente na lista para ver as ações disponíveis para a VM, como gerenciar configurações, agendas e políticas:

    

Explore repositórios de modelos

Os modelos ARM para criar ambientes no DevTest Labs estão disponíveis a partir de duas fontes:

• O DevTest Labs tem um repositório de modelos ARM público que inclui modelos de ambiente pré-criados para Aplicativos Web do Azure, 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 de PaaS. Você pode usar os modelos de ambiente público como estão 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 pull no repositório de modelos públicos do GitHub.

• Você pode armazenar modelos de ambiente em seus próprios repositórios públicos ou privados do GitHub e adicionar esses repositórios ao seu laboratório para disponibilizar seus modelos para todos os usuários do laboratório.

Definir configurações de ambiente público

Você pode configurar seu laboratório para habilitar o uso de modelos do repositório GitHub de modelo público. Quando você habilita o repositório de modelos públicos para um laboratório, os usuários podem criar rapidamente um ambiente de laboratório selecionando esses modelos diretamente no portal do Azure, semelhante à forma como criam uma VM em um laboratório. Além disso, você pode selecionar quais modelos estão disponíveis para os usuários criarem ambientes de laboratório.

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

Configure o acesso ao repositório do ambiente público para um novo laboratório seguindo estas etapas:

1. Durante o processo para criar um recurso DevTest Labs, selecione a guia Configurações básicas .

2. Defina a opção Ambientes públicos como Ativado:

   

Definir o acesso ao ambiente público para laboratórios existentes

Para laboratórios existentes ou laboratórios criados com um modelo ARM, os ambientes públicos podem não estar habilitados. Você pode controlar o acesso a repositórios de ambiente público para qualquer laboratório existente com a opção Habilitar ambientes públicos para este laboratório .

Siga estas etapas para habilitar ou desabilitar o acesso ao repositório do ambiente público para qualquer laboratório existente:

1. No portal do Azure, vá para o recurso de laboratório do DevTest Labs onde você deseja definir o acesso ao ambiente público.

2. Na página Visão geral do laboratório, expanda a seção Configurações no menu à esquerda e selecione Configuração e políticas.

3. Na página Configuração e políticas, expanda a seção Bases de máquinas virtuais no menu à esquerda e selecione Ambientes públicos.

4. Na página Ambientes públicos, defina a opção Habilitar ambientes públicos para este laboratório como Sim:

   

5. Selecione Guardar.

Selecionar modelos de ambiente público disponíveis

Quando você define a opção Habilitar ambientes públicos para este laboratório para controlar o acesso a ambientes públicos para seu laboratório, todos os modelos de ambiente são selecionados por padrão. A configuração de opção permite ou não o acesso a todos os ambientes com base na sua seleção. Você pode usar as caixas de seleção na lista para especificar quais ambientes seus usuários podem acessar.

Siga estas etapas para permitir o acesso apenas a ambientes específicos para o laboratório:

1. Na página Ambientes públicos, defina a opção Habilitar ambientes públicos para este laboratório como Sim.

2. Desmarque ambientes específicos na lista para torná-los indisponíveis para usuários de laboratório:

   

3. Selecione Guardar.

Configurar direitos de usuário do ambiente

Por padrão, os usuários de laboratório recebem a função Leitor em repositórios de ambiente público. Eles não podem alterar os recursos do ambiente e não podem parar ou iniciar recursos.

Use as etapas a seguir para dar aos usuários do laboratório a função de Colaborador e permitir que eles editem recursos do ambiente:

1. No portal do Azure, vá para o recurso de laboratório do DevTest Labs onde você deseja ajustar as atribuições de função de usuário.

2. Na página Visão geral do laboratório, expanda a seção Configurações no menu à esquerda e selecione Configuração e políticas.

3. Na página Configuração e políticas, expanda a seção Configurações no menu à esquerda e selecione Configurações de laboratório.

4. Na página Configurações de laboratório, defina a opção Direitos de usuário do grupo de recursos de acesso>ao ambiente como Colaborador:

   

5. Selecione Guardar.

Automatizar a criação de ambientes

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

Os proprietários e administradores de laboratório podem usar o Azure PowerShell para criar VMs e ambientes a partir de modelos ARM. Você também pode automatizar a implantação por meio da CLI do Azure usando o comando az deployment group create para criar ambientes. Para obter mais informações, consulte Implantar recursos com modelos ARM e a CLI do Azure.

Nota

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

Automatize a implantação de modelo de ambiente ARM com o Azure PowerShell com estas etapas:

1. Armazene o modelo de ambiente ARM em um repositório GitHub.

2. Adicione o repositório de modelos ARM do GitHub ao seu laboratório.

3. Salve o seguinte script do PowerShell em seu computador com o nome de arquivo deployenv.ps1. Este script chama o modelo 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."
   

4. Atualize os seguintes espaços reservados no script com seus próprios valores de laboratório:

   • SubscriptionId
   • LabName
   • ResourceGroupName
   • RepositoryName
   • TemplateName (pasta de modelo no repositório GitHub)
   • EnvironmentName

   O trecho a seguir mostra como executar o script com valores de parâmetro de exemplo:

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

5. Execute o script.

Conteúdos relacionados

• Usar modelos ARM para criar máquinas virtuais do DevTest Labs
• Repositório de modelos de ambiente ARM público no GitHub
• Galeria de Modelos de Início Rápido do Azure no GitHub