Ćwiczenie — tworzenie aplikacji bazy danych MongoDB przy użyciu usługi Azure Cosmos DB dla bazy danych MongoDB

35 min

Nadszedł czas, aby programowo sprawdzić, jak utworzyć nasze bazy danych, kolekcje i dodać dane w usłudze Azure Cosmos DB dla bazy danych MongoDB.

To ćwiczenie można wykonać przy użyciu piaskownicy usługi Microsoft Learn , która udostępnia tymczasową subskrypcję platformy Azure. Aby aktywować subskrypcję piaskownicy, musisz zalogować się przy użyciu konta Microsoft. Subskrypcja piaskownicy zostanie automatycznie usunięta po ukończeniu tego modułu. Po aktywowaniu piaskownicy zaloguj się do witryny Azure Portal przy użyciu poświadczeń subskrypcji piaskownicy. Upewnij się, że pracujesz w katalogu piaskownicy usługi Microsoft Learn — w prawym górnym rogu portalu pod identyfikatorem użytkownika. Jeśli nie, wybierz ikonę użytkownika i przełącz katalog.

Napiwek

Jeśli wolisz, możesz użyć własnej subskrypcji platformy Azure. W tym celu zaloguj się w witrynie Azure Portal przy użyciu poświadczeń subskrypcji. Upewnij się, że pracujesz w katalogu zawierającym subskrypcję — wskazane w prawym górnym rogu pod identyfikatorem użytkownika. Jeśli nie, wybierz ikonę użytkownika i przełącz katalog.

Tworzenie aplikacji MongoDB przy użyciu usługi Node.js Azure Cosmos DB dla bazy danych MongoDB

Tworzenie aplikacji MongoDB przy użyciu usługi Azure Cosmos DB dla bazy danych MongoDB w języku Java

Tworzenie aplikacji MongoDB przy użyciu języka Python usługi Azure Cosmos DB dla bazy danych MongoDB

Tworzenie aplikacji MongoDB przy użyciu języka C# usługi Azure Cosmos DB dla bazy danych MongoDB

W tym ćwiczeniu utworzysz konto usługi Azure Cosmos DB dla bazy danych MongoDB, bazę danych, kolekcję i dodasz kilka dokumentów do kolekcji. Zauważysz, że ten kod jest identyczny z tym, jak można nawiązać połączenie z dowolną bazą danych MongoDB. Następnie należy utworzyć kolekcję przy użyciu poleceń rozszerzenia, które umożliwiają zdefiniowanie przepływności w jednostkach żądań/s (RU) dla kolekcji.

przygotowywanie środowiska programistycznego

Jeśli nie masz konta i środowiska usługi Azure Cosmos DB, w którym pracujesz w tym laboratorium, wykonaj następujące kroki, aby to zrobić. W przeciwnym razie przejdź do sekcji Dodawanie kodu w celu utworzenia baz danych, kolekcji i dokumentu w pliku App.js.

Jeśli nie korzystasz ze środowiska i konta usługi Azure Cosmos DB, na którym pracujesz w tym laboratorium, wykonaj następujące kroki, aby to zrobić. W przeciwnym razie przejdź do sekcji Dodawanie kodu w celu utworzenia baz danych, kolekcji i dokumentu w pliku App.java.

Jeśli nie masz środowiska i konta usługi Azure Cosmos DB, na którym pracujesz w tym laboratorium, wykonaj następujące kroki, aby to zrobić. W przeciwnym razie przejdź do sekcji Dodawanie kodu w celu utworzenia baz danych, kolekcji i dokumentu w pliku app.cs.

W usłudze Azure Cloud Shell skopiuj i wklej następujące polecenia.

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

Napiwek

Jeśli nie używasz piaskownicy dla laboratorium i chcesz określić lokalizację, w której chcesz utworzyć bazę danych i obiekty magazynu, dodaj parametr -l LOCATIONNAME do wywołania init.sh. Ponadto jeśli chcesz określić grupę zasobów, dodaj parametr -r YOURRRESOURCEGROUPNAMEHERE do wywołania init.sh.

Uwaga

Ten skrypt powłoki bash utworzy konto usługi Azure Cosmos DB dla bazy danych MongoDB. Utworzenie tego konta może potrwać od 5 do 10 minut, więc może to być dobry moment, aby uzyskać filiżankę kawy lub herbaty.

