Freigeben über

Beispiel: Verwenden der Azure-Bibliotheken zum Erstellen einer Datenbank

In diesem Beispiel wird veranschaulicht, wie Sie das Azure SDK für Python-Verwaltungsbibliotheken verwenden, um programmgesteuert eine Azure-Datenbank für MySQL flexiblen Server und eine entsprechende Datenbank zu erstellen. Es enthält auch ein grundlegendes Skript, das die Mysql-connector-python-Bibliothek (nicht Teil des Azure SDK) verwendet, um eine Verbindung mit der Datenbank herzustellen und abzufragen.

Sie können dieses Beispiel anpassen, um eine Azure-Datenbank für PostgreSQL flexiblen Server zu erstellen, indem Sie die relevanten SDK-Importe und API-Aufrufe ändern.

Wenn Sie die Azure CLI verwenden möchten, werden die entsprechenden Azure CLI-Befehle weiter unten in diesem Artikel bereitgestellt. Eine grafische Benutzeroberfläche finden Sie in der Dokumentation zum Azure-Portal:

Sofern nicht anders angegeben, funktionieren alle Beispiele und Befehle konsistent für Linux/macOS-Bash- und Windows-Befehlsshells.

1: Einrichten Ihrer lokalen Entwicklungsumgebung

Falls noch nicht geschehen, richten Sie eine Umgebung ein, in der Sie den Code ausführen können. Hier sind einige Optionen:

  • Konfigurieren Sie eine virtuelle Python-Umgebung mit venv oder Ihrem Wahltool. Um mit der Verwendung der virtuellen Umgebung zu beginnen, müssen Sie sie aktivieren. Informationen zum Installieren von Python finden Sie unter Installieren von Python.

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

  • Verwenden Sie eine conda-Umgebung. Informationen zum Installieren von Conda finden Sie unter Installieren von Miniconda.

  • Verwenden Sie einen Dev Container in Visual Studio Code oder GitHub Codespaces.

2: Installieren der erforderlichen Azure-Bibliothekspakete

In diesem Schritt installieren Sie die Azure SDK-Bibliotheken, die zum Erstellen der Datenbank erforderlich sind.

  1. Erstellen Sie in der Konsole eine requirements.txt Datei, in der die in diesem Beispiel verwendeten Verwaltungsbibliotheken aufgelistet sind:

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

    Hinweis

    Die mysql-connector-python Bibliothek ist nicht Teil des Azure SDK. Es ist eine Drittanbieterbibliothek, mit der Sie eine Verbindung mit MySQL-Datenbanken herstellen können. Sie können auch andere Bibliotheken wie PyMySQL oder SQLAlchemy verwenden, um eine Verbindung zu MySQL-Datenbanken herzustellen.

  2. Installieren Sie in Ihrer Konsole mit aktivierter virtueller Umgebung die Anforderungen:

    pip install -r requirements.txt

    Hinweis

    Unter Windows erzeugt der Versuch, die Mysql-Bibliothek in einer 32-Bit-Python-Bibliothek zu installieren, einen Fehler in der Datei mysql.h . Installieren Sie in diesem Fall eine 64-Bit-Version von Python, und versuchen Sie es erneut.

3. Festlegen von Umgebungsvariablen

In diesem Schritt legen Sie Umgebungsvariablen für die Verwendung im Code in diesem Artikel fest. Der Code verwendet die os.environ Methode, um die Werte abzurufen.

#!/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: Schreiben von Code zum Erstellen und Konfigurieren eines flexiblen MySQL-Servers mit einer Datenbank

In diesem Schritt erstellen Sie eine Python-Datei mit dem Namen provision_blob.py mit dem folgenden Code. Dieses Python-Skript verwendet das Azure SDK für Python-Verwaltungsbibliotheken, um eine Ressourcengruppe, einen flexiblen MySQL-Server und eine Datenbank auf diesem Server zu erstellen.

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

Authentifizierung im Code

Später in diesem Artikel melden Sie sich mit der Azure CLI bei Azure an, um den Beispielcode auszuführen. Wenn Ihr Konto über ausreichende Berechtigungen zum Erstellen von Ressourcengruppen und Speicherressourcen in Ihrem Azure-Abonnement verfügt, sollte das Skript ohne zusätzliche Konfiguration erfolgreich ausgeführt werden.

