Implemente uma máquina virtual Azure usando C# e um modelo de Resource Manager

Artigo
07/14/2017

Este artigo mostra-lhe como implementar um modelo de Resource Manager Azure usando C#. O modelo que cria implementa uma única máquina virtual que executa Windows Server numa nova rede virtual com uma única sub-rede.

Para obter uma descrição detalhada do recurso da máquina virtual, consulte máquinas virtuais num modelo de Resource Manager Azure. Para obter mais informações sobre todos os recursos em um modelo, consulte Azure Resource Manager modelo walkthrough.

Leva cerca de 10 minutos para fazer estes passos.

Criar um projeto do Visual Studio

Neste passo, certifique-se de que Visual Studio está instalado e cria uma aplicação de consola usada para implementar o modelo.

Se ainda não o fez, instale Visual Studio. Selecione o desenvolvimento do ambiente de trabalho .NET na página Workloads e, em seguida, clique em Instalar. No resumo, pode ver que .NET Framework ferramentas de desenvolvimento 4 - 4.6 são automaticamente selecionadas para si. Se já tiver instalado Visual Studio, pode adicionar a carga de trabalho .NET utilizando o Visual Studio Launcher.
Em Visual Studio, clique em FileNew>>Project.
Em ModelosVisual>C#, selecione App de Consola (.NET Framework), insira o myDotnetProject para o nome do projeto, selecione a localização do projeto e, em seguida, clique em OK.

Instalar as embalagens

Os pacotes NuGet são a forma mais fácil de instalar as bibliotecas que precisa para terminar estes passos. Para obter as bibliotecas de que precisa em Visual Studio, faça estes passos:

Clique em FerramentasNuget> Gestor de Pacotes e, em seguida, clique Gestor de Pacotes Consola.

Digite estes comandos na consola:

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

Criar os ficheiros

Neste passo, você cria um ficheiro de modelo que implementa os recursos e um arquivo de parâmetros que fornece valores de parâmetros para o modelo. Também cria um ficheiro de autorização que é utilizado para executar operações de Resource Manager Azure.

Criar o ficheiro de modelo

Em Explorador de Soluções, clique com Explorador de Soluções à direita no myDotnetProjectAddNew>>Item e, em seguida, selecione O Ficheiro de Texto em Itens C# Visuais. Nomeie o ficheiro CreateVMTemplate.json e, em seguida, clique em Adicionar.

Adicione este código JSON ao ficheiro que 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')]"
            }
          ]
        }
      }
    }
  ]
}

Guarde o ficheiro CreateVMTemplate.json.

Criar o ficheiro de parâmetros

Para especificar valores para os parâmetros de recurso no modelo, cria um ficheiro de parâmetros que contém os valores.

Em Explorador de Soluções, clique com Explorador de Soluções à direita no myDotnetProjectAddNew>>Item e, em seguida, selecione O Ficheiro de Texto em Itens C# Visuais. Nomeie o ficheiro Parâmetros.json e, em seguida, clique em Adicionar.

Adicione este código JSON ao ficheiro que 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" }
  }
}

Guarde o ficheiro Parâmetros.json.

Criar o ficheiro de autorização

Antes de poder implementar um modelo, certifique-se de que tem acesso a um diretor de serviço do Ative Directory. A partir do diretor de serviço, você adquire um símbolo para autenticação de pedidos para Azure Resource Manager. Deve também registar o ID do pedido, a chave de autenticação e a identificação do inquilino que precisa no ficheiro de autorização.

Em Explorador de Soluções, clique com Explorador de Soluções à direita no myDotnetProjectAddNew>>Item e, em seguida, selecione O Ficheiro de Texto em Itens C# Visuais. Nomeie o ficheiro 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 <o id> de subscrição pelo seu identificador de subscrição, <id> de aplicação pelo identificador de aplicação ative, <chave> de autenticação com a chave de aplicação e <id> do inquilino pelo identificador do inquilino.
Guarde o ficheiro azureauth.properties.
Desaprove uma variável ambiental em Windows nomeado AZURE_AUTH_LOCATION com o caminho completo para o ficheiro de autorização que criou, por exemplo, pode utilizar o seguinte comando PowerShell:
```
[Environment]::SetEnvironmentVariable("AZURE_AUTH_LOCATION", "C:\Visual Studio 2019\Projects\myDotnetProject\myDotnetProject\azureauth.properties", "User")
```

Criar o cliente de gestão

Abra o ficheiro .cs Programa para o projeto que criou. Em seguida, adicione estas declarações usando as declarações existentes no topo do ficheiro:

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 gestão, adicione este código ao método principal:

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 os valores para a aplicação, adicione código ao método principal:

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 a partir de uma conta de armazenamento em Azure. Neste passo, cria-se a conta e faz o upload dos ficheiros.

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

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();

Implementar o modelo

Implemente o modelo e os parâmetros a partir da conta de armazenamento que foi criada.

Para implementar o modelo, adicione este código ao método principal:

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();

Eliminar os recursos

Por ser cobrado pelos recursos utilizados no Azure, é sempre uma boa prática apagar recursos que já não são necessários. Não é necessário eliminar cada recurso separadamente de um grupo de recursos. Eliminar o grupo de recursos e todos os seus recursos são automaticamente eliminados.

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

azure.ResourceGroups.DeleteByName(groupName);

Executar a aplicação

Deve levar cerca de cinco minutos para que esta aplicação da consola seja executada completamente do início ao fim.

Para executar a aplicação da consola, clique em Iniciar.
Antes de pressionar Enter para começar a apagar recursos, pode demorar alguns minutos a verificar a criação dos recursos no portal do Azure. Clique no estado de implementação para ver informações sobre a implementação.

Passos seguintes

Se houvesse problemas com a implantação, um passo seguinte seria analisar os erros comuns de implantação do Azure com o Azure Resource Manager.
Saiba como implementar uma máquina virtual e os seus recursos de suporte através da revisão implementar uma máquina virtual Azure usando C#.

Partilhar via