Exemple : Utilisez les bibliothèques Azure pour créer une machine virtuelle

Dans cet article, vous apprendrez à utiliser les bibliothèques de gestion Azure SDK dans un script Python pour créer un groupe de ressources contenant une machine virtuelle Linux.

Sauf indication contraire, toutes les commandes de cet article fonctionnent de la même façon dans les interpréteurs de commandes Windows et bash Linux/macOS.

Les Commandes CLI Azure équivalentes sont listées plus loin dans cet article. Si vous préférez utiliser le portail Azure, veuillez consulter les sections Créer une VM Linux et Créer une VM Windows.

Remarque

La création d’une machine virtuelle par le biais du code est un processus en plusieurs étapes qui implique l’approvisionnement d’un certain nombre d’autres ressources nécessaires à la machine virtuelle. Si vous exécutez simplement ce type de code à partir de la ligne de commande, il est beaucoup plus facile d’utiliser la commande az vm create, qui provisionne automatiquement ces ressources secondaires avec les valeurs par défaut des paramètres que vous choisissez d’omettre. Les seuls arguments requis sont un groupe de ressources, un nom de machine virtuelle, un nom d’image et des informations d’identification de connexion. Pour plus d’informations, consultez Créer rapidement une machine virtuelle avec l’interface Azure CLI.

1 : Configurez votre environnement de développement local

Si vous ne l’avez pas encore fait, configurez un environnement où vous pouvez exécuter ce code. Voici quelques options possibles :

• Configurez un environnement virtuel Python en utilisant venv ou votre outil de choix. Vous pouvez créer l’environnement virtuel localement ou dans Azure Cloud Shell et y exécuter le code. Assurez-vous d’activer l’environnement virtuel pour commencer à l’utiliser.

• Utilisez un environnement conda.

• Utilisez un conteneur de développement dans Visual Studio Code ou GitHub Codespaces.

2 : Installez les packages de bibliothèques Azure nécessaires

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

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

Ensuite, dans votre terminal ou invite de commande avec l’environnement virtuel activé, installez les bibliothèques de gestion listées dans requirements.txt :

pip install -r requirements.txt

3 : Écrire du code pour créer une machine virtuelle

Créez un fichier Python nommé provision_vm.py avec le code suivant. Les commentaires expliquent les détails :

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

Authentification dans le code

Plus loin dans cet article, vous vous connecterez à Azure avec l’Azure CLI pour exécuter le code d’exemple. Si votre compte dispose des autorisations nécessaires pour créer des groupes de ressources et des ressources réseau et de calcul dans votre abonnement Azure, le code s’exécutera avec succès.

Pour utiliser un tel code dans un script de production, vous pouvez définir des variables d’environnement pour utiliser une méthode d’authentification basée sur un principal de service. Pour en savoir plus, veuillez consulter la section Comment authentifier les applications Python avec les services Azure. Vous devez vous assurer que le principal de service dispose des autorisations suffisantes pour créer des groupes de ressources et des ressources réseau et de calcul dans votre abonnement en lui assignant un rôle approprié dans Azure ; par exemple, le rôle Collaborateur sur votre abonnement.

Liens de référence pour les classes utilisées dans le code

• DefaultAzureCredential (azure.identity)
• ResourceManagementClient (azure.mgmt.resource)
• NetworkManagementClient (azure.mgmt.network)
• ComputeManagementClient (azure.mgmt.compute)

4. Exécutez le script

1. Si ce n’est déjà fait, connectez-vous à Azure en utilisant l’Azure CLI :

   az login
   

2. Définissez la variable d’environnement AZURE_SUBSCRIPTION_ID à votre ID d’abonnement. (Vous pouvez exécuter la commande az account show et obtenir votre ID d’abonnement à partir de la propriété id dans la sortie) :

   cmd

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

   bash

   AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
   

3. Exécutez le script :

   python provision_vm.py
   

Le processus de configuration prend quelques minutes.

5. Vérifiez les ressources

Ouvrez le portail Azure, naviguez jusqu’au groupe de ressources "PythonAzureExample-VM-rg" et notez la machine virtuelle, le disque virtuel, le groupe de sécurité réseau, l’adresse IP publique, l’interface réseau et le réseau virtuel.

Vous pouvez également utiliser l’interface de ligne de commande Azure pour vérifier que la VM existe avec la commande az vm list :

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

Commandes CLI Azure équivalentes

cmd

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

bash

# Provision the resource group

az group create -n PythonAzureExample-VM-rg -l westus2

# 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

# Provision a public IP address

az network public-ip create -g PythonAzureExample-VM-rg -n python-example-ip \
    --allocation-method Dynamic --version IPv4

# 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

# 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

Si vous obtenez une erreur concernant les restrictions de capacité, vous pouvez essayer une taille ou une région différente. Pour plus d’informations, consultez la section Résoudre les erreurs pour SKU non disponible.

6 : Nettoyez les ressources

Laissez les ressources en place si vous souhaitez continuer à utiliser la machine virtuelle et le réseau que vous avez créés dans cet article. Sinon, exécutez la commande az group delete pour supprimer le groupe de ressources.

Les groupes de ressources n’entraînent pas de frais continus dans votre abonnement, mais les ressources contenues dans le groupe, comme les machines virtuelles, peuvent continuer à générer des frais. Il est conseillé de nettoyer tout groupe que vous n’utilisez pas activement. L’argument --no-wait permet à la commande de retourner immédiatement un résultat au lieu d’attendre que l’opération se termine.

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

Vous pouvez également utiliser la méthode ResourceManagementClient.resource_groups.begin_delete pour supprimer un groupe de ressources du code. Le code dans Exemple : Créer un groupe de ressources démontre l’utilisation.

Voir aussi

• Exemple : Créer un groupe de ressources
• Exemple : Lister les groupes de ressources dans un abonnement
• Exemple : Créer un stockage Azure
• Exemple : Utiliser le stockage Azure
• Exemple : Créer une application web et déployer le code
• Exemple : Créer et interroger une base de données
• Utiliser des disques managés Azure avec des machines virtuelles
• Répondre à une courte enquête sur le SDK Azure pour Python

Les ressources suivantes contiennent d’autres exemples complets qui utilise Python pour créer une machine virtuelle :

• Exemples de gestion de machines virtuelles Azure – Python (GitHub). L’exemple démontre d’autres opérations de gestion telles que le démarrage et le redémarrage d’une VM, l’arrêt et la suppression d’une VM, l’augmentation de la taille du disque et la gestion des disques de données.