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

Artigo
11/22/2022

Neste tutorial, você usará o SDK do Python para implantar recursos na MEC (computação de borda de acesso múltiplo pública) pública do Azure. O tutorial fornece um código Python para implantar uma VM (máquina virtual) e as dependências na MEC pública do Azure.

Para saber mais sobre os SDKs do Python, confira Bibliotecas do Azure para padrões de uso do Python.

Neste tutorial, você aprenderá como:

Instalar os pacotes da biblioteca do Azure necessários
Provisionar uma máquina virtual
Executar o script no seu ambiente de desenvolvimento
Criar um jump server na região associada
Acessar as VMs

Pré-requisitos

Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
Adicione uma assinatura incluída na lista de permitidos à sua conta do Azure, o que permite que você implante recursos na MEC pública do Azure. Caso você não tenha uma assinatura ativa permitida, entre em contato com a equipe de produto da MEC pública do Azure.
Configure o Python no ambiente de desenvolvimento local seguindo as instruções descritas em Configurar o ambiente de desenvolvimento local do Python para o Azure. Crie uma entidade de serviço para o desenvolvimento local e crie e ative um ambiente virtual para o projeto deste tutorial.

Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Início Rápido para Bash no Azure Cloud Shell.
Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Para execuções no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
- Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para ver outras opções de entrada, confira Conectar-se com a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.
- Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

Instalar os pacotes da biblioteca do Azure necessários

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

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

Abra um prompt de comando com o ambiente virtual ativado e instale as bibliotecas de gerenciamento listadas em requirements.txt.
```
pip install -r requirements.txt
```

Provisionar uma máquina virtual

Crie um arquivo Python chamado provision_vm_edge.py e preencha-o com o script Python a seguir. O script implantará a VM e a dependência associada na MEC pública do Azure. Os comentários do 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}")

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

Nome da variável	Descrição
LOCALIZAÇÃO	Região do Azure associada à localização da MEC pública do Azure
PUBLIC_MEC_LOCATION	Identificador de localização/ID do Edge Zone da MEC pública do Azure
PASSWORD	Senha a ser usada para entrada na VM

Observação

Cada site da MEC pública do Azure está associado a uma região do Azure. Com base na localização da MEC pública do Azure em que o recurso precisa ser implantado, selecione o valor de região apropriado para o grupo de recursos a ser criado. Para saber mais, confira Principais conceitos da MEC pública do Azure.

Executar o script no seu ambiente de desenvolvimento

Execute o script Python copiado da seção anterior.
```
python provision_vm_edge.py
```

Aguarde alguns minutos para a VM e os recursos de suporte serem criados.

O seguinte exemplo de saída mostra que a operação de criação de VM foi bem-sucedida.

(.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

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

Criar um jump server na região associada

Para usar o SSH para se conectar à VM na MEC pública do Azure, o melhor método é implantar um jump box em uma região do Azure em que o grupo de recursos foi implantado na seção anterior.

Siga as etapas descritas em Usar as bibliotecas do Azure para provisionar uma máquina virtual.
Anote seu publicIpAddress na saída do campo python-example-ip da VM do jump server. Use esse endereço para acessar a VM na próxima seção.

Acessar as VMs

Use o SSH para se conectar à VM jump box implantada na região com o endereço IP já anotado.
```
ssh  azureuser@<python-example-ip>
```
No jump box, use o SSH para se conectar à VM criada na MEC pública do Azure com o endereço IP já anotado.
```
ssh azureuser@<python-example-ip-edge>
```
Verifique se os grupos de segurança de rede do Azure permitem acesso à porta 22 nas VMs criadas.

Limpar os recursos

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

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

Próximas etapas

Em caso de dúvidas sobre a MEC pública do Azure, entre em contato com a equipe de produto:

Equipe de produto da MEC pública do Azure

Compartilhar via