Condividi tramite

Esempio: Usare le librerie di Azure per creare una macchina virtuale

  • Articolo

Questo articolo illustra come usare le librerie di gestione di Azure SDK in uno script Python per creare un gruppo di risorse contenente una macchina virtuale Linux.

Se non diversamente specificato, tutti i comandi di questo articolo funzionano allo stesso modo nella shell Bash Linux/macOS e nella shell dei comandi di Windows.

I comandi equivalenti dell'interfaccia della riga di comando di Azure sono elencati più avanti in questo articolo. Se si preferisce usare il portale di Azure, vedere Creare una macchina virtuale Linux e Creare una macchina virtuale Windows.

Nota

La creazione di una macchina virtuale tramite codice è un processo in più passaggi che prevede il provisioning di una serie di altre risorse richieste dalla macchina virtuale. Se questo codice viene semplicemente eseguito dalla riga di comando, è molto più facile usare il comando az vm create, che effettua automaticamente il provisioning di queste risorse secondarie con i valori predefiniti di qualsiasi impostazione che si sceglie di omettere. Gli unici argomenti obbligatori sono un gruppo di risorse, il nome della macchina virtuale, il nome dell'immagine e le credenziali di accesso. Per altre informazioni, vedere Creare rapidamente una macchina virtuale con l'interfaccia della riga di comando di Azure.

1: Configurare l'ambiente di sviluppo locale

Se non è già stato fatto, configurare un ambiente in cui è possibile eseguire questo codice. Di seguito sono riportate alcuni opzioni:

2: Installare i pacchetti di libreria di Azure necessari

Creare un file requirements.txt in cui elencare le librerie di gestione usate in questo esempio:

azure-mgmt-resource
azure-mgmt-compute
azure-mgmt-network
azure-identity

Quindi, nel terminale o nel prompt dei comandi con l'ambiente virtuale attivato, installare le librerie di gestione elencate in requirements.txt:

pip install -r requirements.txt

3: Scrivere codice per creare una macchina virtuale

Creare un file Python denominato provision_vm.py con il codice seguente. I commenti spiegano i dettagli:

# Import the needed credential and management objects from the libraries.
import os

from azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.resource import ResourceManagementClient

print(
    "Provisioning a virtual machine...some operations might take a \
minute or two."
)

# Acquire a credential object.
credential = DefaultAzureCredential()

# Retrieve subscription ID from environment variable.
subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]


# Step 1: Provision a resource group

# Obtain the management object for resources.
resource_client = ResourceManagementClient(credential, subscription_id)

# Constants we need in multiple places: the resource group name and
# the region in which we provision resources. You can change these
# values however you want.
RESOURCE_GROUP_NAME = "PythonAzureExample-VM-rg"
LOCATION = "westus2"

# Provision the resource group.
rg_result = resource_client.resource_groups.create_or_update(
    RESOURCE_GROUP_NAME, {"location": LOCATION}
)

print(
    f"Provisioned resource group {rg_result.name} in the \
{rg_result.location} region"
)

# For details on the previous code, see Example: Provision a resource
# group at https://learn.microsoft.com/azure/developer/python/
# azure-sdk-example-resource-group

# Step 2: provision a virtual network

# A virtual machine requires a network interface client (NIC). A NIC
# requires a virtual network and subnet along with an IP address.
# Therefore we must provision these downstream components first, then
# provision the NIC, after which we can provision the VM.

# Network and IP address names
VNET_NAME = "python-example-vnet"
SUBNET_NAME = "python-example-subnet"
IP_NAME = "python-example-ip"
IP_CONFIG_NAME = "python-example-ip-config"
NIC_NAME = "python-example-nic"

# Obtain the management object for networks
network_client = NetworkManagementClient(credential, subscription_id)

# Provision the virtual network and wait for completion
poller = network_client.virtual_networks.begin_create_or_update(
    RESOURCE_GROUP_NAME,
    VNET_NAME,
    {
        "location": LOCATION,
        "address_space": {"address_prefixes": ["10.0.0.0/16"]},
    },
)

vnet_result = poller.result()

print(
    f"Provisioned virtual network {vnet_result.name} with address \
prefixes {vnet_result.address_space.address_prefixes}"
)

# Step 3: Provision the subnet and wait for completion
poller = network_client.subnets.begin_create_or_update(
    RESOURCE_GROUP_NAME,
    VNET_NAME,
    SUBNET_NAME,
    {"address_prefix": "10.0.0.0/24"},
)
subnet_result = poller.result()

print(
    f"Provisioned virtual subnet {subnet_result.name} with address \
prefix {subnet_result.address_prefix}"
)

# Step 4: Provision an IP address and wait for completion
poller = network_client.public_ip_addresses.begin_create_or_update(
    RESOURCE_GROUP_NAME,
    IP_NAME,
    {
        "location": LOCATION,
        "sku": {"name": "Standard"},
        "public_ip_allocation_method": "Static",
        "public_ip_address_version": "IPV4",
    },
)

ip_address_result = poller.result()

print(
    f"Provisioned public IP address {ip_address_result.name} \
with address {ip_address_result.ip_address}"
)

# Step 5: Provision the network interface client
poller = network_client.network_interfaces.begin_create_or_update(
    RESOURCE_GROUP_NAME,
    NIC_NAME,
    {
        "location": LOCATION,
        "ip_configurations": [
            {
                "name": IP_CONFIG_NAME,
                "subnet": {"id": subnet_result.id},
                "public_ip_address": {"id": ip_address_result.id},
            }
        ],
    },
)

nic_result = poller.result()

print(f"Provisioned network interface client {nic_result.name}")

# Step 6: Provision the virtual machine

# Obtain the management object for virtual machines
compute_client = ComputeManagementClient(credential, subscription_id)

VM_NAME = "ExampleVM"
USERNAME = "azureuser"
PASSWORD = "ChangePa$$w0rd24"

print(
    f"Provisioning virtual machine {VM_NAME}; this operation might \
take a few minutes."
)

# Provision the VM specifying only minimal arguments, which defaults
# to an Ubuntu 18.04 VM on a Standard DS1 v2 plan with a public IP address
# and a default virtual network/subnet.

poller = compute_client.virtual_machines.begin_create_or_update(
    RESOURCE_GROUP_NAME,
    VM_NAME,
    {
        "location": LOCATION,
        "storage_profile": {
            "image_reference": {
                "publisher": "Canonical",
                "offer": "UbuntuServer",
                "sku": "16.04.0-LTS",
                "version": "latest",
            }
        },
        "hardware_profile": {"vm_size": "Standard_DS1_v2"},
        "os_profile": {
            "computer_name": VM_NAME,
            "admin_username": USERNAME,
            "admin_password": PASSWORD,
        },
        "network_profile": {
            "network_interfaces": [
                {
                    "id": nic_result.id,
                }
            ]
        },
    },
)

vm_result = poller.result()

print(f"Provisioned virtual machine {vm_result.name}")

Autenticazione nel codice

Più avanti in questo articolo si accede ad Azure con l'interfaccia della riga di comando di Azure per eseguire il codice di esempio. Se l'account dispone delle autorizzazioni per creare gruppi di risorse e risorse di rete e di calcolo nella sottoscrizione di Azure, il codice verrà eseguito correttamente.

Per usare questo codice in uno script di produzione, è possibile impostare le variabili di ambiente per usare un metodo basato su entità servizio per l'autenticazione. Per altre informazioni, vedere Come autenticare le app Python con i servizi di Azure. È necessario assicurarsi che l'entità servizio disponga di autorizzazioni sufficienti per creare gruppi di risorse e risorse di rete e di calcolo nella sottoscrizione assegnandole un ruolo appropriato in Azure, ad esempio il ruolo Collaboratore nella sottoscrizione.

4. Eseguire lo script

  1. Se non è già stato fatto, accedere ad Azure usando l'interfaccia della riga di comando di Azure:

    az login

  2. Impostare la AZURE_SUBSCRIPTION_ID variabile di ambiente sull'ID sottoscrizione. È possibile eseguire il comando az account show e ottenere l'ID id sottoscrizione dalla proprietà nell'output:

    set AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000

  3. Eseguire lo script:

    python provision_vm.py

Il processo di provisioning richiede alcuni minuti.

5. Verificare le risorse

Aprire il portale di Azure, passare al gruppo di risorse "PythonAzureExample-VM-rg" e prendere nota della macchina virtuale, del disco virtuale, del gruppo di sicurezza di rete, dell'indirizzo IP pubblico, dell'interfaccia di rete e della rete virtuale.

Pagina del portale di Azure relativa al nuovo gruppo di risorse che mostra la macchina virtuale e le risorse correlate

È anche possibile usare l'interfaccia della riga di comando di Azure per verificare che la macchina virtuale esista con il comando az vm list :

az vm list --resource-group PythonAzureExample-VM-rg

Comandi equivalenti dell'interfaccia della riga di comando di Azure

rem Provision the resource group

az group create -n PythonAzureExample-VM-rg -l westus2

rem Provision a virtual network and subnet

az network vnet create -g PythonAzureExample-VM-rg -n python-example-vnet ^
    --address-prefix 10.0.0.0/16 --subnet-name python-example-subnet ^
    --subnet-prefix 10.0.0.0/24

rem Provision a public IP address

az network public-ip create -g PythonAzureExample-VM-rg -n python-example-ip ^
    --allocation-method Dynamic --version IPv4

rem Provision a network interface client

az network nic create -g PythonAzureExample-VM-rg --vnet-name python-example-vnet ^
    --subnet python-example-subnet -n python-example-nic ^
    --public-ip-address python-example-ip

rem Provision the virtual machine

az vm create -g PythonAzureExample-VM-rg -n ExampleVM -l "westus2" ^
    --nics python-example-nic --image UbuntuLTS --public-ip-sku Standard ^
    --admin-username azureuser --admin-password ChangePa$$w0rd24

Se viene visualizzato un errore relativo alle restrizioni di capacità, è possibile provare una dimensione o un'area diversa. Per altre informazioni, vedere Risolvere gli errori per lo SKU non disponibile.

6: Pulire le risorse

Lasciare invariate le risorse se si vuole continuare a usare la macchina virtuale e la rete creata in questo articolo. In caso contrario, eseguire il comando az group delete per eliminare il gruppo di risorse.

I gruppi di risorse non comportano addebiti in corso nella sottoscrizione, ma le risorse contenute nel gruppo, ad esempio le macchine virtuali, potrebbero continuare a comportare addebiti. È consigliabile pulire qualsiasi gruppo che non si usa attivamente. Con l'argomento --no-wait, il comando restituisce immediatamente il risultato invece di attendere il completamento dell'operazione.

az group delete -n PythonAzureExample-VM-rg --no-wait

Per eliminare un gruppo di risorse dal codice, è anche possibile usare il metodo ResourceManagementClient.resource_groups.begin_delete. Il codice in Esempio: Creare un gruppo di risorse illustra l'utilizzo.

Vedi anche

Le risorse seguenti contengono esempi più completi che usano Python per creare una macchina virtuale: