Creare e gestire macchine virtuali Windows in Azure usando PythonCreate and manage Windows VMs in Azure using Python

Una macchina virtuale di Azure (VM) richiede diverse risorse di supporto di Azure.An Azure Virtual Machine (VM) needs several supporting Azure resources. Questo articolo descrive come creare, gestire ed eliminare le risorse della macchina virtuale usando Python.This article covers creating, managing, and deleting VM resources using Python. Si apprenderà come:You learn how to:

  • Creare un progetto di Visual StudioCreate a Visual Studio project
  • Installare i pacchettiInstall packages
  • Creare le credenzialiCreate credentials
  • Creare le risorseCreate resources
  • Eseguire le attività di gestionePerform management tasks
  • Eliminare le risorseDelete resources
  • Eseguire l'applicazioneRun the application

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

Creare un progetto di Visual StudioCreate a Visual Studio project

  1. Se non è già installato, installare Visual Studio.If you haven't already, install Visual Studio. Selezionare Sviluppo Python nella pagina Carichi di lavoro e quindi fare clic su Installa.Select Python development on the Workloads page, and then click Install. Nel riepilogo si noti che Python 3 a 64 bit (3.6.0) viene selezionato automaticamente.In the summary, you can see that Python 3 64-bit (3.6.0) is automatically selected for you. Se Visual Studio è già stato installato, è possibile aggiungere il carico di lavoro Python usando l'utilità di avvio di Visual Studio.If you have already installed Visual Studio, you can add the Python workload using the Visual Studio Launcher.
  2. Dopo aver installato e avviato Visual Studio, fare clic su File > Nuovo > Progetto.After installing and starting Visual Studio, click File > New > Project.
  3. Fare clic su Modelli > Python > Applicazione Python, immettere myPythonProject come nome del progetto, selezionare il percorso del progetto e quindi fare clic su OK.Click Templates > Python > Python Application, enter myPythonProject for the name of the project, select the location of the project, and then click OK.

Installare i pacchettiInstall packages

  1. In Esplora soluzioni, in myPythonProject, fare clic con il pulsante destro del mouse su Ambienti Python e quindi selezionare Aggiungi ambiente virtuale.In Solution Explorer, under myPythonProject, right-click Python Environments, and then select Add virtual environment.
  2. Nella schermata Aggiungi ambiente virtuale accettare il nome predefinito env, verificare che Python 3.6 (64 bit) sia selezionato per l'interprete di base e quindi fare clic su Crea.On the Add Virtual Environment screen, accept the default name of env, make sure that Python 3.6 (64-bit) is selected for the base interpreter, and then click Create.
  3. Fare clic con il pulsante destro del mouse sull'ambiente env appena creato, fare clic su Installa pacchetto Python, immettere azure nella casella di ricerca e quindi premere INVIO.Right-click the env environment that you created, click Install Python Package, enter azure in the search box, and then press Enter.

La corretta installazione dei pacchetti di Azure verrà indicata nelle finestre di output.You should see in the output windows that the azure packages were successfully installed.

Creare le credenzialiCreate credentials

Prima di iniziare questo passaggio, verificare di disporre di un'entità servizio Active Directory.Before you start this step, make sure that you have an Active Directory service principal. È inoltre necessario registrare l'ID dell'applicazione, la chiave di autenticazione e l'ID del tenant che saranno necessari in un passaggio successivo.You should also record the application ID, the authentication key, and the tenant ID that you need in a later step.

  1. Aprire il file myPythonProject.py che è stato creato e quindi aggiungere questo codice per consentire l'esecuzione dell'applicazione:Open myPythonProject.py file that was created, and then add this code to enable your application to run:

    if __name__ == "__main__":
    
  2. Per importare il codice necessario, aggiungere queste istruzioni all'inizio del file con estensione py:To import the code that is needed, add these statements to the top of the .py file:

    from azure.common.credentials import ServicePrincipalCredentials
    from azure.mgmt.resource import ResourceManagementClient
    from azure.mgmt.compute import ComputeManagementClient
    from azure.mgmt.network import NetworkManagementClient
    from azure.mgmt.compute.models import DiskCreateOption
    
  3. Nel file con estensione py aggiungere quindi le variabili dopo le istruzioni di importazione per specificare i valori comuni usati nel codice:Next in the .py file, add variables after the import statements to specify common values used in the code:

    SUBSCRIPTION_ID = 'subscription-id'
    GROUP_NAME = 'myResourceGroup'
    LOCATION = 'westus'
    VM_NAME = 'myVM'
    

    Sostituire subscription-id con l'identificatore della sottoscrizione.Replace subscription-id with your subscription identifier.

  4. Per creare le credenziali di Active Directory necessarie per inoltrare le richieste, aggiungere questa funzione dopo le variabili nel file con estensione py:To create the Active Directory credentials that you need to make requests, add this function after the variables in the .py file:

    def get_credentials():
        credentials = ServicePrincipalCredentials(
            client_id = 'application-id',
            secret = 'authentication-key',
            tenant = 'tenant-id'
        )
    
        return credentials
    

    Sostituire application-id, authentication-key e tenant-id con i valori raccolti durante la creazione dell'entità servizio di Azure Active Directory.Replace application-id, authentication-key, and tenant-id with the values that you previously collected when you created your Azure Active Directory service principal.

  5. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    credentials = get_credentials()
    

Creare le risorseCreate resources

Inizializzare i client di gestioneInitialize management clients

I client di gestione sono necessari per creare e gestire le risorse tramite Python SDK in Azure.Management clients are needed to create and manage resources using the Python SDK in Azure. Per creare i client di gestione, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To create the management clients, add this code under the if statement at then end of the .py file:

resource_group_client = ResourceManagementClient(
    credentials, 
    SUBSCRIPTION_ID
)
network_client = NetworkManagementClient(
    credentials, 
    SUBSCRIPTION_ID
)
compute_client = ComputeManagementClient(
    credentials, 
    SUBSCRIPTION_ID
)

Creare la macchina virtuale e le risorse di supportoCreate the VM and supporting resources

Tutte le risorse devono essere contenute in un gruppo di risorse.All resources must be contained in a Resource group.

  1. Per creare un gruppo di risorse, aggiungere questa funzione dopo le variabili nel file con estensione py:To create a resource group, add this function after the variables in the .py file:

    def create_resource_group(resource_group_client):
        resource_group_params = { 'location':LOCATION }
        resource_group_result = resource_group_client.resource_groups.create_or_update(
            GROUP_NAME, 
            resource_group_params
        )
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    create_resource_group(resource_group_client)
    input('Resource group created. Press enter to continue...')
    

I set di disponibilità semplificano la manutenzione delle macchine virtuali usate dall'applicazione.Availability sets make it easier for you to maintain the virtual machines used by your application.

  1. Per creare un set di disponibilità, aggiungere questa funzione dopo le variabili nel file con estensione py:To create an availability set, add this function after the variables in the .py file:

    def create_availability_set(compute_client):
        avset_params = {
            'location': LOCATION,
            'sku': { 'name': 'Aligned' },
            'platform_fault_domain_count': 3
        }
        availability_set_result = compute_client.availability_sets.create_or_update(
            GROUP_NAME,
            'myAVSet',
            avset_params
        )
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    create_availability_set(compute_client)
    print("------------------------------------------------------")
    input('Availability set created. Press enter to continue...')
    

Un indirizzo IP pubblico è necessario per comunicare con la macchina virtuale.A Public IP address is needed to communicate with the virtual machine.

  1. Per creare un indirizzo IP pubblico per la macchina virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To create a public IP address for the virtual machine, add this function after the variables in the .py file:

    def create_public_ip_address(network_client):
        public_ip_addess_params = {
            'location': LOCATION,
            'public_ip_allocation_method': 'Dynamic'
        }
        creation_result = network_client.public_ip_addresses.create_or_update(
            GROUP_NAME,
            'myIPAddress',
            public_ip_addess_params
        )
    
        return creation_result.result()
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    creation_result = create_public_ip_address(network_client)
    print("------------------------------------------------------")
    print(creation_result)
    input('Press enter to continue...')
    