Napiwek

Jeśli wrócisz i usługa Cloud Shell zostanie zresetowana, uruchom następujące polecenia w usłudze Cloud Shell, aby użyć środowiska Node w wersji 14. W przeciwnym razie kod w następnej sekcji zakończy się niepowodzeniem.

source ~/.nvm/nvm.sh

Instalacja nvm 14.0.0

npm link mongodb

Po zakończeniu działania pliku init.sh powłoki bash skopiuj gdzieś zwrócone parametry połączenia, nazwę konta usługi Cosmos DB i nazwę grupy zasobów, będziemy potrzebować ich w następnej sekcji. Możesz również przejrzeć kod JSON zwrócony przez skrypt tworzenia konta, który znajduje się przed parametry połączenia. Jeśli spojrzysz gdzieś w środku kodu JSON, powinna zostać wyświetlona właściwość "kind": "MongoDB".

Uwaga

Należy pamiętać, że parametry połączenia, nazwa konta usługi Cosmos DB i nazwa grupy zasobów można również znaleźć w witrynie Azure Portal.

Dodaj kod, aby utworzyć bazy danych, kolekcję i dokument do pliku App.js

Nadszedł czas, aby dodać nasz kod JavaScript w celu utworzenia bazy danych, kolekcji i dodania dokumentu do kolekcji.

Dodaj kod, aby utworzyć bazy danych, kolekcję i dokument do pliku App.java

Nadszedł czas, aby dodać nasz kod Java w celu utworzenia bazy danych, kolekcji i dodania dokumentu do kolekcji.

Dodaj kod, aby utworzyć bazy danych, kolekcję i dokument do pliku App.py

Nadszedł czas, aby dodać nasz kod w języku Python w celu utworzenia bazy danych, kolekcji i dodania dokumentu do kolekcji.

Dodaj kod, aby utworzyć bazy danych, kolekcję i dokument do pliku app.cs

Nadszedł czas, aby dodać nasz kod w języku C#, aby utworzyć bazę danych, kolekcję i dodać dokument do kolekcji.

Otwórz usługę Azure Cloud Shell.

Uruchom następujące polecenie, aby otworzyć edytor kodu.

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

Skopiuj następujący kod do pliku aplikacji. Nie zapomnij, aby zastąpić wartość identyfikatora URI parametry połączenia skopiowaną w poprzedniej sekcji.

Ta część kodu używa sterowników bazy danych MongoDB i używa parametry połączenia do usługi Azure Cosmos DB, tak jak zwykle używać parametry połączenia do dowolnego serwera Bazy danych MongoDB. Następnie kod definiuje i otwiera połączenie z kontem usługi 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);

Następny krok łączy się z bazą danych produktów . Jeśli ta baza danych nie istnieje, tworzy ją tylko wtedy, gdy również tworzy kolekcję w tym samym połączeniu lub za pomocą poleceń rozszerzeń. Dodaj następujący kod do skryptu w edytorze.

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

Następnie połączymy się z kolekcją dokumentów , jeśli już istnieje, a następnie dodamy jeden dokument do kolekcji. Jeśli kolekcja nie istnieje, ten kod tworzy kolekcję, jeśli wykonuje również operację na tej kolekcji w tym samym połączeniu (na przykład dodaj dokument do kolekcji) lub za pomocą poleceń rozszerzenia. Dodaj następujący kod do skryptu w edytorze.


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

Teraz wyszukaj wstawiony dokument i wyświetl go w powłoce. Dodaj następujący kod do skryptu w edytorze.

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

Na koniec zamknijmy połączenie. Dodaj następujący kod do skryptu w edytorze.

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

Skrypt powinien wyglądać następująco:

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

Przejdźmy do przodu i zapiszmy program. Wybierz prawy górny róg edytora kodu i wybierz pozycję Zapisz (lub Ctrl+S). Teraz wybierz pozycję Zamknij edytor (lub Ctrl+Q), aby wrócić do powłoki.

Teraz uruchomimy aplikację za pomocą następującego polecenia.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Ten skrypt powinien zwrócić podobny wynik do poniższego. Oznacza to, że utworzyliśmy bazę danych, kolekcję i dodaliśmy do niej dokument.

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

