Distribuire una macchina virtuale di Azure con C# e un modello di Azure Resource ManagerDeploy an Azure Virtual Machine using C# and a Resource Manager template

Questo articolo descrive come distribuire un modello di Azure Resource Manager tramite C#.This article shows you how to deploy an Azure Resource Manager template using C#. Il modello creato consente di distribuire una singola macchina virtuale che esegue Windows Server in una nuova rete virtuale con un'unica subnet.The template that you create deploys a single virtual machine running Windows Server in a new virtual network with a single subnet.

Per una descrizione dettagliata della risorsa macchina virtuale, vedere Virtual machines in an Azure Resource Manager template (Macchine virtuali in un modello di Azure Resource Manager).For a detailed description of the virtual machine resource, see Virtual machines in an Azure Resource Manager template. Per altre informazioni su tutte le risorse in un modello, vedere Azure Resource Manager template walkthrough (Procedura dettagliata sui modelli di Azure Resource Manager).For more information about all the resources in a template, see Azure Resource Manager template walkthrough.

L'esecuzione di questi passaggi richiede circa 10 minuti.It takes about 10 minutes to do these steps.

Creare un progetto di Visual StudioCreate a Visual Studio project

In questo passaggio, ci si assicura che Visual Studio sia installato e si crea un'applicazione console da usare per distribuire il modello.In this step, you make sure that Visual Studio is installed and you create a console application used to deploy the template.

  1. Se non è già installato, installare Visual Studio.If you haven't already, install Visual Studio. Selezionare Sviluppo per desktop .NET nella pagina Carichi di lavoro e quindi fare clic su Installa.Select .NET desktop development on the Workloads page, and then click Install. Nel riepilogo si noti che Strumenti di sviluppo per .NET Framework 4-4.6 viene selezionato automaticamente.In the summary, you can see that .NET Framework 4 - 4.6 development tools is automatically selected for you. Se Visual Studio è già stato installato, è possibile aggiungere il carico di lavoro .NET usando l'utilità di avvio di Visual Studio.If you have already installed Visual Studio, you can add the .NET workload using the Visual Studio Launcher.
  2. In Visual Studio fare clic su File > Nuovo > Progetto.In Visual Studio, click File > New > Project.
  3. In Modelli > Visual C# selezionare App console (.NET Framework), immettere myDotnetProject come nome del progetto, selezionare il percorso del progetto e quindi fare clic su OK.In Templates > Visual C#, select Console App (.NET Framework), enter myDotnetProject for the name of the project, select the location of the project, and then click OK.

Installare i pacchettiInstall the packages

I pacchetti NuGet sono il modo più semplice per installare le librerie necessarie per completare questi passaggi.NuGet packages are the easiest way to install the libraries that you need to finish these steps. Per ottenere le librerie necessarie in Visual Studio, eseguire questa procedura:To get the libraries that you need in Visual Studio, do these steps:

  1. Fare clic su Strumenti > Gestione pacchetti Nuget e quindi su Console di Gestione Pacchetti.Click Tools > Nuget Package Manager, and then click Package Manager Console.
  2. Nella console digitare questi comandi:Type these commands in the console:

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

Creare i fileCreate the files

In questo passaggio si crea un file di modello che consente di distribuire le risorse e un file di parametri che fornisce i valori dei parametri nel modello.In this step, you create a template file that deploys the resources and a parameters file that supplies parameter values to the template. È possibile anche creare un file di autorizzazione da usare per eseguire operazioni in Azure Resource Manager.You also create an authorization file that is used to perform Azure Resource Manager operations.

Creare il file di modelloCreate the template file

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su myDotnetProject > Aggiungi > Nuovo elemento e quindi selezionare File di testo in Elementi di Visual C#.In Solution Explorer, right-click myDotnetProject > Add > New Item, and then select Text File in Visual C# Items. Assegnare un nome al file CreateVMTemplate.json e quindi fare clic su Aggiungi.Name the file CreateVMTemplate.json, and then click Add.
  2. Aggiungere questo codice JSON al file appena creato:Add this JSON code to the file that you created:

    {
      "$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')]"
                }
              ]
            }
          }
        }
      ]
    }
    
  3. Salvare il file CreateVMTemplate.json.Save the CreateVMTemplate.json file.

Creare il file dei parametriCreate the parameters file

Per specificare i valori per i parametri delle risorse definiti nel modello, creare un file dei parametri contenente i valori.To specify values for the resource parameters that are defined in the template, you create a parameters file that contains the values.

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su myDotnetProject > Aggiungi > Nuovo elemento e quindi selezionare File di testo in Elementi di Visual C#.In Solution Explorer, right-click myDotnetProject > Add > New Item, and then select Text File in Visual C# Items. Assegnare un nome al file Parameters.json e quindi fare clic su Aggiungi.Name the file Parameters.json, and then click Add.
  2. Aggiungere questo codice JSON al file appena creato:Add this JSON code to the file that you created:

    {
      "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json",
      "contentVersion": "1.0.0.0",
      "parameters": {
        "adminUserName": { "value": "azureuser" },
        "adminPassword": { "value": "Azure12345678" }
      }
    }
    
  3. Salvare il file Parameters.json.Save the Parameters.json file.

