Share via

Ejemplo: Uso de las bibliotecas de Azure para crear una base de datos

  • Artículo

En este ejemplo se muestra cómo usar las bibliotecas de administración del SDK de Azure en un script de Python para crear una instancia de servidor flexible y una base de datos de Azure Database for MySQL. También proporciona un script sencillo para consultar la base de datos mediante la biblioteca mysql-connector, que no forma parte de Azure SDK. Puede usar código similar para crear una instancia de servidor flexible y una base de datos de Azure Database for PostgreSQL.

Los comandos equivalentes de la CLI de Azure se encuentran más adelante en este artículo. Si prefiere usar Azure Portal, consulte Creación de un servidor MySQL o Creación de un servidor PostgreSQL.

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.

1: Configuración del entorno de desarrollo local

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

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

Cree un archivo llamado requirements.txt con el siguiente contenido:

azure-mgmt-resource
azure-mgmt-rdbms
azure-identity
mysql-connector-python

En un terminal con el entorno virtual activado, instale los requisitos:

pip install -r requirements.txt

Nota:

En Windows, si intenta instalar la biblioteca de MySQL en una biblioteca de Python de 32 bits, se produce un error con el archivo mysql.h. En este caso, instale una versión de 64 bits de Python e inténtelo de nuevo.

3: Escribir código para crear la base de datos

Cree un archivo de Python llamado provision_db.py con el siguiente código. Los detalles se explican en los comentarios. En concreto, especifique variables de entorno para AZURE_SUBSCRIPTION_ID y PUBLIC_IP_ADDRESS. Esta última variable es la dirección IP de la estación de trabajo para que se ejecute este ejemplo. Puede usar WhatsIsMyIP para buscar la dirección IP.

import random, os
from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.rdbms.mysql_flexibleservers import MySQLManagementClient
from azure.mgmt.rdbms.mysql_flexibleservers.models import Server, ServerVersion

# Acquire a credential object using CLI-based authentication.
credential = DefaultAzureCredential()