Jak widać, ten kod jest tym samym kodem, który można uruchomić w celu utworzenia bazy danych, kolekcji i dokumentu w bazie danych MongoDB. Dlatego programowanie dla usługi Azure Cosmos DB dla bazy danych MongoDB powinno być niewidoczne, jeśli znasz już tworzenie aplikacji łączących się z bazą danych MongoDB.

Tożsamości zarządzane

W przypadku obciążeń produkcyjnych zalecamy używanie tożsamości zarządzanych do uwierzytelniania w usłudze Azure Cosmos DB. W ten sposób nie trzeba przechowywać parametry połączenia w kodzie. W następnej sekcji użyjemy tożsamości zarządzanych do uwierzytelniania w usłudze Azure Cosmos DB.

W środowisku produkcyjnym należy użyć tożsamości zarządzanej z najniższymi uprawnieniami wymaganymi. Możesz utworzyć co najmniej jedną tożsamość zarządzaną przypisaną przez użytkownika i przypisać je do konta usługi Azure Cosmos DB. W tym laboratorium utworzymy tożsamość zarządzaną przypisaną przez system dla konta usługi Azure Cosmos DB.

W witrynie Azure Portal przejdź do utworzonego wcześniej konta usługi Azure Cosmos DB.
W menu po lewej stronie w obszarze Ustawienia wybierz pozycję Tożsamość.
W okienku Tożsamość wybierz pozycję Przypisany system.
Wybierz pozycję Wł. dla pozycji Stan.
Wybierz pozycję Zapisz.
Utworzenie tożsamości zarządzanej trwa minutę lub dwie.

Po utworzeniu tożsamości zarządzanej musimy przypisać tożsamość zarządzaną niezbędne uprawnienia do konta usługi Azure Cosmos DB. Czas użycia kontroli dostępu opartej na rolach (kontrola dostępu oparta na rolach) w celu przypisania tożsamości zarządzanej niezbędnych uprawnień. W tym laboratorium przypiszemy rolę Współautor do tożsamości zarządzanej, aby umożliwić jej odczytywanie i zapisywanie danych na koncie usługi Azure Cosmos DB. W środowisku produkcyjnym należy przypisać wymaganą rolę najniższych uprawnień.

W witrynie Azure Portal przejdź do utworzonego wcześniej konta usługi Azure Cosmos DB.
W menu po lewej stronie w obszarze Ustawienia wybierz pozycję Kontrola dostępu (Zarządzanie dostępem i tożsamościami).
Wybierz pozycję + Dodaj , a następnie pozycję Dodaj przypisanie roli.
W obszarze rola Administrator uprzywilejowany wybierz pozycję Współautor, wybierz pozycję Dalej.
W obszarze Członkowie wybierz pozycję Tożsamość zarządzana, a następnie pozycję + Wybierz członków.
W okienku Wybieranie tożsamości zarządzanych wyszukaj utworzoną wcześniej tożsamość zarządzaną, wybierz ją, a następnie wybierz pozycję Przejrzyj i przypisz.

Masz teraz tożsamość zarządzaną przypisaną do konta usługi Azure Cosmos DB z niezbędnymi uprawnieniami. Teraz użyjemy tożsamości zarządzanej do uwierzytelniania na koncie usługi Azure Cosmos DB.

Używanie poleceń rozszerzenia do zarządzania danymi przechowywanymi w interfejsie API usługi Azure Cosmos DB dla bazy danych MongoDB

Chociaż poprzedni kod, byłby identyczny między nawiązywaniem połączenia z serwerem MongoDB, a następnie połączenie z naszym kontem usługi Azure Cosmos DB dla bazy danych MongoDB, połączenie może nie korzystać z funkcji usługi Azure Cosmos DB. Oznacza to użycie domyślnych metod sterowników do utworzenia kolekcji, a także używa domyślnych parametrów konta usługi Azure Cosmos DB do tworzenia tych kolekcji. Nie możemy więc zdefiniować parametrów tworzenia, takich jak przepływność, klucz fragmentowania lub ustawienia skalowania automatycznego przy użyciu tych metod.

