Ejemplo: Uso de las bibliotecas de Azure para crear una máquina virtual

Este artículo le mostrará cómo usar las bibliotecas de administración de Azure SDK en un script de Python para crear un grupo de recursos que contiene una máquina virtual Linux.

Todos los comandos de este artículo funcionan igual en el bash de Linux o macOS y en los shells de comandos de Windows, a menos que se indique lo contrario.

Más adelante en este artículo se indican los comandos equivalentes de la CLI de Azure. Si prefiere usar Azure Portal, consulte Creación de una máquina virtual Linux y Creación de una máquina virtual Windows.

Nota:

La creación de una máquina virtual mediante código es un proceso de varios pasos que implica el aprovisionamiento de una serie de recursos que la máquina virtual requiere. Si simplemente ejecuta ese código desde la línea de comandos, es mucho más sencillo usar el comando az vm create, que aprovisiona automáticamente estos recursos secundarios con valores predeterminados para cualquier valor que decida omitir. Los únicos argumentos necesarios son un grupo de recursos, el nombre de la máquina virtual, el nombre de la imagen y las credenciales de inicio de sesión. Para más información, consulte Creación rápida de una máquina virtual con la CLI de Azure.

1: Configuración del entorno de desarrollo local

Si aún no lo ha hecho, configure un entorno en el que pueda ejecutar este código. Estas son algunas opciones:

• Configure un entorno virtual de Python mediante venv o la herramienta que prefiera. Puede crear el entorno virtual localmente o en Azure Cloud Shell y ejecutar el código allí. Asegúrese de activar el entorno virtual para empezar a usarlo.

• Use un entorno de conda.

• Use un contenedor de desarrollo en Visual Studio Code o GitHub Codespaces.

2: Instalación de los paquetes de biblioteca de Azure necesarios

Cree un archivo 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

Luego, en el terminal o el símbolo del sistema con el entorno virtual activado, instale las bibliotecas de administración enumeradas en requirements.txt:

pip install -r requirements.txt

3: Escritura de código para crear una máquina virtual

Cree un archivo de Python llamado provision_vm.py con el siguiente código. Los detalles se explican en los comentarios:

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

Autenticación en el código

Más adelante en este artículo, debe iniciar sesión en Azure con la CLI de Azure para ejecutar el código de ejemplo. Si la cuenta tiene permisos para crear grupos de recursos y recursos de red y de proceso en la suscripción de Azure, el código se ejecutará correctamente.

Para usar este código en un script de producción, puede establecer variables de entorno para usar un método basado en la entidad de servicio para la autenticación. Para más información, consulte Autenticación de aplicaciones de Python con los servicios de Azure. Debe asegurarse de que la entidad de servicio tenga permisos suficientes para crear grupos de recursos y red y recursos de proceso en la suscripción mediante la asignación de un rol adecuado en Azure; por ejemplo, el rol Colaborador de la suscripción.

Vínculos de referencia a las clases usadas en el código

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

4. Ejecución del script

1. Si aún no lo ha hecho, inicie sesión en Azure mediante la CLI de Azure:

   az login
   

2. Establezca como valor de la variable de entorno AZURE_SUBSCRIPTION_ID el identificador de su suscripción. (Puede ejecutar el comando az account show y obtener el identificador de suscripción de la propiedad id en la salida):

   cmd

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

   bash

   AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
   

3. Ejecute el script:

   python provision_vm.py
   

El proceso de aprovisionamiento tarda algunos minutos en completarse.

5. Comprobación de los recursos

Abra Azure Portal, navegue hasta el grupo de recursos "PythonAzureExample-VM-rg" y anote la máquina virtual, el disco virtual, el grupo de seguridad de red, la dirección IP pública, la interfaz de red y la red virtual.

También puede usar la CLI de Azure para comprobar que la máquina virtual existe con el comando az vm list:

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

Comandos equivalentes de la CLI de Azure

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 recibe un error sobre restricciones de capacidad, puede probar otro tamaño o región. Para más información, consulte Resolución de los errores de no disponibilidad de la SKU.

6: Limpieza de recursos

Deje los recursos en su lugar si desea seguir usando la máquina virtual y la red que creó en este artículo. De lo contrario, ejecute el comando az group delete para eliminar el grupo de recursos.

Los grupos de recursos no incurren en cargos continuos en la suscripción, pero es posible que los recursos contenidos en el grupo de recursos, como las máquinas virtuales, sigan generando cargos. Es recomendable limpiar cualquier grupo que no esté usando activamente. El argumento --no-wait permite que el comando devuelva el control inmediatamente en lugar de esperar a que finalice la operación.

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

También puede usar el método ResourceManagementClient.resource_groups.begin_delete para eliminar un grupo de recursos del código. El código de Ejemplo: Creación de un grupo de recursos muestra el uso.

Consulte también

• Ejemplo: Creación de un grupo de recursos
• Ejemplo: Enumeración de los grupos de recursos de una suscripción
• Ejemplo: Creación de Azure Storage
• Ejemplo: Uso de Azure Storage
• Ejemplo: Creación de una aplicación web e implementación de código
• Ejemplo: Creación y consulta de una base de datos
• Uso de Azure Managed Disks con máquinas virtuales
• Realización de una breve encuesta sobre el SDK de Azure para Python

Los siguientes recursos incluyen ejemplos más completos del uso de Python para crear una máquina virtual:

• Ejemplos de administración de Azure Virtual Machines: Python (GitHub). El ejemplo muestra más operaciones de administración, como el inicio y el reinicio de una máquina virtual, la detención y eliminación de una máquina virtual, el aumento del tamaño del disco y la administración de discos de datos.