# Retrieve subscription ID from environment variable
subscription_id = os.environ["AZURE_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-DB-rg'
LOCATION = "southcentralus"

# Step 1: Provision the resource group.
resource_client = ResourceManagementClient(credential, subscription_id)

rg_result = resource_client.resource_groups.create_or_update(RESOURCE_GROUP_NAME,
    { "location": LOCATION })

print(f"Provisioned resource group {rg_result.name}")

# For details on the previous code, see Example: Provision a resource group
# at https://docs.microsoft.com/azure/developer/python/azure-sdk-example-resource-group


# Step 2: Provision the database server

# We use a random number to create a reasonably unique database server name.
# If you've already provisioned a database and need to re-run the script, set
# the DB_SERVER_NAME environment variable to that name instead.
#
# Also set DB_USER_NAME and DB_USER_PASSWORD variables to avoid using the defaults.

db_server_name = os.environ.get("DB_SERVER_NAME", f"python-azure-example-mysql-{random.randint(1,100000):05}")
db_admin_name = os.environ.get("DB_ADMIN_NAME", "azureuser")
db_admin_password = os.environ.get("DB_ADMIN_PASSWORD", "ChangePa$$w0rd24")

# Obtain the management client object
mysql_client = MySQLManagementClient(credential, subscription_id)

# Provision the server and wait for the result
poller = mysql_client.servers.begin_create(RESOURCE_GROUP_NAME,
    db_server_name, 
    Server(
        location=LOCATION,
        administrator_login=db_admin_name,
        administrator_login_password=db_admin_password,
        version=ServerVersion.FIVE7
    )
)

server = poller.result()

print(f"Provisioned MySQL server {server.name}")

# Step 3: Provision a firewall rule to allow the local workstation to connect

RULE_NAME = "allow_ip"
ip_address = os.environ["PUBLIC_IP_ADDRESS"]

# For the above code, create an environment variable named PUBLIC_IP_ADDRESS that
# contains your workstation's public IP address as reported by a site like
# https://whatismyipaddress.com/.

# Provision the rule and wait for completion
poller = mysql_client.firewall_rules.begin_create_or_update(RESOURCE_GROUP_NAME,
    db_server_name, RULE_NAME, 
    { "start_ip_address": ip_address, "end_ip_address": ip_address }  
)

firewall_rule = poller.result()

print(f"Provisioned firewall rule {firewall_rule.name}")


# Step 4: Provision a database on the server

db_name = os.environ.get("DB_NAME", "example-db1")
 
poller = mysql_client.databases.begin_create_or_update(RESOURCE_GROUP_NAME,
    db_server_name, db_name, {})

db_result = poller.result()

print(f"Provisioned MySQL database {db_result.name} with ID {db_result.id}")

Autenticación en el código

Más adelante en este artículo, inicia 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 almacenamiento 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 servicios de Azure. Debe asegurarse de que la entidad de servicio tiene permisos suficientes para crear grupos de recursos y recursos de almacenamiento en la suscripción mediante la asignación de un rol adecuado en Azure; por ejemplo, el rol Colaborador de la suscripción.

Para el servidor de bases de datos PostreSQL, consulte:

4: Ejecutar el script

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

    az login

  2. Establezca las variables de AZURE_SUBSCRIPTION_ID entorno y PUBLIC_IP_ADDRESS . Puede ejecutar el comando az account show para obtener el identificador de suscripción de la id propiedad en la salida. Puede usar WhatsIsMyIP para buscar la dirección IP.

    set AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
set PUBLIC_IP_ADDRESS=<Your public IP address>

  3. Opcionalmente, establezca las DB_SERVER_NAMEvariables de entorno , DB_ADMIN_NAMEy DB_ADMIN_PASSWORD ; de lo contrario, se usan los valores predeterminados de código.

  4. Ejecute el script:

    python provision_db.py

5: Insertar un registro y consultar la base de datos

Cree un archivo llamado use_db.py con el código siguiente. Tenga en cuenta las dependencias de las DB_SERVER_NAMEvariables de entorno , DB_ADMIN_NAMEy DB_ADMIN_PASSWORD . Estos valores se obtienen de la salida de la ejecución del código anterior provision_db.py o en el propio código.

Este código solo funciona para MySQL; se usan bibliotecas diferentes para PostgreSQL.

import os
import mysql.connector

db_server_name = os.environ["DB_SERVER_NAME"]
db_admin_name = os.getenv("DB_ADMIN_NAME", "azureuser")
db_admin_password = os.getenv("DB_ADMIN_PASSWORD", "ChangePa$$w0rd24")

db_name = os.getenv("DB_NAME", "example-db1")
db_port = os.getenv("DB_PORT", 3306)

connection = mysql.connector.connect(user=db_admin_name,
    password=db_admin_password, host=f"{db_server_name}.mysql.database.azure.com",
    port=db_port, database=db_name, ssl_ca='./BaltimoreCyberTrustRoot.crt.pem')

cursor = connection.cursor()

"""
# Alternate pyodbc connection; include pyodbc in requirements.txt
import pyodbc

driver = "{MySQL ODBC 5.3 UNICODE Driver}"

connect_string = f"DRIVER={driver};PORT=3306;SERVER={db_server_name}.mysql.database.azure.com;" \
                 f"DATABASE={DB_NAME};UID={db_admin_name};PWD={db_admin_password}"

connection = pyodbc.connect(connect_string)
"""

table_name = "ExampleTable1"

sql_create = f"CREATE TABLE {table_name} (name varchar(255), code int)"

cursor.execute(sql_create)
print(f"Successfully created table {table_name}")

sql_insert = f"INSERT INTO {table_name} (name, code) VALUES ('Azure', 1)"
insert_data = "('Azure', 1)"

cursor.execute(sql_insert)
print("Successfully inserted data into table")

sql_select_values= f"SELECT * FROM {table_name}"

cursor.execute(sql_select_values)
row = cursor.fetchone()

while row:
    print(str(row[0]) + " " + str(row[1]))
    row = cursor.fetchone()

connection.commit()

Todo este código usa la API mysql.connector. El único elemento específico de Azure es el dominio host completo del servidor MySQL (mysql.database.azure.com).

A continuación, descargue el certificado necesario para comunicarse a través de TSL/SSL con el servidor de Azure Database for MySQL desde https://www.digicert.com/CACerts/BaltimoreCyberTrustRoot.crt.pem y guarde el archivo de certificado en la misma carpeta que el archivo de Python. Para más información, consulte Obtención de un certificado SSL en la documentación de Azure Database for MySQL.

Por último, ejecute el código:

python use_db.py

Si ve un error que indica que la dirección IP del cliente no está permitida, compruebe que ha definido correctamente la variable PUBLIC_IP_ADDRESS de entorno. Si ya ha creado el servidor MySQL con la dirección IP incorrecta, puede agregar otro en Azure Portal. En el portal, seleccione el servidor MySQL y, a continuación, seleccione seguridad de Conectar ion. Agregue la dirección IP de la estación de trabajo a la lista de direcciones IP permitidas.

6: Limpieza de recursos

Ejecute el comando az group delete si no es necesario mantener el grupo de recursos y los recursos de almacenamiento creados en este ejemplo.

Los grupos de recursos no incurren en cargos continuos en la suscripción, pero los recursos, como las cuentas de almacenamiento, en el grupo de recursos pueden seguir incurr en 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-DB-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: Crear un grupo de recursos muestra el uso.

Como referencia: comandos equivalentes de la CLI de Azure

Los siguientes comandos de la CLI de Azure realizan los mismos pasos de aprovisionamiento que el script de Python. Para una base de datos postgreSQL, use az postgres flexible-server comandos.

az group create --location southcentralus --name PythonAzureExample-DB-rg

az mysql flexible-server create --location southcentralus --resource-group PythonAzureExample-DB-rg ^
    --name python-azure-example-mysql-12345 --admin-user azureuser --admin-password ChangePa$$w0rd24 ^
    --sku-name Standard_B1ms --version 5.7 --yes

# Change the IP address to the public IP address of your workstation, that is, the address shown
# by a site like https://whatismyipaddress.com/.

az mysql flexible-server firewall-rule create --resource-group PythonAzureExample-DB-rg --name python-azure-example-mysql-12345 ^
    --rule-name allow_ip --start-ip-address 10.11.12.13 --end-ip-address 10.11.12.13

az mysql flexible-server db create --resource-group PythonAzureExample-DB-rg --server-name python-azure-example-mysql-12345 ^
    --database-name example-db1

Consulte también