Örnek: Veritabanı oluşturmak için Azure kitaplıklarını kullanma

Bu örnekte, Program aracılığıyla MySQL için Azure Veritabanı esnek sunucusu ve buna karşılık gelen bir veritabanı oluşturmak üzere Python yönetim kitaplıkları için Azure SDK'nın nasıl kullanılacağı gösterilmektedir. Ayrıca veritabanına bağlanmak ve veritabanını sorgulamak için kitaplığını (Azure SDK parçası değil) kullanan mysql-connector-python bir betik de içerir.

Bu örneği, ilgili SDK içeri aktarmalarını ve API çağrılarını değiştirerek PostgreSQL için Azure Veritabanı esnek sunucusu oluşturmak üzere uyarlayabilirsiniz.

Azure CLI kullanmayı tercih ediyorsanız, bu makalenin devamında Eşdeğer Azure CLI komutları sağlanır. Grafik deneyimi için Azure portalı belgelerine bakın:

Aksi belirtilmediği sürece, bu makaledeki tüm örnekler ve komutlar Linux/macOS bash ve Windows komut kabuklarında tutarlı bir şekilde çalışır.

1: Yerel geliştirme ortamınızı ayarlama

Henüz yapmadıysanız kodu çalıştırabileceğiniz bir ortam ayarlayın. Aşağıda bazı seçenekleri görebilirsiniz:

  • venv veya seçtiğiniz aracı kullanarak bir Python sanal ortamı yapılandırın. Sanal ortamı kullanmaya başlamak için etkinleştirmeyi unutmayın. Python'ı yüklemek için bkz. Python'ı yükleme.

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

  • Conda ortamı kullanın. Conda'yı yüklemek için bkz. Miniconda'yı yükleme.

  • Visual Studio Code veya GitHub Codespaces'taGeliştirme Kapsayıcısı kullanın.

2: Gerekli Azure kitaplık paketlerini yükleme

Bu adımda, veritabanını oluşturmak için gereken Azure SDK kitaplıklarını yüklersiniz.

  1. Konsolunuzda, bu örnekte kullanılan yönetim kitaplıklarını listeleyen bir requirements.txt dosyası oluşturun:

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

    Uyarı

    Kitaplık mysql-connector-python , Azure SDK'nın bir parçası değildir. MySQL veritabanlarına bağlanmak için kullanabileceğiniz bir üçüncü taraf kitaplığıdır. PyMySQL veya SQLAlchemy gibi diğer kitaplıkları da kullanabilirsiniz.

  2. Sanal ortamın etkinleştirildiği konsolunuzda gereksinimleri yükleyin:

    pip install -r requirements.txt

    Uyarı

    Windows'da, mysql kitaplığını 32 bit Python kitaplığına yüklemeye çalışmak mysql.h dosyasıyla ilgili bir hata oluşturur. Bu durumda Python'ın 64 bit sürümünü yükleyin ve yeniden deneyin.

3. Ortam değişkenlerini ayarlama

Bu adımda, bu makaledeki kodda kullanılacak ortam değişkenlerini ayarlarsınız. Kod, değerleri almak için yöntemini kullanır os.environ .

#!/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: Veritabanıyla MySQL Esnek Sunucusu oluşturmak ve yapılandırmak için kod yazma

Bu adımda, aşağıdaki kodla provision_db.py adlı bir Python dosyası oluşturursunuz. Bu betik, Python yönetim kitaplıkları için Azure SDK kullanarak bir kaynak grubu, bir MySQL esnek sunucusu ve bu sunucuda bir veritabanı oluşturur.

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

Kodda kimlik doğrulaması

Bu makalenin ilerleyen bölümlerinde, örnek kodu çalıştırmak için Azure CLI kullanarak Azure oturum açarsınız. Hesabınız Azure aboneliğinizde kaynak grupları ve veritabanı kaynakları oluşturmak için yeterli izinlere sahipse, betik ek yapılandırma olmadan başarıyla çalıştırılır.