Una macchina virtuale deve essere inclusa in una subnet di una rete virtuale.A virtual machine must be in a subnet of a Virtual network.

  1. Per creare una rete virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To create a virtual network, add this function after the variables in the .py file:

    def create_vnet(network_client):
        vnet_params = {
            'location': LOCATION,
            'address_space': {
                'address_prefixes': ['10.0.0.0/16']
            }
        }
        creation_result = network_client.virtual_networks.create_or_update(
            GROUP_NAME,
            'myVNet',
            vnet_params
        )
        return creation_result.result()
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    creation_result = create_vnet(network_client)
    print("------------------------------------------------------")
    print(creation_result)
    input('Press enter to continue...')
    
  3. Per aggiungere una subnet alla rete virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To add a subnet to the virtual network, add this function after the variables in the .py file:

    def create_subnet(network_client):
        subnet_params = {
            'address_prefix': '10.0.0.0/24'
        }
        creation_result = network_client.subnets.create_or_update(
            GROUP_NAME,
            'myVNet',
            'mySubnet',
            subnet_params
        )
    
        return creation_result.result()
    
  4. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    creation_result = create_subnet(network_client)
    print("------------------------------------------------------")
    print(creation_result)
    input('Press enter to continue...')
    

Una macchina virtuale richiede un'interfaccia di rete per comunicare nella rete virtuale.A virtual machine needs a network interface to communicate on the virtual network.

  1. Per creare un'interfaccia di rete, aggiungere questa funzione dopo le variabili nel file con estensione py:To create a network interface, add this function after the variables in the .py file:

    def create_nic(network_client):
        subnet_info = network_client.subnets.get(
            GROUP_NAME, 
            'myVNet', 
            'mySubnet'
        )
        publicIPAddress = network_client.public_ip_addresses.get(
            GROUP_NAME,
            'myIPAddress'
        )
        nic_params = {
            'location': LOCATION,
            'ip_configurations': [{
                'name': 'myIPConfig',
                'public_ip_address': publicIPAddress,
                'subnet': {
                    'id': subnet_info.id
                }
            }]
        }
        creation_result = network_client.network_interfaces.create_or_update(
            GROUP_NAME,
            'myNic',
            nic_params
        )
    
        return creation_result.result()
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    creation_result = create_nic(network_client)
    print("------------------------------------------------------")
    print(creation_result)
    input('Press enter to continue...')
    

Dopo avere creato tutte le risorse di supporto, è possibile creare una macchina virtuale.Now that you created all the supporting resources, you can create a virtual machine.

  1. Per creare una macchina virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To create the virtual machine, add this function after the variables in the .py file:

    def create_vm(network_client, compute_client):  
        nic = network_client.network_interfaces.get(
            GROUP_NAME, 
            'myNic'
        )
        avset = compute_client.availability_sets.get(
            GROUP_NAME,
            'myAVSet'
        )
        vm_parameters = {
            'location': LOCATION,
            'os_profile': {
                'computer_name': VM_NAME,
                'admin_username': 'azureuser',
                'admin_password': 'Azure12345678'
            },
            'hardware_profile': {
                'vm_size': 'Standard_DS1'
            },
            'storage_profile': {
                'image_reference': {
                    'publisher': 'MicrosoftWindowsServer',
                    'offer': 'WindowsServer',
                    'sku': '2012-R2-Datacenter',
                    'version': 'latest'
                }
            },
            'network_profile': {
                'network_interfaces': [{
                    'id': nic.id
                }]
            },
            'availability_set': {
                'id': avset.id
            }
        }
        creation_result = compute_client.virtual_machines.create_or_update(
            GROUP_NAME, 
            VM_NAME, 
            vm_parameters
        )
    
        return creation_result.result()
    

    Nota

    Questa esercitazione illustra come creare una macchina virtuale in cui è in esecuzione una versione del sistema operativo Windows Server.This tutorial creates a virtual machine running a version of the Windows Server operating system. Per altre informazioni sulla selezione di altre immagini, vedere Esplorare e selezionare immagini delle macchine virtuali di Azure con Windows PowerShell e l'interfaccia della riga di comando di Azure.To learn more about selecting other images, see Navigate and select Azure virtual machine images with Windows PowerShell and the Azure CLI.

  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    creation_result = create_vm(network_client, compute_client)
    print("------------------------------------------------------")
    print(creation_result)
    input('Press enter to continue...')
    

Eseguire le attività di gestionePerform management tasks

Durante il ciclo di vita di una macchina virtuale si eseguono attività di gestione come l'avvio, l'arresto o l'eliminazione della macchina virtuale.During the lifecycle of a virtual machine, you may want to run management tasks such as starting, stopping, or deleting a virtual machine. È inoltre possibile creare codice per automatizzare le attività ripetitive o complesse.Additionally, you may want to create code to automate repetitive or complex tasks.

