Démarrage rapide : Utiliser des bibliothèques Azure (SDK) pour Python pour gérer une base de données Azure pour PostgreSQL

Dans ce guide de démarrage rapide, vous allez apprendre à utiliser le Kit de développement logiciel (SDK) Azure Python pour interagir avec une instance de serveur flexible Azure Database pour PostgreSQL.

Azure Database pour PostgreSQL est un service managé pour l’exécution, la gestion et la mise à l’échelle des bases de données PostgreSQL hautement disponibles dans le cloud. Vous pouvez utiliser le Kit de développement logiciel (SDK) Python pour approvisionner une instance de serveur flexible Azure Database pour PostgreSQL, plusieurs serveurs ou plusieurs bases de données sur un serveur.

Avec la suppression en bloc, vous pouvez effectuer les opérations suivantes avec cette bibliothèque :

Création d’une instance de serveur flexible PostgreSQL
Gestion des bases de données
Configuration des règles de pare-feu
Opérations de mise à l’échelle
Sauvegarde et restauration

Ce guide vous aide à explorer les fonctionnalités de base de ce Kit de développement logiciel (SDK), y compris la création d’une instance de serveur flexible, la vérification du serveur créé, la création d’une base de données et la suppression de l’instance.

Prérequis

Compte avec abonnement actif

Compte Azure avec abonnement actif Créer gratuitement un compte.

Installer les bibliothèques

Installez les bibliothèques Azure Python suivantes.

pip install azure-mgmt-resource
pip install azure-identity
pip install azure-mgmt-postgresqlflexibleservers

Connectez-vous à votre compte avec azurecli pour authentifier votre compte.

az login

Une fois cette commande exécutée, sélectionnez un compte valide pour vous connecter, puis sélectionnez l’ID d’abonnement dans la liste pour ouvrir une session.

Créer le serveur

Créez un fichier create_postgres_flexible_server.py et incluez le code suivant.

from azure.identity import DefaultAzureCredential
from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

def main():
    client = PostgreSQLManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="<subscription-id>",
    )

    response = client.servers.begin_create(
        resource_group_name="<resource-group-name>",
        server_name="<server-name>",
        parameters={
            "location": "<region>",
            "properties": {
                "administratorLogin": "<admin-username>",
                "administratorLoginPassword": "<password>",
                "availabilityZone": "1",
                "backup": {"backupRetentionDays": 7, "geoRedundantBackup": "Disabled"},
                "createMode": "Create",
                "highAvailability": {"mode": "ZoneRedundant"},
                "network": {
                    "delegatedSubnetResourceId": "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.Network/virtualNetworks/<vnet-name>/subnets/<subnet-name>",
                    "privateDnsZoneArmResourceId": "/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.Network/privateDnsZones/<private-DNS-zone-name>.postgres.database.azure.com",
                },
                "version": "<pg-version>",
            },
            "sku": {"name": "<sku-name>", "tier": "<tier-type>"},
            "tags": {"ElasticServer": "1"},
        },
    ).result()
    print(response)

if __name__ == "__main__":
    main()

Remplacez les paramètres suivants par les vôtres :