Creare il file di autorizzazioneCreate the authorization file

Prima di poter distribuire un modello, è necessario assicurarsi di avere accesso a un'entità servizio Active Directory.Before you can deploy a template, make sure that you have access to an Active Directory service principal. Dall'entità servizio si acquisisce un token per autenticare le richieste ad Azure Resource Manager.From the service principal, you acquire a token for authenticating requests to Azure Resource Manager. È necessario anche registrare l'ID dell'applicazione, la chiave di autenticazione e l'ID del tenant necessari nel file di autorizzazione.You should also record the application ID, the authentication key, and the tenant ID that you need in the authorization file.

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su myDotnetProject > Aggiungi > Nuovo elemento e quindi selezionare File di testo in Elementi di Visual C#.In Solution Explorer, right-click myDotnetProject > Add > New Item, and then select Text File in Visual C# Items. Assegnare al file il nome azureauth.properties e quindi fare clic su Aggiungi.Name the file azureauth.properties, and then click Add.
  2. Aggiungere le proprietà di autorizzazione seguenti:Add these authorization properties:

    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.windows.net/
    

    Sostituire <subscription-id> con l'identificatore della sottoscrizione, <application-id> con l'identificatore dell'applicazione Active Directory, <authentication-key> con la chiave dell'applicazione e <tenant-id> con l'identificatore del tenant.Replace <subscription-id> with your subscription identifier, <application-id> with the Active Directory application identifier, <authentication-key> with the application key, and <tenant-id> with the tenant identifier.

  3. Salvare il file azureauth.properties.Save the azureauth.properties file.

  4. Impostare una variabile di ambiente Windows denominata AZURE_AUTH_LOCATION con il percorso completo al file di autorizzazione creato. È possibile usare, ad esempio, il comando PowerShell seguente:Set an environment variable in Windows named AZURE_AUTH_LOCATION with the full path to authorization file that you created, for example the following PowerShell command can be used:

    [Environment]::SetEnvironmentVariable("AZURE_AUTH_LOCATION", "C:\Visual Studio 2017\Projects\myDotnetProject\myDotnetProject\azureauth.properties", "User")
    

Creare il client di gestioneCreate the management client

  1. Aprire il file Program.cs per il progetto creato e quindi aggiungere le istruzioni using seguenti alle istruzioni esistenti all'inizio del file:Open the Program.cs file for the project that you created, and then add these using statements to the existing statements at top of the file:

    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;
    
  2. Per creare il client di gestione, aggiungere questo codice al metodo Main:To create the management client, add this code to the Main method:

    var credentials = SdkContext.AzureCredentialsFactory
        .FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
    
    var azure = Azure
        .Configure()
        .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
        .Authenticate(credentials)
        .WithDefaultSubscription();
    

Creare un gruppo di risorseCreate a resource group

Per specificare i valori per l'applicazione, aggiungere il codice necessario al metodo Main:To specify values for the application, add code to the Main method:

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

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

Creare un account di archiviazioneCreate a storage account

Il modello e i parametri vengono distribuiti da un account di archiviazione in Azure.The template and parameters are deployed from a storage account in Azure. In questo passaggio si creerà l'account e si caricheranno i file.In this step, you create the account and upload the files.

Per creare l'account, aggiungere questo codice al metodo Main:To create the account, add this code to the Main method:

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.UploadFromFile("..\\..\\CreateVMTemplate.json");

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

Distribuire il modelloDeploy the template

Distribuire il modello e i parametri dall'account di archiviazione appena creato.Deploy the template and parameters from the storage account that was created.

Per distribuire il modello, aggiungere questo codice al metodo Main:To deploy the template, add this code to the Main method:

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

Eliminare le risorseDelete the resources

Poiché vengono applicati addebiti per le risorse usate in Azure, è sempre consigliabile eliminare le risorse che non sono più necessarie.Because you are charged for resources used in Azure, it is always good practice to delete resources that are no longer needed. Non è necessario eliminare separatamente ogni risorsa da un gruppo di risorse.You don’t need to delete each resource separately from a resource group. Eliminando il gruppo di risorse, tutte le relative risorse verranno eliminate automaticamente.Delete the resource group and all its resources are automatically deleted.

Per eliminare il gruppo di risorse, aggiungere questo codice al metodo Main:To delete the resource group, add this code to the Main method:

azure.ResourceGroups.DeleteByName(groupName);

Eseguire l'applicazioneRun the application

L'esecuzione completa dell'applicazione console dall'inizio alla fine richiederà circa cinque minuti.It should take about five minutes for this console application to run completely from start to finish.

  1. Per eseguire l'applicazione console, fare clic su Avvia.To run the console application, click Start.

  2. Prima di premere INVIO per avviare l'eliminazione delle risorse, è consigliabile dedicare alcuni minuti alla verifica della creazione delle risorse nel Portale di Azure.Before you press Enter to start deleting resources, you could take a few minutes to verify the creation of the resources in the Azure portal. Fare clic sullo stato della distribuzione per visualizzare le informazioni corrispondenti.Click the deployment status to see information about the deployment.

Passaggi successiviNext steps