Delen via

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 basisscript dat gebruikmaakt van de mysql-connector-python-bibliotheek (geen deel van de Azure SDK) om verbinding te maken met en query's uit te voeren op de database.

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 opgegeven, werken alle voorbeelden en opdrachten 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, zoals PyMySQL of SQLAlchemy, gebruiken om verbinding te maken met MySQL-databases.

  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_Passwrod> # Change to your preferred admin password
export DB_NAME=<DB_Name> # Change to your preferred database name
export DB_PORT=3306
export version=ServerVersion.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_blob.py met de volgende code. Dit Python-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://docs.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 opslagresources in uw Azure-abonnement te maken, moet het script zonder aanvullende configuratie worden uitgevoerd.

Voor gebruik in productieomgevingen raden we u aan om u te verifiëren met een service-principal door de juiste omgevingsvariabelen in te stellen. 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. Raadpleeg rollen-gebaseerd toegangsbeheer (RBAC) in Azure voor meer informatie over het toewijzen van rollen.

Zie voor PostreSQL-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. U kunt de bibliotheek mysql-connector gebruiken 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 verschillende bibliotheken voor PostgreSQL gebruikt.

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

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

  2. Download vervolgens het certificaat dat nodig is om via TSL/SSL te communiceren met uw Azure Database for MySQL-server. Zie Een SSL-certificaat verkrijgen in de documentatie van Azure Database for MySQL voor meer informatie.

    #!/bin/bash
# Download Baltimore CyberTrust Root certificate required for Azure MySQL SSL connections
CERT_URL="https://www.digicert.com/CACerts/BaltimoreCyberTrustRoot.crt.pem"
CERT_FILE="BaltimoreCyberTrustRoot.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 Verbindingsbeveiliging. 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 opslagresources die in dit voorbeeld zijn gemaakt, niet hoeft te behouden.

Voor resourcegroepen worden geen doorlopende kosten in uw abonnement in rekening gebracht, maar resources, zoals opslagaccounts, in de resourcegroep kunnen mogelijk wel kosten met zich meebrengen. 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
#!/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="5.7"

# 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