Partilhar via

Tutorial: Implantar uma máquina virtual no MEC público do Azure usando o SDK do Python

  • Artigo

Neste tutorial, você usa o SDK do Python para implantar recursos no MEC (computação de borda de multiacesso) público do Azure. O tutorial fornece código Python para implantar uma máquina virtual (VM) e suas dependências no MEC público do Azure.

Para obter informações sobre SDKs do Python, consulte Bibliotecas do Azure para padrões de uso do Python.

Neste tutorial, irá aprender a:

  • Instalar os pacotes de biblioteca do Azure necessários
  • Aprovisionar uma máquina virtual
  • Execute o script em seu ambiente de desenvolvimento
  • Criar um servidor de salto na região associada
  • Acessar as VMs

Pré-requisitos

  • Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

  • Adicione uma assinatura permitida à sua conta do Azure, que permite implantar recursos no MEC público do Azure. Se você não tiver uma assinatura ativa permitida, entre em contato com a equipe de produto MEC pública do Azure.

  • Configure o Python em seu ambiente de desenvolvimento local seguindo as instruções em Configurar seu ambiente de desenvolvimento Python local para o Azure. Certifique-se de criar uma entidade de serviço para desenvolvimento local e criar e ativar um ambiente virtual para este projeto tutorial.

  • Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Guia de início rápido para Bash no Azure Cloud Shell.

  • Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

    • Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Entrar com a CLI do Azure.

    • Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.

    • Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

Instalar os pacotes de biblioteca do Azure necessários

  1. Crie um arquivo chamado requirements.txt que lista as bibliotecas de gerenciamento usadas neste exemplo.

    azure-mgmt-resource
azure-mgmt-compute
azure-mgmt-network
azure-identity
azure-mgmt-extendedlocation==1.0.0b2

  2. Abra um prompt de comando com o ambiente virtual ativado e instale as bibliotecas de gerenciamento listadas no requirements.txt.

    pip install -r requirements.txt

Aprovisionar uma máquina virtual

  1. Crie um arquivo Python chamado provision_vm_edge.py e preencha-o com o seguinte script Python. O script implanta a VM e sua dependência associada no MEC público do Azure. Os comentários no script explicam os detalhes.

    # Import the needed credential and management objects from the libraries.
from azure.identity import AzureCliCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.compute import ComputeManagementClient
import os

print(f"Provisioning a virtual machine...some operations might take a minute or two.")

# Acquire a credential object using CLI-based authentication.
credential = AzureCliCredential()

# 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, using the credentials from the CLI login.
resource_client = ResourceManagementClient(credential, subscription_id)

# Constants we need in multiple places: the resource group name, the region and the public mec location
# in which we provision resources. Populate the variables with appropriate values. 
RESOURCE_GROUP_NAME = "PythonAzureExample-VM-rg"
LOCATION = "<region>"
PUBLIC_MEC_LOCATION = "<edgezone id>"
USERNAME = "azureuser"
PASSWORD = "<password>"
# 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: Use the Azure libraries to 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-edge"
SUBNET_NAME = "python-example-subnet-edge"
IP_NAME = "python-example-ip-edge"
IP_CONFIG_NAME = "python-example-ip-config-edge"
NIC_NAME = "python-example-nic-edge"

# 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,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},
        "address_space": {
            "address_prefixes": ["10.1.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.1.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
# Only the standard public IP SKU is supported at EdgeZones
poller = network_client.public_ip_addresses.begin_create_or_update(RESOURCE_GROUP_NAME,
    IP_NAME,
    {
        "location": LOCATION,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_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,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_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-edge"

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 DSv2-series 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,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},
        "storage_profile": {
            "image_reference": {
                "publisher": 'Canonical',
                "offer": "UbuntuServer",
                "sku": "18.04-LTS",
                "version": "latest"
            }
        },
        "hardware_profile": {
            "vm_size": "Standard_DS2_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}")

  2. Antes de executar o script, preencha estas variáveis usadas na seção de etapa 1 do script:

    Nome da variável Description
    LOCALIZAÇÃO Região do Azure associada ao local MEC público do Azure
    PUBLIC_MEC_LOCATION Identificador de localização MEC público do Azure/ID de zona de borda
    PALAVRA-PASSE Palavra-passe a utilizar para iniciar sessão na VM

    Nota

    Cada site MEC público do Azure está associado a uma região do Azure. Com base no local MEC público do Azure onde o recurso precisa ser implantado, selecione o valor de região apropriado para o grupo de recursos a ser criado. Para obter mais informações, consulte Principais conceitos para o MEC público do Azure.

Execute o script em seu ambiente de desenvolvimento

  1. Execute o script Python copiado da seção anterior.

    python provision_vm_edge.py

  2. Aguarde alguns minutos para que a VM e os recursos de suporte sejam criados.

    O seguinte resultado de exemplo mostra que a operação de criação da VM foi concluída com êxito.

    (.venv) C:\Users >python provision_vm_edge.py
Provisioning a virtual machine...some operations might take a minute or two.
Provisioned resource group PythonAzureExample-VM-rg in the <region> region
Provisioned virtual network python-example-vnet-edge with address prefixes ['10.1.0.0/16']
Provisioned virtual subnet python-example-subnet-edge with address prefix 10.1.0.0/24
Provisioned public IP address python-example-ip-edge with address <public ip>
Provisioned network interface client python-example-nic-edge
Provisioning virtual machine ExampleVM-edge; this operation might take a few minutes.
Provisioned virtual machine ExampleVM-edge

  3. Na saída do campo python-example-ip-edge, observe seu próprio publicIpAddress. Use esse endereço para acessar a VM na próxima seção.

Criar um servidor de salto na região associada

Para usar SSH para se conectar à VM no MEC público do Azure, o melhor método é implantar uma caixa de salto em uma região do Azure onde seu grupo de recursos foi implantado na seção anterior.

  1. Siga as etapas em Usar as bibliotecas do Azure para provisionar uma máquina virtual.

  2. Observe seu próprio publicIpAddress na saída do campo python-example-ip da VM do servidor de salto. Use esse endereço para acessar a VM na próxima seção.

Acessar as VMs

  1. Use SSH para se conectar à VM de caixa de salto que você implantou na região com seu endereço IP que você anotou anteriormente.

    ssh  azureuser@<python-example-ip>

  2. Na caixa de salto, use SSH para se conectar à VM que você criou no MEC público do Azure com seu endereço IP que você anotou anteriormente.

    ssh azureuser@<python-example-ip-edge>

  3. Verifique se os grupos de segurança de rede do Azure permitem acesso à porta 22 às VMs que você cria.

Clean up resources (Limpar recursos)

Neste tutorial, você criou uma VM no MEC público do Azure usando o SDK do Python. Se você não espera precisar desses recursos no futuro, use o comando az group delete para remover o grupo de recursos, o conjunto de escala e todos os recursos relacionados. O uso do --yes parâmetro exclui os recursos sem um prompt de confirmação.

az group delete --name PythonAzureExample-VM-rg --yes

Próximos passos

Para perguntas sobre o MEC público do Azure, entre em contato com a equipe do produto:

Equipe de produto MEC pública do Azure