Övning – Skapa en MongoDB DB-app med Hjälp av Azure Cosmos DB för MongoDB

  • 35 minuter

Det är dags att programmatiskt se hur du skapar våra Azure Cosmos DB för MongoDB-databaser, samlingar och lägger till data.

Den här övningen kan slutföras med hjälp av en Microsoft Learn-sandbox-miljö som tillhandahåller en tillfällig Azure-prenumeration. Om du vill aktivera sandbox-prenumerationen måste du logga in med ett Microsoft-konto. Sandbox-prenumerationen tas bort automatiskt när du slutför den här modulen. När sandbox-miljön har aktiverats loggar du in på Azure Portal med autentiseringsuppgifterna för din sandbox-prenumeration. Se till att du arbetar i sandbox-katalogen Microsoft Learn – som anges längst upp till höger i portalen under ditt användar-ID. Annars väljer du användarikonen och växlar katalog.

Dricks

Om du vill kan du använda din egen Azure-prenumeration. Om du vill göra det loggar du in på Azure Portal med autentiseringsuppgifter för din prenumeration. Se till att du arbetar i katalogen som innehåller din prenumeration – som anges längst upp till höger under ditt användar-ID. Annars väljer du användarikonen och växlar katalog.

Skapa MongoDB-app med Node.js Azure Cosmos DB för MongoDB

Skapa MongoDB-app med Java Azure Cosmos DB för MongoDB

Skapa MongoDB-app med Hjälp av Python Azure Cosmos DB för MongoDB

Skapa MongoDB-app med C# Azure Cosmos DB för MongoDB

I den här övningen skapar du ett Azure Cosmos DB för MongoDB-konto, en databas, en samling och lägger till ett par dokument i samlingen. Du märker att den här koden är identisk med hur du ansluter till valfri MongoDB-databas. Sedan skapar du en samling med hjälp av tilläggskommandon som gör att du kan definiera dataflödet i enheter för begäran/s (RU: er) för samlingen.

Förbereda utvecklingsmiljön

Om du inte har Azure Cosmos DB-kontot och miljön där du arbetar med det här labbet följer du de här stegen för att göra det. Annars går du till avsnittet Lägg till koden för att skapa databaser, samling och dokument i App.js filavsnittet .

Om du inte har miljön och Azure Cosmos DB-kontot där du arbetar med det här labbet följer du de här stegen för att göra det. Annars går du till avsnittet Lägg till koden för att skapa databaser, samling och dokument i App.java filavsnittet .

Om du inte är det Azure Cosmos DB-konto och den miljö där du arbetar med det här labbet följer du dessa steg för att göra det. Annars går du till avsnittet Lägg till koden för att skapa databaser, samling och dokument i App.py filavsnittet .

Om du inte har miljön och Azure Cosmos DB-kontot där du arbetar med det här labbet följer du de här stegen för att göra det. Annars går du till avsnittet Lägg till koden för att skapa databaser, samling och dokument i app.cs filavsnittet .

  1. I Azure Cloud Shell kopierar och klistrar du in följande kommandon.

    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

    Dricks

    Om du inte använder sandbox-miljön för labbet och vill ange den plats där du vill skapa databas- och lagringsobjekt lägger du till parametern -l LOCATIONNAME i init.sh-anropet. Om du vill ange en resursgrupp lägger du dessutom till parametern -r YOURRRESOURCEGROUPNAMEHERE i init.sh-anropet.

    Kommentar

    Det här bash-skriptet skapar Azure Cosmos DB för MongoDB-kontot. Det kan ta 5-10 minuter att skapa det här kontot så det kan vara en bra tid att få en kopp kaffe eller te.

    Dricks

    Om du kommer tillbaka och cloud shell har återställts kör du följande kommandon i cloud shell för att använda Node version 14, annars misslyckas koden i nästa avsnitt.

    1. källa ~/.nvm/nvm.sh
    2. nvm install 14.0.0
    3. npm länk mongodb

  2. När bash-init.sh filen är klar och kopierar någonstans anslutningssträngen, Cosmos DB-kontonamnet och resursgruppens namn som returneras behöver vi dem i nästa avsnitt. Du kan också granska JSON som returneras av skriptet för att skapa kontot som finns före anslutningssträng. Om du tittar någonstans mitt i JSON bör du se egenskapen "kind": "MongoDB".

    Kommentar

    Observera att anslutningssträngen, Cosmos DB-kontonamnet och resursgruppens namn också kan hittas med hjälp av Azure Portal.

Lägg till koden för att skapa databaser, samling och dokument i filen App.js

Nu är det dags att lägga till vår JavaScript-kod för att skapa en databas, en samling och lägga till ett dokument i samlingen.

Lägg till koden för att skapa databaser, samling och dokument i filen App.java

Nu är det dags att lägga till vår Java-kod för att skapa en databas, en samling och lägga till ett dokument i samlingen.

Lägg till koden för att skapa databaser, samling och dokument i filen App.py

