Partilhar 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 Python para criar programaticamente um banco de dados do Azure para servidor flexível MySQL e um banco de dados correspondente. Ele também inclui um script básico que usa a biblioteca mysql-connector-python (que não faz parte do SDK do Azure) para se conectar e consultar o banco de dados.

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

Se você preferir usar a CLI do Azure, os 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 em shells de comando Linux/macOS bash e Windows.

1: Configure seu ambiente de desenvolvimento local

Se ainda não o fez, configure um ambiente onde possa executar o código. Seguem-se algumas opções:

  • Configure um ambiente virtual Python usando venv ou sua ferramenta de preferência. Para começar a usar o ambiente virtual, não deixe de ativá-lo. 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 de conda. Para instalar o Conda, consulte Instalar o Miniconda.

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

2: Instale os pacotes de biblioteca do Azure necessários

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

  1. No console, crie um arquivo requirements.txt que liste 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, tentar 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ê define variáveis de ambiente para uso no código deste 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: Escreva código para criar e configurar um servidor flexível MySQL com um banco de dados

Nesta etapa, você cria 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 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 configuração, consulte Como autenticar aplicativos Python com serviços do Azure.

Verifique se o Principal de Serviço foi atribuído a uma função com permissões adequadas, como a 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. Se ainda não o fez, inicie sessão no Azure utilizando a CLI do Azure:

    az login

  2. Execute o roteiro:

    python provision_db.py

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

6: Inserir um registo e consultar a base 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.

    Este 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 seu Banco de Dados do Azure para o servidor 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. Finalmente, execute o código:

    python use_db.py

Se você vir um erro informando 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á criou o servidor MySQL com o endereço IP errado, pode adicionar outro no portal do Azure. No portal, selecione o servidor MySQL e, em seguida, selecione Segurança de conexão. Adicione o endereço IP da sua estação de trabalho à lista de endereços IP permitidos.

7: Limpar recursos

Execute o comando az group delete se 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 na sua subscrição, mas os recursos, como contas de armazenamento, no grupo de recursos podem continuar a incorrer em encargos. É uma boa prática eliminar qualquer grupo que não estejas a utilizar ativamente. O argumento --no-wait permite que o comando retorne imediatamente em vez de esperar que a operação termine.

#!/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 seguintes comandos da CLI do Azure concluem 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."

Ver também