Share via

Esempio: Usare le librerie di Azure per creare un database

  • Articolo

Questo esempio illustra come usare le librerie di gestione di Azure SDK in uno script Python per creare un'istanza e un database di server flessibili Database di Azure per MySQL. Fornisce anche uno script semplice per eseguire query sul database usando la libreria mysql-connector (non inclusa in Azure SDK). È possibile usare codice simile per creare un'istanza e un database del server flessibili Database di Azure per PostgreSQL.

I comandi equivalenti dell'interfaccia della riga di comando di Azure sono disponibili più avanti in questo articolo. Se si preferisce usare il portale di Azure, vedere Creare un server MySQL o Creare un server PostgreSQL.

Se non diversamente specificato, tutti i comandi di questo articolo funzionano allo stesso modo nella shell Bash Linux/macOS e nella shell dei comandi di Windows.

1: Configurare l'ambiente di sviluppo locale

Se non è già stato fatto, configurare un ambiente in cui è possibile eseguire il codice. Di seguito sono riportate alcuni opzioni:

2: Installare i pacchetti di libreria di Azure necessari

Creare un file denominato requirements.txt con il contenuto seguente:

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

In un terminale con l'ambiente virtuale attivato installare i requisiti:

pip install -r requirements.txt

Nota

In Windows il tentativo di installare la libreria mysql in una libreria Python a 32 bit genera un errore relativo al file mysql.h. In questo caso, installare una versione a 64 bit di Python e riprovare.

3: Scrivere codice per creare il database

Creare un file Python denominato provision_db.py con il codice seguente. I commenti spiegano i dettagli. In particolare, specificare le variabili di ambiente per AZURE_SUBSCRIPTION_ID e PUBLIC_IP_ADDRESS. La seconda variabile è l'indirizzo IP della workstation per l'esecuzione di questo esempio. Puoi usare WhatsIsMyIP per trovare il tuo indirizzo 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}")

Autenticazione nel codice

Più avanti in questo articolo si accede ad Azure con l'interfaccia della riga di comando di Azure per eseguire il codice di esempio. Se l'account dispone delle autorizzazioni per creare gruppi di risorse e risorse di archiviazione nella sottoscrizione di Azure, il codice verrà eseguito correttamente.

Per usare questo codice in uno script di produzione, è possibile impostare le variabili di ambiente per usare un metodo basato su entità servizio per l'autenticazione. Per altre informazioni, vedere Come autenticare le app Python con i servizi di Azure. È necessario assicurarsi che l'entità servizio disponga di autorizzazioni sufficienti per creare gruppi di risorse e risorse di archiviazione nella sottoscrizione assegnandole un ruolo appropriato in Azure, ad esempio il ruolo Collaboratore nella sottoscrizione.

Per il server di database PostreSQL, vedere:

4: Eseguire lo script

  1. Se non è già stato fatto, accedere ad Azure usando l'interfaccia della riga di comando di Azure:

    az login

  2. Impostare le variabili di AZURE_SUBSCRIPTION_ID ambiente e PUBLIC_IP_ADDRESS . È possibile eseguire il comando az account show per ottenere l'ID id sottoscrizione dalla proprietà nell'output. Puoi usare WhatsIsMyIP per trovare il tuo indirizzo IP.

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

  3. Facoltativamente, impostare le DB_SERVER_NAMEvariabili di ambiente , DB_ADMIN_NAMEe DB_ADMIN_PASSWORD . In caso contrario, vengono usate le impostazioni predefinite del codice.

  4. Eseguire lo script:

    python provision_db.py

5: Inserire un record ed eseguire una query sul database

Creare un file denominato use_db.py con il codice seguente. Si notino le dipendenze dalle DB_SERVER_NAMEvariabili di ambiente , DB_ADMIN_NAMEe DB_ADMIN_PASSWORD . Questi valori vengono restituiti dall'output dell'esecuzione del codice precedente provision_db.py o nel codice stesso.

Questo codice funziona solo per MySQL; si usano librerie diverse per 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()

Tutto questo codice usa l'API mysql.connector. L'unica parte specifica di Azure è il dominio host completo per il server MySQL (mysql.database.azure.com).

Scaricare quindi il certificato necessario per comunicare tramite TSL/SSL con il server Database di Azure per MySQL da https://www.digicert.com/CACerts/BaltimoreCyberTrustRoot.crt.pem e salvare il file del certificato nella stessa cartella del file Python. Per altre informazioni, vedere Ottenere un certificato SSL nella documentazione di Database di Azure per MySQL.

Infine, eseguire il codice:

python use_db.py

Se viene visualizzato un errore che indica che l'indirizzo IP del client non è consentito, verificare di aver definito correttamente la variabile PUBLIC_IP_ADDRESS di ambiente. Se il server MySQL è già stato creato con l'indirizzo IP errato, è possibile aggiungere un altro nell'portale di Azure. Nel portale selezionare il server MySQL e quindi selezionare Connessione sicurezza. Aggiungere l'indirizzo IP della workstation all'elenco di indirizzi IP consentiti.

6: Pulire le risorse

Eseguire il comando az group delete se non è necessario mantenere il gruppo di risorse e le risorse di archiviazione create in questo esempio.

I gruppi di risorse non comportano addebiti in corso nella sottoscrizione, ma le risorse, come gli account di archiviazione, nel gruppo di risorse potrebbero continuare a comportare addebiti. È consigliabile pulire qualsiasi gruppo che non si usa attivamente. Con l'argomento --no-wait, il comando restituisce immediatamente il risultato invece di attendere il completamento dell'operazione.

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

Per eliminare un gruppo di risorse dal codice, è anche possibile usare il metodo ResourceManagementClient.resource_groups.begin_delete. Il codice in Esempio: Creare un gruppo di risorse illustra l'utilizzo.

Per riferimento: comandi equivalenti dell'interfaccia della riga di comando di Azure

I seguenti comandi dell'interfaccia della riga di comando di Azure completano gli stessi passaggi di provisioning dello script Python. Per un database PostgreSQL, usare az postgres flexible-server i comandi.

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

Vedi anche