Tutoriel : Déployer une machine virtuelle dans Azure MEC public à l’aide du SDK Python

Article
03/10/2023

Dans ce tutoriel, vous utilisez le SDK Python pour déployer des ressources dans Azure Multi-Access Edge Compute (MEC) public. Ce tutoriel fournit du code Python pour déployer une machine virtuelle et ses dépendances dans Azure MEC public.

Pour plus d’informations sur les SDK Python, consultez Modèles d’utilisation des bibliothèques Azure pour Python.

Dans ce tutoriel, vous allez apprendre à :

Installer les packages de bibliothèque Azure nécessaires
Approvisionner une machine virtuelle
Exécuter le script dans votre environnement de développement
Créer un serveur de rebond dans la région associée
Accéder aux machines virtuelles

Prérequis

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Ajoutez un abonnement sur liste d’autorisation à votre compte Azure, ce qui vous permet de déployer des ressources dans Azure MEC public. Si vous n’avez pas d’abonnement autorisé actif, contactez l’équipe produit d’Azure MEC public.
Configurez Python dans votre environnement de développement local en suivant les instructions fournies dans Configurer votre environnement de développement Python local pour Azure. Veillez à créer un principal de service pour le développement local, puis créez et activez un environnement virtuel pour le projet de ce tutoriel.

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrage rapide pour Bash dans Azure Cloud Shell.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

Installer les packages de bibliothèque Azure nécessaires

Créez un fichier nommé requirements.txt qui liste les bibliothèques de gestion utilisées dans cet exemple.

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

Ouvrez une invite de commandes avec l’environnement virtuel activé, puis installez les bibliothèques de gestion listées dans requirements.txt.
```
pip install -r requirements.txt
```

Approvisionner une machine virtuelle

Créez un fichier Python nommé provision_vm_edge.py et remplissez-le avec le script Python suivant. Le script déploie la machine virtuelle et sa dépendance associée dans Azure MEC public. Les commentaires dans le script expliquent les détails.

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

Avant d’exécuter le script, renseignez les variables utilisées dans l’étape 1 de cette section du script :

Nom de la variable	Description
LOCATION	Région Azure associée à l’emplacement d’Azure MEC public
PUBLIC_MEC_LOCATION	ID de l’identificateur/EdgeZone de l’emplacement d’Azure MEC public
PASSWORD	Mot de passe à utiliser pour se connecter à la machine virtuelle

Notes

Chaque site Azure MEC public est associé à une région Azure. En fonction de l’emplacement d’Azure MEC public dans lequel la ressource doit être déployée, sélectionnez la valeur de région appropriée pour le groupe de ressources à créer. Pour plus d’informations, consultez Concepts clés d’Azure MEC public.

Exécuter le script dans votre environnement de développement

Exécutez le script Python que vous avez copié dans la section précédente.
```
python provision_vm_edge.py
```

Attendez quelques minutes pour que la machine virtuelle et les ressources de prise en charge soient créées.

L’exemple de sortie suivant illustre la réussite de l’opération de création d’une machine virtuelle.

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

Dans la sortie du champ python-example-ip-edge, notez votre propre valeur publicIpAddress. Utilisez cette adresse pour accéder à la machine virtuelle dans la prochaine section.

Créer un serveur de rebond dans la région associée

Pour utiliser SSH afin de se connecter à la machine virtuelle dans la solution Azure MEC public, la meilleure méthode consiste à déployer un serveur de rebond dans une région Azure où votre groupe de ressources a été déployé lors de la section précédente.

Suivez les étapes décrites dans Utiliser les bibliothèques Azure pour provisionner une machine virtuelle.
Notez votre propre valeur publicIpAddress dans la sortie du champ python-example-ip de la machine virtuelle faisant office de serveur de rebond. Utilisez cette adresse pour accéder à la machine virtuelle dans la prochaine section.

Accéder aux machines virtuelles

Utilisez SSH pour vous connecter à la machine virtuelle faisant office de serveur de rebond que vous avez déployée dans la région avec son adresse IP que vous avez notée précédemment.
```
ssh  azureuser@<python-example-ip>
```
À partir du serveur de rebond, utilisez SSH pour vous connecter à la machine virtuelle que vous avez créée dans la solution Azure MEC public avec son adresse IP que vous avez notée précédemment.
```
ssh azureuser@<python-example-ip-edge>
```
Vérifiez que les groupes de sécurité réseau Azure autorisent l’accès du port 22 aux machines virtuelles que vous créez.

Nettoyer les ressources

Dans ce tutoriel, vous avez créé une machine virtuelle dans Azure MEC public à l’aide du SDK Python. Si vous pensez ne pas avoir besoin de ces ressources à l’avenir, utilisez la commande az group delete pour supprimer le groupe de ressources, le groupe identique et toutes les ressources associées. L’utilisation du paramètre --yes supprime les ressources sans invite de confirmation.

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

Étapes suivantes

Pour toute question sur Azure MEC public, contactez l’équipe produit :

Équipe produit d’Azure MEC public

Partager via