Megosztás a következőn keresztül:

Példa: Adatbázis létrehozása az Azure-kódtárak használatával

Ez a példa bemutatja, hogyan használhatja az Azure SDK for Python felügyeleti kódtárakat egy rugalmas Azure Database for MySQL-kiszolgáló és egy megfelelő adatbázis programozott létrehozására. Emellett tartalmaz egy alapszintű szkriptet is, amely a mysql-connector-python kódtárat használja (nem az Azure SDK részét) az adatbázishoz való csatlakozáshoz és lekérdezéshez.

Ezt a példát rugalmas Azure Database for PostgreSQL-kiszolgáló létrehozásához módosíthatja a vonatkozó SDK-importálások és API-hívások módosításával.

Ha inkább az Azure CLI-t szeretné használni, a cikk későbbi részében egyenértékű Azure CLI-parancsokat ad meg. Grafikus felületért tekintse meg az Azure Portal dokumentációját:

Ha másként nincs megadva, az összes példa és parancs konzisztensen működik a Linux/macOS bash és a Windows parancshéjak között.

1: A helyi fejlesztési környezet beállítása

Ha még nem tette meg, hozzon létre egy környezetet, ahol futtathatja a kódot. Íme néhány lehetőség:

2: A szükséges Azure-kódtárcsomagok telepítése

Ebben a lépésben telepíti az adatbázis létrehozásához szükséges Azure SDK-kódtárakat.

  1. A konzolon hozzon létre egy requirements.txt fájlt, amely felsorolja a példában használt felügyeleti kódtárakat:

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

    Megjegyzés:

    A mysql-connector-python kódtár nem része az Azure SDK-nak. Ez egy külső kódtár, amellyel mySQL-adatbázisokhoz csatlakozhat. Más kódtárakat is használhat, például PyMySQLSQLAlchemya MySQL-adatbázisokhoz való csatlakozáshoz.

  2. Az aktivált virtuális környezettel rendelkező konzolon telepítse a követelményeket:

    pip install -r requirements.txt

    Megjegyzés:

    Windows rendszeren a mysql-kódtár 32 bites Python-kódtárba való telepítésével hibaüzenet jelenik meg a mysql.h fájllal kapcsolatban. Ebben az esetben telepítse a Python 64 bites verzióját, és próbálkozzon újra.

3. Környezeti változók beállítása

Ebben a lépésben környezeti változókat állít be a jelen cikkben szereplő kódban való használatra. A kód a os.environ metódust használja az értékek lekérésére.

#!/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: Kód írása rugalmas MySQL-kiszolgáló adatbázissal való létrehozásához és konfigurálásához

Ebben a lépésben egy provision_blob.py nevű Python-fájlt hoz létre a következő kóddal. Ez a Python-szkript az Azure SDK for Python felügyeleti kódtárakat használja egy erőforráscsoport, egy rugalmas MySQL-kiszolgáló és egy adatbázis létrehozására a kiszolgálón.

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

Hitelesítés a kódban

A cikk későbbi részében az Azure CLI használatával jelentkezik be az Azure-ba a mintakód végrehajtásához. Ha a fiókja rendelkezik megfelelő engedélyekkel az erőforráscsoportok és a tárerőforrások Azure-előfizetésben való létrehozásához, a szkriptnek további konfiguráció nélkül kell sikeresen futnia.

Éles környezetben való használatkor javasoljuk, hogy a megfelelő környezeti változók beállításával hitelesítse magát egy szolgáltatásazonosítóval. Ez a megközelítés biztonságos, nem interaktív hozzáférést tesz lehetővé az automatizáláshoz. A beállítási utasításokért lásd: Python-alkalmazások hitelesítése az Azure-szolgáltatásokkal.

Győződjön meg arról, hogy a szolgáltatásnevezéshez megfelelő engedéllyel rendelkező szerepkört rendeltek hozzá – például az előfizetés vagy az erőforráscsoport szintjén a Közreműködő szerepkört. A szerepkörök hozzárendelésével kapcsolatos részletekért tekintse meg a szerepköralapú hozzáférés-vezérlést (RBAC) az Azure-ban.

A PostreSQL-adatbáziskiszolgálóval kapcsolatban lásd:

5: A szkript futtatása

  1. Ha még nem tette meg, jelentkezzen be az Azure-ba az Azure CLI használatával:

    az login

  2. Futtassa a szkriptet:

    python provision_db.py

    A szkript végrehajtása egy-két percet vesz igénybe.

6: Rekord beszúrása és az adatbázis lekérdezése

Ebben a lépésben létrehoz egy táblát az adatbázisban, és beszúr egy rekordot. A mysql-connector kódtár használatával csatlakozhat az adatbázishoz, és SQL-parancsokat futtathat.

  1. Hozzon létre egy use_db.py nevű fájlt az alábbi kóddal.

    Ez a kód csak a MySQL-hez működik; a PostgreSQL-hez különböző kódtárakat használ.

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

    Ez a kód a mysql.connector API-t használja. Az egyetlen Azure-specifikus rész a MySQL-kiszolgáló teljes gazdatartománya (mysql.database.azure.com).

  2. Ezután töltse le a TSL/SSL protokollon keresztüli kommunikációhoz szükséges tanúsítványt az Azure Database for MySQL-kiszolgálóval. További információ: SSL-tanúsítvány beszerzése az Azure Database for MySQL dokumentációjában.

    #!/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. Végül futtassa a kódot:

    python use_db.py

Ha hibaüzenet jelenik meg, hogy az ügyfél IP-címe nem engedélyezett, ellenőrizze, hogy helyesen definiálta-e a környezeti változót PUBLIC_IP_ADDRESS . Ha már rossz IP-címmel hozta létre a MySQL szervert, felvehet egy másikat az Azure portálon. A portálon válassza ki a MySQL-kiszolgálót, majd válassza a Kapcsolatbiztonság lehetőséget. Adja hozzá a munkaállomás IP-címét az engedélyezett IP-címek listájához.

7: Erőforrások törlése

Futtassa az az group delete parancsot, ha nem kell megőriznie az ebben a példában létrehozott erőforráscsoportot és tárerőforrásokat.

Az erőforráscsoportok nem számolnak fel folyamatos díjakat az előfizetésben, de az erőforráscsoportban lévő erőforrások, például a tárfiókok továbbra is díjakat vonhatnak maga után. Jó gyakorlat minden olyan csoportot eltávolítani, amelyet nem használ aktívan. Az --no-wait argumentum lehetővé teszi, hogy a parancs azonnal visszatérjen a művelet befejezésére való várakozás helyett.

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

A metódussal ResourceManagementClient.resource_groups.begin_delete egy erőforráscsoportot is törölhet a kódból. A példakód: Erőforráscsoport létrehozása a használatot mutatja be.

Hivatkozás: egyenértékű Azure CLI-parancsok

Az alábbi Azure CLI-parancsok ugyanazokat a kiépítési lépéseket hajtják végre, mint a Python-szkript. PostgreSQL-adatbázisokhoz használjon az postgres flexible-server parancsokat.

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

Lásd még