Cvičení – vytvoření aplikace MongoDB DB pomocí služby Azure Cosmos DB pro MongoDB

35 min

Je čas si programově prohlédnout, jak vytvořit databáze, kolekce MongoDB a přidat nějaká data.

Toto cvičení je možné dokončit pomocí sandboxu Microsoft Learn, který poskytuje dočasné předplatné Azure. Pokud chcete aktivovat předplatné sandboxu, musíte se přihlásit pomocí účtu Microsoft. Předplatné sandboxu se po dokončení tohoto modulu automaticky odstraní. Po aktivaci sandboxu se přihlaste k webu Azure Portal pomocí přihlašovacích údajů pro vaše předplatné sandboxu. Ujistěte se, že pracujete v adresáři Sandboxu Microsoft Learn , který je uvedený v pravém horním rohu portálu pod VAŠÍM ID uživatele. Pokud ne, vyberte ikonu uživatele a přepněte adresář.

Návod

Pokud chcete, můžete použít vlastní předplatné Azure. Pokud to chcete udělat, přihlaste se k webu Azure Portal pomocí přihlašovacích údajů pro vaše předplatné. Ujistěte se, že pracujete v adresáři obsahujícím vaše předplatné – uvedené v pravém horním rohu pod ID uživatele. Pokud ne, vyberte ikonu uživatele a přepněte adresář.

Vytvoření aplikace MongoDB pomocí Node.js Azure Cosmos DB pro MongoDB

Vytvoření aplikace MongoDB pomocí Služby Azure Cosmos DB pro MongoDB v Javě

Vytvoření aplikace MongoDB pomocí Pythonu Azure Cosmos DB pro MongoDB

Vytvoření aplikace MongoDB pomocí služby Azure Cosmos DB v jazyce C# pro MongoDB

V tomto cvičení vytvoříte účet Služby Azure Cosmos DB pro MongoDB, databázi, kolekci a do kolekce přidáte několik dokumentů. Všimněte si, že tento kód je shodný s tím, jak byste se připojili k jakékoli databázi MongoDB. Pak vytvoříte kolekci pomocí rozšiřujících příkazů, které umožňují definovat propustnost v jednotkách žádostí za sekundu (RU) pro kolekci.

Příprava vývojového prostředí

Pokud nemáte účet a prostředí služby Azure Cosmos DB, ve kterém pracujete na tomto cvičení, postupujte podle těchto kroků. V opačném případě přejděte do části Přidat kód a vytvořte databáze, kolekci a dokument do oddílu App.js soubor .

Pokud prostředí a účet služby Azure Cosmos DB, ve kterém pracujete na tomto cvičení, postupujte podle těchto kroků. V opačném případě přejděte do části Přidat kód a vytvořte databáze, kolekci a dokument do oddílu App.java soubor .

Pokud nemáte účet a prostředí Služby Azure Cosmos DB, ve kterém pracujete na tomto cvičení, postupujte podle těchto kroků. V opačném případě přejděte do části Přidat kód a vytvořte databáze, kolekci a dokument do oddílu App.py souboru .

Pokud nemáte prostředí a účet služby Azure Cosmos DB, ve kterém pracujete na tomto cvičení, postupujte podle těchto kroků. V opačném případě přejděte do části Přidat kód a vytvořte databáze, kolekci a dokument do oddílu app.cs soubor .

V Azure Cloud Shellu zkopírujte a vložte následující příkazy.

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

Návod

Pokud pro testovací prostředí nepoužíváte sandbox a chcete zadat umístění, kam chcete vytvořit objekty databáze a úložiště, přidejte do volání init.sh parametr -l LOCATIONNAME. Pokud chcete také zadat skupinu prostředků, přidejte do volání init.sh parametr -r YOURRRESOURCEGROUPNAMEHERE.

Poznámka:

Tento skript Bash vytvoří účet Služby Azure Cosmos DB pro MongoDB. Vytvoření tohoto účtu může trvat 5 až 10 minut, takže může být vhodná doba na získání šálek kávy nebo čaje.

Návod

Pokud se vrátíte a cloud shell má resetování, spusťte v Cloud Shellu následující příkazy, které použijí Node verze 14, jinak kód v další části selže.

zdroj ~/.nvm/nvm.sh

nvm install 14.0.0

npm link mongodb

Až se soubor bash init.sh dokončí, zkopírujte někam připojovací řetězec, název účtu služby Cosmos DB a vrácený název skupiny prostředků, budeme je potřebovat v další části. Můžete také zkontrolovat JSON vrácený skriptem pro vytvoření účtu, který se nachází před připojovací řetězec. Pokud se podíváte někde uprostřed JSON, měla by se zobrazit vlastnost "kind": "MongoDB".

Poznámka:

Všimněte si, že připojovací řetězec, název účtu služby Cosmos DB a název skupiny prostředků najdete také na webu Azure Portal.

Přidání kódu pro vytvoření databází, kolekcí a dokumentů do souboru App.js

