Een virtuele Azure-machine implementeren met C# en een Resource Manager-sjabloon

Artikel
2017-07-14

In dit artikel leest u hoe u een Azure Resource Manager-sjabloon implementeert met behulp van C#. Met de sjabloon die u maakt, wordt één virtuele machine met Windows Server geïmplementeerd in een nieuw virtueel netwerk met één subnet.

Zie Virtuele machines in een Azure Resource Manager-sjabloonvoor een gedetailleerde beschrijving van de resource van de virtuele machine. Zie Overzicht van Azure Resource Manager-sjablonenvoor meer informatie over alle resources in een sjabloon.

Het duurt ongeveer 10 minuten om deze stappen uit te voeren.

Een Visual Studio-project maken

In deze stap zorgt u ervoor dat Visual Studio is geïnstalleerd en maakt u een consoletoepassing die wordt gebruikt om de sjabloon te implementeren.

Als u dat nog niet hebt gedaan, installeert u Visual Studio. Selecteer .NET-bureaubladontwikkeling op de pagina Workloads en klik vervolgens op Installeren. In de samenvatting ziet u dat .NET Framework 4 - 4.6-ontwikkelhulpprogramma's automatisch voor u worden geselecteerd. Als u Visual Studio al hebt geïnstalleerd, kunt u de .NET-workload toevoegen met behulp van het Startprogramma voor Visual Studio.
Klik in Visual Studio op File>New>Project.
Selecteer in Sjablonen>Visual C#console-app (.NET Framework), voer myDotnetProject in als naam van het project, selecteer de locatie van het project en klik vervolgens op OK.

De pakketten installeren

NuGet-pakketten zijn de eenvoudigste manier om de bibliotheken te installeren die u nodig hebt om deze stappen te voltooien. Voer de volgende stappen uit om de bibliotheken op te halen die u nodig hebt in Visual Studio:

Klik op Tools>Nuget Package Manager-en klik vervolgens op Package Manager Console.

Typ deze opdrachten in de console:

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

De bestanden maken

In deze stap maakt u een sjabloonbestand waarmee de resources en een parameterbestand worden geïmplementeerd dat parameterwaarden aan de sjabloon levert. U maakt ook een autorisatiebestand dat wordt gebruikt voor het uitvoeren van Azure Resource Manager-bewerkingen.

Het sjabloonbestand maken

Klik in Solution Explorer met de rechtermuisknop op myDotnetProject>Add>New Itemen selecteer Tekstbestand in Visual C#-items. Geef het bestand een naam CreateVMTemplate.jsonen klik vervolgens op Toevoegen.

Voeg deze JSON-code toe aan het bestand dat u hebt gemaakt:

{
  "$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')]"
            }
          ]
        }
      }
    }
  ]
}

Sla het CreateVMTemplate.json bestand op.

Het parameterbestand maken

Als u waarden wilt opgeven voor de resourceparameters in de sjabloon, maakt u een parameterbestand dat de waarden bevat.

Klik in Solution Explorer met de rechtermuisknop op myDotnetProject>Add>New Itemen selecteer Tekstbestand in Visual C#-items. Geef het bestand een naam Parameters.jsonen klik vervolgens op Toevoegen.

Voeg deze JSON-code toe aan het bestand dat u hebt gemaakt:

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

Sla het Parameters.json bestand op.

Het autorisatiebestand maken

Voordat u een sjabloon kunt implementeren, moet u ervoor zorgen dat u toegang hebt tot een Active Directory-service-principal. Van de service-principal verkrijgt u een token voor het verifiëren van aanvragen bij Azure Resource Manager. U moet ook de toepassings-id, de verificatiesleutel en de tenant-id vastleggen die u nodig hebt in het autorisatiebestand.

Klik in Solution Explorer met de rechtermuisknop op myDotnetProject>Add>New Itemen selecteer Tekstbestand in Visual C#-items. Geef het bestand de naam azureauth.propertiesen klik vervolgens op toevoegen.

Voeg deze autorisatie-eigenschappen toe:

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/

Vervang <abonnements-id> door uw abonnements-id, <toepassings-id> door de Active Directory-toepassings-id, <verificatiesleutel> door de toepassingssleutel en <tenant-id> met de tenant-id.

Sla het bestand azureauth.properties op.
Stel een omgevingsvariabele in Windows in met de naam AZURE_AUTH_LOCATION met het volledige pad naar het autorisatiebestand dat u hebt gemaakt, bijvoorbeeld met de volgende PowerShell-opdracht:
```
[Environment]::SetEnvironmentVariable("AZURE_AUTH_LOCATION", "C:\Visual Studio 2019\Projects\myDotnetProject\myDotnetProject\azureauth.properties", "User")
```

De beheerclient maken

Open het Program.cs-bestand voor het project dat u hebt gemaakt. Voeg deze using-instructies vervolgens toe aan de bestaande instructies boven aan het bestand:

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;

Als u de beheerclient wilt maken, voegt u deze code toe aan de main-methode:

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

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

Een brongroep maken

Als u waarden voor de toepassing wilt opgeven, voegt u code toe aan de main-methode:

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

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

Een opslagaccount maken

De sjabloon en parameters worden geïmplementeerd vanuit een opslagaccount in Azure. In deze stap maakt u het account en uploadt u de bestanden.

Als u het account wilt maken, voegt u deze code toe aan de main-methode:

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

De sjabloon implementeren

Implementeer de sjabloon en parameters van het opslagaccount dat is gemaakt.

Als u de sjabloon wilt implementeren, voegt u deze code toe aan de main-methode:

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

De bronnen verwijderen

Omdat er kosten in rekening worden gebracht voor resources die worden gebruikt in Azure, is het altijd raadzaam om resources te verwijderen die niet meer nodig zijn. U hoeft elke resource niet afzonderlijk van een resourcegroep te verwijderen. Verwijder de resourcegroep en alle bijbehorende resources worden automatisch verwijderd.

Als u de resourcegroep wilt verwijderen, voegt u deze code toe aan de main-methode:

azure.ResourceGroups.DeleteByName(groupName);

De toepassing uitvoeren

Het duurt ongeveer vijf minuten voordat deze consoletoepassing volledig van begin tot eind wordt uitgevoerd.

Klik op Startom de consoletoepassing uit te voeren.
Voordat u op Enter drukt om resources te verwijderen, kan het enkele minuten duren voordat u het maken van de resources in Azure Portal controleert. Klik op de implementatiestatus om informatie over de implementatie te bekijken.

Volgende stappen

Als er problemen zijn met de implementatie, is er een volgende stap om te kijken naar Veelvoorkomende Azure-implementatiefouten met Azure Resource Manager-oplossen.
Meer informatie over het implementeren van een virtuele machine en de bijbehorende ondersteunende resources door Een virtuele Azure-machine implementeren met C#-te bekijken.

Delen via