Partager via

bibliothèque de client Azure App Configuration pour Python - version 1.5.0

  • Article

Azure App Configuration est un service managé qui permet aux développeurs de centraliser leurs configurations d’application de façon simple et sécurisée.

Les programmes modernes, en particulier les programmes qui s’exécutent dans un cloud, ont généralement de nombreux composants qui sont par nature distribués. La répartition des paramètres de configuration sur tous ces composants peut rendre les erreurs difficiles à corriger pendant le déploiement d’une application. Utilisez App Configuration pour stocker en toute sécurité tous les paramètres de votre application au même endroit.

Utilisez la bibliothèque cliente pour App Configuration afin de créer et de gérer les paramètres de configuration d’application.

| Code sourcePackage (Pypi) | Package (Conda) | Documentation de référence sur les | APIDocumentation produit

Clause d’exclusion de responsabilité

La prise en charge des packages Python du SDK Azure pour Python 2.7 a pris fin le 1er janvier 2022. Pour plus d’informations et de questions, reportez-vous à https://github.com/Azure/azure-sdk-for-python/issues/20691Python 3.7 ou version ultérieure nécessaire pour utiliser ce package. Pour plus d’informations, reportez-vous à la stratégie de prise en charge des versions du Kit de développement logiciel (SDK) Azure pour Python.

Prise en main

Installer le package

Installez la bibliothèque cliente Azure App Configuration pour Python avec pip :

pip install azure-appconfiguration

Prérequis

Pour créer un magasin de configuration, vous pouvez utiliser le portail Azure ou Azure CLI.

Après cela, créez le magasin de configuration :

az appconfig create --name <config-store-name> --resource-group <resource-group-name> --location eastus

Authentifier le client

Pour interagir avec le service App Configuration, vous devez créer un instance de la classe AzureAppConfigurationClient. Pour ce faire, vous pouvez utiliser le chaîne de connexion du magasin de configuration ou utiliser un jeton AAD.

Utiliser la chaîne de connexion

Récupérer les informations d’identification

Utilisez l’extrait de code Azure CLI ci-dessous pour obtenir les chaîne de connexion à partir du magasin de configuration.

az appconfig credential list --name <config-store-name>

Vous pouvez également obtenir le chaîne de connexion à partir du portail Azure.

Créer un client

Une fois que vous avez la valeur de la chaîne de connexion, vous pouvez créer azureAppConfigurationClient :

import os
from azure.appconfiguration import AzureAppConfigurationClient

CONNECTION_STRING = os.environ["APPCONFIGURATION_CONNECTION_STRING"]

# Create app config client
client = AzureAppConfigurationClient.from_connection_string(CONNECTION_STRING)

Utiliser un jeton AAD

Ici, nous montrons l’utilisation de DefaultAzureCredential pour l’authentification en tant que principal de service. Toutefois, AzureAppConfigurationClient accepte toutes les informations d’identification azure-identity . Pour plus d’informations sur les autres informations d’identification, consultez la documentation azure-identity .

Créer un principal de service (facultatif)

Cet extrait de code Azure CLI montre comment créer un principal de service. Avant de l’utiliser, remplacez « your-application-name » par le nom approprié pour votre principal de service.

Créez un principal de service :

az ad sp create-for-rbac --name http://my-application --skip-assignment

Sortie :

{
    "appId": "generated app id",
    "displayName": "my-application",
    "name": "http://my-application",
    "password": "random password",
    "tenant": "tenant id"
}

Utilisez la sortie pour définir les variables d’environnement AZURE_CLIENT_ID (« appId » ci-dessus), AZURE_CLIENT_SECRET (« mot de passe » ci-dessus) et AZURE_TENANT_ID (« locataire » ci-dessus). L’exemple suivant montre comment procéder dans Bash :

export AZURE_CLIENT_ID="generated app id"
export AZURE_CLIENT_SECRET="random password"
export AZURE_TENANT_ID="tenant id"

Attribuez l’un des rôles App Configuration applicables au principal de service.

Créer un client

Une fois les variables d’environnement AZURE_CLIENT_ID, AZURE_CLIENT_SECRET et AZURE_TENANT_ID définies, DefaultAzureCredential peut authentifier AzureAppConfigurationClient.

