Gyakorlat – MongoDB DB-alkalmazás létrehozása a MongoDB-hez készült Azure Cosmos DB használatával

35 perc

Itt az ideje, hogy programozott módon ellenőrizze, hogyan hozhat létre Azure Cosmos DB for MongoDB-adatbázisokat, gyűjteményeket és adhat hozzá néhány adatot.

Ez a gyakorlat egy Microsoft Learn tesztkörnyezet használatával végezhető el, amely egy ideiglenes Azure-előfizetést biztosít. A tesztkörnyezet-előfizetés aktiválásához Microsoft-fiókkal kell bejelentkeznie. A tesztkörnyezet-előfizetés automatikusan törlődik a modul befejezésekor. A tesztkörnyezet aktiválása után jelentkezzen be az Azure Portalra a tesztkörnyezet-előfizetés hitelesítő adataival. Győződjön meg arról, hogy a Microsoft Learn Tesztkörnyezet könyvtárban dolgozik – ezt a portál jobb felső sarkában, a felhasználói azonosítója alatt találja. Ha nem, válassza a felhasználó ikont, és váltson könyvtárra.

Tipp.

Ha szeretné, használhatja saját Azure-előfizetését. Ehhez jelentkezzen be az Azure Portalra az előfizetés hitelesítő adataival. Győződjön meg arról, hogy az előfizetést tartalmazó könyvtárban dolgozik – a felhasználói azonosító alatt, a jobb felső sarokban. Ha nem, válassza a felhasználó ikont, és váltson könyvtárra.

MongoDB-alkalmazás létrehozása a MongoDB-hez készült Azure Cosmos DBNode.jshasználatával

MongoDB-alkalmazás létrehozása a MongoDB-hez készült Java Azure Cosmos DB használatával

MongoDB-alkalmazás létrehozása Python Azure Cosmos DB használatával, amely a MongoDB-hez készült

MongoDB-alkalmazás létrehozása a MongoDB-hez készült C# Azure Cosmos DB használatával

Ebben a gyakorlatban létrehoz egy Azure Cosmos DB-t MongoDB-fiókhoz, egy adatbázishoz, egy gyűjteményhez, és hozzáad néhány dokumentumot a gyűjteményhez. Láthatja, hogy ez a kód megegyezik azzal, ahogyan bármely MongoDB-adatbázishoz csatlakozna. Ezután bővítményparancsokkal létrehoz egy gyűjteményt, amely lehetővé teszi a gyűjtemény átviteli sebességének meghatározását a kérelemegységekben/mp-ben (kérelemegységekben).

A fejlesztőkörnyezet előkészítése

Ha nem rendelkezik az Azure Cosmos DB-fiókkal és -környezettel, ahol ezen a laboron dolgozik, kövesse az alábbi lépéseket. Ellenkező esetben menjen a kód hozzáadása az adatbázisok, gyűjtemények és dokumentumok létrehozásához c. részhez a App.js fájlban.

Ha nem a környezetet és az Azure Cosmos DB-fiókot használja a laborban, kövesse az alábbi lépéseket. Ellenkező esetben lépjen a Kód hozzáadása a App.java fájlhoz az adatbázisok, gyűjtemények és dokumentumok létrehozásához szakaszra.

Ha nem az Azure Cosmos DB-fiókot és -környezetet használja, ahol a laboron dolgozik, kövesse az alábbi lépéseket. Ellenkező esetben lépjen a Kód hozzáadása elemre az adatbázisok, gyűjtemények és dokumentumok létrehozásához a App.py fájlszakaszban .

Ha nem rendelkezik a környezettel és az Azure Cosmos DB-fiókkal, ahol a laboron dolgozik, kövesse az alábbi lépéseket. Ellenkező esetben lépjen a Kód hozzáadása az adatbázisok, gyűjtemények és dokumentumok létrehozásához az app.cs fájl szakaszra .

Az Azure Cloud Shellben másolja és illessze be a következő parancsokat.

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

Tipp.

Ha nem a laboratóriumi tesztkörnyezetet használja, és meg szeretné adni a helyet, ahol létrehozná az adatbázist és a tároló objektumokat, adjon hozzá egy -l LOCATIONNAME paramétert a init.sh híváshoz. Emellett ha erőforráscsoportot szeretne megadni, adjon hozzá egy -r YOURRRESOURCEGROUPNAMEHERE paramétert a init.sh híváshoz.

Feljegyzés

Ez a bash-szkript létrehozza az Azure Cosmos DB for MongoDB-fiókot. A fiók létrehozása 5-10 percet is igénybe vehet , így érdemes lehet egy csésze kávét vagy teát beszerezni.

Tipp.

Ha visszatér, és a felhőrendszerhéj alaphelyzetbe áll, futtassa a következő parancsokat a cloud shellben a Csomópont 14-es verziójának használatához, ellenkező esetben a következő szakaszban szereplő kód sikertelen lesz.

forrás ~/.nvm/nvm.sh

nvm install 14.0.0

npm link mongodb

Amikor a bash init.sh fájl fut, másolja valahová a kapcsolati sztringet, a Cosmos DB-fiók nevét és az erőforráscsoport nevét , majd a következő szakaszban szükségünk lesz rájuk. A kapcsolati sztring előtt található fióklétrehozó szkript által visszaadott JSON-t is áttekintheti. Ha valahol a JSON közepén keres, akkor a "kind": "MongoDB" tulajdonságnak kell megjelennie.

Feljegyzés

Vegye figyelembe, hogy a kapcsolati sztring, a Cosmos DB-fiók neve és az erőforráscsoport neve is megtalálható az Azure Portalon.

Adja hozzá a kódot az adatbázisok, gyűjtemények és dokumentumok létrehozásához a App.js fájlhoz

Itt az ideje, hogy hozzáadjuk a JavaScript-kódunkat egy adatbázis, egy gyűjtemény létrehozásához és egy dokumentum gyűjteményhez való hozzáadásához.

Adja hozzá a kódot az adatbázisok, gyűjtemények és dokumentumok létrehozásához a App.java fájlhoz

Itt az ideje, hogy hozzáadjuk a Java-kódunkat egy adatbázis, egy gyűjtemény létrehozásához és egy dokumentum gyűjteményhez való hozzáadásához.

Adja hozzá a kódot az adatbázisok, gyűjtemények és dokumentumok létrehozásához a App.py fájlhoz

Itt az ideje, hogy hozzáadjuk a Python-kódunkat egy adatbázis, egy gyűjtemény létrehozásához és egy dokumentum gyűjteményhez való hozzáadásához.

Adja hozzá a kódot az adatbázisok, gyűjtemények és dokumentumok létrehozásához a app.cs fájlhoz

Itt az ideje, hogy hozzáadjuk a C#-kódunkat egy adatbázis, egy gyűjtemény létrehozásához és egy dokumentum gyűjteményhez való hozzáadásához.

Ha még nem nyitotta meg, nyissa meg az Azure Cloud Shellt.

A kódszerkesztő megnyitásához futtassa a következő parancsot.

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

Másolja a következő kódot az alkalmazásfájlba. Ne felejtse el, hogy az előző szakaszban másolt kapcsolati sztring URI-értékét kell lecserélnie.

A kód ezen része a MongoDB-illesztőprogramokat használja, és a kapcsolati sztring használja az Azure Cosmos DB-hez, mintha egy kapcsolati sztring használna bármely MongoDB-kiszolgálóhoz. A kód ezután meghatározza és megnyitja a kapcsolatot az Azure Cosmos DB-fiókkal.

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

A következő lépés a termékek adatbázisához csatlakozik. Ha ez az adatbázis nem létezik, akkor csak akkor hozza létre, ha ugyanabban a kapcsolatban vagy bővítményparancsok használatával is létrehoz egy gyűjteményt. Adja hozzá a következőt a szkripthez a szerkesztőben.

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

Ezután csatlakozunk a dokumentumgyűjteményhez , ha már létezik, majd hozzáad egy dokumentumot a gyűjteményhez. Ha a gyűjtemény nem létezik, ez a kód akkor hozza létre a gyűjteményt, ha ugyanazon a kapcsolaton is végrehajt egy műveletet (például egy dokumentumot a gyűjteményhez ad hozzá), vagy bővítményparancsok használatával. Adja hozzá a következőt a szkripthez a szerkesztőben.


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

Most keresse meg a beszúrt dokumentumot, és jelenítse meg a rendszerhéjban. Adja hozzá a következőt a szkripthez a szerkesztőben.

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

Végül zárjuk be a kapcsolatot. Adja hozzá a következőt a szkripthez a szerkesztőben.

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

A szkriptnek így kell kinéznie:

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

Menjünk tovább, és mentsük a programot. A kódszerkesztő jobb felső sarkában válassza a Mentés (vagy Ctrl+S) lehetőséget. Most válassza a Szerkesztő bezárása (vagy Ctrl+Q) lehetőséget a rendszerhéjhoz való visszatéréshez.

