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

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). 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 como controla os custos para VMs de laboratório individuais.

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

Pré-requisitos

• É útil ter experiência na configuração de ambientes de laboratório no DevTest Labs. Se você não estiver familiarizado com o trabalho com laboratórios, comece revisando as instruções na seção Definir configurações de ambiente público. Você precisa saber 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 serem consideradas ao criar laboratórios a partir de modelos do ARM no DevTest Labs:

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

• O DevTest Labs não avalia todas as políticas de laboratório quando você implanta modelos do 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 do ARM que cria 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.

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

1. No portal do Azure, acesse o 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 esquerdo e selecione Meus ambientes.

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

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

   

5. No painel Adicionar, insira um nome de 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 do 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 do ARM (azuredeploy.parameters.json) produzem campos de configuração em branco no painel Adicionar (sem valor padrão). Esses valores de parâmetros 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 Azure Key Vault. Para saber como armazenar segredos em um cofre de chaves e usá-los ao criar recursos de laboratório, confira Armazenar segredos no Azure Key Vault.

6. Selecione Adicionar para criar o ambiente. O ambiente inicia o provisionamento imediatamente.

   Observação

   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.

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

   

   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. Você pode selecionar Atualizar na barra de ferramentas para atualizar o modo de exibição de página e verificar o status atual.

8. Quando o ambiente estiver pronto, você poderá expandir o ambiente 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 do ARM. Selecione o nome do ambiente na lista Meus ambientes para exibir o grupo de recursos e todos os recursos que o modelo criou:

   

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

    

Explorar repositórios de modelo

Os modelos do ARM para criar ambientes no DevTest Labs estão disponíveis em duas fontes:

• O Azure DevTest Labs tem um repositório de modelos do ARM públicos que inclui modelos de ambiente pré-criados para aplicativos Web do Azure, um cluster do Service Fabric do Azure e farms 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. Você também pode sugerir revisões ou adições a um modelo público enviando um pull request para o repositório de modelos públicos do GitHub.

• É possível armazenar modelos de ambiente em seus próprios repositórios GitHub 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.

Definir configurações de ambiente público

Configure seu laboratório para habilitar o uso de modelos do repositório GitHub de modelo público. Ao habilitar o repositório de modelos públicos para um laboratório, os usuários poderão criar rapidamente um ambiente de laboratório selecionando esses modelos diretamente no portal do Azure, da mesma forma que criam uma VM em um laboratório. Além disso, você pode selecionar quais modelos estarã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 de ambiente público para um novo laboratório seguindo estas etapas:

1. Durante o processo de criação de um recurso do 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 do 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 de ambiente público para qualquer laboratório existente:

1. No portal do Azure, acesse o recurso de laboratório do DevTest Labs no qual deseja definir o acesso ao ambiente público.

2. Na página Visão geral do seu 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áquina virtual 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 Salvar.

Selecionar modelos de ambiente público disponíveis

Ao definir a opção Habilitar Ambientes Públicos para este laboratório opção para controlar o acesso a ambientes públicos para seu laboratório, todos os modelos de ambiente serão selecionados por padrão. A configuração da opção permite ou não permite o acesso a todos os ambientes com base em 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 os usuários do laboratório:

   

3. Selecione Salvar.

Configurar direitos de usuário de ambiente

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

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

1. No portal do Azure, acesse o recurso de laboratório do DevTest Labs no qual deseja ajustar as atribuições de função do usuário.

2. Na página Visão geral do seu 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 do laboratório.

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

   

5. Selecione Salvar.

Automatize a criação de ambientes

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.

Os proprietários e os administradores do laboratório podem usar o Azure PowerShell para criar VMs e ambientes de modelos do 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, confira Implantar recursos com modelos do ARM e a CLI do Azure.

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

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

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

3. Salve o script do PowerShell a seguir em seu computador com o nome de arquivo 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."
   

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 snippet 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údo relacionado

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