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

Artikel
07/14/2017

In dit artikel wordt beschreven hoe u een Azure Resource Manager 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 voor een gedetailleerde beschrijving van de virtuele-machineresource. Zie azure Resource Manager template walkthrough (Overzicht van Azure Resource Manager-sjablonen) voor 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 Visual Studio. Selecteer .NET-desktopontwikkeling 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 is geselecteerd. Als u al een Visual Studio hebt geïnstalleerd, kunt u de .NET-workload toevoegen met behulp van Visual Studio Launcher.
Klik in Visual Studio op File>New>Project.
> Selecteer console-app (.NET Framework) in SjablonenVisual C#, 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. Als u de bibliotheken wilt op halen die u nodig hebt in Visual Studio, moet u deze stappen volgen:

Klik opExtraNuget> Pakketbeheer en klik vervolgens op Pakketbeheer 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 dat de resources implementeert en een parameterbestand dat parameterwaarden aan de sjabloon levert. U maakt ook een autorisatiebestand dat wordt gebruikt om Azure-Resource Manager uitvoeren.

Het sjabloonbestand maken

Klik Solution Explorer met de rechtermuisknop op myDotnetProjectAddNew>>Item en selecteer vervolgens Tekstbestand in Visual C#-items. Noem het bestand CreateVMTemplate.json en 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 bestand CreateVMTemplate.json op.

Het parametersbestand maken

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

Klik Solution Explorer met de rechtermuisknop op myDotnetProjectAddNew>>Item en selecteer vervolgens Tekstbestand in Visual C#-items. Noem het bestand Parameters.json en 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 bestand Parameters.json op.

Het autorisatiebestand maken

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

Klik Solution Explorer met de rechtermuisknop op myDotnetProjectAddNew>>Item en selecteer vervolgens Tekstbestand in Visual C#-items. Noem het bestand azureauth.properties en 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 <subscription-id> door uw abonnements-id, <application-id> door de Active Directory-toepassings-id,< authentication-key><door de toepassingssleutel en tenant-id> door de tenant-id.

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

De beheerclient maken

Open het bestand Program.cs 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 methode Main:

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

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

Een resourcegroep maken

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

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

De sjabloon implementeren

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

Als u de sjabloon wilt implementeren, voegt u deze code toe aan de methode 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();

De resources verwijderen

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

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

azure.ResourceGroups.DeleteByName(groupName);

De toepassing uitvoeren

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

Klik op Start om de consoletoepassing uit te voeren.
Voordat u op Enter drukt om te beginnen met het verwijderen van resources, kan het enkele minuten duren om te controleren of de resources in de Azure Portal. Klik op de implementatiestatus voor informatie over de implementatie.

Volgende stappen

Als er problemen zijn met de implementatie, is een volgende stap te kijken naar Veelvoorkomende fouten bij azure-implementaties oplossen met Azure Resource Manager.
Lees Deploy an Azure Virtual Machine Using C# (Een virtuele Azure-machine implementeren met C#) voor meer informatie over het implementeren van een virtuele machine en de ondersteunende resources.

Delen via