Most futtassa az alkalmazást a következő paranccsal.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Ennek a szkriptnek az alábbihoz hasonló eredményt kell visszaadnia. Ez azt jelenti, hogy létrehoztuk az adatbázist, a gyűjteményt, és hozzáadtunk hozzá egy dokumentumot.

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

Mint látható, ez a kód ugyanaz a kód, amelyet egy MongoDB-adatbázis adatbázisának, gyűjteményének és dokumentumának létrehozásához futtatna. Az Azure Cosmos DB for MongoDB programozásának tehát átláthatónak kell lennie, ha már ismeri a MongoDB-hez csatlakozó alkalmazások létrehozását.

Felügyelt identitások

Éles számítási feladatok esetén javasoljuk, hogy felügyelt identitásokkal hitelesítse magát az Azure Cosmos DB-ben. Így nem kell a kódban tárolnia a kapcsolati sztring. Ebben a következő szakaszban felügyelt identitásokkal fogunk hitelesíteni az Azure Cosmos DB-ben.

Éles környezetben olyan felügyelt identitást kell használnia, amely a legkevésbé szükséges jogosultsággal rendelkezik. Létrehozhat egy vagy több felhasználó által hozzárendelt felügyelt identitást, és hozzárendelheti őket az Azure Cosmos DB-fiókhoz. Ebben a laborban hozzunk létre egy rendszer által hozzárendelt felügyelt identitást az Azure Cosmos DB-fiókhoz.

Az Azure Portalon keresse meg a korábban létrehozott Azure Cosmos DB-fiókot.
A bal oldali menü Beállítások területén válassza az Identitás lehetőséget.
Az Identitás panelen válassza a Hozzárendelt rendszer lehetőséget.
Az állapothoz válassza a Be lehetőséget.
Válassza a Mentés lehetőséget.
A felügyelt identitás létrehozása egy-két percet vesz igénybe.

A felügyelt identitás létrehozása után a felügyelt identitást a szükséges engedélyekkel kell hozzárendelnünk az Azure Cosmos DB-fiókhoz. Ideje az RBAC (szerepköralapú hozzáférés-vezérlés) használatával hozzárendelni a felügyelt identitáshoz a szükséges engedélyeket. Ebben a laborban hozzárendeljük a közreműködői szerepkört a felügyelt identitáshoz, hogy lehetővé tegye az adatok olvasását és írását az Azure Cosmos DB-fiókba. Éles környezetben a legkevésbé szükséges jogosultsági szerepkört kell hozzárendelnie.

Az Azure Portalon keresse meg a korábban létrehozott Azure Cosmos DB-fiókot.
A bal oldali menü Beállítások területén válassza a Hozzáférés-vezérlés (IAM) lehetőséget.
Válassza a + Hozzáadás, majd a Szerepkör-hozzárendelés hozzáadása lehetőséget.
A Kiemelt rendszergazda szerepkör alatt válassza a Közreműködő lehetőséget, majd a Tovább lehetőséget.
A Tagok területen válassza a Felügyelt identitás, majd a + Tagok kijelölése lehetőséget.
A Felügyelt identitások kiválasztása panelen keresse meg a korábban létrehozott felügyelt identitást, jelölje ki, majd válassza a Véleményezés + hozzárendelés lehetőséget.

Most már rendelkezik egy felügyelt identitással az Azure Cosmos DB-fiókhoz a szükséges engedélyekkel. Most használjuk a felügyelt identitást az Azure Cosmos DB-fiókban való hitelesítéshez.

Bővítményparancsok használata az Azure Cosmos DB MongoDB-hez készült API-jában tárolt adatok kezeléséhez

Bár az előző kód megegyezik a MongoDB-kiszolgálóhoz való csatlakozás, majd az Azure Cosmos DB for MongoDB-fiókhoz való csatlakozás között, a kapcsolat nem feltétlenül használja ki az Azure Cosmos DB funkcióit. Ez azt jelenti, hogy az alapértelmezett illesztőprogram-metódusok használatával hozza létre a gyűjteményeket, és az alapértelmezett Azure Cosmos DB-fiókparamétereket is használja a gyűjtemények létrehozásához. Így nem tudjuk definiálni az olyan létrehozási paramétereket, mint az átviteli sebesség, a horizontális skálázási kulcs vagy az automatikus skálázási beállítások ezen metódusok használatával.

Az Azure Cosmos DB MongoDB-hez készült API-jával élvezheti a Cosmos DB előnyeit. Ezek az előnyök közé tartozik a globális terjesztés, az automatikus skálázás, a magas rendelkezésre állás, a késési garanciák, az automatikus, a inaktív titkosítás, a biztonsági mentések és még sok más. Ezen felül a MongoDB-alkalmazásba való befektetés megőrzésének további előnye. Az Azure Cosmos DB MongoDB-hez készült API-jával a nyílt forráskódú MongoDB-ügyfélillesztők bármelyikével kommunikálhat. Az Azure Cosmos DB MongoDB-hez készült API-ja lehetővé teszi a meglévő ügyfélillesztők használatát a MongoDB-drótprotokollhoz való csatlakoztatással.

Hozzunk létre néhány olyan kódot, amely lehetővé teszi egy gyűjtemény létrehozását, valamint a skálázási kulcs és az átviteli sebesség meghatározását.

Ha még nem nyitotta meg, nyissa meg az Azure Cloud Shellt.

A kódszerkesztő megnyitásához futtassa a következő parancsot.

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

Másolja a következő kódot a fájlba.

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

A következő lépés az alkalmazottak adatbázisához csatlakozik. Ha ez az adatbázis nem létezik, akkor csak akkor hozza létre, ha ugyanabban a kapcsolatban vagy bővítményparancsok használatával is létrehoz egy gyűjteményt. Adja hozzá a következőt a szkripthez a szerkesztőben.

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

Eddig úgy néz ki, mint az előző szakaszban szereplő kód. Ebben a lépésben kihasználjuk a bővítményparancsokat, és létrehozunk egy egyéni műveletet. Ez a művelet lehetővé teszi a gyűjtemény átviteli sebességének és skálázási kulcsának meghatározását. A lépés viszont megadja az Azure Cosmos DB-nek a gyűjtemény létrehozásakor használni kívánt paramétereket. Adja hozzá a következőt a szkripthez a szerkesztőben.

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

A többi megegyezik az előző példával. Csatlakozunk a gyűjteményhez, beszúrunk néhány sort, végül lekérdezünk és visszaadunk egy sort. Adja hozzá a következőt a szkripthez a szerkesztőben.

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

A szkriptnek így kell kinéznie:

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

Menjünk tovább, és mentsük a programot. A kódszerkesztő jobb felső sarkában válassza a Mentés (vagy Ctrl+S) lehetőséget. Most válassza a Szerkesztő bezárása (vagy Ctrl+Q) lehetőséget a rendszerhéjhoz való visszatéréshez.

Most futtassa az alkalmazást a következő paranccsal.

node App.js

mvn clean compile exec:java

python App.py

dotnet run

Ennek az alábbihoz hasonló eredményt kell visszaadnia. Ez azt jelenti, hogy létrehoztuk az adatbázist, a gyűjteményt, és hozzáadtunk hozzá egy dokumentumot.

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

Ez az utolsó eredményhalmaz azonban csak megerősítette, hogy valóban létrehoztunk egy adatbázist, gyűjteményt és dokumentumot, de mi a helyzet a szegmenskulcsunkkal és az átviteli sebességünkkel, valóban megváltoztak? A Cloud Shellben futtassa az alábbi parancsokat a módosítások érvénybe lépésének ellenőrzéséhez.
1. Ellenőrizzük, hogy a shard kulcs EmployeeId értékre változott-e (az alapértelmezett id). Ne felejtse el módosítani az erőforráscsoport nevét és a fiók nevét azokra a nevekre, amelyeket a labor elején elmentettünk.
```
az cosmosdb mongodb collection show --name Employee --database-name HumanResources --resource-group learn-20c8df29-1419-49f3-84bb-6613f052b5ae --account-name learn-account-cosmos-845083734
```
  Az eredménynek tartalmaznia kell a "shardKey": {"EmployeeId": "Hash" } tulajdonságot.
2. Ellenőrizzük, hogy az átviteli sebességünk 1000-re változott-e (az alapértelmezett érték 400). Ne felejtse el módosítani az erőforráscsoport nevét és a fiók nevét azokra a nevekre, amelyeket a labor elején elmentettünk.
```
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
```
  Az eredménynek tartalmaznia kell az "átviteli sebesség" tulajdonságot: 1000.

Ez a kód a kiterjesztett parancsok használatát szemlélteti a kódban, amely lehetővé teszi az Azure Cosmos DB létrehozási paramétereinek meghatározását. Ez lehetővé teszi, hogy kihasználjuk a gyűjtemények Azure Cosmos DB általi létrehozásának és feldolgozásának szabályozását.

A gyakorlat elvégzése után folytassa a modulhoz tartozó tudáspróba kérdéseivel.

Visszajelzés

Hasznosnak találta ezt az oldalt?