Üretim ortamları için bir hizmet sorumlusu kullanarak kimlik doğrulaması yapın ve uygun ortam değişkenlerini ayarlayın. Bu yaklaşım, otomasyon için uygun güvenli, etkileşimli olmayan erişim sağlar. Kurulum yönergeleri için bkz. Azure hizmetleriyle Python uygulamalarının kimliğini doğrulama.

Hizmet sorumlusuna abonelik veya kaynak grubu düzeyinde Katkıda Bulunan rolü gibi yeterli izinlere sahip bir rol atandığından emin olun. Rol atama hakkında ayrıntılı bilgi için bkz. Azure rol tabanlı erişim denetimi (RBAC).

PostgreSQL veritabanı sunucusu için bkz:

5: Betiği çalıştır

  1. Henüz yapmadıysanız Azure CLI kullanarak Azure oturum açın:

    az login

  2. Betiği Çalıştırın:

    python provision_db.py

    Komut dosyasının tamamlanması bir veya iki dakika sürer.

6: Kayıt ekleme ve veritabanını sorgulama

Bu adımda, veritabanında bir tablo oluşturur ve bir kayıt eklersiniz. mysql-connector Veritabanına bağlanmak ve SQL komutlarını çalıştırmak için kitaplığı kullanın.

  1. Aşağıdaki kodla use_db.py adlı bir dosya oluşturun.

    Bu kod yalnızca MySQL için çalışır. PostgreSQL için farklı kitaplıklar kullanırsınız.

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

    Bu kodun tümü API'yi mysql.connector kullanır. Azure’a özgü tek kısım, MySQL sunucusu için tam ana bilgisayar etki alanı adıdır (mysql.database.azure.com).

  2. Ardından, MySQL için Azure Veritabanı sunucunuzla TLS/SSL üzerinden iletişim kurmak için gereken kök sertifikayı indirin. Azure MySQL Esnek Sunucusu DigiCert Genel Kök G2 sertifikasını kullanır. Daha fazla bilgi için bkz. MySQL için Azure Veritabanı - Şifrelenmiş bağlantılara sahip Esnek Sunucuya bağlanma.

    #!/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. Son olarak kodu çalıştırın:

    python use_db.py

İstemci IP adresinize izin verilmediğini belirten bir hata görürseniz ortam değişkenini PUBLIC_IP_ADDRESS doğru tanımlamış olup olmadığınızı denetleyin. MySQL sunucusunu yanlış IP adresiyle oluşturduysanız Azure portalında başka bir sunucu ekleyebilirsiniz. Portalda MySQL sunucusunu seçin ve ardından Ağ seçeneğini seçin. İş istasyonunuzun IP adresini izin verilen IP adresleri listesine ekleyin.

7: Kaynakları temizleme

Bu örnekte oluşturulan kaynak grubunu ve veritabanı kaynaklarını tutmanız gerekmiyorsa az group delete komutunu çalıştırın.

Kaynak grupları aboneliğinizde devam eden bir ücret ödemez, ancak kaynak grubundaki kaynaklar ücretlendirilmeye devam edebilir. Etkin olarak kullanmadığınız tüm grupları temizlemek iyi bir uygulamadır. --no-wait bağımsız değişkeni, işlemin bitmesini beklemek yerine komutun hemen geri dönmesini sağlar.

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

Bir kaynak grubunu koddan silmek için yöntemini de kullanabilirsiniz ResourceManagementClient.resource_groups.begin_delete . Örnek: Kaynak grubu oluşturma kodunda kullanım gösterilmektedir.

Referans için: eşdeğer Azure CLI komutları

Aşağıdaki Azure CLI komutları, Python betiğiyle aynı sağlama adımlarını tamamlar. PostgreSQL veritabanı için komutları kullanın az postgres flexible-server .

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

Ayrıca bakınız

  • Last updated on