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

2025-06-11

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.

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.

Anmärkning

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 är några alternativ:

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

Använd en conda-miljö. Information om hur du installerar Conda finns i Installera Miniconda.
Använd en Dev-container i Visual Studio Code eller GitHub Codespaces.

2: Installera nödvändiga Azure-bibliotekspaket

Skapa en requirements.txt fil som anger de Azure SDK-hanteringspaket som krävs av det här skriptet.

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

Installera sedan de hanteringsbibliotek som anges i requirements.txt:

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://free.blessedness.top/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 Hjälp av Azure CLI för att köra exempelkoden. Om ditt konto har tillräcklig behörighet för att skapa resursgrupper och lagringsresurser i din Azure-prenumeration bör skriptet köras utan ytterligare konfiguration.

Om du vill använda den här koden i en produktionsmiljö autentiserar du med tjänstens huvudnamn genom att ange miljövariabler. Den här metoden möjliggör säker, automatiserad åtkomst utan att förlita sig på interaktiv inloggning. Detaljerad vägledning finns i Autentisera Python-appar med Azure-tjänster.

Kontrollera att tjänstens huvudkonto har tilldelats en roll med tillräcklig behörighet för att skapa resursgrupper och lagringskonton. Om du till exempel tilldelar rollen Deltagare på prenumerationsnivå får du nödvändig åtkomst. Mer information om rolltilldelningar finns i Rollbaserad åtkomstkontroll (RBAC) i Azure.

Referenslänkar för klasser som används i koden

4. Kör skriptet

Logga in på Azure med hjälp av Azure CLI om du inte redan har gjort det.
```
az login
```
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):
```
export AZURE_SUBSCRIPTION_ID=$(az account show --query id -o tsv)
```
Kör skriptet:
```
python provision_vm.py
```

Provisioneringsprocessen tar några minuter för att slutföras.

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

# 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

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 metoden ResourceManagementClient.resource_groups.begin_delete 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:

Azure Virtual Machines Management-exempel – Python (GitHub). Exemplet visar fler hanteringsåtgärder som att starta och starta om en virtuell dator, stoppa och ta bort en virtuell dator, öka diskstorleken och hantera datadiskar.

Feedback

Var den här sidan till hjälp?