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

Dans cet article, vous allez apprendre à utiliser les bibliothèques de gestion du Kit de développement logiciel (SDK) Azure dans un script Python pour créer un groupe de ressources qui contient une machine virtuelle Linux.

Les commandes Azure CLI équivalentes sont répertoriées plus loin dans cet article. Si vous préférez utiliser le portail Azure, consultez Créer une machine virtuelle Linux et créer une machine virtuelle Windows.

Remarque

La création d’une machine virtuelle via du code est un processus en plusieurs étapes qui implique l’approvisionnement d’un certain nombre de ressources dont la machine virtuelle a besoin. Si vous exécutez simplement ce code à partir de la ligne de commande, il est beaucoup plus facile d’utiliser la az vm create commande, qui provisionne automatiquement ces ressources secondaires avec des valeurs par défaut pour n’importe quel paramètre 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éation rapide d’une machine virtuelle avec Azure CLI.

1 : Configurer votre environnement de développement local

Si ce n’est déjà fait, configurez un environnement dans lequel vous pouvez exécuter ce code. Voici quelques options :

#!/bin/bash
# Create a virtual environment
python -m venv .venv
# Activate the virtual environment
source .venv/Scripts/activate # only required for Windows (Git Bash)

• Utilisez un environnement conda. Pour installer Conda, consultez Installer Miniconda.

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

2 : Installer les packages de bibliothèque Azure nécessaires

Créez un fichier requirements.txt spécifiant les packages de gestion du Kit de développement logiciel (SDK) Azure requis par ce script.

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

Ensuite, installez les bibliothèques de gestion spécifié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 connectez à Azure à l’aide d’Azure CLI pour exécuter l’exemple de code. Si votre compte dispose des autorisations suffisantes pour créer des groupes de ressources et des ressources de stockage dans votre abonnement Azure, le script doit s’exécuter correctement sans configuration supplémentaire.

Pour utiliser ce code dans un environnement de production, authentifiez-vous à l’aide d’un principal de service en définissant des variables d’environnement. Cette approche permet un accès sécurisé et automatisé sans compter sur la connexion interactive. Pour obtenir des instructions détaillées, consultez Comment authentifier les applications Python avec les services Azure.

Vérifiez que le principal de service est affecté à un rôle disposant d’autorisations suffisantes pour créer des groupes de ressources et des comptes de stockage. Par exemple, l’attribution du rôle Contributeur au niveau de l’abonnement fournit l’accès nécessaire. Pour en savoir plus sur les attributions de rôles, consultez Contrôle d’accès en fonction du rôle (RBAC) dans Azure.

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

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

4. Exécuter le script

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

   az login
   

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

   export AZURE_SUBSCRIPTION_ID=$(az account show --query id -o tsv)
   

3. Exécutez le script :

   python provision_vm.py
   

Le processus d’approvisionnement prend quelques minutes.

5. Vérifier les ressources

Ouvrez le portail Azure, accédez au groupe de ressources « PythonAzureExample-VM-rg », puis 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 Azure CLI pour vérifier que la machine virtuelle existe avec la commande az vm list :

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

Commandes Azure CLI équivalentes

# 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 autre taille ou région. Pour plus d’informations, consultez Résoudre les erreurs pour la référence SKU non disponible.

6 : Nettoyer 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, telles que les machines virtuelles, peuvent continuer à entraîner des frais. Il est recommandé de nettoyer n’importe quel groupe que vous n’utilisez pas activement. L’argument --no-wait permet à la commande de retourner immédiatement au lieu d’attendre la fin de l’opération.

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 l’exemple : Créer un groupe de ressources illustre l’utilisation.

Voir aussi

• Exemple : Créer un groupe de ressources
• Exemple : répertorier 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 du code
• Exemple : Créer et interroger une base de données
• Utiliser des disques managés Azure avec des machines virtuelles
• Effectuer une courte enquête sur le Kit de développement logiciel (SDK) Azure pour Python

Les ressources suivantes contiennent des exemples plus complets utilisant Python pour créer une machine virtuelle :

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