Příklad: Vytvoření databáze pomocí knihoven Azure

Tento příklad ukazuje, jak pomocí sady Azure SDK pro knihovny pro správu Pythonu programově vytvořit flexibilní server Azure Database for MySQL a odpovídající databázi. Obsahuje také skript, který k připojení k databázi používá mysql-connector-python knihovnu (nikoli část Azure SDK).

Tento příklad můžete přizpůsobit tak, aby vytvořil flexibilní server Azure Database for PostgreSQL úpravou příslušných importů a volání rozhraní API sady SDK.

Pokud raději používáte Azure CLI, najdete ekvivalentní příkazy Azure CLI dále v tomto článku. Grafické prostředí najdete v dokumentaci k webu Azure Portal:

Pokud není uvedeno jinak, všechny příklady a příkazy v tomto článku fungují konzistentně napříč prostředími Bash pro Linux/macOS a Windows příkazové prostředí.

1: Nastavení místního vývojového prostředí

Pokud jste to ještě neudělali, nastavte prostředí, ve kterém můžete kód spustit. Tady jsou některé možnosti:

  • Nakonfigurujte virtuální prostředí Pythonu pomocí venv nebo libovolného nástroje podle vašeho výběru. Pokud chcete začít používat virtuální prostředí, nezapomeňte ho aktivovat. Pokud chcete nainstalovat Python, přečtěte si téma Instalace Pythonu.

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

  • Použijte prostředí Conda. Pokud chcete nainstalovat Conda, přečtěte si téma Instalace Miniconda.

  • Použijte vývojový kontejner v editoru Visual Studio Code nebo GitHub Codespaces.

2: Instalace potřebných balíčků knihovny Azure

V tomto kroku nainstalujete knihovny Azure SDK potřebné pro vytvoření databáze.

  1. V konzole vytvořte souborrequirements.txt se seznamem knihoven pro správu použitých v tomto příkladu:

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

    Poznámka:

    Knihovna mysql-connector-python není součástí sady Azure SDK. Jedná se o knihovnu třetí strany, kterou můžete použít pro připojení k databázím MySQL. Můžete také použít jiné knihovny, například PyMySQL .SQLAlchemy

  2. V konzole s aktivovaným virtuálním prostředím nainstalujte požadavky:

    pip install -r requirements.txt

    Poznámka:

    Při pokusu o instalaci knihovny mysql do 32bitové knihovny Pythonu ve Windows dojde k chybě o souboru mysql.h . V tomto případě nainstalujte 64bitovou verzi Pythonu a zkuste to znovu.

3. Nastavení proměnných prostředí

V tomto kroku nastavíte proměnné prostředí pro použití v kódu v tomto článku. Kód používá metodu os.environ k načtení hodnot.

#!/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: Napsání kódu pro vytvoření a konfiguraci flexibilního serveru MySQL s databází

V tomto kroku vytvoříte soubor Python s názvem provision_db.py s následujícím kódem. Tento skript používá Azure SDK pro knihovny pro správu Python k vytvoření skupiny prostředků, flexibilního serveru MySQL a databáze na tomto serveru.

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

Ověřování v kódu

Později v tomto článku se přihlásíte k Azure pomocí Azure CLI ke spuštění ukázkového kódu. Pokud má váš účet dostatečná oprávnění k vytváření skupin prostředků a databázových prostředků ve vašem Azure předplatném, skript se úspěšně spustí bez další konfigurace.

Pro produkční prostředí se ověřujte pomocí instančního objektu služby a nastavte odpovídající proměnné prostředí. Tento přístup umožňuje zabezpečený, neinteraktivní přístup vhodný pro automatizaci. Pokyny k nastavení najdete v tématu Ověřování aplikací v Pythonu pomocí služeb Azure.

Ujistěte se, že je instančnímu objektu služby přiřazena role s dostatečnými oprávněními, například role Přispěvatel na úrovni předplatného nebo skupiny prostředků. Podrobnosti o přiřazování rolí najdete v tématu Řízení přístupu na základě role (RBAC) v Azure.

Databázový server PostgreSQL najdete tady:

5: Spuštění skriptu

  1. Pokud jste to ještě neudělali, přihlaste se k Azure pomocí Azure CLI:

    az login

  2. Spusťte skript:

    python provision_db.py

    Dokončení skriptu trvá minutu nebo dvě.

6: Vložení záznamu a dotazování databáze

V tomto kroku vytvoříte v databázi tabulku a vložíte záznam. mysql-connector Pomocí knihovny se připojte k databázi a spusťte příkazy SQL.

  1. Vytvořte soubor s názvem use_db.py s následujícím kódem.

    Tento kód funguje jenom pro MySQL. Pro PostgreSQL používáte různé knihovny.

    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()

    Veškerý tento kód používá mysql.connector rozhraní API. Jedinou částí specifickou pro Azure je úplný název domény hostitele pro server MySQL (mysql.database.azure.com).

  2. Dále si stáhněte kořenový certifikát potřebný ke komunikaci přes protokol TLS/SSL s vaším Azure Database for MySQL serverem. Azure Flexibilní server MySQL používá certifikát DigiCert Global Root G2. Další informace najdete v tématu Pojení k Azure Database for MySQL – flexibilní server s šifrovanými připojeními.

    #!/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. Nakonec spusťte kód:

    python use_db.py

Pokud se zobrazí chyba, že ip adresa klienta není povolená, zkontrolujte, jestli jste správně definovali proměnnou PUBLIC_IP_ADDRESS prostředí. Pokud jste už vytvořili server MySQL s nesprávnou IP adresou, můžete na webu Azure Portal přidat další. Na portálu vyberte server MySQL a pak vyberte Sítě. Přidejte IP adresu pracovní stanice do seznamu povolených IP adres.

7: Vyčištění prostředků

Pokud v tomto příkladu nepotřebujete zachovat skupinu prostředků a databázové prostředky vytvořené v tomto příkladu, spusťte příkaz az group delete .

Ve vašem předplatném se za skupiny prostředků neúčtují žádné průběžné poplatky, ale za prostředky ve skupině prostředků se můžou dál účtovat poplatky. Je vhodné vyčistit jakoukoli skupinu, kterou aktivně nepoužíváte. Argument --no-wait umožňuje, aby se příkaz vrátil okamžitě místo čekání na dokončení operace.

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

Metodu ResourceManagementClient.resource_groups.begin_delete můžete použít také k odstranění skupiny prostředků z kódu. Kód v příkladu: Vytvoření skupiny prostředků ukazuje použití.

Referenční informace: Ekvivalentní příkazy Azure CLI

Následující příkazy Azure CLI dokončí stejné kroky zřizování jako skript Pythonu. Pro databázi PostgreSQL použijte az postgres flexible-server příkazy.

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

Viz také

  • Last updated on