Udostępnij za pośrednictwem

Przykład: tworzenie bazy danych przy użyciu bibliotek platformy Azure

W tym przykładzie pokazano, jak programowo utworzyć elastyczny serwer usługi Azure Database for MySQL i odpowiednią bazę danych za pomocą zestawu Azure SDK dla języka Python. Zawiera również podstawowy skrypt, który używa biblioteki mysql-connector-python (a nie części zestawu Azure SDK) do nawiązywania połączenia z bazą danych i wykonywania zapytań względem niej.

Ten przykład można dostosować do tworzenia elastycznego serwera usługi Azure Database for PostgreSQL, modyfikując odpowiednie importy zestawu SDK i wywołania interfejsu API.

Jeśli wolisz używać interfejsu wiersza polecenia platformy Azure, równoważne polecenia interfejsu wiersza polecenia platformy Azure są udostępniane w dalszej części tego artykułu. Aby zapoznać się ze środowiskiem graficznym, zapoznaj się z dokumentacją witryny Azure Portal:

O ile nie określono inaczej, wszystkie przykłady i polecenia działają tak samo w powłoce bash na systemach Linux/macOS oraz w powłoce poleceń systemu Windows.

1: Konfigurowanie lokalnego środowiska projektowego

Jeśli jeszcze tego nie zrobiono, skonfiguruj środowisko, w którym można uruchomić kod. Oto kilka opcji:

2: Instalowanie wymaganych pakietów bibliotek platformy Azure

W tym kroku zainstalujesz biblioteki zestawu Azure SDK potrzebne do utworzenia bazy danych.

  1. W konsoli utwórz plik requirements.txt zawierający listę bibliotek zarządzania używanych w tym przykładzie:

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

    Uwaga / Notatka

    Biblioteka mysql-connector-python nie jest częścią zestawu Azure SDK. Jest to biblioteka innej firmy, której można użyć do łączenia się z bazami danych MySQL. Możesz również użyć innych bibliotek, takich jak PyMySQL lub SQLAlchemy, aby nawiązać połączenie z bazami danych MySQL.

  2. W konsoli z aktywowanym środowiskiem wirtualnym zainstaluj wymagania:

    pip install -r requirements.txt

    Uwaga / Notatka

    W systemie Windows próba zainstalowania biblioteki mysql w 32-bitowej bibliotece języka Python powoduje błąd dotyczący pliku mysql.h . W takim przypadku zainstaluj 64-bitową wersję języka Python i spróbuj ponownie.

3. Ustawianie zmiennych środowiskowych

W tym kroku ustawisz zmienne środowiskowe do użycia w kodzie w tym artykule. Kod używa os.environ metody do pobrania wartości.

#!/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. Pisanie kodu w celu utworzenia i skonfigurowania serwera elastycznego MySQL z bazą danych

W tym kroku utworzysz plik w języku Python o nazwie provision_blob.py przy użyciu następującego kodu. Ten skrypt języka Python używa zestawu Azure SDK dla bibliotek zarządzania języka Python do tworzenia grupy zasobów, serwera elastycznego MySQL i bazy danych na tym serwerze.

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

Uwierzytelnianie w kodzie

W dalszej części tego artykułu zalogujesz się do platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure, aby wykonać przykładowy kod. Jeśli twoje konto ma wystarczające uprawnienia do tworzenia grup zasobów i zasobów magazynu w ramach subskrypcji platformy Azure, skrypt powinien zostać uruchomiony pomyślnie bez dodatkowej konfiguracji.

Do użytku w środowiskach produkcyjnych zalecamy uwierzytelnianie za pomocą jednostki usługi przez ustawienie odpowiednich zmiennych środowiskowych. Takie podejście umożliwia bezpieczny, nieinterakcyjny dostęp odpowiedni do automatyzacji. Aby uzyskać instrukcje dotyczące konfiguracji, zobacz Jak uwierzytelniać aplikacje języka Python za pomocą usług platformy Azure.

Upewnij się, że jednostka usługi ma przypisaną rolę z odpowiednimi uprawnieniami, takimi jak rola Współautor na poziomie subskrypcji lub grupy zasobów. Aby uzyskać szczegółowe informacje na temat przypisywania ról, zobacz Kontrola dostępu oparta na rolach (RBAC) na platformie Azure.

W przypadku serwera bazy danych PostreSQL zobacz:

5. Uruchamianie skryptu

  1. Jeśli jeszcze tego nie zrobiono, zaloguj się do platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure:

    az login

  2. Uruchom skrypt:

    python provision_db.py

    Wykonanie skryptu trwa minutę lub dwie.

6: Wstawianie rekordu i wykonywanie zapytań względem bazy danych

W tym kroku utworzysz tabelę w bazie danych i wstawisz rekord. Aby nawiązać połączenie z bazą danych i uruchomić polecenia SQL, możesz użyć biblioteki mysql-connector.

  1. Utwórz plik o nazwie use_db.py przy użyciu następującego kodu.

    Ten kod działa tylko w przypadku programu MySQL; używasz różnych bibliotek dla bazy danych 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()

    Cały ten kod używa interfejsu API mysql.connector. Jedyną częścią specyficzną dla platformy Azure jest pełna domena hosta dla serwera MySQL (mysql.database.azure.com).

  2. Następnie pobierz certyfikat wymagany do komunikacji za pośrednictwem protokołu TSL/SSL z serwerem usługi Azure Database for MySQL. Aby uzyskać więcej informacji, zobacz Uzyskiwanie certyfikatu SSL w dokumentacji usługi 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. Na koniec uruchom kod:

    python use_db.py

Jeśli zostanie wyświetlony błąd, że adres IP klienta jest niedozwolony, sprawdź, czy zmienna środowiskowa PUBLIC_IP_ADDRESS została zdefiniowana poprawnie. Jeśli serwer MySQL został już utworzony przy użyciu nieprawidłowego adresu IP, możesz dodać inny adres w witrynie Azure Portal. W portalu wybierz serwer MySQL, a następnie wybierz pozycję Zabezpieczenia połączeń. Dodaj adres IP stacji roboczej do listy dozwolonych adresów IP.

7. Czyszczenie zasobów

Uruchom polecenie az group delete , jeśli nie musisz przechowywać grupy zasobów i zasobów magazynu utworzonych w tym przykładzie.

Grupy zasobów nie generują żadnych bieżących opłat w ramach subskrypcji, ale zasoby, takie jak konta magazynu, w grupie zasobów mogą nadal generować opłaty. Dobrym rozwiązaniem jest wyczyszczenie każdej grupy, której nie używasz aktywnie. Argument --no-wait umożliwia polecenie natychmiastowego zwrócenia zamiast oczekiwania na zakończenie operacji.

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

Możesz również użyć ResourceManagementClient.resource_groups.begin_delete metody , aby usunąć grupę zasobów z kodu. Kod w przykładzie: Tworzenie grupy zasobów demonstruje użycie.

W celach informacyjnych: równoważne polecenia Azure CLI

Następujące polecenia Azure CLI wykonują te same kroki aprowizacji co skrypt w języku Python. W przypadku bazy danych PostgreSQL użyj az postgres flexible-server poleceń.

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

Zobacz także