Ottenere informazioni sulla VMGet information about the VM

  1. Per ottenere informazioni sulla macchina virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To get information about the virtual machine, add this function after the variables in the .py file:

    def get_vm(compute_client):
        vm = compute_client.virtual_machines.get(GROUP_NAME, VM_NAME, expand='instanceView')
        print("hardwareProfile")
        print("   vmSize: ", vm.hardware_profile.vm_size)
        print("\nstorageProfile")
        print("  imageReference")
        print("    publisher: ", vm.storage_profile.image_reference.publisher)
        print("    offer: ", vm.storage_profile.image_reference.offer)
        print("    sku: ", vm.storage_profile.image_reference.sku)
        print("    version: ", vm.storage_profile.image_reference.version)
        print("  osDisk")
        print("    osType: ", vm.storage_profile.os_disk.os_type.value)
        print("    name: ", vm.storage_profile.os_disk.name)
        print("    createOption: ", vm.storage_profile.os_disk.create_option.value)
        print("    caching: ", vm.storage_profile.os_disk.caching.value)
        print("\nosProfile")
        print("  computerName: ", vm.os_profile.computer_name)
        print("  adminUsername: ", vm.os_profile.admin_username)
        print("  provisionVMAgent: {0}".format(vm.os_profile.windows_configuration.provision_vm_agent))
        print("  enableAutomaticUpdates: {0}".format(vm.os_profile.windows_configuration.enable_automatic_updates))
        print("\nnetworkProfile")
        for nic in vm.network_profile.network_interfaces:
            print("  networkInterface id: ", nic.id)
        print("\nvmAgent")
        print("  vmAgentVersion", vm.instance_view.vm_agent.vm_agent_version)
        print("    statuses")
        for stat in vm_result.instance_view.vm_agent.statuses:
            print("    code: ", stat.code)
            print("    displayStatus: ", stat.display_status)
            print("    message: ", stat.message)
            print("    time: ", stat.time)
        print("\ndisks");
        for disk in vm.instance_view.disks:
            print("  name: ", disk.name)
            print("  statuses")
            for stat in disk.statuses:
                print("    code: ", stat.code)
                print("    displayStatus: ", stat.display_status)
                print("    time: ", stat.time)
        print("\nVM general status")
        print("  provisioningStatus: ", vm.provisioning_state)
        print("  id: ", vm.id)
        print("  name: ", vm.name)
        print("  type: ", vm.type)
        print("  location: ", vm.location)
        print("\nVM instance status")
        for stat in vm.instance_view.statuses:
            print("  code: ", stat.code)
            print("  displayStatus: ", stat.display_status)
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    get_vm(compute_client)
    print("------------------------------------------------------")
    input('Press enter to continue...')
    

Arrestare la VMStop the VM

È possibile arrestare una macchina virtuale e mantenere tutte le sue impostazioni, pur continuando a vedersela addebitata oppure è possibile arrestare una macchina virtuale e deallocarla.You can stop a virtual machine and keep all its settings, but continue to be charged for it, or you can stop a virtual machine and deallocate it. Quando una macchina virtuale viene deallocata, lo stesso viene fatto per tutte le risorse associate e la fatturazione termina.When a virtual machine is deallocated, all resources associated with it are also deallocated and billing ends for it.

  1. Per arrestare la macchina virtuale senza deallocarla, aggiungere questa funzione dopo le variabili nel file con estensione py:To stop the virtual machine without deallocating it, add this function after the variables in the .py file:

    def stop_vm(compute_client):
        compute_client.virtual_machines.power_off(GROUP_NAME, VM_NAME)
    

    Per deallocare la macchina virtuale, sostituire la chiamata power_off con il codice seguente:If you want to deallocate the virtual machine, change the power_off call to this code:

    compute_client.virtual_machines.deallocate(GROUP_NAME, VM_NAME)
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    stop_vm(compute_client)
    input('Press enter to continue...')
    

Avviare la VMStart the VM

  1. Per avviare la macchina virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To start the virtual machine, add this function after the variables in the .py file:

    def start_vm(compute_client):
        compute_client.virtual_machines.start(GROUP_NAME, VM_NAME)
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    start_vm(compute_client)
    input('Press enter to continue...')
    

Ridimensionare la VMResize the VM

Al momento di decidere le dimensioni della macchina virtuale, è necessario considerare molti aspetti della distribuzione.Many aspects of deployment should be considered when deciding on a size for your virtual machine. Per altre informazioni, vedere Dimensioni delle macchine virtuali.For more information, see VM sizes.

  1. Per modificare le dimensioni della macchina virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To change the size of the virtual machine, add this function after the variables in the .py file:

    def update_vm(compute_client):
        vm = compute_client.virtual_machines.get(GROUP_NAME, VM_NAME)
        vm.hardware_profile.vm_size = 'Standard_DS3'
        update_result = compute_client.virtual_machines.create_or_update(
            GROUP_NAME, 
            VM_NAME, 
            vm
        )
    
    return update_result.result()
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    update_result = update_vm(compute_client)
    print("------------------------------------------------------")
    print(update_result)
    input('Press enter to continue...')
    

Aggiungere un disco dati alla VMAdd a data disk to the VM

Le macchine virtuali possono disporre di uno o più dischi dati archiviati in dischi rigidi virtuali.Virtual machines can have one or more data disks that are stored as VHDs.

  1. Per aggiungere un disco dati alla macchina virtuale, aggiungere questa funzione dopo le variabili nel file con estensione py:To add a data disk to the virtual machine, add this function after the variables in the .py file:

    def add_datadisk(compute_client):
        disk_creation = compute_client.disks.create_or_update(
            GROUP_NAME,
            'myDataDisk1',
            {
                'location': LOCATION,
                'disk_size_gb': 1,
                'creation_data': {
                    'create_option': DiskCreateOption.empty
                }
            }
        )
        data_disk = disk_creation.result()
        vm = compute_client.virtual_machines.get(GROUP_NAME, VM_NAME)
        add_result = vm.storage_profile.data_disks.append({
            'lun': 1,
            'name': 'myDataDisk1',
            'create_option': DiskCreateOption.attach,
            'managed_disk': {
                'id': data_disk.id
            }
        })
        add_result = compute_client.virtual_machines.create_or_update(
            GROUP_NAME,
            VM_NAME,
            vm)
    
        return add_result.result()
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    add_result = add_datadisk(compute_client)
    print("------------------------------------------------------")
    print(add_result)
    input('Press enter to continue...')
    

Eliminare le risorseDelete resources

Dal momento che le risorse usate in Azure vengono addebitate, è sempre consigliabile eliminare le risorse non più necessarie.Because you are charged for resources used in Azure, it's always a good practice to delete resources that are no longer needed. Per eliminare le macchine virtuali e tutte le risorse di supporto, è sufficiente eliminare il gruppo di risorse.If you want to delete the virtual machines and all the supporting resources, all you have to do is delete the resource group.

  1. Per eliminare il gruppo di risorse e tutte le risorse, aggiungere questa funzione dopo le variabili nel file con estensione py:To delete the resource group and all resources, add this function after the variables in the .py file:

    def delete_resources(resource_group_client):
        resource_group_client.resource_groups.delete(GROUP_NAME)
    
  2. Per chiamare la funzione aggiunta in precedenza, aggiungere questo codice sotto l'istruzione if alla fine del file con estensione py:To call the function that you previously added, add this code under the if statement at the end of the .py file:

    delete_resources(resource_group_client)
    
  3. Salvare myPythonProject.py.Save myPythonProject.py.

Eseguire l'applicazioneRun the application

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

  2. Premere INVIO dopo che è stato restituito lo stato di ogni risorsa.Press Enter after the status of each resource is returned. Nelle informazioni sullo stato dovrebbe essere visualizzato lo stato di provisioning Completato.In the status information, you should see a Succeeded provisioning state. Dopo che la macchina virtuale è stata creata, si avrà l'opportunità di eliminare tutte le risorse create.After the virtual machine is created, you have the opportunity to delete all the resources that you create. Prima di premere INVIO per iniziare a eliminare le risorse, è consigliabile dedicare qualche minuto alla verifica della loro creazione nel portale di Azure.Before you press Enter to start deleting resources, you could take a few minutes to verify their creation in the Azure portal. Se il portale di Azure è aperto, potrebbe essere necessario aggiornare il pannello per visualizzare le nuove risorse.If you have the Azure portal open, you might have to refresh the blade to see new resources.

    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. L'eliminazione di tutte le risorse e del gruppo di risorse potrebbe richiedere alcuni minuti dopo l'esecuzione completa dell'applicazione.It may take several minutes after the application has finished before all the resources and the resource group are deleted.

Passaggi successiviNext steps