Nu är det dags att lägga till vår Python-kod för att skapa en databas, en samling och lägga till ett dokument i samlingen.

Lägg till koden för att skapa databaser, samling och dokument i filen app.cs

Nu är det dags att lägga till vår C#-kod för att skapa en databas, en samling och lägga till ett dokument i samlingen.

  1. Öppna Azure Cloud Shell i inte redan öppnat.

  2. Kör följande kommando för att öppna kodredigeraren.

    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

  3. Kopiera följande kod till appfilen. Glöm inte att du behöver ersätta URI-värdet för anslutningssträng kopierade i föregående avsnitt.

    Den här delen av koden använder MongoDB-drivrutinerna och använder anslutningssträng till Azure Cosmos DB som om du normalt skulle använda en anslutningssträng till valfri MongoDB-server. Koden definierar och öppnar sedan anslutningen till Azure Cosmos DB-kontot.

    // 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);

  4. Nästa steg ansluter till produktdatabasen. Om den här databasen inte finns skapas den bara om den också skapar en samling i samma anslutning eller med hjälp av tilläggskommandon. Lägg till följande i skriptet i redigeraren.

    // 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");

  5. Därefter ansluter vi till dokumentsamlingen om den redan finns och lägger sedan till ett dokument i samlingen. Om samlingen inte finns skapar den här koden samlingen om den också utför en åtgärd på samlingen i samma anslutning (till exempel genom att lägga till ett dokument i samlingen) eller med hjälp av tilläggskommandon. Lägg till följande i skriptet i redigeraren.

    
  // 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);

  6. Nu ska vi söka efter det infogade dokumentet och visa det i gränssnittet. Lägg till följande i skriptet i redigeraren.

      // 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);
  }
}

  7. Slutligen stänger vi anslutningen. Lägg till följande i skriptet i redigeraren.

      // 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.

  8. Skriptet bör se ut så här:

    // 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);
  }
}

  9. Nu ska vi gå vidare och spara programmet. Välj i det övre högra hörnet i kodredigeraren och välj Spara (eller Ctrl+S). Välj stäng redigeraren (eller Ctrl+Q) för att gå tillbaka till gränssnittet.

  10. Nu kör vi appen med följande kommando.

    node App.js

    mvn clean compile exec:java

    python App.py

    dotnet run

  11. Det här skriptet bör returnera ett liknande resultat som följande. Det innebär att vi har skapat databasen, samlingen och lagt till ett dokument i den.

    {
  _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'

Som du ser är den här koden samma kod som du skulle köra för att skapa en databas, samling och ett dokument i en MongoDB-databas. Därför bör programmering för Azure Cosmos DB for MongoDB vara transparent för dig om du redan är bekant med att skapa appar som ansluter till MongoDB.

Hanterade identiteter

För produktionsarbetsbelastningar rekommenderar vi att du använder hanterade identiteter för att autentisera till Azure Cosmos DB. På så sätt behöver du inte lagra anslutningssträng i koden. I nästa avsnitt använder vi hanterade identiteter för att autentisera till Azure Cosmos DB.

I en produktionsmiljö bör du använda en hanterad identitet med minsta möjliga behörighet. Du kan skapa en eller flera användartilldelade hanterade identiteter och tilldela dem till Azure Cosmos DB-kontot. I det här labbet ska vi skapa en systemtilldelad hanterad identitet för Azure Cosmos DB-kontot.

  1. I Azure Portal navigerar du till det Azure Cosmos DB-konto som du skapade tidigare.
  2. I den vänstra menyn går du till Inställningar och väljer Identitet.
  3. I fönstret Identitet väljer du Systemtilldelad.
  4. Välj På för Status.
  5. Välj Spara.
  6. Det tar en minut eller två innan den hanterade identiteten skapas.

När den hanterade identiteten har skapats måste vi tilldela den hanterade identiteten nödvändiga behörigheter till Azure Cosmos DB-kontot. Tid att använda RBAC (rollbaserad åtkomstkontroll) för att tilldela den hanterade identiteten nödvändiga behörigheter. För den här labbuppgiften tilldelar vi rollen Deltagare till den hanterade identiteten så att den kan läsa och skriva data till Azure Cosmos DB-kontot. I en produktionsmiljö bör du tilldela den minsta behörighetsroll som krävs.

  1. I Azure Portal navigerar du till det Azure Cosmos DB-konto som du skapade tidigare.
  2. Välj Åtkomstkontroll (IAM) under Inställningar på den vänstra menyn.
  3. Välj + Lägg till och sedan Lägg till rolltilldelning.
  4. Under rollen Privilegierad administratör väljer du Deltagare och sedan Nästa.
  5. Under Medlemmar väljer du Hanterad identitet och sedan + Välj medlemmar.
  6. I fönstret Välj hanterade identiteter söker du efter den hanterade identitet som du skapade tidigare, väljer den och väljer sedan Granska + tilldela.

Nu har du en hanterad identitet tilldelad till Azure Cosmos DB-kontot med nödvändiga behörigheter. Nu ska vi använda den hanterade identiteten för att autentisera till Azure Cosmos DB-kontot.

Använda tilläggskommandon för att hantera data som lagras i Azure Cosmos DB:s API för MongoDB

Den föregående koden skulle vara identisk mellan att ansluta till en MongoDB-server och sedan ansluta till vårt Azure Cosmos DB för MongoDB-konto, men anslutningen kanske inte drar nytta av Azure Cosmos DB-funktioner. Det innebär att använda standarddrivrutinsmetoderna för att skapa våra samlingar, och använder även standardparametrarna för Azure Cosmos DB-kontot för att skapa dessa samlingar. Därför kan vi inte definiera skapandeparametrar som vårt dataflöde, partitioneringsnyckel eller inställningar för automatisk skalning med hjälp av dessa metoder.

Genom att använda Azure Cosmos DB:s API för MongoDB kan du dra nytta av fördelarna med Cosmos DB. Dessa fördelar omfattar global distribution, automatisk horisontell partitionering, hög tillgänglighet, svarstidsgarantier, automatisk kryptering i vila, säkerhetskopior och många fler. Plus den extra fördelen med att bevara dina investeringar i din MongoDB-app. Du kan kommunicera med Azure Cosmos DB:s API för MongoDB med någon av MongoDB-klientdrivrutinerna med öppen källkod. Med Azure Cosmos DB:s API för MongoDB kan du använda befintliga klientdrivrutiner genom att följa MongoDB-trådprotokollet.

Nu ska vi skapa en kod som gör att vi kan skapa en samling och definiera dess horisontella nyckel och dataflöde.

  1. Öppna Azure Cloud Shell i inte redan öppnat.

  2. Kör följande kommando för att öppna kodredigeraren.

    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

  3. Kopiera följande kod till filen.

    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);

  4. Nästa steg ansluter till medarbetardatabasen. Om den här databasen inte finns skapas den bara om den också skapar en samling i samma anslutning eller med hjälp av tilläggskommandon. Lägg till följande i skriptet i redigeraren.

      // 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");

  5. Hittills ser det ungefär ut som koden i föregående avsnitt. I det här steget använder vi tilläggskommandona och skapar en anpassad åtgärd. Med den här åtgärden kan vi definiera dataflödet och partitioneringsnyckeln för samlingen. I sin tur ger steget Azure Cosmos DB de parametrar som ska användas när samlingen skapas. Lägg till följande i skriptet i redigeraren.

      // 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""}");

  6. Resten är identiskt med föregående exempel. Vi ansluter till samlingen, infogar några rader, slutligen frågar och matar ut en rad tillbaka. Lägg till följande i skriptet i redigeraren.

      // 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);
  }
}

  7. Skriptet bör se ut så här:

    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);
    }
}

  8. Nu ska vi gå vidare och spara programmet. Välj i det övre högra hörnet i kodredigeraren och välj Spara (eller Ctrl+S). Välj stäng redigeraren (eller Ctrl+Q) för att gå tillbaka till gränssnittet.

  9. Nu kör vi appen med följande kommando.

    node App.js

    mvn clean compile exec:java

    python App.py

    dotnet run

  10. Detta bör returnera ett liknande resultat som det nedan. Det innebär att vi skapade databasen, samlingen och lade till ett dokument i den.

    {
  _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'

  11. Men den senaste resultatuppsättningen bekräftade bara att vi verkligen skapade en databas, samling och dokument, men hur är det med vår fragmentnyckel och dataflöde, ändrades de verkligen? I Cloud Shell kör vi följande kommandon för att kontrollera att våra ändringar trädde i kraft.

    1. Nu ska vi kontrollera att vår Shard-nyckel har ändrats till EmployeeId (standardvärdet är ID). Glöm inte att ändra resursgruppens namn och kontonamn för de namn som vi sparade i början av den här labbuppgiften.

      az cosmosdb mongodb collection show --name Employee --database-name HumanResources --resource-group learn-20c8df29-1419-49f3-84bb-6613f052b5ae --account-name learn-account-cosmos-845083734

      Resultatet bör innehålla egenskapen "shardKey": {"EmployeeId": "Hash"}.

    2. Nu ska vi kontrollera att vårt dataflöde har ändrats till 1 000 (standardvärdet är 400). Glöm inte att ändra resursgruppens namn och kontonamn för de namn som vi sparade i början av den här labbuppgiften.

      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

      Resultatet bör innehålla egenskapen "dataflöde": 1000.

Den här koden illustrerade kraften i att använda utökade kommandon i vår kod, vilket gör att vi kan definiera skapandeparametrarna för Azure Cosmos DB. På så sätt kan vi dra nytta av att styra hur våra samlingar ska skapas och bearbetas av Azure Cosmos DB.

När du har slutfört den här övningen fortsätter du till kunskapstestfrågorna för den här modulen.