Udostępnij za pośrednictwem

Przykład: tworzenie maszyny wirtualnej przy użyciu bibliotek platformy Azure

  • Artykuł

Z tego artykułu dowiesz się, jak za pomocą bibliotek zarządzania zestawu Azure SDK w skryscie języka Python utworzyć grupę zasobów zawierającą maszynę wirtualną z systemem Linux.

Wszystkie polecenia w tym artykule działają tak samo w powłokach poleceń systemu Linux/macOS i Windows, chyba że zostały zaznaczone.

Równoważne polecenia interfejsu wiersza polecenia platformy Azure są wymienione w dalszej części tego artykułu. Jeśli wolisz korzystać z witryny Azure Portal, zobacz Tworzenie maszyny wirtualnej z systemem Linux i Tworzenie maszyny wirtualnej z systemem Windows.

Uwaga

Tworzenie maszyny wirtualnej za pomocą kodu to wieloetapowy proces obejmujący aprowizowanie wielu innych zasobów, których wymaga maszyna wirtualna. Jeśli po prostu uruchamiasz taki kod z wiersza polecenia, znacznie łatwiej jest użyć az vm create polecenia , które automatycznie aprowizuje te zasoby pomocnicze z wartościami domyślnymi dla dowolnego wybranego ustawienia. Jedynymi wymaganymi argumentami są grupa zasobów, nazwa maszyny wirtualnej, nazwa obrazu i poświadczenia logowania. Aby uzyskać więcej informacji, zobacz Szybkie tworzenie maszyny wirtualnej przy użyciu interfejsu wiersza polecenia platformy Azure.

1: Konfigurowanie lokalnego środowiska projektowego

Jeśli jeszcze tego nie zrobiono, skonfiguruj środowisko, w którym można uruchomić ten kod. Oto kilka opcji:

  • Skonfiguruj środowisko wirtualne języka Python przy użyciu venv lub wybranego narzędzia. Środowisko wirtualne można utworzyć lokalnie lub w usłudze Azure Cloud Shell i uruchomić tam kod. Pamiętaj, aby aktywować środowisko wirtualne, aby rozpocząć korzystanie z niego.

  • Użyj środowiska conda.

  • Użyj kontenera deweloperskiego w programie Visual Studio Code lub GitHub Codespaces.

2: Instalowanie wymaganych pakietów bibliotek platformy Azure

Utwórz plik requirements.txt zawierający listę bibliotek zarządzania używanych w tym przykładzie:

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

Następnie w terminalu lub wierszu polecenia z aktywowanym środowiskiem wirtualnym zainstaluj biblioteki zarządzania wymienione w requirements.txt:

pip install -r requirements.txt

3. Pisanie kodu w celu utworzenia maszyny wirtualnej

Utwórz plik w języku Python o nazwie provision_vm.py przy użyciu następującego kodu. Komentarze wyjaśniają szczegóły:

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

Uwierzytelnianie w kodzie

W dalszej części tego artykułu zalogujesz się na platformie Azure przy użyciu interfejsu wiersza polecenia platformy Azure, aby uruchomić przykładowy kod. Jeśli Twoje konto ma uprawnienia do tworzenia grup zasobów oraz zasobów sieciowych i obliczeniowych w ramach subskrypcji platformy Azure, kod zostanie uruchomiony pomyślnie.

Aby użyć takiego kodu w skryscie produkcyjnym, można ustawić zmienne środowiskowe, aby użyć metody opartej na jednostce usługi na potrzeby uwierzytelniania. Aby dowiedzieć się więcej, zobacz Jak uwierzytelniać aplikacje języka Python za pomocą usług platformy Azure. Musisz upewnić się, że jednostka usługi ma wystarczające uprawnienia do tworzenia grup zasobów i zasobów sieciowych i obliczeniowych w ramach subskrypcji, przypisując jej odpowiednią rolę na platformie Azure, na przykład rolę Współautor w ramach subskrypcji.

4. Uruchamianie skryptu

  1. Jeśli jeszcze tego nie zrobiono, zaloguj się do platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure:

    az login

  2. Ustaw zmienną środowiskową AZURE_SUBSCRIPTION_ID na identyfikator subskrypcji. (Możesz uruchomić polecenie az account show i pobrać identyfikator subskrypcji z id właściwości w danych wyjściowych):

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

  3. Uruchom skrypt:

    python provision_vm.py

Proces aprowizacji trwa kilka minut.

5. Weryfikowanie zasobów

Otwórz witrynę Azure Portal, przejdź do grupy zasobów "PythonAzureExample-VM-rg" i zanotuj maszynę wirtualną, dysk wirtualny, sieciową grupę zabezpieczeń, publiczny adres IP, interfejs sieciowy i sieć wirtualną.

Strona witryny Azure Portal dla nowej grupy zasobów przedstawiająca maszynę wirtualną i powiązane zasoby

Możesz również użyć interfejsu wiersza polecenia platformy Azure, aby sprawdzić, czy maszyna wirtualna istnieje za pomocą polecenia az vm list :

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

Równoważne polecenia interfejsu wiersza polecenia platformy Azure

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

Jeśli wystąpi błąd dotyczący ograniczeń pojemności, możesz spróbować użyć innego rozmiaru lub regionu. Aby uzyskać więcej informacji, zobacz Rozwiązywanie błędów dotyczących niedostępnych jednostek SKU.

6. Czyszczenie zasobów

Pozostaw zasoby w miejscu, jeśli chcesz nadal korzystać z maszyny wirtualnej i sieci utworzonej w tym artykule. W przeciwnym razie uruchom polecenie az group delete , aby usunąć grupę zasobów.

Grupy zasobów nie generują żadnych bieżących opłat w ramach subskrypcji, ale zasoby zawarte w grupie, takie jak maszyny wirtualne, mogą nadal ponosić opłaty. Dobrym rozwiązaniem jest wyczyszczenie każdej grupy, której nie używasz aktywnie. Argument --no-wait umożliwia polecenie natychmiastowego zwrócenia zamiast oczekiwania na zakończenie operacji.

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

Możesz również użyć ResourceManagementClient.resource_groups.begin_delete metody , aby usunąć grupę zasobów z kodu. Kod w przykładzie: Tworzenie grupy zasobów demonstruje użycie.

Zobacz też

Poniższe zasoby zawierają bardziej kompleksowe przykłady użycia języka Python do utworzenia maszyny wirtualnej: