Partager via

Exemple : Utiliser les bibliothèques Azure pour créer une base de données

Cet exemple montre comment utiliser le Kit de développement logiciel (SDK) Azure pour les bibliothèques de gestion Python pour créer par programmation un serveur flexible Azure Database pour MySQL et une base de données correspondante. Il inclut également un script de base qui utilise la bibliothèque mysql-connector-python (qui ne fait pas partie du Kit de développement logiciel (SDK) Azure pour se connecter à la base de données et l’interroger.

Vous pouvez adapter cet exemple pour créer un serveur flexible Azure Database pour PostgreSQL en modifiant les importations et les appels d’API appropriés.

Si vous préférez utiliser Azure CLI, les commandes Azure CLI équivalentes sont fournies plus loin dans cet article. Pour une expérience graphique, reportez-vous à la documentation du portail Azure :

Sauf indication contraire, tous les exemples et commandes fonctionnent de manière cohérente sur les interpréteurs de commandes Linux/macOS bash et Windows.

1 : Configurer votre environnement de développement local

Si ce n’est déjà fait, configurez un environnement dans lequel vous pouvez exécuter le code. Voici quelques options :

  • Configurez un environnement virtuel Python à l’aide de venv ou de votre outil de choix. Pour commencer à utiliser l’environnement virtuel, veillez à l’activer. Pour installer Python, consultez Installer 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)

  • Utilisez un environnement conda. Pour installer Conda, consultez Installer Miniconda.

  • Utilisez un conteneur de développement dans Visual Studio Code ou GitHub Codespaces.

2 : Installer les packages de bibliothèque Azure nécessaires

Dans cette étape, vous installez les bibliothèques du Kit de développement logiciel (SDK) Azure nécessaires pour créer la base de données.

  1. Dans votre console, créez un fichier requirements.txt qui répertorie les bibliothèques de gestion utilisées dans cet exemple :

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

    Remarque

    La mysql-connector-python bibliothèque ne fait pas partie du Kit de développement logiciel (SDK) Azure. Il s’agit d’une bibliothèque tierce que vous pouvez utiliser pour vous connecter aux bases de données MySQL. Vous pouvez également utiliser d’autres bibliothèques, telles que PyMySQL ou SQLAlchemy, pour vous connecter aux bases de données MySQL.

  2. Dans votre console avec l’environnement virtuel activé, installez les conditions requises :

    pip install -r requirements.txt

    Remarque

    Sur Windows, la tentative d’installation de la bibliothèque mysql dans une bibliothèque Python 32 bits génère une erreur concernant le fichier mysql.h . Dans ce cas, installez une version 64 bits de Python et réessayez.

3. Définir des variables d’environnement

Dans cette étape, vous définissez des variables d’environnement à utiliser dans le code de cet article. Le code utilise la os.environ méthode pour récupérer les valeurs.

#!/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 : Écrire du code pour créer et configurer un serveur flexible MySQL avec une base de données

Dans cette étape, vous créez un fichier Python nommé provision_blob.py avec le code suivant. Ce script Python utilise le Kit de développement logiciel (SDK) Azure pour les bibliothèques de gestion Python pour créer un groupe de ressources, un serveur flexible MySQL et une base de données sur ce serveur.

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

Authentification dans le code

Plus loin dans cet article, vous vous connectez à Azure à l’aide d’Azure CLI pour exécuter l’exemple de code. Si votre compte dispose des autorisations suffisantes pour créer des groupes de ressources et des ressources de stockage dans votre abonnement Azure, le script doit s’exécuter correctement sans configuration supplémentaire.

Pour une utilisation dans les environnements de production, nous vous recommandons de vous authentifier auprès d’un principal de service en définissant les variables d’environnement appropriées. Cette approche permet un accès sécurisé et non interactif adapté à l’automatisation. Pour obtenir des instructions d’installation, consultez Comment authentifier les applications Python avec les services Azure.

Vérifiez que le principal de service est affecté à un rôle disposant d’autorisations adéquates, telles que le rôle Contributeur au niveau de l’abonnement ou du groupe de ressources. Pour plus d’informations sur l’attribution de rôles, reportez-vous au contrôle d’accès en fonction du rôle (RBAC) dans Azure.

Pour le serveur de base de données PostreSQL, consultez :

5 : Exécuter le script

  1. Si ce n’est déjà fait, connectez-vous à Azure à l’aide d’Azure CLI :

    az login

  2. Exécutez le script :

    python provision_db.py

    Le script prend une minute ou deux pour se terminer.

6 : Insérer un enregistrement et interroger la base de données

Dans cette étape, vous créez une table dans la base de données et insérez un enregistrement. Vous pouvez utiliser la bibliothèque mysql-connector pour vous connecter à la base de données et exécuter des commandes SQL.

  1. Créez un fichier nommé use_db.py avec le code suivant.

    Ce code fonctionne uniquement pour MySQL ; vous utilisez différentes bibliothèques pour 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()

    Tout ce code utilise l’API mysql.connector. La seule partie spécifique à Azure est le domaine hôte complet pour le serveur MySQL (mysql.database.azure.com).

  2. Ensuite, téléchargez le certificat nécessaire pour communiquer via TSL/SSL avec votre serveur Azure Database pour MySQL. Pour plus d’informations, consultez Obtenir un certificat SSL dans la documentation Azure Database pour 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. Enfin, exécutez le code :

    python use_db.py

Si vous voyez une erreur indiquant que votre adresse IP cliente n’est pas autorisée, vérifiez que vous avez correctement défini la variable PUBLIC_IP_ADDRESS d’environnement. Si vous avez déjà créé le serveur MySQL avec l’adresse IP incorrecte, vous pouvez ajouter un autre dans le portail Azure. Dans le portail, sélectionnez le serveur MySQL, puis sélectionnez Sécurité de connexion. Ajoutez l’adresse IP de votre station de travail à la liste des adresses IP autorisées.

7 : Nettoyer les ressources

Exécutez la commande az group delete si vous n’avez pas besoin de conserver le groupe de ressources et les ressources de stockage créées dans cet exemple.

Les groupes de ressources n’entraînent pas de frais continus dans votre abonnement, mais les ressources, comme les comptes de stockage, dans le groupe de ressources peuvent continuer à entraîner des frais. Il est recommandé de nettoyer n’importe quel groupe que vous n’utilisez pas activement. L’argument --no-wait permet à la commande de retourner immédiatement au lieu d’attendre la fin de l’opération.

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

Vous pouvez également utiliser la méthode ResourceManagementClient.resource_groups.begin_delete pour supprimer un groupe de ressources du code. Le code dans l’exemple : Créer un groupe de ressources illustre l’utilisation.

Pour référence : commandes Azure CLI équivalentes

Les commandes Azure CLI suivantes effectuent les mêmes étapes d’approvisionnement que le script Python. Pour une base de données PostgreSQL, utilisez les commandes az postgres flexible-server.

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

Voir aussi