Voorbeeld: De Azure-bibliotheken gebruiken om een database te maken

In dit voorbeeld ziet u hoe u de Azure SDK voor Python-beheerbibliotheken gebruikt om programmatisch een flexibele Azure Database for MySQL-server en een bijbehorende database te maken. Het bevat ook een script dat gebruikmaakt van de mysql-connector-python bibliotheek (geen deel van de Azure SDK) om verbinding te maken met de database en er query's op uit te voeren.

U kunt dit voorbeeld aanpassen om een flexibele Azure Database for PostgreSQL-server te maken door de relevante SDK-import- en API-aanroepen te wijzigen.

Als u liever de Azure CLI gebruikt, vindt u equivalente Azure CLI-opdrachten verderop in dit artikel. Raadpleeg de documentatie van Azure Portal voor een grafische ervaring:

Tenzij anders vermeld, werken alle voorbeelden en opdrachten in dit artikel consistent in Linux/macOS bash en Windows opdrachtshells.

1: Uw lokale ontwikkelomgeving instellen

Als u dat nog niet hebt gedaan, stelt u een omgeving in waar u de code kunt uitvoeren. Hieronder volgen een aantal opties:

  • Configureer een virtuele Python-omgeving met behulp van venv of uw hulpprogramma naar keuze. Als u de virtuele omgeving wilt gaan gebruiken, moet u deze activeren. Om Python te installeren, zie Python installeren.

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

  • Gebruik een conda-omgeving. Zie Miniconda installeren om Conda te installeren.

  • Gebruik een Dev Container- in Visual Studio Code- of GitHub Codespaces.

2: De benodigde Azure-bibliotheekpakketten installeren

In deze stap installeert u de Azure SDK-bibliotheken die nodig zijn om de database te maken.

  1. Maak in uw console een requirements.txt bestand met de beheerbibliotheken die in dit voorbeeld worden gebruikt:

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

    Opmerking

    De mysql-connector-python bibliotheek maakt geen deel uit van de Azure SDK. Het is een bibliotheek van derden die u kunt gebruiken om verbinding te maken met MySQL-databases. U kunt ook andere bibliotheken gebruiken, zoals PyMySQL of SQLAlchemy.

  2. Installeer de vereisten in de console waarop de virtuele omgeving is geactiveerd:

    pip install -r requirements.txt

    Opmerking

    In Windows produceert een poging om de mysql-bibliotheek te installeren in een 32-bits Python-bibliotheek een fout over het bestand mysql.h . In dit geval installeert u een 64-bits versie van Python en probeert u het opnieuw.

3. Omgevingsvariabelen instellen

In deze stap stelt u omgevingsvariabelen in voor gebruik in de code in dit artikel. De code gebruikt de os.environ methode om de waarden op te halen.

#!/bin/bash
export AZURE_RESOURCE_GROUP_NAME=<ResourceGroupName> # Change to your preferred resource group name
export LOCATION=<Location> # Change to your preferred region
export AZURE_SUBSCRIPTION_ID=$(az account show --query id --output tsv)
export PUBLIC_IP_ADDRESS=$(curl -s https://api.ipify.org)
export DB_SERVER_NAME=<DB_Server_Name> # Change to your preferred DB server name
export DB_ADMIN_NAME=<DB_Admin_Name> # Change to your preferred admin name
export DB_ADMIN_PASSWORD=<DB_Admin_Password> # Change to your preferred admin password
export DB_NAME=<DB_Name> # Change to your preferred database name
export DB_PORT=3306
export DB_SERVER_VERSION=EIGHT0_21

4: Code schrijven om een Flexibele MySQL-server te maken en te configureren met een database

In deze stap maakt u een Python-bestand met de naam provision_db.py met de volgende code. Dit script maakt gebruik van de Azure SDK voor Python beheerbibliotheken om een resourcegroep, een flexibele MySQL-server en een database op die server te maken.

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"]

# Retrieve resource group name and location from environment variables
RESOURCE_GROUP_NAME = os.environ["AZURE_RESOURCE_GROUP_NAME"]
LOCATION = os.environ["LOCATION"]

# 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://learn.microsoft.com/azure/developer/python/azure-sdk-example-resource-group


# Step 2: Provision the database server

# Retrieve server name, admin name, and admin password from environment variables

db_server_name = os.environ.get("DB_SERVER_NAME")
db_admin_name = os.environ.get("DB_ADMIN_NAME")
db_admin_password = os.environ.get("DB_ADMIN_PASSWORD")

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

# Provision the server and wait for the result
server_version = os.environ.get("DB_SERVER_VERSION") 

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[server_version]  # Note: dictionary-style enum access
    )
)

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"]

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

