Exercice - Créer une application MongoDB en utilisant Azure Cosmos DB for MongoDB

35 minutes

Il est temps de découvrir par programmation comment créer nos bases de données et collections Azure Cosmos DB for MongoDB et comment y ajouter des données.

Cet exercice peut être suivi en utilisant un bac à sable (sandbox) Microsoft Learn, qui fournit un abonnement Azure temporaire. Pour activer l’abonnement de bac à sable, vous devez vous connecter avec un compte Microsoft. L’abonnement au bac à sable est automatiquement supprimé quand vous terminez ce module. Une fois le bac à sable activé, connectez-vous au Portail Azure à l’aide des informations d’identification de votre abonnement au bac à sable. Veillez à travailler dans l’annuaire Microsoft Learn Sandbox, indiqué en haut à droite du portail sous votre ID d’utilisateur. Si ce n’est pas le cas, sélectionnez l’icône de l’utilisateur et changez d’annuaire.

Conseil

Si vous préférez, vous pouvez utiliser votre propre abonnement Azure. Pour ce faire, connectez-vous au portail Azure avec les informations d’identification de votre abonnement. Veillez à travailler dans l’annuaire contenant votre abonnement, indiqué en haut à droite sous votre ID d’utilisateur. Si ce n’est pas le cas, sélectionnez l’icône de l’utilisateur et changez d’annuaire.

Créer une application MongoDB avec Azure Cosmos DB for MongoDB Node.js

Créer une application MongoDB avec Azure Cosmos DB for MongoDB Java

Créer une application MongoDB avec Azure Cosmos DB for MongoDB Python

Créer une application MongoDB avec Azure Cosmos DB for MongoDB C#

Dans cet exercice, vous créez un compte, une base de données et une collection Azure Cosmos DB for MongoDB, puis vous ajoutez quelques documents à la collection. Notez que ce code est identique à celui qui sert à vous connecter à n’importe quelle base de données MongoDB. Vous créez ensuite une collection avec des commandes d’extension qui vous permettent de définir le débit en unités de requête par seconde (RU/s) pour la collection.

Préparer votre environnement de développement

Si vous ne disposez pas du compte Azure Cosmos DB et de l’environnement avec lesquels vous travaillez dans ce labo, effectuez les étapes suivantes. Dans le cas contraire, accédez à la section Ajouter le code pour créer la base de données, la collection et le document dans le fichier App.js.

Si vous ne disposez pas de l’environnement et du compte Azure Cosmos DB avec lesquels vous travaillez dans ce labo, effectuez les étapes suivantes. Dans le cas contraire, accédez à la section Ajouter le code pour créer la base de données, la collection et le document dans le fichier App.java.

Dans Azure Cloud Shell, copiez et collez les commandes suivantes.

git clone https://github.com/MicrosoftLearning/mslearn-cosmosdb.git
cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/node/

# Update Azure Cloud Shell node to Version 14.0.0, since the MongoDB driver requires ver 10+
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
source ~/.nvm/nvm.sh
nvm install 14.0.0
npm install -g mongodb
npm link mongodb
# Check if the node version is now v14.0.0
node --version

# Create an Azure Cosmos DB for MongoDB account
bash ../init.sh

git clone https://github.com/MicrosoftLearning/mslearn-cosmosdb.git
cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/java
# Download and install the Maven project, this will take a minute or two
mvn archetype:generate -DgroupId=com.fabrikam -DartifactId=AzureApp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
# Replace the projects pom.xml file with the github one that has the MongoDB definition
mv pom.xml1 ./AzureApp/pom.xml

# Create an Azure Cosmos DB for MongoDB account
bash ../init.sh

git clone https://github.com/MicrosoftLearning/mslearn-cosmosdb.git
cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/python
# Install the MongoDB Python drivers
python -m pip install pymongo
# Create an Azure Cosmos DB for MongoDB account
bash ../init.sh

git clone https://github.com/MicrosoftLearning/mslearn-cosmosdb.git
cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/csharp

# Add MongoDB driver to DotNet
dotnet add package MongoDB.Driver --version 2.16.0

# Create an Azure Cosmos DB for MongoDB account
bash ../init.sh

Conseil

Si vous n’utilisez pas le bac à sable pour le labo et voulez spécifier l’emplacement où créer vos objets de base de données et de stockage, ajoutez un paramètre -l LOCATIONNAME à l’appel init.sh. En outre, si vous souhaitez spécifier un groupe de ressources, ajoutez un paramètre -r YOURRRESOURCEGROUPNAMEHERE à l’appel init.sh.

Notes

Ce script bash crée le compte Azure Cosmos DB for MongoDB. La création de ce compte peut prendre 5 à 10 minutes, donc c’est probablement le bon moment pour aller prendre un café ou un thé.

Conseil

Si vous revenez et que Cloud Shell a été réinitialisé, exécutez les commandes suivantes dans Cloud Shell pour utiliser Node version 14. Sinon, le code de la section suivante échoue.

source ~/.nvm/nvm.sh

nvm install 14.0.0

npm link mongodb

Au terme de l’exécution du fichier bash init.sh, copiez quelque part la Chaîne de connexion, le Nom du compte Cosmos DB et le Nom du groupe de ressources retournés, car nous en aurons besoin dans la section suivante. Vous pouvez également consulter le JSON retourné par le script de création de compte situé avant la chaîne de connexion. Si vous regardez vers le milieu du JSON, vous devriez voir la propriété "kind": "MongoDB".