Teď je čas přidat kód JavaScriptu pro vytvoření databáze, kolekce a přidání dokumentu do kolekce.

Přidání kódu pro vytvoření databází, kolekcí a dokumentů do souboru App.java

Teď je čas přidat kód Java pro vytvoření databáze, kolekce a přidání dokumentu do kolekce.

Přidání kódu pro vytvoření databází, kolekce a dokumentu do souboru App.py

Teď je čas přidat kód Pythonu pro vytvoření databáze, kolekce a přidání dokumentu do kolekce.

Přidání kódu pro vytvoření databází, kolekcí a dokumentů do souboru app.cs

Teď je čas přidat kód jazyka C# pro vytvoření databáze, kolekce a přidání dokumentu do kolekce.

V neotevřené aplikaci otevřete Azure Cloud Shell.

Spuštěním následujícího příkazu otevřete editor kódu.

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

Zkopírujte následující kód do souboru aplikace. Nezapomeňte, že musíte nahradit hodnotu identifikátoru URI pro připojovací řetězec zkopírovanou v předchozí části.

Tato část kódu používá ovladače MongoDB a používá připojovací řetězec do služby Azure Cosmos DB, jako byste normálně používali připojovací řetězec na jakýkoli server MongoDB. Kód pak definuje a otevře připojení k účtu služby 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);

Další krok se připojí k databázi produktů . Pokud tato databáze neexistuje, vytvoří ji pouze v případě, že vytvoří kolekci ve stejném připojení nebo pomocí příkazů rozšíření. Do skriptu v editoru přidejte následující kód.

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

Dále se připojíme k kolekci dokumentů , pokud už existuje, a pak do kolekce přidáme jeden dokument. Pokud kolekce neexistuje, vytvoří tento kód kolekci, pokud provede také operaci s touto kolekcí ve stejném připojení (například přidat dokument do kolekce) nebo pomocí příkazů rozšíření. Do skriptu v editoru přidejte následující kód.


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

Umožňuje teď vyhledat vložený dokument a zobrazit ho v prostředí. Do skriptu v editoru přidejte následující kód.

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

Nakonec připojení zavřeme. Do skriptu v editoru přidejte následující kód.

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

Skript by měl vypadat takto:

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

Pojďme program uložit. Vyberte v pravém horním rohu editoru kódu a vyberte Uložit (nebo Ctrl+S). Teď vyberte Zavřít editor (nebo Ctrl+Q) a vraťte se do prostředí.

Teď spustíme aplikaci pomocí následujícího příkazu.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Tento skript by měl vrátit podobný výsledek jako následující. To znamená, že jsme vytvořili databázi, kolekci a přidali do ní 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 si můžete všimnout, tento kód je stejný kód, který byste spustili pro vytvoření databáze, kolekce a dokumentu v databázi MongoDB. Pokud už máte zkušenosti s vytvářením aplikací, které se připojují k MongoDB, musí být programování pro Azure Cosmos DB pro MongoDB transparentní.

Spravované identity

Pro produkční úlohy doporučujeme použít spravované identity k ověření ve službě Azure Cosmos DB. Tímto způsobem nemusíte ukládat připojovací řetězec do kódu. V této další části použijeme spravované identity k ověření ve službě Azure Cosmos DB.

V produkčním prostředí byste měli použít spravovanou identitu s minimálními potřebnými oprávněními. Můžete vytvořit jednu nebo více spravovaných identit přiřazených uživatelem a přiřadit je k účtu služby Azure Cosmos DB. V tomto cvičení vytvoříme spravovanou identitu přiřazenou systémem pro účet služby Azure Cosmos DB.

Na webu Azure Portal přejděte k účtu služby Azure Cosmos DB, který jste vytvořili dříve.
V nabídce vlevo v části Nastavení vyberte Identita.
V podokně Identita vyberte Systém přiřazený.
Vyberte Zapnutopro stav.
Zvolte Uložit.
Vytvoření spravované identity trvá minutu nebo dvě.

Po vytvoření spravované identity musíme spravované identitě přiřadit potřebná oprávnění k účtu služby Azure Cosmos DB. Čas použít řízení přístupu na základě role (RBAC) k přiřazení spravované identity potřebných oprávnění. V tomto cvičení přiřadíme roli Přispěvatel spravované identitě, která jí umožní číst a zapisovat data do účtu služby Azure Cosmos DB. V produkčním prostředí byste měli přiřadit nejnižší potřebnou roli oprávnění.

Na webu Azure Portal přejděte k účtu služby Azure Cosmos DB, který jste vytvořili dříve.
V nabídce vlevo v části Nastavení vyberte Řízení přístupu (IAM).
Vyberte + Přidat a pak přidejte přiřazení role.
V části Role Privilegovaného správce vyberte Přispěvatel a vyberte Další.
V části Členové vyberte Spravovanou identitu a pak + Vybrat členy.
V podokně Vybrat spravované identity vyhledejte spravovanou identitu, kterou jste vytvořili dříve, vyberte ji a pak vyberte Zkontrolovat a přiřadit.

Teď máte spravovanou identitu přiřazenou k účtu služby Azure Cosmos DB s potřebnými oprávněními. Teď použijeme spravovanou identitu k ověření v účtu služby Azure Cosmos DB.

Použití příkazů rozšíření ke správě dat uložených v rozhraní API služby Azure Cosmos DB pro MongoDB

I když by předchozí kód byl stejný mezi připojením k serveru MongoDB a připojením k našemu účtu Azure Cosmos DB pro MongoDB, připojení nemusí využívat výhod funkcí služby Azure Cosmos DB. To znamená, že k vytvoření kolekcí se používají výchozí metody ovladače. K vytvoření těchto kolekcí se používají také výchozí parametry účtu služby Azure Cosmos DB. Proto pomocí těchto metod nemůžeme definovat parametry vytváření, jako je propustnost, klíč horizontálního dělení nebo nastavení automatického škálování.

Pomocí rozhraní API služby Azure Cosmos DB pro MongoDB můžete využívat výhody služby Cosmos DB. Mezi tyto výhody patří globální distribuce, automatické horizontální dělení, vysoká dostupnost, záruky latence, automatické šifrování neaktivních uložených dat, zálohování a mnoho dalších. Navíc je přidaná výhoda zachování investic do aplikace MongoDB. S rozhraním API služby Azure Cosmos DB pro MongoDB můžete komunikovat pomocí libovolného opensourcového klientského ovladače MongoDB. Rozhraní API služby Azure Cosmos DB pro MongoDB umožňuje používat existující klientské ovladače tím, že dodržuje protokol přenosu MongoDB.

Pojďme vytvořit nějaký kód, který nám umožní vytvořit kolekci a definovat její klíč horizontálního dělení a propustnost.

V neotevřené aplikaci otevřete Azure Cloud Shell.

Spuštěním následujícího příkazu otevřete editor kódu.

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

Zkopírujte do souboru následující kód.

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

Další krok se připojí k databázi zaměstnanců . Pokud tato databáze neexistuje, vytvoří ji pouze v případě, že vytvoří kolekci ve stejném připojení nebo pomocí příkazů rozšíření. Do skriptu v editoru přidejte následující kód.

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

Zatím to vypadá podobně jako kód v předchozí části. V tomto kroku využijeme příkazy rozšíření a vytvoříme vlastní akci. Tato akce nám umožňuje definovat propustnost a klíč horizontálního dělení kolekce. Naopak tento krok poskytuje službě Azure Cosmos DB parametry, které se mají použít při vytváření kolekce. Do skriptu v editoru přidejte následující kód.

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

Zbytek je stejný jako v předchozím příkladu. Připojíme se k kolekci, vložíme některé řádky, nakonec odešleme dotaz a vypíšeme řádek zpět. Do skriptu v editoru přidejte následující kód.

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

Skript by měl vypadat takto:

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

Pojďme program uložit. Vyberte v pravém horním rohu editoru kódu a vyberte Uložit (nebo Ctrl+S). Teď vyberte Zavřít editor (nebo Ctrl+Q) a vraťte se do prostředí.

Teď spustíme aplikaci pomocí následujícího příkazu.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Měl by se vrátit podobný výsledek jako v následujícím příkladu. To znamená, že jsme vytvořili databázi, kolekci a přidali do ní 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'

Tato poslední sada výsledků ale pouze potvrdila, že jsme skutečně vytvořili databázi, kolekci a dokumenty, ale co náš klíč horizontálního oddílu a propustnost, skutečně se změnily? V Cloud Shellu spusťme následující příkazy, abychom ověřili, že se naše změny projevily.
1. Pojďme ověřit, že se náš klíč horizontálního oddílu změnil na EmployeeId (výchozí hodnota je ID). Nezapomeňte změnit název skupiny prostředků a název účtu pro názvy, které jsme uložili na začátku tohoto cvičení.
```
az cosmosdb mongodb collection show --name Employee --database-name HumanResources --resource-group learn-20c8df29-1419-49f3-84bb-6613f052b5ae --account-name learn-account-cosmos-845083734
```
  Výsledek by měl obsahovat vlastnost shardKey: {"EmployeeId": "Hash"}.
2. Pojďme ověřit, že se naše propustnost změnila na 1 000 (výchozí hodnota je 400). Nezapomeňte změnit název skupiny prostředků a název účtu pro názvy, které jsme uložili na začátku tohoto cvičení.
```
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
```
  Výsledek by měl zahrnovat vlastnost propustnost: 1000.

Tento kód znázorňuje sílu použití rozšířených příkazů v našem kódu, což nám umožňuje definovat parametry vytvoření služby Azure Cosmos DB. To nám umožňuje využít výhod řízení způsobu vytváření a zpracování kolekcí službou Azure Cosmos DB.

Jakmile toto cvičení dokončíte, pokračujte na otázky ke kontrole znalostí pro tento modul.

Váš názor

Byla tato stránka užitečná?