Implantar uma Máquina Virtual do Azure usando C# e um modelo do Resource Manager

Artigo
07/14/2017

Este artigo mostra como implantar um modelo do Azure Resource Manager usando o C#. O modelo criado implanta uma única máquina virtual que executa o Windows Server em uma nova rede virtual com uma única sub-rede.

Para obter uma descrição detalhada do recurso de máquina virtual, confira Virtual machines in an Azure Resource Manager template (Máquinas virtuais em um modelo do Azure Resource Manager). Para saber mais sobre todos os recursos em um modelo, confira Passo a passo do modelo do Azure Resource Manager.

São necessários cerca de 10 minutos para a conclusão destas etapas.

Criar um projeto do Visual Studio

Nesta etapa, você verifica se o Visual Studio está instalado e cria um aplicativo de console usado para implantar o modelo.

Se você ainda não fez isso, instale o Visual Studio. Selecione Desenvolvimento para desktop com o .NET na página Cargas de trabalho e, em seguida, clique em Instalar. No resumo, é possível verificar que as ferramentas de desenvolvimento do .NET Framework 4 - 4.6 são automaticamente selecionadas. Se o Visual Studio já estiver instalado, você poderá adicionar a carga de trabalho .NET utilizando o Iniciador do Visual Studio.
No Visual Studio, clique em Arquivo>Novo>Projeto.
Em Modelos>Visual C# , selecione Aplicativo de Console (.NET Framework) , digite myDotnetProject para o nome do projeto, selecione o local do projeto e, em seguida, clique em OK.

Instalar os pacotes

Os pacotes NuGet são a maneira mais fácil de instalar as bibliotecas de que você precisa para concluir estas etapas. Para obter as bibliotecas que você precisa no Visual Studio, siga estas etapas:

Clique em Ferramentas>Gerenciador de Pacotes Nuget e em Console do Gerenciador de Pacotes.

Digite os seguintes comandos no console:

Install-Package Microsoft.Azure.Management.Fluent
Install-Package WindowsAzure.Storage

Criar os arquivos

Nesta etapa, você cria um arquivo de modelo que implanta os recursos e um arquivo de parâmetros que fornece valores de parâmetro para o modelo. Você também cria um arquivo de autorização que é usado para executar operações do Azure Resource Manager.

Criar o arquivo de modelo

No Gerenciador de Soluções, clique com o botão direito do mouse em myDotnetProject>Adicionar>Novo Item e, em seguida, selecione Arquivo de Texto em Itens do Visual C# . Nomeie o arquivo CreateVMTemplate.json e, em seguida, clique em Adicionar.

Adicione este código JSON ao arquivo que você criou:

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "adminUsername": { "type": "string" },
    "adminPassword": { "type": "securestring" }
  },
  "variables": {
    "vnetID": "[resourceId('Microsoft.Network/virtualNetworks','myVNet')]", 
    "subnetRef": "[concat(variables('vnetID'),'/subnets/mySubnet')]", 
  },
  "resources": [
    {
      "apiVersion": "2016-03-30",
      "type": "Microsoft.Network/publicIPAddresses",
      "name": "myPublicIPAddress",
      "location": "[resourceGroup().location]",
      "properties": {
        "publicIPAllocationMethod": "Dynamic",
        "dnsSettings": {
          "domainNameLabel": "myresourcegroupdns1"
        }
      }
    },
    {
      "apiVersion": "2016-03-30",
      "type": "Microsoft.Network/virtualNetworks",
      "name": "myVNet",
      "location": "[resourceGroup().location]",
      "properties": {
        "addressSpace": { "addressPrefixes": [ "10.0.0.0/16" ] },
        "subnets": [
          {
            "name": "mySubnet",
            "properties": { "addressPrefix": "10.0.0.0/24" }
          }
        ]
      }
    },
    {
      "apiVersion": "2016-03-30",
      "type": "Microsoft.Network/networkInterfaces",
      "name": "myNic",
      "location": "[resourceGroup().location]",
      "dependsOn": [
        "[resourceId('Microsoft.Network/publicIPAddresses/', 'myPublicIPAddress')]",
        "[resourceId('Microsoft.Network/virtualNetworks/', 'myVNet')]"
      ],
      "properties": {
        "ipConfigurations": [
          {
            "name": "ipconfig1",
            "properties": {
              "privateIPAllocationMethod": "Dynamic",
              "publicIPAddress": { "id": "[resourceId('Microsoft.Network/publicIPAddresses','myPublicIPAddress')]" },
              "subnet": { "id": "[variables('subnetRef')]" }
            }
          }
        ]
      }
    },
    {
      "apiVersion": "2016-04-30-preview",
      "type": "Microsoft.Compute/virtualMachines",
      "name": "myVM",
      "location": "[resourceGroup().location]",
      "dependsOn": [
        "[resourceId('Microsoft.Network/networkInterfaces/', 'myNic')]"
      ],
      "properties": {
        "hardwareProfile": { "vmSize": "Standard_DS1" },
        "osProfile": {
          "computerName": "myVM",
          "adminUsername": "[parameters('adminUsername')]",
          "adminPassword": "[parameters('adminPassword')]"
        },
        "storageProfile": {
          "imageReference": {
            "publisher": "MicrosoftWindowsServer",
            "offer": "WindowsServer",
            "sku": "2012-R2-Datacenter",
            "version": "latest"
          },
          "osDisk": {
            "name": "myManagedOSDisk",
            "caching": "ReadWrite",
            "createOption": "FromImage"
          }
        },
        "networkProfile": {
          "networkInterfaces": [
            {
              "id": "[resourceId('Microsoft.Network/networkInterfaces','myNic')]"
            }
          ]
        }
      }
    }
  ]
}

Salve o arquivo CreateVMTemplate.json.

Criar o arquivo de parâmetros

Para especificar valores para os parâmetros de recursos no modelo, você cria um arquivo de parâmetros que contém os valores.

No Gerenciador de Soluções, clique com o botão direito do mouse em myDotnetProject>Adicionar>Novo Item e, em seguida, selecione Arquivo de Texto em Itens do Visual C# . Nomeie o arquivo Parameters.json e, em seguida, clique em Adicionar.

Adicione este código JSON ao arquivo que você criou:

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "adminUserName": { "value": "azureuser" },
    "adminPassword": { "value": "Azure12345678" }
  }
}

Salve o arquivo Parameters.json.

Criar o arquivo de autorização

Antes de poder implantar um modelo, verifique se você tem acesso a uma entidade de serviço do Active Directory. Na entidade de serviço, você adquire um token para autenticar as solicitações para o Azure Resource Manager. Além disso, registre a ID do aplicativo, a chave de autenticação e a ID do locatário de que você precisa no arquivo de autorização.

No Gerenciador de Soluções, clique com o botão direito do mouse em myDotnetProject>Adicionar>Novo Item e, em seguida, selecione Arquivo de Texto em Itens do Visual C# . Nomeie o arquivo azureauth.properties e, em seguida, clique em Adicionar.
Adicione estas propriedades de autorização:
```
subscription=<subscription-id>
client=<application-id>
key=<authentication-key>
tenant=<tenant-id>
managementURI=https://management.core.windows.net/
baseURL=https://management.azure.com/
authURL=https://login.windows.net/
graphURL=https://graph.microsoft.com/
```
Substitua <subscription-id> pelo identificador da assinatura, <application-id> pelo identificador de aplicativo do Active Directory, <authentication-key> pela chave do aplicativo e <tenant-id> pelo identificador do locatário.
Salve o arquivo azureauth.properties.
Defina uma variável de ambiente no Windows chamada AZURE_AUTH_LOCATION com o caminho completo para o arquivo de autorização que você criou, por exemplo, é possível usar o seguinte comando do PowerShell:
```
[Environment]::SetEnvironmentVariable("AZURE_AUTH_LOCATION", "C:\Visual Studio 2019\Projects\myDotnetProject\myDotnetProject\azureauth.properties", "User")
```

Criar o cliente de gerenciamento

Abra o arquivo Program.cs do projeto que você criou. Adicione estas instruções de uso às instruções existentes na parte superior do arquivo:

using Microsoft.Azure.Management.Compute.Fluent;
using Microsoft.Azure.Management.Compute.Fluent.Models;
using Microsoft.Azure.Management.Fluent;
using Microsoft.Azure.Management.ResourceManager.Fluent;
using Microsoft.Azure.Management.ResourceManager.Fluent.Core;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;

