Exemplo: Usar as bibliotecas do Azure para criar uma máquina virtual

  • Artigo

Neste artigo, você aprenderá a usar as bibliotecas de gerenciamento do SDK do Azure em um script Python para criar um grupo de recursos que contém uma máquina virtual Linux.

Todos os comandos neste artigo funcionam da mesma forma em shells de comando Linux/macOS bash e Windows, a menos que indicado.

Os comandos equivalentes da CLI do Azure são listados posteriormente neste artigo. Se preferir usar o portal do Azure, consulte Criar uma VM Linux e Criar uma VM do Windows.

Nota

A criação de uma máquina virtual por meio de código é um processo de várias etapas que envolve o provisionamento de vários outros recursos que a máquina virtual exige. Se você estiver simplesmente executando esse código a partir da linha de comando, é muito mais fácil usar o az vm create comando, que provisiona automaticamente esses recursos secundários com padrões para qualquer configuração que você optar por omitir. Os únicos argumentos necessários são um grupo de recursos, nome da VM, nome da imagem e credenciais de login. Para obter mais informações, consulte Criar rapidamente uma máquina virtual com a CLI do Azure.

1: Configure seu ambiente de desenvolvimento local

Se ainda não o fez, configure um ambiente onde possa executar este código. Seguem-se algumas opções:

  • Configure um ambiente virtual Python usando venv ou sua ferramenta de escolha. Você pode criar o ambiente virtual localmente ou no Azure Cloud Shell e executar o código lá. Certifique-se de ativar o ambiente virtual para começar a usá-lo.

  • Use um ambiente de conda.

  • Use um contêiner de desenvolvimento no Visual Studio Code ou GitHub Codespaces.

2: Instale os pacotes de biblioteca do Azure necessários

Crie um arquivo requirements.txt que liste as bibliotecas de gerenciamento usadas neste exemplo:

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

Em seguida, no seu terminal ou prompt de comando com o ambiente virtual ativado, instale as bibliotecas de gerenciamento listadas em requirements.txt:

pip install -r requirements.txt

3: Escreva código para criar uma máquina virtual

Crie um arquivo Python chamado provision_vm.py com o código a seguir. Os comentários explicam os pormenores:

# 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://video2.skills-academy.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}")

Autenticação no código

Mais adiante neste artigo, você entra no Azure com a CLI do Azure para executar o código de exemplo. Se sua conta tiver permissões para criar grupos de recursos e recursos de rede e computação em sua assinatura do Azure, o código será executado com êxito.

Para usar esse código em um script de produção, você pode definir variáveis de ambiente para usar um método baseado em entidade de serviço para autenticação. Para saber mais, consulte Como autenticar aplicativos Python com serviços do Azure. Você precisa garantir que a entidade de serviço tenha permissões suficientes para criar grupos de recursos e recursos de rede e computação em sua assinatura, atribuindo-lhe uma função apropriada no Azure, por exemplo, a função de Colaborador em sua assinatura.

4. Execute o script

  1. Se ainda não o fez, inicie sessão no Azure utilizando a CLI do Azure:

    az login

  2. Defina a variável de ambiente para sua ID de AZURE_SUBSCRIPTION_ID assinatura. (Você pode executar o comando az account show e obter seu ID de assinatura da id propriedade na saída):

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

  3. Execute o script:

    python provision_vm.py

O processo de provisionamento leva alguns minutos para ser concluído.

5. Verifique os recursos

Abra o portal do Azure, navegue até o grupo de recursos "PythonAzureExample-VM-rg" e anote a máquina virtual, o disco virtual, o grupo de segurança de rede, o endereço IP público, a interface de rede e a rede virtual.

Página do portal do Azure para o novo grupo de recursos mostrando a máquina virtual e os recursos relacionados

Você também pode usar a CLI do Azure para verificar se a VM existe com o comando az vm list:

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

Comandos equivalentes da CLI do 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

Se você receber um erro sobre restrições de capacidade, poderá tentar um tamanho ou região diferente. Para obter mais informações, consulte Resolver erros para SKU não disponível.

6: Limpar recursos

Deixe os recursos no lugar se quiser continuar a usar a máquina virtual e a rede criadas neste artigo. Caso contrário, execute o comando az group delete para excluir o grupo de recursos.

Os grupos de recursos não incorrem em encargos contínuos na sua subscrição, mas os recursos contidos no grupo, como máquinas virtuais, podem continuar a incorrer em encargos. É uma boa prática limpar qualquer grupo que você não esteja usando ativamente. O --no-wait argumento permite que o comando retorne imediatamente em vez de esperar que a operação seja concluída.

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

Você também pode usar o ResourceManagementClient.resource_groups.begin_delete método para excluir um grupo de recursos do código. O código em Exemplo: Criar um grupo de recursos demonstra o uso.

Consulte também

Os recursos a seguir contêm exemplos mais abrangentes usando Python para criar uma máquina virtual: