Condividi tramite

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

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.

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.

Annotazioni

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 esegui semplicemente questo codice dalla riga di comando, è molto più semplice usare il comando az vm create, che configura automaticamente queste risorse secondarie con impostazioni predefinite per qualsiasi impostazione tu scelga 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 Creazione rapida di 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. Ecco alcune opzioni:

#!/bin/bash
# Create a virtual environment
python -m venv .venv
# Activate the virtual environment
source .venv/Scripts/activate # only required for Windows (Git Bash)

2: Installare i pacchetti di libreria di Azure necessari

Creare un filerequirements.txt che specifica i pacchetti di gestione di Azure SDK richiesti da questo script.

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

Installare quindi le librerie di gestione specificate 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 usando l'interfaccia della riga di comando di Azure per eseguire il codice di esempio. Se l'account dispone di autorizzazioni sufficienti per creare gruppi di risorse e risorse di archiviazione nella sottoscrizione di Azure, lo script deve essere eseguito correttamente senza configurazione aggiuntiva.

Per usare questo codice in un ambiente di produzione, eseguire l'autenticazione usando un'entità servizio impostando le variabili di ambiente. Questo approccio consente l'accesso sicuro e automatizzato senza basarsi sull'accesso interattivo. Per indicazioni dettagliate, vedere Come autenticare le app Python con i servizi di Azure.

Assicuratevi che al principale del servizio sia assegnato un ruolo con autorizzazioni sufficienti per creare gruppi di risorse e account di archiviazione. Ad esempio, l'assegnazione del ruolo Collaboratore a livello di sottoscrizione fornisce l'accesso necessario. Per altre informazioni sulle assegnazioni di ruolo, vedere Controllo degli accessi in base al ruolo in Azure.

4. Eseguire lo script

  1. Se non l'hai già fatto, accedi ad Azure usando l'Azure CLI.

    az login

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

    export AZURE_SUBSCRIPTION_ID=$(az account show --query id -o tsv)

  3. Eseguire lo script:

    python provision_vm.py

Il processo di provisioning richiede alcuni minuti per essere completato.

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 per il 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 della riga di comando di Azure

# Provision the resource group

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

# 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

# Provision a public IP address

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

# 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

# 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 eliminare qualsiasi gruppo che non stai utilizzando attivamente. L'argomento --no-wait consente al comando di restituire immediatamente anziché attendere il completamento dell'operazione.

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

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

Vedere anche

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