Verificatie in de code

Verderop in dit artikel meldt u zich aan bij Azure met behulp van de Azure CLI om de voorbeeldcode uit te voeren. Als uw account voldoende machtigingen heeft om resourcegroepen en databaseresources te maken in uw Azure-abonnement, wordt het script uitgevoerd zonder extra configuratie.

Verifieer voor productieomgevingen met behulp van een service-principal en stel de juiste omgevingsvariabelen in. Deze aanpak maakt veilige, niet-interactieve toegang mogelijk die geschikt is voor automatisering. Zie Python-apps verifiëren met Azure-services voor installatie-instructies.

Zorg ervoor dat aan de service-principal een rol met voldoende machtigingen is toegewezen, zoals de rol Inzender op abonnements- of resourcegroepniveau. Zie op rollen gebaseerd toegangsbeheer (RBAC) in Azure voor meer informatie over het toewijzen van rollen.

Zie voor PostgreSQL-databaseserver:

5: Het script uitvoeren

  1. Als u dat nog niet hebt gedaan, meldt u zich aan bij Azure met behulp van de Azure CLI:

    az login

  2. Voer het script uit:

    python provision_db.py

    Het duurt een paar minuten voordat het script is voltooid.

6: Een record invoegen en een query uitvoeren op de database

In deze stap maakt u een tabel in de database en voegt u een record in. Gebruik de mysql-connector bibliotheek om verbinding te maken met de database en SQL-opdrachten uit te voeren.

  1. Maak een bestand met de naam use_db.py met de volgende code.

    Deze code werkt alleen voor MySQL. U gebruikt verschillende bibliotheken voor PostgreSQL.

    import os
import mysql.connector

db_server_name = os.environ["DB_SERVER_NAME"]
db_admin_name = os.getenv("DB_ADMIN_NAME")
db_admin_password = os.getenv("DB_ADMIN_PASSWORD")

db_name = os.getenv("DB_NAME")
db_port = os.getenv("DB_PORT")

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='./DigiCertGlobalRootG2.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()

    Al deze code maakt gebruik van de mysql.connector API. Het enige Azure-specifieke onderdeel is het volledige hostdomein voor MySQL-server (mysql.database.azure.com).

  2. Download vervolgens het basiscertificaat dat nodig is om via TLS/SSL te communiceren met uw Azure Database for MySQL-server. Azure MySQL Flexible Server maakt gebruik van het DigiCert Global Root G2-certificaat. Zie Verbinding maken met Azure Database for MySQL - Flexible Server met versleutelde verbindingen voor meer informatie.

    #!/bin/bash
# Download DigiCert Global Root G2 certificate required for Azure MySQL SSL connections
CERT_URL="https://cacerts.digicert.com/DigiCertGlobalRootG2.crt.pem"
CERT_FILE="DigiCertGlobalRootG2.crt.pem"
echo "Downloading SSL certificate..."
curl -o "$CERT_FILE" "$CERT_URL"

  3. Voer ten slotte de code uit:

    python use_db.py