Para criar o cliente de gerenciamento, adicione este código ao método Main:

var credentials = SdkContext.AzureCredentialsFactory
    .FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));

var azure = Azure
    .Configure()
    .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
    .Authenticate(credentials)
    .WithDefaultSubscription();

Criar um grupo de recursos

Para especificar valores para o aplicativo, adicione código ao método Main:

var groupName = "myResourceGroup";
var location = Region.USWest;

var resourceGroup = azure.ResourceGroups.Define(groupName)
    .WithRegion(location)
    .Create();

Criar uma conta de armazenamento

O modelo e os parâmetros são implantados por meio de uma conta de armazenamento no Azure. Nesta etapa, você cria a conta e carrega os arquivos.

Para criar a conta, adicione este código ao método Main:

string storageAccountName = SdkContext.RandomResourceName("st", 10);

Console.WriteLine("Creating storage account...");
var storage = azure.StorageAccounts.Define(storageAccountName)
    .WithRegion(Region.USWest)
    .WithExistingResourceGroup(resourceGroup)
    .Create();

var storageKeys = storage.GetKeys();
string storageConnectionString = "DefaultEndpointsProtocol=https;"
    + "AccountName=" + storage.Name
    + ";AccountKey=" + storageKeys[0].Value
    + ";EndpointSuffix=core.windows.net";

var account = CloudStorageAccount.Parse(storageConnectionString);
var serviceClient = account.CreateCloudBlobClient();

Console.WriteLine("Creating container...");
var container = serviceClient.GetContainerReference("templates");
container.CreateIfNotExistsAsync().Wait();
var containerPermissions = new BlobContainerPermissions()
    { PublicAccess = BlobContainerPublicAccessType.Container };
container.SetPermissionsAsync(containerPermissions).Wait();

Console.WriteLine("Uploading template file...");
var templateblob = container.GetBlockBlobReference("CreateVMTemplate.json");
templateblob.UploadFromFileAsync("..\\..\\CreateVMTemplate.json").Result();

Console.WriteLine("Uploading parameters file...");
var paramblob = container.GetBlockBlobReference("Parameters.json");
paramblob.UploadFromFileAsync("..\\..\\Parameters.json").Result();

Implantar o modelo

Implante o modelo e os parâmetros da conta de armazenamento que foi criada.

Para implantar o modelo, adicione este código ao método Main:

var templatePath = "https://" + storageAccountName + ".blob.core.windows.net/templates/CreateVMTemplate.json";
var paramPath = "https://" + storageAccountName + ".blob.core.windows.net/templates/Parameters.json";
var deployment = azure.Deployments.Define("myDeployment")
    .WithExistingResourceGroup(groupName)
    .WithTemplateLink(templatePath, "1.0.0.0")
    .WithParametersLink(paramPath, "1.0.0.0")
    .WithMode(Microsoft.Azure.Management.ResourceManager.Fluent.Models.DeploymentMode.Incremental)
    .Create();
Console.WriteLine("Press enter to delete the resource group...");
Console.ReadLine();

Excluir os recursos

Como você é cobrado pelos recursos utilizados no Azure, sempre é uma boa prática excluir os recursos que não são mais necessários. Você não precisa excluir cada recurso separadamente de um grupo de recursos. Exclua o grupo de recursos e todos os seus recursos serão excluídos automaticamente.

Para excluir o grupo de recursos, adicione este código ao método Main:

azure.ResourceGroups.DeleteByName(groupName);

Executar o aplicativo

Devem ser necessários cerca de cinco minutos para o aplicativo de console executar completamente do início ao fim.

Para executar o aplicativo de console, clique em Iniciar.
Antes de pressionar Enter para iniciar a exclusão de recursos, reserve alguns minutos para verificar a criação dos recursos no portal do Azure. Clique no status de implantação para ver informações sobre a implantação.

Próximas etapas

Se houver problemas com a implantação, a próxima etapa será examinar Troubleshoot common Azure deployment errors with Azure Resource Manager (Solucionar erros comuns de implantação do Azure com o Azure Resource Manager).
Saiba como implantar uma máquina virtual e seus recursos de suporte examinando Implantar uma máquina virtual do Azure usando o C#.

Compartilhar via