Démarrage rapide : Bibliothèque de client Azure Cosmos DB pour Apache Gremlin pour Python

S’applique à: ✅ Apache Gremlin

Important

Recherchez-vous une solution de base de données pour des scénarios à grande échelle avec un contrat de niveau de service de disponibilité (SLA) de 99,999%, une mise à l’échelle automatique instantanée et un basculement automatique entre plusieurs régions ? Considérez Azure Cosmos DB pour NoSQL.

Voulez-vous implémenter un graphique OLAP (Online Analytical Processing) ou migrer une application Apache Gremlin existante ? Considérez Graph dans Microsoft Fabric.

Prise en main de la bibliothèque de client Azure Cosmos DB pour Apache Gremlin pour Python pour stocker, gérer et interroger des données non structurées. Suivez les étapes décrites dans ce guide pour créer un compte, installer une bibliothèque de client Python, vous connecter au compte, effectuer des opérations courantes et interroger vos exemples de données finaux.

Code source de la bibliothèque | Package (PyPi)

Prérequis

Un abonnement Azure
- Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Dernière version d’Azure CLI dans Azure Cloud Shell.
- Si vous préférez exécuter des commandes de référence CLI localement, connectez-vous à Azure CLI à l’aide de la az login commande.

Python 3.12 ou version ultérieure

Configuration

Tout d’abord, configurez l’environnement de compte et de développement pour ce guide. Cette section vous guide tout au long du processus de création d’un compte, de l’obtention de ses informations d’identification, puis de la préparation de votre environnement de développement.

Créer un compte

Commencez par créer une API pour un compte Apache Gremlin. Une fois le compte créé, créez les ressources de base de données et de graphique.

Azure CLI
portail Azure

Si vous n’avez pas encore de groupe de ressources cible, utilisez la az group create commande pour créer un groupe de ressources dans votre abonnement.
```
az group create \
    --name "<resource-group-name>" \
    --location "<location>"
```

Utilisez la az cosmosdb create commande pour créer un compte Azure Cosmos DB pour Apache Gremlin avec les paramètres par défaut.

az cosmosdb create \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --locations "regionName=<location>" \
    --capabilities "EnableGremlin"

Créez une nouvelle base de données en utilisant az cosmosdb gremlin database create nommée cosmicworks.

az cosmosdb gremlin database create \
    --resource-group "<resource-group-name>" \
    --account-name "<account-name>" \
    --name "cosmicworks"

Utilisez la az cosmosdb gremlin graph create commande pour créer un graphe nommé products.

az cosmosdb gremlin graph create \
    --resource-group "<resource-group-name>" \
    --account-name "<account-name>" \
    --database-name "cosmicworks" \
    --name "products" \
    --partition-key-path "/category"

Connectez-vous au portail Azure (https://portal.azure.com).
Entrez Azure Cosmos DB dans la barre de recherche globale.
Dans Services, sélectionnez Azure Cosmos DB.
Dans le volet Azure Cosmos DB , sélectionnez Créer, puis Azure Cosmos DB pour Apache Gremlin dans l’onglet Autres .

Dans le volet Informations de base, configurez les options suivantes, puis sélectionnez Avis+ créer :

	Valeur
Type de charge de travail	Apprentissage
Abonnement	Sélectionnez votre abonnement Azure.
Groupe de ressources	Créer un groupe de ressources ou en sélectionner un
Nom du compte	Fournir un nom globalement unique
Zones de disponibilité	Désactiver
Lieu	Sélectionnez une région Azure prise en charge pour votre abonnement

Conseil

Vous pouvez laisser les options non spécifiées à leur valeur par défaut. Vous pouvez également configurer le compte pour limiter le débit total du compte à 1 000 unités de requête par seconde (RU/s) ou activer le niveau gratuit pour réduire vos coûts.

Dans le volet Avis+ créer, attendez que la validation de votre compte se termine avec succès, puis sélectionnez Créer.
Le portail accède automatiquement au panneau Déploiement. Attendez que le déploiement se termine.
Une fois le déploiement terminé, sélectionnez Accéder à la ressource pour accéder à la nouvelle API pour le compte Apache Gremlin.
Dans le menu de la ressource, sélectionnez l’option Explorateur de données .
Dans l’Explorateur de données, sélectionnez + Nouveau graphique.

Dans la boîte de dialogue Ajouter un graphique , configurez les options suivantes, puis sélectionnez OK :

	Valeur
Base de données	Créer
Nom de la base de données	`cosmicworks`
Nom du graphe	`products`
Clé de partition	`/category`

Conseil

Vous pouvez laisser les options non spécifiées à leur valeur par défaut.

Obtenir les informations d’identification

À présent, obtenez le mot de passe de la bibliothèque cliente à utiliser pour créer une connexion au compte récemment créé.

Azure CLI
portail Azure

Utilisez az cosmosdb show pour obtenir l'hôte du compte.

az cosmosdb show \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --query "{host:name}"

Enregistrez la valeur de la host propriété à partir de la sortie des commandes précédentes. La valeur de cette propriété est l’hôte que vous utilisez ultérieurement dans ce guide pour vous connecter au compte avec la bibliothèque.

Utilisez az cosmosdb keys list pour obtenir les clés du compte.

az cosmosdb keys list \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --type "keys"

Enregistrez la valeur de la primaryMasterKey propriété à partir de la sortie des commandes précédentes. La valeur de cette propriété est la clé que vous utilisez plus loin dans ce guide pour vous connecter au compte avec la bibliothèque.

Préparer l’environnement de développement

Ensuite, configurez votre environnement de développement avec un nouveau projet et la bibliothèque cliente. Cette étape est la dernière condition requise avant de passer au reste de ce guide.

Démarrez dans un dossier vide.
Importez le gremlinpython package à partir de Python Package Index (PyPI).
```
pip install gremlinpython
```
Créez le fichier app.py.

Modèle d'objet

	Descriptif
`GremlinClient`	Représente le client utilisé pour se connecter et interagir avec le serveur Gremlin
`GraphTraversalSource`	Utilisé pour construire et exécuter des parcours Gremlin

Authentifier le client

Commencez par authentifier le client à l’aide des informations d’identification collectées précédemment dans ce guide.

Ouvrez le fichier app.py dans votre environnement de développement intégré (IDE).
Importez les types suivants à partir de la gremlin_python.driver bibliothèque :
- gremlin_python.driver.client
- gremlin_python.driver.serializer
```
from gremlin_python.driver import client, serializer
```
Créez des variables de chaîne pour les informations d’identification collectées précédemment dans ce guide. Nommez les variables hostname et primary_key.
```
hostname = "<host>"
primary_key = "<key>"
```

Créez un Client objet à l’aide des informations d’identification et des variables de configuration créées aux étapes précédentes. Nommez la variable client.

client = client.Client(
    url=f"wss://{hostname}.gremlin.cosmos.azure.com:443/",
    traversal_source="g",
    username="/dbs/cosmicworks/colls/products",
    password=f"{primary_key}",
    message_serializer=serializer.GraphSONSerializersV2d0()
)

Insertion des données

Ensuite, insérez de nouvelles données de vertex et de périphérie dans le graphique. Avant de créer les nouvelles données, effacez le graphique des données existantes.

Exécutez la g.V().drop() requête pour effacer tous les sommets et bords du graphique.
```
client.submit("g.V().drop()").all().result()
```

Créez une requête Gremlin qui ajoute un sommet.

insert_vertex_query = (
    "g.addV('product')"
    ".property('id', prop_id)"
    ".property('name', prop_name)"
    ".property('category', prop_category)"
    ".property('quantity', prop_quantity)"
    ".property('price', prop_price)"
    ".property('clearance', prop_clearance)"
)

Ajoutez un sommet pour un seul produit.

client.submit(
    message=insert_vertex_query,
    bindings={
        "prop_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
        "prop_name": "Yamba Surfboard",
        "prop_category": "gear-surf-surfboards",
        "prop_quantity": 12,
        "prop_price": 850.00,
        "prop_clearance": False,
    },
).all().result()

Ajoutez deux sommets supplémentaires pour deux produits supplémentaires.

client.submit(
    message=insert_vertex_query,
    bindings={
        "prop_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
        "prop_name": "Montau Turtle Surfboard",
        "prop_category": "gear-surf-surfboards",
        "prop_quantity": 5,
        "prop_price": 600.00,
        "prop_clearance": True,
    },
).all().result()

client.submit(
    message=insert_vertex_query,
    bindings={
        "prop_id": "cccccccc-2222-3333-4444-dddddddddddd",
        "prop_name": "Noosa Surfboard",
        "prop_category": "gear-surf-surfboards",
        "prop_quantity": 31,
        "prop_price": 1100.00,
        "prop_clearance": False,
    },
).all().result()

Créez une autre requête Gremlin qui ajoute un bord.

insert_edge_query = (
    "g.V([prop_partition_key, prop_source_id])"
    ".addE('replaces')"
    ".to(g.V([prop_partition_key, prop_target_id]))"
)

Ajoutez deux bords.

client.submit(
    message=insert_edge_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_source_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
        "prop_target_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    },
).all().result()

client.submit(
    message=insert_edge_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_source_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
        "prop_target_id": "cccccccc-2222-3333-4444-dddddddddddd",
    },
).all().result()

Lire les données

Ensuite, lisez les données qui ont été insérées précédemment dans le graphique.

Créez une requête qui lit un vertex à l’aide de l’identificateur unique et de la valeur de clé de partition.
```
read_vertex_query = "g.V([prop_partition_key, prop_id])"
```

Ensuite, lisez un vertex en fournissant les paramètres requis.

matched_item = client.submit(
    message=read_vertex_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"
    }
).one()

Rechercher des données

Enfin, utilisez une requête pour rechercher toutes les données qui correspondent à une traversée ou un filtre spécifique dans le graphique.

Créez une requête qui recherche tous les sommets qui partent d’un sommet spécifique.

find_vertices_query = (
    "g.V().hasLabel('product')"
    ".has('category', prop_partition_key)"
    ".has('name', prop_name)"
    ".outE('replaces').inV()"
)

Exécutez la requête spécifiant le Montau Turtle Surfboard produit.

find_results = client.submit(
    message=find_vertices_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_name": "Montau Turtle Surfboard",
    },
).all().result()

Itérer sur les résultats de la requête.

for result in find_results:
    # Do something here with each result

Exécuter le code

Exécutez l’application nouvellement créée à l’aide d’un terminal dans votre répertoire d’application.

python app.py

Nettoyer les ressources

Lorsque vous n’avez plus besoin du compte, supprimez le compte de votre abonnement Azure en supprimant la ressource.

Azure CLI
portail Azure

az cosmosdb delete \
    --resource-group "<resource-group-name>" \
    --name "<account-name>"

Rétroaction

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

Last updated on 2025-07-25