Als er een foutbericht wordt weergegeven dat het IP-adres van de client niet is toegestaan, controleert u of u de omgevingsvariabele PUBLIC_IP_ADDRESS juist hebt gedefinieerd. Als u de MySQL-server al met het verkeerde IP-adres hebt gemaakt, kunt u een andere server toevoegen in Azure Portal. Selecteer in de portal de MySQL-server en selecteer Vervolgens Netwerken. Voeg het IP-adres van uw werkstation toe aan de lijst met toegestane IP-adressen.

7: Resources opschonen

Voer de opdracht az group delete uit als u de resourcegroep en databaseresources die in dit voorbeeld zijn gemaakt, niet hoeft te behouden.

Er worden geen lopende kosten in rekening gebracht voor resourcegroepen binnen uw abonnement, maar voor resources in de resourcegroep kunnen wel kosten blijven ontstaan. Het is een goede gewoonte om een groep op te schonen die u niet actief gebruikt. Met het argument --no-wait kan de opdracht onmiddellijk worden geretourneerd in plaats van te wachten tot de bewerking is voltooid.

#!/bin/bash
az group delete -n $AZURE_RESOURCE_GROUP_NAME --no-wait

U kunt ook de methode ResourceManagementClient.resource_groups.begin_delete gebruiken om een resourcegroep uit code te verwijderen. De code in voorbeeld: Een resourcegroep maken laat het gebruik zien.

Ter referentie: equivalente Azure CLI-opdrachten

De volgende Azure CLI-opdrachten voeren dezelfde inrichtingsstappen uit als het Python-script. Gebruik az postgres flexible-server opdrachten voor een PostgreSQL-database.

#!/bin/bash

# Set variables
export LOCATION=<Location> # Change to your preferred region
export AZURE_RESOURCE_GROUP_NAME=<ResourceGroupName> # Change to your preferred resource group name
export DB_SERVER_NAME=<DB_Server_Name> # Change to your preferred DB server name
export DB_ADMIN_NAME=<DB_Admin_Name> # Change to your preferred admin name
export DB_ADMIN_PASSWORD=<DB_Admin_Password> # Change to your preferred admin password
export DB_NAME=<DB_Name> # Change to your preferred database name
export DB_SERVER_VERSION="8.4"

# Get public IP address
export PUBLIC_IP_ADDRESS=$(curl -s https://api.ipify.org)

# Provision the resource group
echo "Creating resource group: $AZURE_RESOURCE_GROUP_NAME"
az group create \
    --location "$LOCATION" \
    --name "$AZURE_RESOURCE_GROUP_NAME"

# Provision the MySQL Flexible Server
echo "Creating MySQL Flexible Server: $DB_SERVER_NAME"
az mysql flexible-server create \
    --location "$LOCATION" \
    --resource-group "$AZURE_RESOURCE_GROUP_NAME" \
    --name "$DB_SERVER_NAME" \
    --admin-user "$DB_ADMIN_NAME" \
    --admin-password "$DB_ADMIN_PASSWORD" \
    --sku-name Standard_B1ms \
    --version "$DB_SERVER_VERSION" \
    --yes

# Provision a firewall rule to allow access from the public IP address
echo "Creating firewall rule for public IP: $PUBLIC_IP_ADDRESS"
az mysql flexible-server firewall-rule create \
    --resource-group "$AZURE_RESOURCE_GROUP_NAME" \
    --name "$DB_SERVER_NAME" \
    --rule-name allow_ip \
    --start-ip-address "$PUBLIC_IP_ADDRESS" \
    --end-ip-address "$PUBLIC_IP_ADDRESS"

# Provision the database
echo "Creating database: $DB_NAME"
az mysql flexible-server db create \
    --resource-group "$AZURE_RESOURCE_GROUP_NAME" \
    --server-name "$DB_SERVER_NAME" \
    --database-name "$DB_NAME"

echo "MySQL Flexible Server and database created successfully."

Zie ook

  • Last updated on