Notes

Notez que la Chaîne de connexion, le Nom du compte Cosmos DB et le Nom du groupe de ressources sont également disponibles dans le portail Azure.

Ajouter le code pour créer les bases de données, la collection et le document au fichier App.js

Il est maintenant temps d’ajouter notre code JavaScript pour créer une base de données et une collection et ajouter un document à la collection.

Ajouter le code pour créer les bases de données, la collection et le document au fichier App.java

Il est maintenant temps d’ajouter notre code Java pour créer une base de données et une collection et ajouter un document à la collection.

Ajouter le code pour créer les bases de données, la collection et le document au fichier App.py

Il est maintenant temps d’ajouter notre code Python pour créer une base de données et une collection et ajouter un document à la collection.

Ajouter le code pour créer les bases de données, la collection et le document au fichier app.cs

Il est maintenant temps d’ajouter notre code C# pour créer une base de données et une collection et ajouter un document à la collection.

S’il n’est pas déjà ouvert, ouvrez Azure Cloud Shell.

Exécutez la commande suivante pour ouvrir l’éditeur de code.

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/node/
code App.js

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/java/AzureApp
code ./src/main/java/com/fabrikam/App.java

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/python
code App.py

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/csharp
code app.cs

Copiez le code suivant dans le fichier App. N’oubliez pas que vous devez remplacer la valeur d’URI de la chaîne de connexion copiée dans la section précédente.

Cette partie du code utilise les pilotes MongoDB et utilise la chaîne de connexion à Azure Cosmos DB comme vous le feriez normalement pour n’importe quel serveur MongoDB. Le code définit et ouvre ensuite la connexion au compte Azure Cosmos DB.

// Uses the MongoDB driver
const {MongoClient} = require("mongodb");

