Dela via

Exempel: Använd Azure-biblioteken för att skapa en databas

Det här exemplet visar hur du använder Azure SDK för Python-hanteringsbibliotek för att programmatiskt skapa en flexibel Azure Database for MySQL-server och en motsvarande databas. Det innehåller också ett grundläggande skript som använder biblioteket mysql-connector-python (inte en del av Azure SDK) för att ansluta till och köra frågor mot databasen.

Du kan anpassa det här exemplet för att skapa en flexibel Azure Database for PostgreSQL-server genom att ändra relevanta SDK-importer och API-anrop.

Om du föredrar att använda Azure CLI tillhandahålls motsvarande Azure CLI-kommandon senare i den här artikeln. En grafisk upplevelse finns i dokumentationen för Azure-portalen:

Om inget annat anges fungerar alla exempel och kommandon konsekvent i Linux/macOS bash- och Windows-kommandogränssnitt.

1: Konfigurera din lokala utvecklingsmiljö

Om du inte redan har gjort det konfigurerar du en miljö där du kan köra koden. Här är några alternativ:

  • Konfigurera en virtuell Python-miljö med hjälp av venv eller valfritt verktyg. Om du vill börja använda den virtuella miljön måste du aktivera den. Information om hur du installerar Python finns i Installera 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)

  • Använd en conda-miljö. Information om hur du installerar Conda finns i Installera Miniconda.

  • Använd en Dev-container i Visual Studio Code eller GitHub Codespaces.

2: Installera nödvändiga Azure-bibliotekspaket

I det här steget installerar du de Azure SDK-bibliotek som behövs för att skapa databasen.

  1. I konsolen skapar du en requirements.txt fil som visar de hanteringsbibliotek som används i det här exemplet:

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

    Anmärkning

    Biblioteket mysql-connector-python är inte en del av Azure SDK. Det är ett bibliotek från tredje part som du kan använda för att ansluta till MySQL-databaser. Du kan också använda andra bibliotek, till exempel PyMySQL eller SQLAlchemy, för att ansluta till MySQL-databaser.

  2. Installera kraven i konsolen med den virtuella miljön aktiverad:

    pip install -r requirements.txt

    Anmärkning

    Om du försöker installera mysql-biblioteket i ett 32-bitars Python-bibliotek i Windows uppstår ett fel om filen mysql.h . I det här fallet installerar du en 64-bitarsversion av Python och försöker igen.

3. Ange miljövariabler

I det här steget anger du miljövariabler som ska användas i koden i den här artikeln. Koden använder os.environ metoden för att hämta värdena.

#!/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: Skriv kod för att skapa och konfigurera en flexibel MySQL-server med en databas

I det här steget skapar du en Python-fil med namnet provision_blob.py med följande kod. Det här Python-skriptet använder Azure SDK för Python-hanteringsbibliotek för att skapa en resursgrupp, en flexibel MySQL-server och en databas på den servern.

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

Autentisering i koden

Senare i den här artikeln loggar du in på Azure med Hjälp av Azure CLI för att köra exempelkoden. Om ditt konto har tillräcklig behörighet för att skapa resursgrupper och lagringsresurser i din Azure-prenumeration bör skriptet köras utan ytterligare konfiguration.

För användning i produktionsmiljöer rekommenderar vi att du autentiserar med tjänstens huvudnamn genom att ange lämpliga miljövariabler. Den här metoden möjliggör säker, icke-interaktiv åtkomst som lämpar sig för automatisering. Installationsinstruktioner finns i Autentisera Python-appar med Azure-tjänster.

Se till att tjänstens huvudprincip har tilldelats en roll med tillräckliga behörigheter, till exempel rollen Deltagare på prenumerationsnivå eller nivå för resursgrupp. Mer information om hur du tilldelar roller finns i Rollbaserad åtkomstkontroll (RBAC) i Azure.

Information om PostreSQL-databasservern finns i:

5: Kör skriptet

  1. Logga in på Azure med hjälp av Azure CLI om du inte redan har gjort det.

    az login

  2. Kör skriptet:

    python provision_db.py

    Skriptet tar en minut eller två att slutföra.

6: Infoga en post och göra en sökning i databasen

I det här steget skapar du en tabell i databasen och infogar en post. Du kan använda biblioteket mysql-connector för att ansluta till databasen och köra SQL-kommandon.

  1. Skapa en fil med namnet use_db.py med följande kod.

    Den här koden fungerar endast för MySQL; du använder olika bibliotek 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()

    All den här koden använder API:et mysql.connector. Den enda Azure-specifika delen är den fullständiga värddomänen för MySQL-servern (mysql.database.azure.com).

  2. Ladda sedan ned certifikatet som behövs för att kommunicera via TSL/SSL med din Azure Database for MySQL-server. Mer information finns i Hämta ett SSL-certifikat i Dokumentation om 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. Kör slutligen koden:

    python use_db.py

Om du ser ett fel om att klientens IP-adress inte är tillåten kontrollerar du att du har definierat miljövariabeln PUBLIC_IP_ADDRESS korrekt. Om du redan har skapat MySQL-servern med fel IP-adress kan du lägga till en annan i Azure-portalen. I portalen väljer du MySQL-servern och sedan Anslutningssäkerhet. Lägg till IP-adressen för din arbetsstation i listan över tillåtna IP-adresser.

7: Rensa resurser

Kör kommandot az group delete om du inte behöver behålla resursgruppen och lagringsresurserna som skapas i det här exemplet.

Resursgrupper debiteras inte några löpande avgifter i din prenumeration, men resurser, till exempel lagringskonton, i resursgruppen kan fortsätta att debiteras. Det är en bra idé att rensa alla grupper som du inte aktivt använder. Argumentet --no-wait gör att kommandot kan returneras omedelbart i stället för att vänta på att åtgärden ska slutföras.

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

Du kan också använda metoden ResourceManagementClient.resource_groups.begin_delete för att ta bort en resursgrupp från koden. Koden i Exempel: Skapa en resursgrupp visar användning.

Som referens: motsvarande Azure CLI-kommandon

Följande Azure CLI-kommandon utför samma etableringssteg som Python-skriptet. För en PostgreSQL-databas, använd az postgres flexible-server-kommandon.

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

Se även