Korzystając z interfejsu API usługi Azure Cosmos DB dla bazy danych MongoDB, możesz korzystać z zalet usługi Cosmos DB. Te korzyści obejmują dystrybucję globalną, automatyczne fragmentowanie, wysoką dostępność, gwarancje opóźnienia, automatyczne, szyfrowanie magazynowane, kopie zapasowe i wiele innych. Plus dodatkową zaletą zachowania inwestycji w aplikację MongoDB. Możesz komunikować się z interfejsem API usługi Azure Cosmos DB dla bazy danych MongoDB przy użyciu dowolnego sterownika klienta bazy danych MongoDB typu open source. Interfejs API usługi Azure Cosmos DB dla bazy danych MongoDB umożliwia korzystanie z istniejących sterowników klienta przez przestrzeganie protokołu przewodowego bazy danych MongoDB.

Utwórzmy kod, który pozwala nam utworzyć kolekcję i zdefiniować jej klucz fragmentowania i przepływność.

Otwórz usługę Azure Cloud Shell.

Uruchom następujące polecenie, aby otworzyć edytor kodu.

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

Skopiuj następujący kod do pliku.

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

Następny krok łączy się z bazą danych pracowników . Jeśli ta baza danych nie istnieje, tworzy ją tylko wtedy, gdy również tworzy kolekcję w tym samym połączeniu lub za pomocą poleceń rozszerzeń. Dodaj następujący kod do skryptu w edytorze.

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

Do tej pory wygląda to podobnie do kodu w poprzedniej sekcji. W tym kroku skorzystamy z poleceń rozszerzenia i utworzymy akcję niestandardową. Ta akcja umożliwia zdefiniowanie przepływności i klucza fragmentowania kolekcji. Z kolei krok daje usłudze Azure Cosmos DB parametry do użycia podczas tworzenia kolekcji. Dodaj następujący kod do skryptu w edytorze.

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

Reszta jest identyczna z poprzednim przykładem. Nawiązujemy połączenie z kolekcją, wstawiamy wiersze, na koniec wysyłamy zapytanie i zwracamy wiersz. Dodaj następujący kod do skryptu w edytorze.

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

Skrypt powinien wyglądać następująco:

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

Przejdźmy do przodu i zapiszmy program. Wybierz prawy górny róg edytora kodu i wybierz pozycję Zapisz (lub Ctrl+S). Teraz wybierz pozycję Zamknij edytor (lub Ctrl+Q), aby wrócić do powłoki.

Teraz uruchomimy aplikację za pomocą następującego polecenia.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Powinno to zwrócić podobny wynik do poniższego. Oznacza to, że utworzyliśmy bazę danych, kolekcję i dodaliśmy do niej dokument.

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

Jednak ten ostatni zestaw wyników potwierdził tylko, że rzeczywiście utworzyliśmy bazę danych, kolekcję i dokumenty, ale co z naszym kluczem fragmentu i przepływnością, czy naprawdę się zmieniły? W usłudze Cloud Shell uruchomimy następujące polecenia, aby sprawdzić, czy nasze zmiany zaszły w życie.
1. Sprawdźmy, czy nasz klucz fragmentu został zmieniony na EmployeeId (wartość domyślna to id). Nie zapomnij zmienić nazwy grupy zasobów i nazwy konta zapisanych na początku tego laboratorium.
```
az cosmosdb mongodb collection show --name Employee --database-name HumanResources --resource-group learn-20c8df29-1419-49f3-84bb-6613f052b5ae --account-name learn-account-cosmos-845083734
```
  Wynik powinien zawierać właściwość "shardKey": {"EmployeeId": "Hash"}.
2. Sprawdźmy, czy nasza przepływność została zmieniona na 1000 (wartość domyślna to 400). Nie zapomnij zmienić nazwy grupy zasobów i nazwy konta zapisanych na początku tego laboratorium.
```
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
```
  Wynik powinien zawierać właściwość "przepływność": 1000.

Ten kod ilustruje możliwości korzystania z rozszerzonych poleceń w naszym kodzie, co pozwala nam zdefiniować parametry tworzenia usługi Azure Cosmos DB. Dzięki temu możemy kontrolować sposób tworzenia i przetwarzania kolekcji przez usługę Azure Cosmos DB.

Po ukończeniu tego ćwiczenia przejdź do pytań dotyczących sprawdzania wiedzy dla tego modułu.

Sprzężenie zwrotne

Czy ta strona była pomocna?