Compartilhar via

Exemplo: usar as bibliotecas do Azure para criar um banco de dados

Este exemplo demonstra como usar o SDK do Azure para bibliotecas de gerenciamento do Python para criar programaticamente um servidor flexível do Banco de Dados do Azure para MySQL e um banco de dados correspondente. Ele também inclui um script básico que usa a biblioteca mysql-connector-python (não parte do SDK do Azure) para se conectar e consultar o banco de dados.

Você pode adaptar este exemplo para criar um servidor flexível do Banco de Dados do Azure para PostgreSQL modificando as importações relevantes do SDK e as chamadas à API.

Se você preferir usar a CLI do Azure, comandos equivalentes da CLI do Azure serão fornecidos posteriormente neste artigo. Para obter uma experiência gráfica, consulte a documentação do portal do Azure:

A menos que especificado de outra forma, todos os exemplos e comandos funcionam consistentemente entre shells de comando do Linux/macOS e do Windows.

1: Configurar seu ambiente de desenvolvimento local

Caso ainda não tenha feito isso, configure um ambiente em que você possa executar o código. Aqui estão algumas opções:

  • Configure um ambiente virtual do Python usando venv ou sua ferramenta de escolha. Para começar a usar o ambiente virtual, ative-o. Para instalar o Python, consulte Instalar o 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)

  • Use um ambiente conda. Para instalar o Conda, consulte Instalar o Miniconda.

  • Use um contêiner de desenvolvimento no Visual Studio Code ou no GitHub Codespaces.

2: Instalar os pacotes necessários da biblioteca do Azure

Nesta etapa, você instalará as bibliotecas do SDK do Azure necessárias para criar o banco de dados.

  1. No console, crie um arquivo requirements.txt que lista as bibliotecas de gerenciamento usadas neste exemplo:

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

    Observação

    A mysql-connector-python biblioteca não faz parte do SDK do Azure. É uma biblioteca de terceiros que você pode usar para se conectar a bancos de dados MySQL. Você também pode usar outras bibliotecas, como PyMySQL ou SQLAlchemy, para se conectar a bancos de dados MySQL.

  2. No console com o ambiente virtual ativado, instale os requisitos:

    pip install -r requirements.txt

    Observação

    No Windows, a tentativa de instalar a biblioteca mysql em uma biblioteca python de 32 bits produz um erro sobre o arquivo mysql.h . Nesse caso, instale uma versão de 64 bits do Python e tente novamente.

3. Definir variáveis de ambiente

Nesta etapa, você definirá variáveis de ambiente para uso no código neste artigo. O código usa o os.environ método para recuperar os valores.

#!/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: Escrever código para criar e configurar um Servidor Flexível MySQL com um banco de dados

Nesta etapa, você criará um arquivo Python chamado provision_blob.py com o código a seguir. Esse script Python usa o SDK do Azure para bibliotecas de gerenciamento do Python para criar um grupo de recursos, um servidor flexível mySQL e um banco de dados nesse servidor.

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

Autenticação no código

Mais adiante neste artigo, você entra no Azure usando a CLI do Azure para executar o código de exemplo. Se sua conta tiver permissões suficientes para criar grupos de recursos e recursos de armazenamento em sua assinatura do Azure, o script deverá ser executado com êxito sem configuração adicional.

Para uso em ambientes de produção, recomendamos que você se autentique com uma entidade de serviço definindo as variáveis de ambiente apropriadas. Essa abordagem permite acesso seguro e não interativo adequado para automação. Para obter instruções de instalação, consulte Como autenticar aplicativos Python com os serviços do Azure.

Assegure-se de que a entidade de serviço tenha uma função com permissões adequadas, como uma função de Colaborador no nível da assinatura ou do grupo de recursos. Para obter detalhes sobre como atribuir funções, consulte RBAC (controle de acesso baseado em função) no Azure.

Para o servidor de banco de dados PostreSQL, consulte:

5: Executar o script

  1. Caso ainda não tenha feito isso, entre no Azure usando a CLI do Azure:

    az login

  2. Executar o script:

    python provision_db.py

    O script leva um ou dois minutos para ser concluído.

6: Inserir um registro e consultar o banco de dados

Nesta etapa, você cria uma tabela no banco de dados e insere um registro. Você pode usar a biblioteca mysql-connector para se conectar ao banco de dados e executar comandos SQL.

  1. Crie um arquivo chamado use_db.py com o código a seguir.

    Esse código funciona apenas para MySQL; você usa bibliotecas diferentes para 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()

    Todo esse código usa a API mysql.connector. A única parte específica do Azure é o domínio de host completo para o servidor MySQL (mysql.database.azure.com).

  2. Em seguida, baixe o certificado necessário para se comunicar por TSL/SSL com o servidor do Banco de Dados do Azure para MySQL. Para obter mais informações, consulte Obter um certificado SSL na documentação do Banco de Dados do Azure para 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. Por fim, execute o código:

    python use_db.py

Se você vir um erro de que o endereço IP do cliente não é permitido, verifique se você definiu a variável PUBLIC_IP_ADDRESS de ambiente corretamente. Se você já tiver criado o servidor MySQL com o endereço IP errado, poderá adicionar outro no portal do Azure. No portal, selecione o servidor MySQL e selecione Segurança de conexão. Adicione o endereço IP da estação de trabalho à lista de endereços IP permitidos.

7: Limpar recursos

Execute o comando az group delete se você não precisar manter o grupo de recursos e os recursos de armazenamento criados neste exemplo.

Os grupos de recursos não incorrem em encargos contínuos em sua assinatura, mas recursos, como contas de armazenamento, no grupo de recursos podem continuar a incorrer em encargos. É uma boa prática limpar qualquer grupo que você não esteja usando ativamente. O --no-wait argumento permite que o comando retorne imediatamente em vez de aguardar a conclusão da operação.

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

Você também pode usar o ResourceManagementClient.resource_groups.begin_delete método para excluir um grupo de recursos do código. O código em Exemplo: Criar um grupo de recursos demonstra o uso.

Para referência: comandos equivalentes da CLI do Azure

Os comandos da CLI do Azure a seguir completam as mesmas etapas de provisionamento que o script Python. Para um banco de dados PostgreSQL, use az postgres flexible-server comandos.

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

Consulte também