Beispiel: Verwenden der Azure-Bibliotheken zum Erstellen eines virtuellen Computers

  • Artikel

In diesem Artikel erfahren Sie, wie Sie die Azure SDK-Verwaltungsbibliotheken in einem Python-Skript verwenden, um eine Ressourcengruppe zu erstellen, die einen virtuellen Linux-Computer enthält.

Alle Befehle in diesem Artikel funktionieren in Linux-/macOS-Bash- und Windows-Befehlsshells identisch, sofern nicht anders angegeben.

Die entsprechenden Azure CLI-Befehle werden weiter unten in diesem Artikel aufgeführt. Wenn Sie die Azure-Portal verwenden möchten, lesen Sie "Erstellen einer Linux-VM" und "Erstellen einer Windows-VM".

Hinweis

Das Erstellen eines virtuellen Computers über Code ist ein mehrstufiger Prozess, bei dem eine Reihe anderer Ressourcen bereitgestellt werden muss, die der virtuelle Computer benötigt. Wenn Sie solchen Code über die Befehlszeile ausführen, ist es wesentlich einfacher, den Befehl az vm create zu verwenden. Hierdurch werden diese sekundären Ressourcen jeweils automatisch mit Standardwerten für die weggelassenen Einstellungen bereitgestellt. Die einzigen erforderlichen Argumente sind eine Ressourcengruppe, ein VM-Name, ein Imagename und Anmeldeinformationen. Weitere Informationen finden Sie unter Schnelles Erstellen einer VM mit der Azure CLI.

1: Einrichten Ihrer lokalen Entwicklungsumgebung

Falls noch nicht geschehen, richten Sie eine Umgebung ein, in der Sie diesen Code ausführen können. Hier einige Optionen:

2: Installieren der erforderlichen Azure-Bibliothekspakete

Erstellen Sie eine Datei requirements.txt, in der die in diesem Beispiel verwendeten Verwaltungsbibliotheken aufgeführt sind:

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

Installieren Sie dann in Ihrem Terminal oder an der Eingabeaufforderung mit aktivierter virtueller Umgebung die in requirements.txt aufgeführten Verwaltungsbibliotheken:

pip install -r requirements.txt

3: Schreiben von Code zum Erstellen eines virtuellen Computers

Erstellen Sie eine Python-Datei mit dem Namen provision_vm.py und dem folgenden Code. Die Details werden in den Kommentaren erläutert:

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

Authentifizierung im Code

Später in diesem Artikel melden Sie sich mit der Azure CLI bei Azure an, um den Beispielcode auszuführen. Wenn Ihr Konto über Berechtigungen zum Erstellen von Ressourcengruppen und Netzwerk- und Computeressourcen in Ihrem Azure-Abonnement verfügt, wird der Code erfolgreich ausgeführt.

Um diesen Code in einem Produktionsskript zu verwenden, können Sie Umgebungsvariablen so festlegen, dass eine dienstprinzipalbasierte Methode für die Authentifizierung verwendet wird. Weitere Informationen finden Sie unter Authentifizieren von Python-Apps mit Azure-Diensten. Sie müssen sicherstellen, dass der Dienstprinzipal über ausreichende Berechtigungen zum Erstellen von Ressourcengruppen und Netzwerk- und Computeressourcen in Ihrem Abonnement verfügt, indem Sie ihm eine entsprechende Rolle in Azure zuweisen, z. B. die Rolle "Mitwirkender " in Ihrem Abonnement.

4. Ausführen des Skripts

  1. Falls noch nicht geschehen, melden Sie sich mit der Azure CLI bei Azure an:

    az login

  2. Legen Sie die AZURE_SUBSCRIPTION_ID Umgebungsvariable auf Ihre Abonnement-ID fest. (Sie können den Befehl "az account show" ausführen und Ihre Abonnement-ID aus der Eigenschaft in der id Ausgabe abrufen):

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

  3. Ausführen des Skripts:

    python provision_vm.py

Der Bereitstellungsprozess dauert einige Minuten.

5. Überprüfen der Ressourcen

Öffnen Sie die Azure-Portal, navigieren Sie zur Ressourcengruppe "PythonAzureExample-VM-rg", und notieren Sie sich den virtuellen Computer, den virtuellen Datenträger, die Netzwerksicherheitsgruppe, die öffentliche IP-Adresse, die Netzwerkschnittstelle und das virtuelle Netzwerk.

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

Sie können auch die Azure CLI verwenden, um zu überprüfen, ob der virtuelle Computer mit dem Befehl "az vm list " vorhanden ist:

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

Entsprechende Azure CLI-Befehle

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

Wenn Sie eine Fehlermeldung zu Kapazitätsbeschränkungen erhalten, können Sie eine andere Größe oder Region ausprobieren. Weitere Informationen finden Sie unter Beheben von Fehlern für SKU, die nicht verfügbar sind.

6: Ressourcen bereinigen

Behalten Sie die Ressourcen bei, wenn Sie weiterhin den virtuellen Computer und das Netzwerk verwenden möchten, den Sie in diesem Artikel erstellt haben. Führen Sie andernfalls den Befehl "az group delete " aus, um die Ressourcengruppe zu löschen.

Ressourcengruppen verursachen keine laufenden Gebühren in Ihrem Abonnement, aber Ressourcen, die in der Gruppe enthalten sind, wie virtuelle Computer, verursachen möglicherweise weiterhin Gebühren. Es empfiehlt sich, jede Gruppe zu sauber, die Sie nicht aktiv verwenden. Das Argument --no-wait ermöglicht die direkte Rückgabe des Befehls, und es muss nicht auf den Abschluss des Vorgangs gewartet werden.

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

Sie können auch die ResourceManagementClient.resource_groups.begin_delete-Methode verwenden, um eine Ressourcengruppe aus dem Code zu löschen. Der Code im Beispiel: Erstellen einer Ressourcengruppe veranschaulicht die Verwendung.

Weitere Informationen

Die folgenden Ressourcen enthalten weitere umfassende Beispiele für die Verwendung von Python zum Erstellen eines virtuellen Computers: