Freigeben über

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

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.

Die entsprechenden Azure CLI-Befehle werden weiter unten in diesem Artikel aufgeführt. Wenn Sie das 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 diesen Code einfach über die Befehlszeile ausführen, ist es viel einfacher, den az vm create Befehl zu verwenden, der diese sekundären Ressourcen automatisch mit Standardwerten für jede Einstellung bereit stellt, die Sie weglassen möchten. Die einzigen erforderlichen Argumente sind eine Ressourcengruppe, der VM-Name, der Bildname und die Anmeldeinformationen. Weitere Informationen finden Sie unter Quick Create a virtual machine with the 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 sind einige Optionen:

#!/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: Installieren der erforderlichen Azure-Bibliothekspakete

Erstellen Sie eine requirements.txt Datei, die die für dieses Skript erforderlichen Azure SDK-Verwaltungspakete angibt.

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

Installieren Sie als Nächstes die in requirements.txtangegebenen 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 mit dem folgenden Code. Die Kommentare erläutern die Details:

# 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 ausreichende Berechtigungen zum Erstellen von Ressourcengruppen und Speicherressourcen in Ihrem Azure-Abonnement verfügt, sollte das Skript ohne zusätzliche Konfiguration erfolgreich ausgeführt werden.

Um diesen Code in einer Produktionsumgebung zu verwenden, authentifizieren Sie sich mithilfe eines Dienstprinzipals, indem Sie Umgebungsvariablen festlegen. Dieser Ansatz ermöglicht einen sicheren, automatisierten Zugriff, ohne sich auf die interaktive Anmeldung zu verlassen. Ausführliche Anleitungen finden Sie unter Authentifizieren von Python-Apps mit Azure-Diensten.

Stellen Sie sicher, dass dem Dienstprinzipal eine Rolle mit ausreichenden Berechtigungen zum Erstellen von Ressourcengruppen und Speicherkonten zugewiesen ist. Beispielsweise bietet das Zuweisen der Rolle "Mitwirkender" auf Abonnementebene den erforderlichen Zugriff. Weitere Informationen zu Rollenzuweisungen finden Sie unter Rollenbasierte Zugriffssteuerung (Role-based access control, RBAC) in Azure.

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 id-Eigenschaft in der Ausgabe abrufen):

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

  3. Ausführen des Skripts:

    python provision_vm.py

Der Bereitstellungsprozess dauert einige Minuten.

5. Überprüfen der Ressourcen

Öffnen Sie das 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-Portalseite für die neue Ressourcengruppe mit dem virtuellen Computer und den zugehörigen Ressourcen

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

# 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

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, alle Gruppen zu bereinigen, die Sie nicht aktiv verwenden. Mit dem Argument --no-wait kann der Befehl sofort zurückgegeben werden, anstatt auf den Abschluss des Vorgangs zu warten.

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 Code zu löschen. Der Code im Beispiel: Erstellen einer Ressourcengruppe veranschaulicht die Verwendung.

Siehe auch

Die folgenden Ressourcen enthalten umfassendere Beispiele, die Python zum Erstellen eines virtuellen Computers verwenden:

  • Azure Virtual Machines Management Samples - Python (GitHub). Im Beispiel werden weitere Verwaltungsvorgänge demonstriert, wie das Starten und Neustarten einer VM, das Stoppen und Löschen einer VM, das Erhöhen der Festplattengröße und das Verwalten von Datenträgern.