async function main() {

    // One of the values you copied earlier was the connection string, replace it in the following line 
    var url = "TheConnectionStringYouCopiedEarlier";

    // define the connection using the MongoClient method ane the url above
    var mongoClient = new MongoClient(url, function(err,client)
    {
        if (err)
        {
            console.log("error connecting")
        }
    }
    );

    // open the connection
    await mongoClient.connect();

package com.fabrikam;

// Uses the MongoDB driver
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import static com.mongodb.client.model.Filters.eq;

public class App {
    public static void main(String[] args) {

        // One of the values you copied earlier was the connection string, replace it in the following line 
        MongoClientURI uri = new MongoClientURI("TheConnectionStringYouCopiedEarlier");

        MongoClient mongoClient = null;
        try {
            // define the connection using the MongoClient method ane the url above and open the connection 
            mongoClient = new MongoClient(uri);

# Use the MongoDB drivers
import pymongo


def main():
    # One of the values you copied earlier was the connection string, replace it in the following line 
    uri = "TheConnectionStringYouCopiedEarlier"

    # We use the "MongoClient" method and the "uri" value to connect to the account 
    client = pymongo.MongoClient(uri)

    ```

// Uses the MongoDB driver
using MongoDB.Driver;
using MongoDB.Bson;
using System;

public class Products {
    public ObjectId Id { get; set; }  
    public int ProductId { get; set; }
    public string name { get; set; }
}

class App {
    public static void Main (string[] args) {

    // One of the values you copied earlier was the connection string, replace it in the following line 
    string connectionString = 
        @"TheConnectionStringYouCopiedEarlier";

    MongoClientSettings settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));

    // define the connection using the MongoClient method ane the connectionString above and open the connection 
    var mongoClient = new MongoClient(settings);

L’étape suivante consiste à se connecter à la base de données products. Si cette base de données n’existe pas, le code la crée seulement s’il crée aussi une collection dans la même connexion ou en utilisant des commandes d’extension. Ajoutez ce qui suit au script dans l’éditeur.

// connect to the database "products"
var ProductDatabase = mongoClient.db("products");

    // connect to the database "products"
    MongoDatabase ProductDatabase = mongoClient.getDatabase("products");

    # connect to the database "products"
    ProductDatabase = client["products"]

    // connect to the database "products"
    var ProductDatabase = mongoClient.GetDatabase("products");

Ensuite, nous nous connectons à la collection documents si elle existe déjà, puis nous ajoutons un document à cette collection. Si la collection n’existe pas, ce code crée la collection s’il effectue également une opération sur cette collection dans la même connexion (par exemple, ajouter un document à la collection) ou en utilisant des commandes d’extension. Ajoutez ce qui suit au script dans l’éditeur.


  // create a collection "documents" and add one document for "bread"
  var collection = ProductDatabase.collection('documents');
  var insertResult = await collection.insertOne({ ProductId: 1, name: "bread" });

            // create a collection "documents" and add one document for "bread" 
            MongoCollection collection = ProductDatabase.getCollection("products");

            collection.insertOne(new Document()
                        .append("ProductId", 1)
                        .append("name", "bread"));

    # create a collection "products" and add one document for "bread"
    collection = ProductDatabase["products"]
    collection.insert_one({ "ProductId": 1, "name": "bread" })

    // create a collection "products" and add one document for "bread" 
    var mongoCollection = ProductDatabase.GetCollection<Products>("products");

    Products Product = new Products {ProductId=1,name="bread"};
    mongoCollection.InsertOne (Product);

Recherchons à présent le document inséré et affichons-le dans l’interpréteur de commandes. Ajoutez ce qui suit au script dans l’éditeur.

  // return data where ProductId = 1
  const findProduct = await collection.find({ProductId: 1});
  await findProduct.forEach(console.log);

            // return data where ProductId = 1
            Document findProduct = (Document) collection.find(eq("ProductId", 1)).first();
            System.out.println(findProduct.toJson());
        }

    # return data where ProductId = 1
    Product_1 = collection.find_one({"ProductId": 1})

    print(Product_1)

    // return data where ProductId = 1
    Products ProductFound =  mongoCollection.Find(_ => _.ProductId == 1).FirstOrDefault();
    Console.WriteLine ("Id: {0}, ProductId: {1}, name: \'{2}\'", ProductFound.Id, ProductFound.ProductId, ProductFound.name);
  }
}

Pour finir, fermons la connexion. Ajoutez ce qui suit au script dans l’éditeur.

  // close the connection
  mongoClient.close();
}

main();

        // close the connection
        finally {
            if (mongoClient != null) {
                mongoClient.close();
            }
        }
    }
}

    # close the connection
    client.close()

if __name__ == '__main__':
    main()

// Note C# doesn't need to close the connection, it disposes of the connection when the program ends.

Le script devrait ressembler à ceci :

// Uses the MongoDB driver
const {MongoClient} = require("mongodb");

async function main() {

  // One of the values you copied earlier was the connection string, replace it in the following line
  var url = "TheConnectionStringYouCopiedEarlier";

  // define the connection using the MongoClient method ane the url above
  var mongoClient = new MongoClient(url, function(err,client)
    {
      if (err)
      {
        console.log("error connecting")
      }
    }
  );

  // open the connection
  await mongoClient.connect();

  // connect to the database "products"
  var ProductDatabase = mongoClient.db("products");

  // create a collection "documents" and add one document for "bread"
  var collection = ProductDatabase.collection('documents');
  var insertResult = await collection.insertOne({ ProductId: 1, name: "bread" });

  // return data where ProductId = 1
  const findProduct = await collection.find({ProductId: 1});
  await findProduct.forEach(console.log);

  // close the connection
  mongoClient.close();
}

main();

package com.fabrikam;

// Uses the MongoDB driver
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import static com.mongodb.client.model.Filters.eq;

public class App {
    public static void main(String[] args) {

        // One of the values you copied earlier was the connection string, replace it in the following line
        MongoClientURI uri = new MongoClientURI("TheConnectionStringYouCopiedEarlier");

        MongoClient mongoClient = null;
        try {
            // define the connection using the MongoClient method ane the url above and open the connection 
            mongoClient = new MongoClient(uri);

            // connect to the database "products"
            MongoDatabase ProductDatabase = mongoClient.getDatabase("products");

            // create a collection "products" and add one document for "bread" 
            MongoCollection collection = ProductDatabase.getCollection("products");

            collection.insertOne(new Document()
                        .append("ProductId", 1)
                        .append("name", "bread"));

            // return data where ProductId = 1
            Document findProduct = (Document) collection.find(eq("ProductId", 1)).first();
            System.out.println(findProduct.toJson());
        }
        // close the connection
        finally {
            if (mongoClient != null) {
                mongoClient.close();
            }
        }
    }
}

# Use the MongoDB drivers
import pymongo

def main():
    # One of the values you copied earlier was the connection string, replace it in the following line
    uri = "TheConnectionStringYouCopiedEarlier"

    # We use the "MongoClient" method and the "uri" value to connect to the account 
    client = pymongo.MongoClient(uri)

    # connect to the database "products"
    ProductDatabase = client["products"]

    # create a collection "products" and add one document for "bread"
    collection = ProductDatabase["products"]
    collection.insert_one({ "ProductId": 1, "name": "bread" })

    # return data where ProductId = 1
    Product_1 = collection.find_one({"ProductId": 1})

    print(Product_1)

    # close the connection
    client.close()

if __name__ == '__main__':
    main()

// Uses the MongoDB driver
using MongoDB.Driver;
using MongoDB.Bson;
using System;

  public class Products {
    public ObjectId Id { get; set; }  
    public int ProductId { get; set; }
    public string name { get; set; }
  }

class App {
  public static void Main (string[] args) {

    // One of the values you copied earlier was the connection string, replace it in the following line
    string connectionString = 
      @"TheConnectionStringYouCopiedEarlier";

    MongoClientSettings settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));

    // define the connection using the MongoClient method ane the connectionString above and open the connection 
    var mongoClient = new MongoClient(settings);

    // connect to the database "products"
    var ProductDatabase = mongoClient.GetDatabase("products");

    // create a collection "products" and add one document for "bread" 
    var mongoCollection = ProductDatabase.GetCollection<Products>("products");

    Products Product = new Products {ProductId=1,name="bread"};
    mongoCollection.InsertOne (Product);

    // return data where ProductId = 1
    Products ProductFound =  mongoCollection.Find(_ => _.ProductId == 1).FirstOrDefault();
    Console.WriteLine ("Id: {0}, ProductId: {1}, name: \'{2}\'", ProductFound.Id, ProductFound.ProductId, ProductFound.name);
  }
}

Allons-y et enregistrons le programme. Sélectionnez dans le coin supérieur droit de l’éditeur de code, puis sélectionnez Enregistrer (ou Ctrl+S). Sélectionnez Fermer l’éditeur (ou Ctrl+Q) pour revenir au shell.

Exécutons maintenant l’application avec la commande suivante.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Ce script doit retourner un résultat similaire au suivant. Cela signifie que nous avons créé la base de données et la collection, et que nous avons ajouté un document à cette dernière.

{
  _id: new ObjectId("62aed08663c0fd62d30240db"),
  ProductId: 1,
  name: 'bread'
}

INFO: Opened connection [connectionId{localValue:3, serverValue:74678510}] to learn-account-cosmos-665601-westus.mongo.cosmos.azure.com:10255
{ "_id" : { "$oid" : "62afa8c3dff473012e7b7910" }, "ProductId" : 1, "name" : "bread" }
Jun 19, 2022 10:52:59 PM com.mongodb.diagnostics.logging.JULLogger log
INFO: Closed connection [connectionId{localValue:3, serverValue:74678510}] to learn-account-cosmos-665601-westus.mongo.cosmos.azure.com:10255 because the pool has been closed.

{'_id': ObjectId('62afecc3a04e32b92451ac5d'), 'ProductId': 1, 'name': 'bread'}

Id: 62affed8147b5206db146298, ProductId: 1, name: 'bread'

Comme vous pouvez le constater, ce code est le même que celui que vous exécuteriez pour créer une base de données, une collection et un document sur une base de données MongoDB. Par conséquent, la programmation pour Azure Cosmos DB for MongoDB devrait être transparente si vous savez déjà créer des applications qui se connectent à MongoDB.

Identités managées

Pour les charges de travail de production, nous vous recommandons d’utiliser des identités managées pour l’authentification auprès d’Azure Cosmos DB. De cette façon, vous n’avez pas besoin de stocker la chaîne de connexion dans votre code. Dans la section suivante, nous allons utiliser des identités managées pour l’authentification auprès d’Azure Cosmos DB.

Dans un environnement de production, vous devez utiliser une identité managée avec le moins de privilèges nécessaires. Vous pouvez créer une ou plusieurs identités managées affectées par l’utilisateur et les affecter au compte Azure Cosmos DB. Pour ce labo, créons une identité managée affectée par le système pour le compte Azure Cosmos DB.

Dans le Portail Azure, accédez au compte Azure Cosmos DB que vous avez créé précédemment.
Dans le menu de gauche, sous Paramètres, sélectionnez Identité.
Dans le volet Identité, sélectionnez Affectée par le système.
Sélectionnez Actif pour État.
Cliquez sur Enregistrer.
La création de l’identité managée prend une ou deux minutes.

Une fois l’identité managée créée, nous devons lui affecter les autorisations nécessaires au compte Azure Cosmos DB. Il est temps d’utiliser le contrôle d’accès en fonction du rôle (RBAC) pour affecter à l’identité managée les autorisations nécessaires. Pour ce labo, nous attribuons le rôle Contributeur à l’identité managée pour lui permettre de lire et d’écrire des données dans le compte Azure Cosmos DB. Dans un environnement de production, vous devez attribuer le rôle avec les privilèges minimum nécessaire.

Dans le Portail Azure, accédez au compte Azure Cosmos DB que vous avez créé précédemment.
Dans le menu de gauche, sous Paramètres, sélectionnez Contrôle d’accès (IAM).
Sélectionnez + Ajouter, puis Ajouter une attribution de rôle.
Sous le Rôle d’administrateur privilégié, sélectionnez Contributeur, puis Suivant.
Sous Membres, sélectionnez Identité managée, puis + Sélectionner des membres.
Dans le volet Sélectionner les identités managées, recherchez l’identité managée que vous avez créée précédemment, sélectionnez-la, puis sélectionnez Vérifier + attribuer.

Vous disposez désormais d’une identité managée affectée au compte Azure Cosmos DB avec les autorisations nécessaires. Utilisons maintenant l’identité managée pour l’authentification auprès du compte Azure Cosmos DB.

Utilisation des commandes d’extension pour gérer les données stockées dans l’API Azure Cosmos DB pour MongoDB

Bien que le code précédent soit identique entre la connexion à un serveur MongoDB et la connexion à notre compte Azure Cosmos DB for MongoDB, la connexion peut ne pas tirer parti des fonctionnalités d’Azure Cosmos DB. Cela signifie que l’utilisation des méthodes de pilote par défaut pour créer nos collections se sert aussi des paramètres du compte Azure Cosmos DB par défaut pour créer ces collections. Nous ne pouvons donc pas définir les paramètres de création comme nos paramètres de débit, de clé de partitionnement ou de mise à l’échelle automatique avec ces méthodes.

En utilisant l’API d’Azure Cosmos DB for MongoDB, vous pouvez profiter des avantages de Cosmos DB. Parmi ces avantages, citons la distribution globale, le partitionnement automatique, la haute disponibilité, les garanties de latence, le chiffrement automatique au repos, les sauvegardes, etc. Ajoutons à cela l’avantage de pouvoir préserver vos investissements dans votre application MongoDB. Vous pouvez communiquer avec l'API Azure Cosmos DB pour MongoDB par le biais de n'importe quel pilote du client MongoDB open source. L’API Azure Cosmos DB pour MongoDB permet d’utiliser les pilotes clients existants en adhérant au protocole filaire MongoDB.

Nous allons créer du code qui nous permettra de créer une collection et de définir sa clé de sharding et son débit.

S’il n’est pas déjà ouvert, ouvrez Azure Cloud Shell.

Exécutez la commande suivante pour ouvrir l’éditeur de code.

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/node
code App.js

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/java/AzureApp
code ./src/main/java/com/fabrikam/App.java

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/python
code App.py

cd ~/mslearn-cosmosdb/api-for-mongodb/01-create-mongodb-objects/csharp
code app.cs

Copiez le code suivant dans le fichier .

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
const { MongoClient, ObjectId } = require('mongodb');
import axios from "axios";

async function main() {
    // Environment variables
    const endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
    const listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
    const scope = process.env.AZURE_COSMOS_SCOPE;

    // For system-assigned managed identity.
    const credential = new DefaultAzureCredential();

    // Acquire the access token
    const accessToken = await credential.getToken(scope);

    // Get the connection string
    const config = {
        method: 'post',
        url: listConnectionStringUrl,
        headers: {
            'Authorization': 'Bearer ${accessToken.token}'
        }
    };
    const response = await axios(config);
    const keysDict = response.data;
    const connectionString = keysDict['connectionStrings'][0]['connectionString'];

    // Connect to Azure Cosmos DB for MongoDB
    const mongoClient = new MongoClient(connectionString);

    // open the connection
    await mongoClient.connect();

package com.fabrikam;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import com.azure.identity.*;
import com.azure.core.credential.*;
import java.net.http.*;
import java.net.URI;

public class App {
    public static void main(String[] args) {
        // Environment variables
        String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
        String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
        String scope = System.getenv("AZURE_COSMOS_SCOPE");

        // For system-assigned managed identity.
        DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();


    MongoClient mongoClient = null;

    try {
        // Acquire the access token
        AccessToken accessToken = defaultCredential
            .getToken(new TokenRequestContext().addScopes(scope))
            .block();
        String token = accessToken.getToken();

        // Retrieve the connection string
        HttpClient client = HttpClient.newBuilder().build();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(new URI(listConnectionStringUrl))
            .header("Authorization", "Bearer " + token)
            .POST(HttpRequest.BodyPublishers.noBody())
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        JSONParser parser = new JSONParser();
        JSONObject responseBody = parser.parse(response.body());
        List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
        String connectionString = connectionStrings.get(0).get("connectionString");

        // Connect to Azure Cosmos DB for MongoDB
        MongoClientURI uri = new MongoClientURI(connectionString);
        mongoClient = new MongoClient(uri);

import os
import pymongo
import requests
from azure.identity import ManagedIdentityCredential, ClientSecretCredential

def main():
    # Environment variables
    endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
    listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
    scope = os.getenv('AZURE_COSMOS_SCOPE')

    # For system-assigned managed identity
    cred = ManagedIdentityCredential()

    # Get the connection string
    session = requests.Session()
    token = cred.get_token(scope)
    response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
    keys_dict = response.json()
    conn_str = keys_dict["connectionStrings"][0]["connectionString"]

    # Connect to Azure Cosmos DB for MongoDB
    client = pymongo.MongoClient(conn_str)

using MongoDB.Driver;
using Azure.Identity;
using Azure.Core;
using System;
using System.Net.Http;
using System.Text.Json;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Products
{
    public int ProductId { get; set; }
    public string name { get; set; }
}

class App
{
    public static async Task Main(string[] args)
    {
        // Environment variables
        var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
        var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
        var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");

        // For system-assigned identity.
        var tokenProvider = new DefaultAzureCredential();

        // Acquire the access token.
        AccessToken accessToken = await tokenProvider.GetTokenAsync(
            new TokenRequestContext(scopes: new[] { scope }));

        // Get the connection string.
        using var httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
        var response = await httpClient.PostAsync(listConnectionStringUrl, null);
        response.EnsureSuccessStatusCode();
        var responseBody = await response.Content.ReadAsStringAsync();

        // Parse the connection string.
        var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
        string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];

        // Initialize the MongoClient with the connection string.
        var mongoClient = new MongoClient(connectionString);

L’étape suivante consiste à se connecter à la base de données employees. Si cette base de données n’existe pas, le code la crée seulement s’il crée aussi une collection dans la même connexion ou en utilisant des commandes d’extension. Ajoutez ce qui suit au script dans l’éditeur.

  // connect to the database "HumanResources"
  var EmployeeDatabase = mongoClient.db("HumanResources");

            // connect to the database "HumanResources"
            MongoDatabase EmployeeDatabase = mongoClient.getDatabase("HumanResources");

    # connect to the database "HumanResources"
    EmployeeDatabase = client["HumanResources"]

     // connect to the database "HumanResources"
    var EmployeeDatabase = mongoClient.GetDatabase("HumanResources");

Jusqu’à présent, ce code ressemble beaucoup à celui de la section précédente. Dans cette étape, nous tirons parti des commandes d’extension et créons une action personnalisée. Cette action nous permet de définir le débit et la clé de sharding de la collection. À son tour, l’étape donne à Azure Cosmos DB les paramètres à utiliser lors de la création de la collection. Ajoutez ce qui suit au script dans l’éditeur.

  // create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
  var result = EmployeeDatabase.command({customAction: "CreateCollection", collection: "Employee", offerThroughput: 1000, shardKey: "EmployeeId"});

            // create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
            Document employeeCollectionDef = new Document();
            employeeCollectionDef.append("customAction", "CreateCollection");
            employeeCollectionDef.append("collection", "Employee");
            employeeCollectionDef.append("offerThroughput", 1000);
            employeeCollectionDef.append("shardKey", "EmployeeId");

            Document result = EmployeeDatabase.runCommand(employeeCollectionDef);

    # create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
    EmployeeDatabase.command({'customAction': "CreateCollection", 'collection': "Employee", 'offerThroughput': 1000, 'shardKey': "EmployeeId"})

    // create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
    var result = EmployeeDatabase.RunCommand<BsonDocument>(@"{customAction: ""CreateCollection"", collection: ""Employee"", offerThroughput: 1000, shardKey: ""EmployeeId""}");

Le reste est identique à l’exemple précédent. Nous nous connectons à la collection, insérons quelques lignes, puis interrogeons et retournons une ligne. Ajoutez ce qui suit au script dans l’éditeur.

  // Connect to the collection "Employee" and add two documents for "Marcos" and "Tam" 
  var collection = EmployeeDatabase.collection('Employee');

  var insertResult = await collection.insertOne({EmployeeId: 1, email: "Marcos@fabrikam.com", name: "Marcos"});
  insertResult = await collection.insertOne({EmployeeId: 2, email: "Tam@fabrikam.com", name: "Tam"});

  // return data where ProductId = 1
  const findProduct = await collection.find({EmployeeId: 1});
  await findProduct.forEach(console.log);

  // close the connection
  mongoClient.close();
}

main();

            // Connect to the collection "Employee" and add two documents for "Marcos" and "Tam" 
            MongoCollection collection = EmployeeDatabase.getCollection("Employee");

            collection.insertOne(new Document()
                        .append("EmployeeId", 1)
                        .append("email","Marcos@fabrikam.com")
                        .append("name", "Marcos"));

            collection.insertOne(new Document()
                        .append("EmployeeId", 2)
                        .append("email","Tam@fabrikam.com")
                        .append("name", "Tam"));

            // return data where EmployeeId = 1
            Document findEmployee = (Document) collection.find(eq("EmployeeId", 1)).first();
            System.out.println(findEmployee.toJson());
        }
        // close the connection
        finally {
            if (mongoClient != null) {
                mongoClient.close();
            }
        }
    }
}

    # Connect to the collection "Employee" and add two documents for "Marcos" and "Tam"
    collection = EmployeeDatabase["Employee"]
    collection.insert_one({ "EmployeeId": 1, "email": "Marcos@fabrikan.com", "name": "Marcos" })
    collection.insert_one({ "EmployeeId": 2, "email": "Tam@fabrikan.com", "name": "Tam" })

    # return data where ProductId = 1
    Product_1 = collection.find_one({"EmployeeId": 1})

    print(Product_1)

    # close the connection
    client.close()

if __name__ == '__main__':
    main()

    // Connect to the collection "Employee" and add two documents for "Marcos" and "Tam" 
    var mongoCollection = EmployeeDatabase.GetCollection<Employees>("Employee");

    Employees Employee = new Employees {EmployeeId=1,email="Marcos@fabrikam.com",name="Marcos"};
    mongoCollection.InsertOne (Employee);

    Employee = new Employees {EmployeeId=2,email="Tam@fabrikam.com",name="Tam"};
    mongoCollection.InsertOne (Employee);

    // return data where EmployeeId = 1
    Employees EmployeeFound =  mongoCollection.Find(_ => _.EmployeeId == 1).FirstOrDefault();
    Console.WriteLine ("Id: {0}, EmployeeId: {1}, email: \'{2}\', name: \'{3}\'", EmployeeFound.Id, EmployeeFound.EmployeeId, EmployeeFound.email, EmployeeFound.name);
  }
}

Le script devrait ressembler à ceci :

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
const { MongoClient, ObjectId } = require('mongodb');
import axios from "axios";

async function main() {
    // Environment variables
    const endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
    const listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
    const scope = process.env.AZURE_COSMOS_SCOPE;

    // For system-assigned managed identity.
    const credential = new DefaultAzureCredential();

    // Acquire the access token
    const accessToken = await credential.getToken(scope);

    // Get the connection string
    const config = {
        method: 'post',
        url: listConnectionStringUrl,
        headers: {
            'Authorization': 'Bearer ${accessToken.token}'
        }
    };
    const response = await axios(config);
    const keysDict = response.data;
    const connectionString = keysDict['connectionStrings'][0]['connectionString'];

    // Connect to Azure Cosmos DB for MongoDB
    const mongoClient = new MongoClient(connectionString);

    // open the connection
    await mongoClient.connect();

    // connect to the database "HumanResources"
    var EmployeeDatabase = mongoClient.db("HumanResources");

    // create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
    var result = EmployeeDatabase.command({customAction: "CreateCollection", collection: "Employee", offerThroughput: 1000, shardKey: "EmployeeId"});

    // Connect to the collection "Employee" and add two documents for "Marcos" and "Tam" 
    var collection = EmployeeDatabase.collection('Employee');

    var insertResult = await collection.insertOne({EmployeeId: 1, email: "Marcos@fabrikam.com", name: "Marcos"});
    insertResult = await collection.insertOne({EmployeeId: 2, email: "Tam@fabrikam.com", name: "Tam"});

    // return data where ProductId = 1
    const findProduct = await collection.find({EmployeeId: 1});
    await findProduct.forEach(console.log);

    // close the connection
    mongoClient.close();
}

main();

package com.fabrikam;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import com.azure.identity.*;
import com.azure.core.credential.*;
import java.net.http.*;
import java.net.URI;

public class App {
    public static void main(String[] args) {
        // Environment variables
        String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
        String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
        String scope = System.getenv("AZURE_COSMOS_SCOPE");

        // For system-assigned managed identity.
        DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();


        MongoClient mongoClient = null;

        try {
            // Acquire the access token
            AccessToken accessToken = defaultCredential
                .getToken(new TokenRequestContext().addScopes(scope))
                .block();
            String token = accessToken.getToken();

            // Retrieve the connection string
            HttpClient client = HttpClient.newBuilder().build();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI(listConnectionStringUrl))
                .header("Authorization", "Bearer " + token)
                .POST(HttpRequest.BodyPublishers.noBody())
                .build();
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            JSONParser parser = new JSONParser();
            JSONObject responseBody = parser.parse(response.body());
            List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
            String connectionString = connectionStrings.get(0).get("connectionString");

            // Connect to Azure Cosmos DB for MongoDB
            MongoClientURI uri = new MongoClientURI(connectionString);
            mongoClient = new MongoClient(uri);

            // connect to the database "HumanResources"
            MongoDatabase EmployeeDatabase = mongoClient.getDatabase("HumanResources");

            // create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
            Document employeeCollectionDef = new Document();
            employeeCollectionDef.append("customAction", "CreateCollection");
            employeeCollectionDef.append("collection", "Employee");
            employeeCollectionDef.append("offerThroughput", 1000);
            employeeCollectionDef.append("shardKey", "EmployeeId");

            Document result = EmployeeDatabase.runCommand(employeeCollectionDef);

            // Connect to the collection "Employee" and add two documents for "Marcos" and "Tam" 
            MongoCollection collection = EmployeeDatabase.getCollection("Employee");

            collection.insertOne(new Document()
                    .append("EmployeeId", 1)
                    .append("email","Marcos@fabrikam.com")
                    .append("name", "Marcos"));

            collection.insertOne(new Document()
                    .append("EmployeeId", 2)
                    .append("email","Tam@fabrikam.com")
                    .append("name", "Tam"));

            // return data where EmployeeId = 1
            Document findEmployee = (Document) collection.find(eq("EmployeeId", 1)).first();
            System.out.println(findEmployee.toJson());
        }
        // close the connection
        finally {
            if (mongoClient != null) {
                mongoClient.close();
            }
        }
    }
}

import os
import pymongo
import requests
from azure.identity import ManagedIdentityCredential, ClientSecretCredential

def main():
    # Environment variables
    endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
    listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
    scope = os.getenv('AZURE_COSMOS_SCOPE')

    # For system-assigned managed identity
    cred = ManagedIdentityCredential()

    # Get the connection string
    session = requests.Session()
    token = cred.get_token(scope)
    response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
    keys_dict = response.json()
    conn_str = keys_dict["connectionStrings"][0]["connectionString"]

    # Connect to Azure Cosmos DB for MongoDB
    client = pymongo.MongoClient(conn_str)

    # connect to the database "HumanResources"
    EmployeeDatabase = client["HumanResources"]

    # create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
    EmployeeDatabase.command({'customAction': "CreateCollection", 'collection': "Employee", 'offerThroughput': 1000, 'shardKey': "EmployeeId"})

    # Connect to the collection "Employee" and add two documents for "Marcos" and "Tam"
    collection = EmployeeDatabase["Employee"]
    collection.insert_one({ "EmployeeId": 1, "email": "Marcos@fabrikan.com", "name": "Marcos" })
    collection.insert_one({ "EmployeeId": 2, "email": "Tam@fabrikan.com", "name": "Tam" })

    # return data where ProductId = 1
    Product_1 = collection.find_one({"EmployeeId": 1})

    print(Product_1)

    # close the connection
    client.close()

if __name__ == '__main__':
    main()

using MongoDB.Driver;
using Azure.Identity;
using Azure.Core;
using System;
using System.Net.Http;
using System.Text.Json;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Products
{
    public int ProductId { get; set; }
    public string name { get; set; }
}

class App
{
    public static async Task Main(string[] args)
    {
        // Environment variables
        var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
        var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
        var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");

        // For system-assigned identity.
        var tokenProvider = new DefaultAzureCredential();

        // Acquire the access token.
        AccessToken accessToken = await tokenProvider.GetTokenAsync(
            new TokenRequestContext(scopes: new[] { scope }));

        // Get the connection string.
        using var httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
        var response = await httpClient.PostAsync(listConnectionStringUrl, null);
        response.EnsureSuccessStatusCode();
        var responseBody = await response.Content.ReadAsStringAsync();

        // Parse the connection string.
        var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
        string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];

        // Initialize the MongoClient with the connection string.
        var mongoClient = new MongoClient(connectionString);

        // connect to the database "HumanResources"
        var EmployeeDatabase = mongoClient.GetDatabase("HumanResources");

        // create the Employee collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
        var result = EmployeeDatabase.RunCommand<BsonDocument>(@"{customAction: ""CreateCollection"", collection: ""Employee"", offerThroughput: 1000, shardKey: ""EmployeeId""}");

        // Connect to the collection "Employee" and add two documents for "Marcos" and "Tam" 
        var mongoCollection = EmployeeDatabase.GetCollection<Employees>("Employee");

        Employees Employee = new Employees {EmployeeId=1,email="Marcos@fabrikam.com",name="Marcos"};
        mongoCollection.InsertOne (Employee);

        Employee = new Employees {EmployeeId=2,email="Tam@fabrikam.com",name="Tam"};
        mongoCollection.InsertOne (Employee);

        // return data where EmployeeId = 1
        Employees EmployeeFound =  mongoCollection.Find(_ => _.EmployeeId == 1).FirstOrDefault();
        Console.WriteLine ("Id: {0}, EmployeeId: {1}, email: \'{2}\', name: \'{3}\'", EmployeeFound.Id, EmployeeFound.EmployeeId, EmployeeFound.email, EmployeeFound.name);
    }
}

Allons-y et enregistrons le programme. Sélectionnez dans le coin supérieur droit de l’éditeur de code, puis sélectionnez Enregistrer (ou Ctrl+S). Sélectionnez Fermer l’éditeur (ou Ctrl+Q) pour revenir au shell.

Exécutons maintenant l’application avec la commande suivante.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Elle doit retourner un résultat semblable à celui ci-dessous. Cela signifie que nous avons créé la base de données et la collection, et que nous avons ajouté un document à cette dernière.

{
  _id: new ObjectId("62aed08663c0fd62d30240db"),
  EmployeeId: 1,
  email: 'Marcos@fabrikam.com'
  name: 'Marcos'
}

INFO: Opened connection [connectionId{localValue:3, serverValue:2080122971}] to learn-account-cosmos-845083734-westus.mongo.cosmos.azure.com:10255
{ "_id" : { "$oid" : "62afd8e2c471f3011bd415fe" }, "EmployeeId" : 1, "email" : "Marcos@fabrikam.com", "name" : "Marcos" }
Jun 20, 2022 2:18:11 AM com.mongodb.diagnostics.logging.JULLogger log
INFO: Closed connection [connectionId{localValue:3, serverValue:2080122971}] to learn-account-cosmos-845083734-westus.mongo.cosmos.azure.com:10255 because the pool has been closed.

{'_id': ObjectId('62afecc3a04e32b92451ac5d'), 'EmployeeId': 1, 'email': 'Marcos@fabrikan.com', 'name': 'Marcos'}

Id: 62affed8147b5206db146298, EmployeeId: 1, email: 'Marcos@fabrikam.com', name: 'Marcos'

Toutefois, ce dernier jeu de résultats a juste confirmé que nous avons effectivement créé une base de données, une collection et des documents, mais qu’en est-il de notre clé de partition et de notre débit, ont-ils vraiment changé ? Dans Cloud Shell, nous allons exécuter les commandes suivantes pour vérifier que nos modifications ont pris effet.
1. Vérifions que notre clé de partition a été changée en EmployeeId (la valeur par défaut est id). N’oubliez pas de changer le Nom du groupe de ressources et le Nom du compte que nous avons enregistrés au début de ce labo.
```
az cosmosdb mongodb collection show --name Employee --database-name HumanResources --resource-group learn-20c8df29-1419-49f3-84bb-6613f052b5ae --account-name learn-account-cosmos-845083734
```
  Le résultat devrait inclure la propriété "shardKey": {"EmployeeId": "Hash"}.
2. Vérifions que notre débit est passé à 1 000 (la valeur par défaut est 400). N’oubliez pas de changer le Nom du groupe de ressources et le Nom du compte que nous avons enregistrés au début de ce labo.
```
az cosmosdb mongodb collection throughput show --name Employee --database-name HumanResources --resource-group learn-20c8df29-1419-49f3-84bb-6613f052b5ae --account-name learn-account-cosmos-845083734
```
  Le résultat devrait inclure la propriété "throughput": 1000.

Ce code a montré la puissance de l’utilisation des commandes étendues dans notre code, ce qui nous permet de définir les paramètres de création d’Azure Cosmos DB. Nous pourrons ainsi contrôler la façon dont nos collections seront créées et traitées par Azure Cosmos DB.

Une fois que vous avez terminé cet exercice, poursuivez en répondant aux questions du contrôle des connaissances de ce module.

Exercice - Créer une application MongoDB en utilisant Azure Cosmos DB for MongoDB

Créer une application MongoDB avec Azure Cosmos DB for MongoDB Node.js

Créer une application MongoDB avec Azure Cosmos DB for MongoDB Java

Créer une application MongoDB avec Azure Cosmos DB for MongoDB Python

Créer une application MongoDB avec Azure Cosmos DB for MongoDB C#

Préparer votre environnement de développement

Ajouter le code pour créer les bases de données, la collection et le document au fichier App.js

Ajouter le code pour créer les bases de données, la collection et le document au fichier App.java

Ajouter le code pour créer les bases de données, la collection et le document au fichier App.py

Ajouter le code pour créer les bases de données, la collection et le document au fichier app.cs

Identités managées

Utilisation des commandes d’extension pour gérer les données stockées dans l’API Azure Cosmos DB pour MongoDB

Commentaires