Dela via

Exempel: Använd Azure-biblioteken för att skapa en virtuell dator

  • Artikel

I den här artikeln får du lära dig hur du använder Azure SDK-hanteringsbiblioteken i ett Python-skript för att skapa en resursgrupp som innehåller en virtuell Linux-dator.

Alla kommandon i den här artikeln fungerar på samma sätt i Linux/macOS bash- och Windows-kommandogränssnitt om de inte anges.

Motsvarande Azure CLI-kommandon visas senare i den här artikeln. Om du föredrar att använda Azure-portalen kan du läsa Skapa en virtuell Linux-dator och Skapa en virtuell Windows-dator.

Kommentar

Att skapa en virtuell dator via kod är en process i flera steg som innebär etablering av ett antal andra resurser som den virtuella datorn kräver. Om du bara kör sådan kod från kommandoraden är det mycket enklare att använda az vm create kommandot, vilket automatiskt etablerar dessa sekundära resurser med standardvärden för alla inställningar som du väljer att utelämna. De enda argument som krävs är en resursgrupp, vm-namn, avbildningsnamn och inloggningsuppgifter. Mer information finns i Snabbskapa en virtuell dator med Azure CLI.

1: Konfigurera din lokala utvecklingsmiljö

Om du inte redan har gjort det konfigurerar du en miljö där du kan köra den här koden. Här följer några alternativ:

2: Installera nödvändiga Azure-bibliotekspaket

Skapa en requirements.txt fil som visar de hanteringsbibliotek som används i det här exemplet:

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

Installera sedan hanteringsbiblioteken i requirements.txt i terminalen eller kommandotolken med den virtuella miljön aktiverad:

pip install -r requirements.txt

3: Skriva kod för att skapa en virtuell dator

Skapa en Python-fil med namnet provision_vm.py med följande kod. Kommentarerna förklarar informationen:

# 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}")

Autentisering i koden

Senare i den här artikeln loggar du in på Azure med Azure CLI för att köra exempelkoden. Om ditt konto har behörighet att skapa resursgrupper och nätverks- och beräkningsresurser i din Azure-prenumeration körs koden.

Om du vill använda sådan kod i ett produktionsskript kan du ange miljövariabler så att de använder en tjänsthuvudnamnsbaserad metod för autentisering. Mer information finns i Autentisera Python-appar med Azure-tjänster. Du måste se till att tjänstens huvudnamn har tillräcklig behörighet för att skapa resursgrupper och nätverks- och beräkningsresurser i din prenumeration genom att tilldela den en lämplig roll i Azure, till exempel rollen Deltagare i din prenumeration.

4. Kör skriptet

  1. Om du inte redan har gjort det loggar du in på Azure med Hjälp av Azure CLI:

    az login

  2. AZURE_SUBSCRIPTION_ID Ange miljövariabeln till ditt prenumerations-ID. (Du kan köra kommandot az account show och hämta ditt prenumerations-ID från id egenskapen i utdata):

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

  3. Kör skriptet:

    python provision_vm.py

Etableringsprocessen tar några minuter att slutföra.

5. Kontrollera resurserna

Öppna Azure-portalen, gå till resursgruppen "PythonAzureExample-VM-rg" och notera den virtuella datorn, den virtuella disken, nätverkssäkerhetsgruppen, den offentliga IP-adressen, nätverksgränssnittet och det virtuella nätverket.

Azure-portalsidan för den nya resursgruppen som visar den virtuella datorn och relaterade resurser

Du kan också använda Azure CLI för att kontrollera att den virtuella datorn finns med kommandot az vm list :

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

Motsvarande Azure CLI-kommandon

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

Om du får ett felmeddelande om kapacitetsbegränsningar kan du prova en annan storlek eller region. Mer information finns i Lösa fel för SKU som inte är tillgängligt.

6: Rensa resurser

Låt resurserna vara kvar om du vill fortsätta att använda den virtuella datorn och nätverket som du skapade i den här artikeln. Annars kör du kommandot az group delete för att ta bort resursgruppen.

Resursgrupper debiteras inte några löpande avgifter i din prenumeration, men resurser som ingår i gruppen, till exempel virtuella datorer, kan fortsätta att debiteras. Det är en bra idé att rensa alla grupper som du inte aktivt använder. Argumentet --no-wait gör att kommandot kan returneras omedelbart i stället för att vänta på att åtgärden ska slutföras.

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

Du kan också använda ResourceManagementClient.resource_groups.begin_delete metoden för att ta bort en resursgrupp från koden. Koden i Exempel: Skapa en resursgrupp visar användning.

Se även

Följande resurser innehåller mer omfattande exempel som använder Python för att skapa en virtuell dator: