Sdílet prostřednictvím

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é základní skript, který k připojení k databázi a dotazování databáze používá knihovnu mysql-connector-python (nikoli součást sady 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 fungují konzistentně napříč prostředími Linux/macOS Bash a Windows.

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. K připojení k databázím MySQL můžete použít také jiné knihovny, například PyMySQL nebo 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_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: Napsání kódu pro vytvoření a konfiguraci flexibilního serveru MySQL s databází

V tomto kroku vytvoříte soubor Pythonu s názvem provision_blob.py s následujícím kódem. Tento skript Pythonu používá knihovny pro správu Azure SDK pro 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://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}")

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 prostředků úložiště ve vašem předplatném Azure, skript by se měl úspěšně spustit bez další konfigurace.

Pro použití v produkčních prostředích doporučujeme ověřit se pomocí služebního principálu nastavením příslušných proměnných 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 služebnímu objektu přiřazena role s odpovídajícími oprávněními, jako je 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 PostreSQL 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. Knihovnu mysql-connector můžete použít k připojení k databázi a spuštění příkazů SQL.

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

    Tento kód funguje pouze pro MySQL; používáte různé knihovny pro 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()

    Veškerý tento kód používá rozhraní API mysql.connectoru. Jediná část specifická pro Azure je úplná hostitelská doména pro server MySQL (mysql.database.azure.com).

  2. Dále stáhněte certifikát potřebný ke komunikaci přes protokol TSL/SSL se serverem Azure Database for MySQL. Další informace najdete v tématu Získání certifikátu SSL v dokumentaci ke službě Azure Database for MySQL.

    #!/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. 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 Zabezpečení připojení. 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 prostředky úložiště 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, jako jsou účty úložiště, se ve skupině prostředků 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
#!/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."

Viz také

  • Last updated on