Tutorial: Implementación de una máquina virtual en la versión preliminar de MEC público de Azure mediante el SDK para Python

Artículo
03/10/2023

En este tutorial, usará el SDK de Python para implementar recursos en el proceso perimetral multiacceso (MEC) público de Azure. En el tutorial se proporciona código de Python para implementar una máquina virtual (VM) y sus dependencias en el MEC público de Azure.

Para información sobre los SDK de Python, consulte Bibliotecas de Azure para patrones de uso de Python.

En este tutorial, aprenderá a:

Instalar los paquetes de biblioteca de Azure necesarios
Aprovisionamiento de una máquina virtual
Ejecutar el script en el entorno de desarrollo
Crear un servidor de salto en la región asociada
Acceder a las máquinas virtuales

Requisitos previos

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.
Agregue una suscripción de la lista de permitidos a su cuenta de Azure, lo que le permite implementar recursos en MEC público de Azure. Si no tiene ninguna suscripción permitida activa, póngase en contacto con el equipo de producto del MEC público de Azure.
Configure Python en el entorno de desarrollo local siguiendo las instrucciones que se indican en Configuración del entorno de desarrollo local de Python para Azure. Asegúrese de crear una entidad de servicio para desarrollo local, así como de crear y activar un entorno virtual para el proyecto de este tutorial.

Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Inicio rápido para Bash en Azure Cloud Shell.
Si prefiere ejecutar comandos de referencia de la CLI localmente, instale la CLI de Azure. Si utiliza Windows o macOS, considere la posibilidad de ejecutar la CLI de Azure en un contenedor Docker. Para más información, vea Ejecución de la CLI de Azure en un contenedor de Docker.
- Si usa una instalación local, inicie sesión en la CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Inicio de sesión con la CLI de Azure.
- En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.
- Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.

Instalar los paquetes de biblioteca de Azure necesarios

Cree un archivo llamado requirements.txt en el que se enumeren las bibliotecas de administración que se usan en este ejemplo.
```
azure-mgmt-resource
azure-mgmt-compute
azure-mgmt-network
azure-identity
azure-mgmt-extendedlocation==1.0.0b2
```
Abra un símbolo del sistema con el entorno virtual activado e instale las bibliotecas de administración enumeradas en requirements.txt.
```
pip install -r requirements.txt
```

Aprovisionamiento de una máquina virtual

Cree un archivo de Python llamado provision_vm_edge.py e incluya el siguiente script de Python. El script implementa la máquina virtual y su dependencia asociada en el MEC público de Azure. En los comentarios del script se explican los detalles.

# 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 ejecutar el script, rellene estas variables usadas en la sección del paso 1 del script:

Nombre de la variable	Descripción
LOCATION	Región de Azure asociada a la ubicación del MEC público de Azure.
PUBLIC_MEC_LOCATION	Identificador de ubicación/identificador de zona perimetral del MEC público de Azure.
PASSWORD	Contraseña que se usará para iniciar sesión en la máquina virtual.

Nota:

Cada sitio del MEC público de Azure está asociado a una región de Azure. En función de la ubicación del MEC público de Azure donde se deba implementar el recurso, seleccione el valor de región adecuado para el grupo de recursos que se va a crear. Para más información, consulte Conceptos clave sobre el MEC público de Azure.

Ejecutar el script en el entorno de desarrollo

Ejecute el script de Python que copió de la sección anterior.
```
python provision_vm_edge.py
```

Espere unos minutos a que se creen la máquina virtual y los recursos auxiliares.

En la salida de ejemplo siguiente se muestra que la operación de creación de la máquina virtual se realizó correctamente.

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

En la salida del campo python-example-ip-edge, anote su propio valor de publicIpAddress. Use esta dirección para acceder a la máquina virtual en la sección siguiente.

Crear un servidor de salto en la región asociada

Para usar SSH para conectarse a la máquina virtual en el MEC público de Azure, el mejor método es implementar un JumpBox en una región de Azure donde se implementó el grupo de recursos en la sección anterior.

Siga los pasos que se indican en Uso de las bibliotecas de Azure para aprovisionar una máquina virtual.
Anote su propio valor de publicIpAddress en la salida del campo python-example-ip de la máquina virtual del servidor de salto. Use esta dirección para acceder a la máquina virtual en la sección siguiente.

Acceder a las máquinas virtuales

Use SSH para conectarse a la máquina virtual de JumpBox que implementó en la región con su dirección IP que anotó anteriormente.
```
ssh  azureuser@<python-example-ip>
```
Desde el JumpBox, use SSH para conectarse a la máquina virtual que creó en el MEC público de Azure con su dirección IP que anotó anteriormente.
```
ssh azureuser@<python-example-ip-edge>
```
Asegúrese de que los grupos de seguridad de red de Azure permiten el acceso en el puerto 22 a las máquinas virtuales que cree.

Limpieza de recursos

En este tutorial, ha creado una máquina virtual en el MEC público de Azure mediante el SDK de Python. Si no cree que vaya a necesitar estos recursos en el futuro, use el comando az group delete para quitar el grupo de recursos, el conjunto de escalado y todos los recursos relacionados. Al usar el parámetro --yes, se eliminan los recursos sin una solicitud de confirmación.

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

Pasos siguientes

Si tiene preguntas sobre el MEC público de Azure, póngase en contacto con el equipo del producto:

Equipo de producto de MEC público de Azure