subscription-id : votre propre ID d’abonnement.
resource-group : nom du groupe de ressources que vous souhaitez utiliser. Le script en crée s’il n’existe pas.
server-name : nom unique qui identifie votre instance de serveur flexible Azure Database pour PostgreSQL. Le nom de domaine postgres.database.azure.com est ajouté au nom de serveur que vous renseignez. Le nom du serveur doit comporter au moins 3 caractères et au maximum 63. Il ne doit contenir que des minuscules, des chiffres et des traits d’union.
Emplacement : région Azure dans laquelle vous souhaitez créer votre instance de serveur flexible Azure Database pour PostgreSQL. Il définit l’emplacement géographique dans lequel résident votre serveur et ses données. Choisissez une région à proximité de vos utilisateurs pour réduire la latence. L’emplacement doit être spécifié au format des noms courts de région Azure, tels que westus2, eastus ou northeurope.
admin-username : nom d’utilisateur de l’administrateur principal du serveur. Une fois le serveur créé, vous pouvez créer des utilisateurs supplémentaires.
password : mot de passe pour l’administrateur principal du serveur. Il doit contenir entre 8 et 128 caractères. Votre mot de passe doit contenir des caractères appartenant à trois catégories : lettres majuscules anglaises, lettres minuscules anglaises, chiffres (0 à 9) et caractères non alphanumériques (!, $, #, %, etc.).

Vous pouvez également ajouter des valeurs pour d’autres paramètres tels que vnet-name, subnet-name et private-DNS-zone. Vous pouvez aussi personnaliser d’autres paramètres tels que la taille de stockage, la version du moteur, etc.

Remarque

La classe DefaultAzureCredential tente l’authentification avec différentes méthodes, telles que les variables d’environnement, les identités managées ou l’interface de ligne de commande Azure.
Vérifiez que l’une de ces méthodes est configurée. Vous trouverez plus d’informations sur l’authentification dans la documentation du SDK Azure.

L’exécution de ce code lance le processus de création d’instance, ce qui peut prendre quelques minutes.

Vérifier les ressources déployées

Vous pouvez utiliser le SDK Python, le portail Azure, Azure CLI, Azure PowerShell et divers autres outils pour valider le déploiement et passer en revue les ressources déployées. Vous trouverez ci-dessous des exemples.

Valider le déploiement avec le Kit de développement logiciel (SDK) Python

Ajoutez la fonction check_server_created à votre script existant pour utiliser l’attribut des serveurs de l’instance PostgreSQLManagementClient et vérifier ainsi si le serveur flexible Azure Database pour PostgreSQL a été créé :

def check_server_created(subscription_id, resource_group, server_name):
    # Authenticate with your Azure account
    credential = DefaultAzureCredential()

    # Create PostgreSQL management client
    postgres_client = PostgreSQLManagementClient(credential, subscription_id)

    try:
        server = postgres_client.servers.get(resource_group, server_name)
        if server:
            print(f"Server '{server_name}' exists in resource group '{resource_group}'.")
            print(f"Server state: {server.state}")
        else:
            print(f"Server '{server_name}' not found in resource group '{resource_group}'.")
    except Exception as e:
        print(f"Error occurred: {e}")
        print(f"Server '{server_name}' not found in resource group '{resource_group}'.")

Appelez-le avec les paramètres appropriés.

 check_server_created(subscription_id, resource_group, server_name)

Remarque

La fonction check_server_created retourne l’état du serveur dès que le serveur est approvisionné. Toutefois, quelques minutes peuvent être nécessaires pour que le serveur soit complètement disponible. Attendez bien que le serveur soit à l’état Prêt avant de vous y connecter. Cette fonction retourne l’état, l’ID, le nom, l’emplacement et d’autres paramètres en réponse à la méthode postgres_client.servers.get.

Créer une base de données avec Python

Créer une base de données dans votre instance de serveur flexible avec cet exemple de code

from azure.identity import DefaultAzureCredential
from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

def main():
    client = PostgreSQLManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id=<subscription-id>,
    )
    # Create database
    response = client.databases.begin_create(
        resource_group_name="<resource-group-name>",
        server_name="<server-name>",
        database_name="<database-name>",
        parameters={"properties": {"charset": "utf8", "collation": "en_US.utf8"}},
    ).result()
    print(response)

if __name__ == "__main__":
    main()

Remplacez les paramètres suivants par vos données

subscription-id : votre ID d’abonnement.
resource-group-name : nom du groupe de ressources que vous souhaitez utiliser. Le script crée un groupe de ressources s’il n’existe pas.
server-name : nom de l’instance de serveur flexible Azure Database que vous avez préalablement créée
database-name : nom de la base de données que vous souhaitez créer.

Nettoyer les ressources

Si vous n’avez plus besoin de l’instance de serveur flexible Azure Database pour PostgreSQL, vous pouvez la supprimer avec le groupe de ressources associé en utilisant le Portail, le Kit de développement logiciel (SDK) Python ou Azure CLI.

Utiliser le Kit de développement logiciel (SDK) Python pour supprimer l’instance

Créez un fichier « delete_server.py » pour supprimer l’instance de serveur Azure Database pour PostgreSQL créée.

Python
CLI

from azure.identity import DefaultAzureCredential
from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

def main():
    client = PostgreSQLManagementClient(
          credential=DefaultAzureCredential(),
          subscription_id=<subscription-id>,)
    client.servers.begin_delete(
          resource_group_name=<rg-name>,
          server_name=<server-name>,
    ).result()
if __name__ == "__main__":
    main()

az postgres flexible-server delete \
  --resource-group <resource-group> \
  --name <server-name>

Créez une base de données Azure pour PostgreSQL.

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-02-07