Sdílet prostřednictvím

Příklad: Vytvoření virtuálního počítače pomocí knihoven Azure

  • Článek

V tomto článku se dozvíte, jak pomocí knihoven pro správu sady Azure SDK ve skriptu Pythonu vytvořit skupinu prostředků, která obsahuje virtuální počítač s Linuxem.

Všechny příkazy v tomto článku fungují stejně v prostředích Bash pro Linux/macOS a Windows, pokud není uvedeno.

Ekvivalentní příkazy Azure CLI jsou uvedeny dále v tomto článku. Pokud raději používáte Azure Portal, přečtěte si téma Vytvoření virtuálního počítače s Linuxem a vytvoření virtuálního počítače s Windows.

Poznámka:

Vytvoření virtuálního počítače prostřednictvím kódu je vícekrokový proces, který zahrnuje zřízení řady dalších prostředků, které virtuální počítač vyžaduje. Pokud takový kód jednoduše spouštíte z příkazového řádku, je mnohem jednodušší použít az vm create příkaz, který automaticky zřídí tyto sekundární prostředky s výchozím nastavením pro všechna nastavení, která se rozhodnete vynechat. Jedinými povinnými argumenty jsou skupina prostředků, název virtuálního počítače, název image a přihlašovací údaje. Další informace najdete v tématu Rychlé vytvoření virtuálního počítače pomocí Azure CLI.

1: Nastavení místního vývojového prostředí

Pokud jste to ještě neudělali, nastavte prostředí, ve kterém můžete tento kód spustit. Zde je uvedeno několik možností:

2: Instalace potřebných balíčků knihovny Azure

Vytvořte soubor requirements.txt se seznamem knihoven pro správu použitých v tomto příkladu:

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

Potom v terminálu nebo příkazovém řádku s aktivovaným virtuálním prostředím nainstalujte knihovny pro správu uvedené v requirements.txt:

pip install -r requirements.txt

3: Napsání kódu pro vytvoření virtuálního počítače

Vytvořte soubor Pythonu s názvem provision_vm.py s následujícím kódem. Komentáře vysvětlují podrobnosti:

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

Ověřování v kódu

Později v tomto článku se přihlásíte k Azure pomocí Azure CLI a spustíte vzorový kód. Pokud má váš účet oprávnění k vytváření skupin prostředků a síťových a výpočetních prostředků ve vašem předplatném Azure, kód se úspěšně spustí.

Pokud chcete tento kód použít v produkčním skriptu, můžete nastavit proměnné prostředí tak, aby pro ověřování používaly metodu založenou na instančním objektu. Další informace najdete v tématu Ověřování aplikací v Pythonu pomocí služeb Azure. Musíte zajistit, aby instanční objekt má dostatečná oprávnění k vytváření skupin prostředků a síťových a výpočetních prostředků ve vašem předplatném tím, že mu v Azure přiřadíte odpovídající roli, například roli Přispěvatel ve vašem předplatném.

4. Spusťte skript.

  1. Pokud jste to ještě neudělali, přihlaste se k Azure pomocí Azure CLI:

    az login

  2. Nastavte proměnnou AZURE_SUBSCRIPTION_ID prostředí na ID vašeho předplatného. (Příkaz az account show můžete spustit a získat ID předplatného id z vlastnosti ve výstupu):

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

  3. Spusťte skript:

    python provision_vm.py

Dokončení procesu zřizování trvá několik minut.

5. Ověření prostředků

Otevřete Azure Portal, přejděte do skupiny prostředků PythonAzureExample-VM-rg a poznamenejte si virtuální počítač, virtuální disk, skupinu zabezpečení sítě, veřejnou IP adresu, síťové rozhraní a virtuální síť.

Azure portal page for the new resource group showing the virtual machine and related resources

Pomocí Azure CLI můžete také ověřit, že virtuální počítač existuje, pomocí příkazu az vm list :

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

Ekvivalentní příkazy Azure CLI

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

Pokud se zobrazí chyba týkající se omezení kapacity, můžete vyzkoušet jinou velikost nebo oblast. Další informace naleznete v tématu Řešení chyb skladové položky není k dispozici.

6: Vyčištění prostředků

Pokud chcete dál používat virtuální počítač a síť, které jste vytvořili v tomto článku, ponechte prostředky na místě. V opačném případě spusťte příkaz az group delete a odstraňte skupinu prostředků.

Ve vašem předplatném se za skupiny prostředků neúčtují žádné průběžné poplatky, ale za prostředky obsažené ve skupině, jako jsou virtuální počítače, se můžou dál účtovat poplatky. Je vhodné vyčistit jakoukoli skupinu, kterou aktivně nepoužíváte. Argument --no-wait umožňuje, aby se příkaz vrátil okamžitě místo čekání na dokončení operace.

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

Metodu ResourceManagementClient.resource_groups.begin_delete můžete použít také k odstranění skupiny prostředků z kódu. Kód v příkladu: Vytvoření skupiny prostředků ukazuje použití.

Viz také

Následující zdroje informací obsahují komplexnější příklady použití Pythonu k vytvoření virtuálního počítače: