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 SDK Python pour provisionner une instance de serveur flexible Azure Database for PostgreSQL, plusieurs serveurs ou plusieurs bases de données sur un serveur.

Vous pouvez effectuer les opérations suivantes avec cette bibliothèque :

Création d’une instance de serveur flexible PostgreSQL
Gestion de 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 SDK, notamment la création d'une instance de serveur flexible, la consultation du serveur créé, la création d'une base de données et la suppression de l'instance.

Prerequisites

Compte avec abonnement actif

Un compte Azure avec un abonnement actif : créez 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 via azurecli afin de l'authentifier.

az login

Une fois cette commande exécutée, sélectionnez un compte valide pour vous connecter, puis sélectionnez ultérieurement l'ID d'abonnement dans la liste pour vous connecter.

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 : ID de votre abonnement.
resource-group : nommez le groupe de ressources à utiliser. S'il n'existe pas, le script en crée un nouveau.
server-name : nom unique qui identifie votre instance de serveur flexible Azure Database for PostgreSQL. Le nom de domaine postgres.database.azure.com est ajouté au nom de serveur que vous avez fourni. Le nom du serveur doit comporter au moins trois caractères et au maximum 63 caractères, et ne peut contenir que des lettres minuscules, des chiffres et des traits d'union.
Location : région Azure dans laquelle vous souhaitez créer votre instance de serveur flexible Azure Database for PostgreSQL. Elle définit l'emplacement géographique où résident votre serveur et ses données. Choisissez une région proche de vos utilisateurs afin de réduire la latence. L'emplacement doit être spécifié au format des noms courts des régions Azure, comme westus2, eastus ou northeurope.
admin-username : nom d'utilisateur de l'administrateur principal du serveur. Après la création du serveur, 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 des catégories suivantes : lettres majuscules, lettres minuscules, 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, private-DNS-zone, et personnaliser d'autres paramètres comme la taille du stockage, la version du moteur, etc.

Note

La classe DefaultAzureCredential tente de s'authentifier à l'aide de 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 de l'instance, qui peut prendre quelques minutes.

Passer en revue 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 SDK Python

Ajoutez la fonction check_server_created à votre script existant pour utiliser l'attribut servers de l'instance PostgreSQLManagementClient afin de vérifier si l'instance de serveur flexible Azure Database for PostgreSQL a été créée :

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)

Note

La fonction check_server_created renvoie l'état du serveur dès que celui-ci est provisionné. Cependant, le serveur peut prendre quelques minutes avant d'être entièrement disponible. Assurez-vous d'attendre que le serveur soit à l'état Prêt avant de vous y connecter. Elle renverra 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 à l'aide de 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 : ID de votre abonnement.
resource-group-name : nommez le groupe de ressources à 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 créée précédemment
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 Azure Database for PostgreSQL flexible server, vous pouvez la supprimer ainsi que le groupe de ressources associé à l'aide du Portail, du SDK Python ou d'Azure CLI.

Utiliser le SDK Python pour supprimer l'instance

Créez un fichier « delete_server.py » pour supprimer l'instance Azure Databases for PostgreSQL Server qui a été 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.

Commentaires

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

Last updated on 2025-12-31