Für die Verwendung in Produktionsumgebungen wird empfohlen, dass Sie sich bei einem Dienstprinzipal authentifizieren, indem Sie die entsprechenden Umgebungsvariablen festlegen. Dieser Ansatz ermöglicht einen sicheren, nicht interaktiven Zugriff, der für die Automatisierung geeignet ist. Anweisungen zum Einrichten finden Sie unter Authentifizieren von Python-Apps mit Azure-Diensten.

Stellen Sie sicher, dass dem Dienstprinzipal eine Rolle mit angemessenen Berechtigungen zugewiesen wird, z. B. die Rolle "Mitwirkender" auf Abonnement- oder Ressourcengruppenebene. Ausführliche Informationen zum Zuweisen von Rollen finden Sie unter Rollenbasierte Zugriffssteuerung (Role-based Access Control, RBAC) in Azure.

Informationen zum PostreSQL-Datenbankserver finden Sie unter:

5: Ausführen des Skripts

  1. Falls noch nicht geschehen, melden Sie sich mit der Azure CLI bei Azure an:

    az login

  2. Ausführen des Skripts:

    python provision_db.py

    Das Skript benötigt ein oder zwei Minuten zur Ausführung.

6: Einfügen eines Datensatzes und Abfragen der Datenbank

In diesem Schritt erstellen Sie eine Tabelle in der Datenbank und fügen einen Datensatz ein. Sie können die Mysql-Connector-Bibliothek verwenden, um eine Verbindung mit der Datenbank herzustellen und SQL-Befehle auszuführen.

  1. Erstellen Sie eine Datei mit dem Namen use_db.py mit dem folgenden Code.

    Dieser Code funktioniert nur für MySQL; Sie verwenden unterschiedliche Bibliotheken für 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='./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()

    Dieser Code verwendet die mysql.connector-API. Der einzige azurespezifische Teil ist die vollständige Hostdomäne für MySQL-Server (mysql.database.azure.com).

  2. Laden Sie als Nächstes das Zertifikat herunter, das für die Kommunikation über TSL/SSL mit Ihrem Azure-Datenbank für MySQL-Server erforderlich ist. Weitere Informationen finden Sie unter Abrufen eines SSL-Zertifikats in der Azure-Datenbank für MySQL-Dokumentation.

    #!/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. Führen Sie schließlich den Code aus:

    python use_db.py

Wenn ein Fehler angezeigt wird, dass Ihre Client-IP-Adresse nicht zulässig ist, überprüfen Sie, ob Sie die Umgebungsvariable richtig definiert haben PUBLIC_IP_ADDRESS . Wenn Sie den MySQL-Server bereits mit der falschen IP-Adresse erstellt haben, können Sie ein weiteres im Azure-Portal hinzufügen. Wählen Sie im Portal den MySQL-Server und dann die Verbindungssicherheit aus. Fügen Sie die IP-Adresse Ihrer Arbeitsstation zur Liste der zulässigen IP-Adressen hinzu.

7: Bereinigen von Ressourcen

Führen Sie den Befehl " az group delete " aus, wenn Sie die in diesem Beispiel erstellte Ressourcengruppe und Speicherressourcen nicht beibehalten müssen.

Ressourcengruppen verursachen keine laufenden Gebühren in Ihrem Abonnement, aber Ressourcen wie Speicherkonten in der Ressourcengruppe verursachen möglicherweise weiterhin Gebühren. Es empfiehlt sich, jede Gruppe zu bereinigen, die Sie nicht aktiv verwenden. Mit dem Argument --no-wait kann der Befehl sofort zurückgegeben werden, anstatt auf den Abschluss des Vorgangs zu warten.

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

Sie können auch die ResourceManagementClient.resource_groups.begin_delete-Methode verwenden, um eine Ressourcengruppe aus Code zu löschen. Der Code im Beispiel: Erstellen einer Ressourcengruppe veranschaulicht die Verwendung.

Referenz: entsprechende Azure CLI-Befehle

Die folgenden Azure CLI-Befehle führen die gleichen Bereitstellungsschritte wie das Python-Skript aus. Verwenden Sie az postgres flexible-server-Befehle für eine PostgreSQL-Datenbank.

#!/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."

Siehe auch