La construction du client nécessite également l’URL de votre magasin de configuration, que vous pouvez obtenir à partir d’Azure CLI ou du portail Azure. Dans le portail Azure, l’URL est répertoriée en tant que service « Point de terminaison »

from azure.identity import DefaultAzureCredential
from azure.appconfiguration import AzureAppConfigurationClient

credential = DefaultAzureCredential()

client = AzureAppConfigurationClient(base_url="your_endpoint_url", credential=credential)

Concepts clés

Paramètre de configuration

Un paramètre de configuration est la ressource fondamentale d’un magasin de configurations. Dans sa forme la plus simple, il s’agit d’une clé et d’une valeur. Toutefois, il existe des propriétés supplémentaires, telles que le type de contenu modifiable et les champs de balises, qui permettent d’interpréter ou d’associer la valeur de différentes manières.

La propriété Label d’un paramètre de configuration permet de séparer les paramètres de configuration en différentes dimensions. Ces dimensions sont définies par l’utilisateur et peuvent prendre n’importe quelle forme. Parmi les exemples courants de dimensions à utiliser pour une étiquette, citons les régions, les versions sémantiques ou les environnements. De nombreuses applications ont un ensemble requis de clés de configuration qui ont des valeurs variables, car l’application existe sur différentes dimensions.

Par exemple, MaxRequests peut être 100 dans « NorthAmerica » et 200 dans « WestEurope ». En créant un paramètre de configuration nommé MaxRequests avec une étiquette « NorthAmerica » et un autre, uniquement avec une valeur différente, dans l’étiquette « WestEurope », une application peut récupérer en toute transparence les paramètres de configuration au fur et à mesure de son exécution dans ces deux dimensions.

Propriétés d’un paramètre de configuration :

key : str
label : str
content_type : str
value : str
last_modified : str
read_only : bool
tags : dict
etag : str

Instantané

Azure App Configuration permet aux utilisateurs de créer une instantané dans le temps de leur magasin de configuration, ce qui leur permet de traiter les paramètres comme une version cohérente. Cette fonctionnalité permet aux applications de conserver une vue cohérente de la configuration, ce qui garantit qu’il n’existe aucune incompatibilité de version avec les paramètres individuels en raison de la lecture au fur et à mesure que des mises à jour ont été effectuées. Les captures instantanées sont immuables, ce qui garantit que la configuration peut être restaurée en toute confiance vers une dernière configuration correcte connue en cas de problème.

Exemples

Les sections suivantes fournissent plusieurs extraits de code couvrant certaines des tâches de service de configuration les plus courantes, notamment :

Créer un paramètre de configuration

Créez un paramètre de configuration à stocker dans le magasin de configuration. Il existe deux façons de stocker un paramètre de configuration :

  • add_configuration_setting crée un paramètre uniquement si le paramètre n’existe pas déjà dans le magasin.
config_setting = ConfigurationSetting(
    key="MyKey", label="MyLabel", value="my value", content_type="my content type", tags={"my tag": "my tag value"}
)
added_config_setting = client.add_configuration_setting(config_setting)
  • set_configuration_setting crée un paramètre s’il n’existe pas ou remplace un paramètre existant.
added_config_setting.value = "new value"
added_config_setting.content_type = "new content type"
updated_config_setting = client.set_configuration_setting(added_config_setting)

Obtenir un paramètre de configuration

Obtenir un paramètre de configuration précédemment stocké.

fetched_config_setting = client.get_configuration_setting(key="MyKey", label="MyLabel")

Supprimer un paramètre de configuration

Supprimer un paramètre de configuration existant.

client.delete_configuration_setting(
    key="MyKey",
    label="MyLabel",
)

Répertorier les paramètres de configuration

Répertorie tous les paramètres de configuration filtrés avec label_filter et/ou key_filter.

config_settings = client.list_configuration_settings(label_filter="MyLabel")
for item in config_settings:
    print_configuration_setting(item)

Créer un instantané

from azure.appconfiguration import ConfigurationSettingsFilter

filters = [ConfigurationSettingsFilter(key="my_key1", label="my_label1")]
response = client.begin_create_snapshot(name=snapshot_name, filters=filters)
created_snapshot = response.result()
print_snapshot(created_snapshot)

Obtenir un instantané

received_snapshot = client.get_snapshot(name=snapshot_name)

Archiver un instantané

archived_snapshot = client.archive_snapshot(name=snapshot_name)
print_snapshot(archived_snapshot)

Récupérer un instantané

recovered_snapshot = client.recover_snapshot(name=snapshot_name)
print_snapshot(recovered_snapshot)

Répertorier les instantanés

for snapshot in client.list_snapshots():
    print_snapshot(snapshot)

Répertorier les paramètres de configuration d’un instantané

for config_setting in client.list_configuration_settings(snapshot_name=snapshot_name):
    print_configuration_setting(config_setting)

API asynchrones

Le client asynchrone est pris en charge. Pour utiliser la bibliothèque de client asynchrone, importez azureAppConfigurationClient à partir du package azure.appconfiguration.aio au lieu d’azure.appconfiguration

import os
from azure.appconfiguration.aio import AzureAppConfigurationClient

CONNECTION_STRING = os.environ["APPCONFIGURATION_CONNECTION_STRING"]

# Create app config client
client = AzureAppConfigurationClient.from_connection_string(CONNECTION_STRING)

Ce azureAppConfigurationClient asynchrone a les mêmes signatures de méthode que les signatures de synchronisation, sauf qu’elles sont asynchrones. Pour instance, pour récupérer un paramètre de configuration de manière asynchrone, async_client pouvez être utilisé :

fetched_config_setting = await client.get_configuration_setting(key="MyKey", label="MyLabel")

Pour utiliser list_configuration_settings, appelez-le de façon synchrone et effectuez une itération sur l’itérateur asynchrone retourné de manière asynchrone

config_settings = client.list_configuration_settings(label_filter="MyLabel")
async for item in config_settings:
    print_configuration_setting(item)

from azure.appconfiguration import ConfigurationSettingsFilter

filters = [ConfigurationSettingsFilter(key="my_key1", label="my_label1")]
response = await client.begin_create_snapshot(name=snapshot_name, filters=filters)
created_snapshot = await response.result()
print_snapshot(created_snapshot)

received_snapshot = await client.get_snapshot(name=snapshot_name)

archived_snapshot = await client.archive_snapshot(name=snapshot_name)
print_snapshot(archived_snapshot)

recovered_snapshot = await client.recover_snapshot(name=snapshot_name)
print_snapshot(recovered_snapshot)

async for snapshot in client.list_snapshots():
    print_snapshot(snapshot)

async for config_setting in client.list_configuration_settings(snapshot_name=snapshot_name):
    print_configuration_setting(config_setting)

Dépannage

Consultez le guide de résolution des problèmes pour plus d’informations sur la façon de diagnostiquer différents scénarios d’échec.

Étapes suivantes

Autres exemples de code

Plusieurs exemples de bibliothèque de client App Configuration sont disponibles dans ce dépôt GitHub. Il s’agit notamment des paramètres suivants :

Pour plus d’informations, consultez les exemples LISEZ-MOI.

Contribution

Ce projet accepte les contributions et les suggestions. La plupart des contributions vous demandent d’accepter un contrat de licence de contribution (CLA) déclarant que vous avez le droit de nous accorder, et que vous nous accordez réellement, les droits d’utilisation de votre contribution. Pour plus d’informations, visitez https://cla.microsoft.com.

Quand vous envoyez une demande de tirage (pull request), un bot CLA détermine automatiquement si vous devez fournir un contrat CLA et agrémenter la demande de tirage de façon appropriée (par exemple, avec une étiquette ou un commentaire). Suivez simplement les instructions fournies par le bot. Vous ne devez effectuer cette opération qu’une seule fois sur tous les dépôts utilisant notre contrat CLA.

Ce projet a adopté le Code de conduite Open Source de Microsoft. Pour plus d'informations, consultez la FAQ du Code de conduite ou contactez opencode@microsoft.com pour toute question ou commentaire supplémentaire.