Exercício – Criar um aplicativo de banco de dados do MongoDB usando o Azure Cosmos DB for MongoDB

  • 35 minutos

É hora de verificar programaticamente como criar nossos bancos de dados e coleções do Azure Cosmos DB para MongoDB e como adicionar alguns dados.

Este exercício pode ser concluído usando uma área restrita do Microsoft learn, que fornece uma assinatura temporária do Azure. Para ativar a assinatura da área restrita, você deve entrar usando um conta Microsoft. A assinatura da área restrita será excluída automaticamente quando você concluir este módulo. Depois que a área restrita for ativada, entre no portal do Azure usando as credenciais da sua assinatura de área restrita. Verifique se você está trabalhando no diretório da área restrita do Microsoft Learn, indicado no canto superior direito do portal, sob sua ID de usuário. Caso contrário, selecione o ícone de usuário e o troque o diretório.

Dica

Se preferir, você pode usar sua própria assinatura do Azure. Para fazer isso, entre no portal do Azure usando as credenciais da sua assinatura. Verifique se você está trabalhando no diretório que contém sua assinatura, indicado no canto superior direito sob sua ID de usuário. Caso contrário, selecione o ícone de usuário e o troque o diretório.

Criar um aplicativo do MongoDB usando o Azure Cosmos DB for MongoDB do Node.js

Neste exercício, você vai criar uma conta, um banco de dados e uma coleção do Azure Cosmos DB for MongoDB e adicionar alguns documentos à coleção. Você observará que esse código será idêntico à maneira como você se conectaria a qualquer banco de dados do MongoDB. Em seguida, você criará uma coleção usando comandos de extensão que permitem definir a taxa de transferência em RUs (Unidades de Solicitação/s) para a coleção.

Preparar seu ambiente de desenvolvimento

Se você ainda não preparou a conta e o ambiente do Azure Cosmos DB em que está trabalhando neste laboratório, siga estas etapas para fazer isso. Caso contrário, vá para a seção Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo App.js.

  1. No Azure Cloud Shell, copie e cole os comandos a seguir.

    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

    Dica

    Se você não estiver usando a área restrita no laboratório e quiser especificar a localização em que deseja criar o banco de dados e os objetos de armazenamento, adicione um parâmetro -l LOCATIONNAME à chamada a init.sh. Além disso, se você quiser especificar um grupo de recursos, adicione um parâmetro -r YOURRRESOURCEGROUPNAMEHERE à chamada a init.sh.

    Observação

    Esse script do bash criará a conta do Azure Cosmos DB for MongoDB. Pode levar de 5 a 10 minutos para criar essa conta, então pode ser uma boa hora para tomar uma xícara de café ou chá.

    Dica

    Se você voltar e o cloud shell tiver sido redefinido, execute os seguintes comandos no cloud shell para usar o Node versão 14, caso contrário, o código da próxima seção falhará.

    1. source ~/.nvm/nvm.sh
    2. nvm install 14.0.0
    3. npm link mongodb

  2. Quando o arquivo init.sh do bash concluir a execução, copie em algum lugar a Cadeia de Conexão, o Nome da conta do Cosmos DB e o Nome do Grupo de Recursos retornados; precisaremos dessas informações na próxima seção. Você também pode examinar o JSON retornado pelo script de criação da conta localizado antes da cadeia de conexão. Se você procurar em algum lugar nesse JSON, verá a propriedade "kind": "MongoDB".

    Observação

    A Cadeia de conexão, o Nome da conta do Cosmos DB e o Nome do grupo de recursos também podem ser encontrados usando o portal do Azure.

Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo App.js

Agora vamos adicionar nosso código JavaScript para criar um Banco de Dados, uma Coleção e adicionar um documento à coleção.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir no arquivo App.js. Não se esqueça de que você precisará substituir o valor da URL pela cadeia de conexão copiada na etapa 2 da seção anterior. A cadeia de conexão deverá ter essa aparência

    mongodb://learn-account-cosmos-92903170:XvrarRd8LnqWNZiq3ahHXngbZoVRxVO192WahrcdsmHVivBGbRqnHx2cq0oMGnc0DUPAWpyGu7kt7APVH4nqXg==@learn-account-cosmos-92903170.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@learn-account-cosmos-92903170@.

    Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

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

async function main() {

  // Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
  // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
  // Or replace it with the connection string if you have it.
  var url = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@";

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

  4. A próxima etapa se conecta ao banco de dados de produtos. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Em seguida, nos conectaremos à coleção de documentos, se ela já existir, e adicionaremos um documento à coleção. Observe que, se a coleção não existir, esse código só criará a coleção se ele também executar uma operação nessa coleção na mesma conexão (por exemplo, como adicionar um documento à coleção) ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  6. Agora, vamos pesquisar o documento que acabamos de inserir e exibi-lo no shell. Adicione o que vem a seguir ao script no editor.

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

  7. Por fim, vamos fechar a conexão e chamar a função main para executá-la. Adicione o que vem a seguir ao script no editor.

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

main();

  8. O script deve parecer com este:

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

async function main() {

  // Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
  // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
  // Or replace it with the connection string if you have it.
  var url = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@";

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

  9. Vamos continuar e salvar o programa JavaScript. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  10. Agora, vamos executar o Aplicativo JavaScript com o comando a seguir.

    node App.js

  11. O resultado deverá ser semelhante ao que está abaixo. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

Como você deve ter notado, esse código é o mesmo código que você executaria para criar um banco de dados, uma coleção e um documento em um banco de dados MongoDB. Portanto, a programação relacionada ao Azure Cosmos DB for MongoDB será fácil se você já estiver familiarizado com a criação de aplicativos que se conectam ao MongoDB.

Usar comandos de extensão para gerenciar dados armazenados na API do Azure Cosmos DB para MongoDB

Embora o código acima, exceto pela cadeia de conexão, seja idêntico para a conexão com um servidor MongoDB e a conexão com a conta do Azure Cosmos DB for MongoDB, talvez ele não aproveite os recursos do Azure Cosmos DB. Isso significa que o uso dos métodos de driver padrão para criar nossas coleções, também usará os parâmetros padrão da Conta do Azure Cosmos DB para criar essas coleções. Portanto, não poderemos definir parâmetros de criação, como a taxa de transferência, a chave de fragmentação nem as configurações de dimensionamento automático usando esses métodos.

Usando a API do Azure Cosmos DB para MongoDB, você pode aproveitar os benefícios do Cosmos DB, como distribuição global, fragmentação automática, alta disponibilidade, garantias de latência, automático, criptografia em repouso, backups e muito mais, preservando seus investimentos em seu aplicativo MongoDB. Você pode usar qualquer um dos drivers para cliente do MongoDB open-source para se comunicar com a API do Azure Cosmos DB para MongoDB. A API do Azure Cosmos DB para MongoDB permite o uso de drivers de cliente existentes ao aderir ao protocolo de transmissão do MongoDB.

Vamos criar um código que nos permitirá criar uma coleção e definir sua chave de fragmentação e taxa de transferência.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir e substitua o conteúdo existente do arquivo app.cs. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

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

async function main() {

  // Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
  // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
  // Or replace it with the connection string if you have it.
  var url = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@";

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

  4. A próxima etapa se conecta ao banco de dados de funcionários. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Até agora, ele se parece muito com o código da seção anterior. Nesta etapa, aproveitaremos os comandos de extensão e criaremos uma ação personalizada. Essa ação nos permitirá definir a taxa de transferência e a chave de fragmentação da coleção, o que, por sua vez, dará ao Azure Cosmos DB os parâmetros a serem usados ao criar a coleção. Adicione o que vem a seguir ao script no editor.

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

  6. O restante será bastante idêntico ao exemplo anterior: vamos nos conectar à coleção, inserir algumas linhas e, por fim, consultar e gerar uma linha de volta. Adicione o que vem a seguir ao script no editor.

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

  7. O script deve parecer com este:

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

async function main() {

  // Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
  // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
  // Or replace it with the connection string if you have it.
  var url = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@";

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

  8. Vamos salvar o programa Node.js. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  9. Agora, vamos executar o Aplicativo Node.js com o comando a seguir.

    node App.js

  10. O resultado deverá ser semelhante ao que está abaixo. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

  11. No entanto, este último conjunto de resultados só confirmou que realmente criamos um banco de dados, uma coleção e os documentos, mas e quanto à chave de fragmentação e à taxa de transferência, elas realmente mudaram? No Cloud Shell vamos executar os comandos a seguir para verificar se nossas alterações entraram em vigor.

    1. Vamos verificar se nossa chave de fragmentação foi alterada para EmployeeId (o padrão é id). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

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

      O resultado deve incluir a propriedade "shardKey": {"EmployeeId": "Hash"}.

    2. Vamos verificar se nossa taxa de transferência foi alterada para 1000 (o padrão é 400). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

      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

      O resultado deve incluir a propriedade "throughput": 1000.

Esse código ilustrou o potencial do uso de comandos estendidos em nosso código, o que nos permite definir os parâmetros de criação do Azure Cosmos DB. Isso nos permite aproveitar o controle de como nossas coleções serão criadas e processadas pelo Azure Cosmos DB.

Criar um aplicativo do MongoDB usando o Azure Cosmos DB for MongoDB do Java

Neste exercício, você vai criar uma conta, um banco de dados e uma coleção do Azure Cosmos DB for MongoDB e adicionar alguns documentos à coleção. Você observará que esse código será idêntico à maneira como você se conectaria a qualquer banco de dados do MongoDB. Para usar o mecanismo Java, criaremos e compilaremos um aplicativo que executa o Maven. Em seguida, você criará uma coleção usando comandos de extensão que permitem definir a taxa de transferência em RUs (Unidades de Solicitação) para a coleção.

Preparar seu ambiente de desenvolvimento

Se você ainda não preparou o ambiente e a conta do Azure Cosmos DB em que está trabalhando neste laboratório, siga estas etapas para fazer isso. Caso contrário, vá para a seção Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo App.java.

  1. No Azure Cloud Shell, copie e cole os comandos a seguir.

    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

    Dica

    Se você não estiver usando a área restrita no laboratório e quiser especificar a localização em que deseja criar o banco de dados e os objetos de armazenamento, adicione um parâmetro -l LOCATIONNAME à chamada a init.sh. Além disso, se você quiser especificar um grupo de recursos, adicione um parâmetro -r YOURRRESOURCEGROUPNAMEHERE à chamada a init.sh.

    Observação

    Esse script do bash criará a conta do Azure Cosmos DB for MongoDB. Pode levar de 5 a 10 minutos para criar essa conta, então pode ser uma boa hora para tomar uma xícara de café ou chá.

  2. Quando o arquivo init.sh do bash concluir a execução, copie em algum lugar a Cadeia de Conexão, o Nome da conta do Cosmos DB e o Nome do Grupo de Recursos retornados; precisaremos dessas informações na próxima seção. Você também pode examinar o JSON retornado pelo script de criação da conta localizado antes da cadeia de conexão. Se você procurar em algum lugar nesse JSON, verá a propriedade "kind": "MongoDB".

    Observação

    Observe que a Cadeia de conexão, o Nome da conta do Cosmos DB e o Nome do grupo de recursos também podem ser encontrados usando o portal do Azure.

Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo App.java

Agora vamos adicionar nosso código Java para criar um Banco de Dados, uma Coleção e adicionar um documento à coleção.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir e substitua o conteúdo existente do arquivo App.java. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. A cadeia de conexão deverá ter essa aparência

    mongodb://learn-account-cosmos-92903170:XvrarRd8LnqWNZiq3ahHXngbZoVRxVO192WahrcdsmHVivBGbRqnHx2cq0oMGnc0DUPAWpyGu7kt7APVH4nqXg==@learn-account-cosmos-92903170.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@learn-account-cosmos-92903170@.

    Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

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

        // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
        // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
        // Or replace it with the connection string if you have it.
        MongoClientURI uri = new MongoClientURI("mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@");

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

  4. A próxima etapa se conecta ao banco de dados de produtos. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Em seguida, nos conectaremos à coleção de documentos, se ela já existir, e adicionaremos um documento à coleção. Observe que, se a coleção não existir, esse código só criará a coleção se ele também executar uma operação nessa coleção na mesma conexão (por exemplo, como adicionar um documento à coleção) ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  6. Agora, vamos pesquisar o documento que acabamos de inserir e exibi-lo no shell. Adicione o que vem a seguir ao script no editor.

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

  7. Por fim, vamos fechar a conexão. Adicione o que vem a seguir ao script no editor.

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

  8. O script deve parecer com este:

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

        // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
        // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
        // Or replace it with the connection string if you have it.
        MongoClientURI uri = new MongoClientURI("mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@");

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

  9. Vamos continuar e salvar o programa Java. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  10. Agora, vamos executar o Aplicativo Java com o comando a seguir.

    mvn clean compile exec:java

  11. O resultado deverá ser semelhante ao que está abaixo. Como mencionamos no início deste exercício, estamos usando o Maven para criar e compilar este aplicativo. Você observará que essa saída é muito detalhada; isso é normal, pois essa saída geralmente é direcionada para um arquivo de log. No entanto, no final, você deverá ver a mensagem INFO abaixo com os resultados JSON da consulta ProductId = 1 em nosso código. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

    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.

Como você deve ter notado, esse código é o mesmo código que você executaria para criar um banco de dados, uma coleção e um documento em um banco de dados MongoDB. Portanto, a programação relacionada ao Azure Cosmos DB for MongoDB será fácil se você já estiver familiarizado com a criação de aplicativos que se conectam ao MongoDB.

Usar comandos de extensão para gerenciar dados armazenados na API do Azure Cosmos DB para MongoDB

Embora o código acima, exceto pela cadeia de conexão, seja idêntico para a conexão com um servidor MongoDB e a conexão com a conta do Azure Cosmos DB for MongoDB, talvez ele não aproveite os recursos do Azure Cosmos DB. Isso significa que o uso dos métodos de driver padrão para criar nossas coleções, também usará os parâmetros padrão da Conta do Azure Cosmos DB para criar essas coleções. Portanto, não poderemos definir parâmetros de criação, como a taxa de transferência, a chave de fragmentação nem as configurações de dimensionamento automático usando esses métodos.

Usando a API do Azure Cosmos DB para MongoDB, você pode aproveitar os benefícios do Cosmos DB, como distribuição global, fragmentação automática, alta disponibilidade, garantias de latência, automático, criptografia em repouso, backups e muito mais, preservando seus investimentos em seu aplicativo MongoDB. Você pode usar qualquer um dos drivers para cliente do MongoDB open-source para se comunicar com a API do Azure Cosmos DB para MongoDB. A API do Azure Cosmos DB para MongoDB permite o uso de drivers de cliente existentes ao aderir ao protocolo de transmissão do MongoDB.

Vamos criar um código que nos permitirá criar uma coleção e definir sua chave de fragmentação e taxa de transferência.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir e substitua o conteúdo existente do arquivo App.java. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

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

        // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
        // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
        // Or replace it with the connection string if you have it.
        MongoClientURI uri = new MongoClientURI("mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@");

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

  4. A próxima etapa se conecta ao banco de dados de funcionários. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Até agora, ele se parece muito com o código da seção anterior. Nesta etapa, aproveitaremos os comandos de extensão e criaremos uma ação personalizada. Essa ação nos permitirá definir a taxa de transferência e a chave de fragmentação da coleção, o que, por sua vez, dará ao Azure Cosmos DB os parâmetros a serem usados ao criar a coleção. Adicione o que vem a seguir ao script no editor.

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

  6. O restante será bastante idêntico ao exemplo anterior: vamos nos conectar à coleção, inserir algumas linhas, consultar e gerar uma linha de volta e, por fim, fechar a conexão. Adicione o que vem a seguir ao script no editor.

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

  7. O script deve parecer com este:

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

        // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
        // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
        // Or replace it with the connection string if you have it.
        MongoClientURI uri = new MongoClientURI("mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@");

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

  8. Vamos continuar e salvar o programa Java. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  9. Agora, vamos executar o Aplicativo Java com o comando a seguir.

    mvn clean compile exec:java

  10. O resultado deverá ser semelhante ao que está abaixo. Como mencionamos no início deste exercício, estamos usando o Maven para criar e compilar este aplicativo. Você observará que essa saída é muito detalhada; isso é normal, pois essa saída geralmente é direcionada para um arquivo de log. No entanto, no final, você deverá ver a mensagem INFO abaixo com os resultados JSON da consulta EmployeeId = 1 em nosso código. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

  11. No entanto, este último conjunto de resultados só confirmou que realmente criamos um banco de dados, uma coleção e os documentos, mas e quanto à chave de fragmentação e à taxa de transferência, elas realmente mudaram? No Cloud Shell vamos executar os comandos a seguir para verificar se nossas alterações entraram em vigor.

    1. Vamos verificar se nossa chave de fragmentação foi alterada para EmployeeId (o padrão é id). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

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

      O resultado deve incluir a propriedade "shardKey": {"EmployeeId": "Hash"}.

    2. Vamos verificar se nossa taxa de transferência foi alterada para 1000 (o padrão é 400). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

      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

      O resultado deve incluir a propriedade "throughput": 1000.

Esse código ilustrou o potencial do uso de comandos estendidos em nosso código, o que nos permite definir os parâmetros de criação do Azure Cosmos DB. Isso nos permite aproveitar o controle de como nossas coleções serão criadas e processadas pelo Azure Cosmos DB.

Criar um aplicativo do MongoDB usando o Azure Cosmos DB for MongoDB do Python

Neste exercício, você vai criar uma conta, um banco de dados e uma coleção do Azure Cosmos DB for MongoDB e adicionar alguns documentos à coleção. Você observará que esse código será idêntico à maneira como você se conectaria a qualquer banco de dados do MongoDB. Em seguida, você criará uma coleção usando comandos de extensão que permitem definir a taxa de transferência em RUs (Unidades de Solicitação/s) para a coleção.

Preparar seu ambiente de desenvolvimento

Se você ainda não preparou a conta e o ambiente do Azure Cosmos DB em que está trabalhando neste laboratório, siga estas etapas para fazer isso. Caso contrário, vá para a seção Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo App.py.

  1. No Azure Cloud Shell, copie e cole os comandos a seguir.

    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

    Dica

    Se você não estiver usando a área restrita no laboratório e quiser especificar a localização em que deseja criar o banco de dados e os objetos de armazenamento, adicione um parâmetro -l LOCATIONNAME à chamada a init.sh. Além disso, se você quiser especificar um grupo de recursos, adicione um parâmetro -r YOURRRESOURCEGROUPNAMEHERE à chamada a init.sh.

    Observação

    Esse script do bash criará a conta do Azure Cosmos DB for MongoDB. Pode levar de 5 a 10 minutos para criar essa conta, então pode ser uma boa hora para tomar uma xícara de café ou chá.

  2. Quando o arquivo init.sh do bash concluir a execução, copie em algum lugar a Cadeia de Conexão, o Nome da conta do Cosmos DB e o Nome do Grupo de Recursos retornados; precisaremos dessas informações na próxima seção. Você também pode examinar o JSON retornado pelo script de criação da conta localizado antes da cadeia de conexão. Se você procurar em algum lugar nesse JSON, verá a propriedade "kind": "MongoDB".

    Observação

    A Cadeia de conexão, o Nome da conta do Cosmos DB e o Nome do grupo de recursos também podem ser encontrados usando o portal do Azure.

Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo App.py

Agora vamos adicionar nosso código Python para criar um Banco de Dados, uma Coleção e adicionar um documento à coleção.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir no arquivo App.js. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. A cadeia de conexão deverá ter essa aparência

    mongodb://learn-account-cosmos-92903170:XvrarRd8LnqWNZiq3ahHXngbZoVRxVO192WahrcdsmHVivBGbRqnHx2cq0oMGnc0DUPAWpyGu7kt7APVH4nqXg==@learn-account-cosmos-92903170.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@learn-account-cosmos-92903170@.

    Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

    # Use the MongoDB drivers
import pymongo


def main():
    # Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB
    # account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    # Or replace it with the connection string if you have it.
    uri = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@"

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

    ```

  4. A próxima etapa se conecta ao banco de dados de produtos. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Em seguida, nos conectaremos à coleção de documentos, se ela já existir, e adicionaremos um documento à coleção. Observe que, se a coleção não existir, esse código só criará a coleção se ele também executar uma operação nessa coleção na mesma conexão (por exemplo, como adicionar um documento à coleção) ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  6. Agora, vamos pesquisar o documento que acabamos de inserir e exibi-lo no shell. Adicione o que vem a seguir ao script no editor.

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

    print(Product_1)

  7. Por fim, vamos fechar a conexão e chamar a função main para executá-la. Adicione o que vem a seguir ao script no editor.

        # close the connection
    client.close()

if __name__ == '__main__':
    main()

  8. O script deve parecer com este:

    # Use the MongoDB drivers
import pymongo

def main():
    # Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB
    # account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    # Or replace it with the connection string if you have it.
    uri = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@"

    # 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()

  9. Vamos continuar e salvar o programa Python. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  10. Agora, vamos executar o Aplicativo Python com o comando a seguir.

    python App.py

  11. O resultado deverá ser semelhante ao que está abaixo. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

Como você deve ter notado, esse código é o mesmo código que você executaria para criar um banco de dados, uma coleção e um documento em um banco de dados MongoDB. Portanto, a programação relacionada ao Azure Cosmos DB for MongoDB será fácil se você já estiver familiarizado com a criação de aplicativos que se conectam ao MongoDB.

Usar comandos de extensão para gerenciar dados armazenados na API do Azure Cosmos DB para MongoDB

Embora o código acima, exceto pela cadeia de conexão, seja idêntico para a conexão com um servidor MongoDB e a conexão com a conta do Azure Cosmos DB for MongoDB, talvez ele não aproveite os recursos do Azure Cosmos DB. Isso significa que o uso dos métodos de driver padrão para criar nossas coleções, também usará os parâmetros padrão da Conta do Azure Cosmos DB para criar essas coleções. Portanto, não poderemos definir parâmetros de criação, como a taxa de transferência, a chave de fragmentação nem as configurações de dimensionamento automático usando esses métodos.

Usando a API do Azure Cosmos DB para MongoDB, você pode aproveitar os benefícios do Cosmos DB, como distribuição global, fragmentação automática, alta disponibilidade, garantias de latência, automático, criptografia em repouso, backups e muito mais, preservando seus investimentos em seu aplicativo MongoDB. Você pode usar qualquer um dos drivers para cliente do MongoDB open-source para se comunicar com a API do Azure Cosmos DB para MongoDB. A API do Azure Cosmos DB para MongoDB permite o uso de drivers de cliente existentes ao aderir ao protocolo de transmissão do MongoDB.

Vamos criar um código que nos permitirá criar uma coleção e definir sua chave de fragmentação e taxa de transferência.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir e substitua o conteúdo existente do arquivo app.cs. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

    # Use the MongoDB drivers
import pymongo

def main():
    # Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB
    # account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    # Or replace it with the connection string if you have it.
    uri = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@"

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

  4. A próxima etapa se conecta ao banco de dados de funcionários. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Até agora, ele se parece muito com o código da seção anterior. Nesta etapa, aproveitaremos os comandos de extensão e criaremos uma ação personalizada. Essa ação nos permitirá definir a taxa de transferência e a chave de fragmentação da coleção, o que, por sua vez, dará ao Azure Cosmos DB os parâmetros a serem usados ao criar a coleção. Adicione o que vem a seguir ao script no editor.

        # 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"})

  6. O restante será bastante idêntico ao exemplo anterior: vamos nos conectar à coleção, inserir algumas linhas e, por fim, consultar e gerar uma linha de volta. Adicione o que vem a seguir ao script no editor.

        # 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()

  7. O script deve parecer com este:

    # Use the MongoDB drivers
import pymongo

def main():
    # Replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB
    # account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    # Or replace it with the connection string if you have it.
    uri = "mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@"

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

    # 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()

  8. Vamos continuar e salvar o programa Python. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  9. Agora, vamos executar o Aplicativo Python com o comando a seguir.

    python App.py

  10. O resultado deverá ser semelhante ao que está abaixo. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

  11. No entanto, este último conjunto de resultados só confirmou que realmente criamos um banco de dados, uma coleção e os documentos, mas e quanto à chave de fragmentação e à taxa de transferência, elas realmente mudaram? No Cloud Shell vamos executar os comandos a seguir para verificar se nossas alterações entraram em vigor.

    1. Vamos verificar se nossa chave de fragmentação foi alterada para EmployeeId (o padrão é id). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

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

      O resultado deve incluir a propriedade "shardKey": {"EmployeeId": "Hash"}.

    2. Vamos verificar se nossa taxa de transferência foi alterada para 1000 (o padrão é 400). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

      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

      O resultado deve incluir a propriedade "throughput": 1000.

Esse código ilustrou o potencial do uso de comandos estendidos em nosso código, o que nos permite definir os parâmetros de criação do Azure Cosmos DB. Isso nos permite aproveitar o controle de como nossas coleções serão criadas e processadas pelo Azure Cosmos DB.

Criar um aplicativo do MongoDB usando o Azure Cosmos DB for MongoDB do C#

Neste exercício, você vai criar uma conta, um banco de dados e uma coleção do Azure Cosmos DB for MongoDB e adicionar alguns documentos à coleção. Você observará que esse código será idêntico à maneira como você se conectaria a qualquer banco de dados do MongoDB. Em seguida, você criará uma coleção usando comandos de extensão que permitem definir a taxa de transferência em RUs (Unidades de Solicitação) para a coleção.

Preparar seu ambiente de desenvolvimento

Se você ainda não preparou o ambiente e a conta do Azure Cosmos DB em que está trabalhando neste laboratório, siga estas etapas para fazer isso. Caso contrário, vá para a seção Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo app.cs.

  1. No Azure Cloud Shell, copie e cole os comandos a seguir.

    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

    Dica

    Se você não estiver usando a área restrita no laboratório e quiser especificar a localização em que deseja criar o banco de dados e os objetos de armazenamento, adicione um parâmetro -l LOCATIONNAME à chamada a init.sh. Além disso, se você quiser especificar um grupo de recursos, adicione um parâmetro -r YOURRRESOURCEGROUPNAMEHERE à chamada a init.sh.

    Observação

    Esse script do bash criará a conta do Azure Cosmos DB for MongoDB. Pode levar de 5 a 10 minutos para criar essa conta, então pode ser uma boa hora para tomar uma xícara de café ou chá.

  2. Quando o arquivo init.sh do bash concluir a execução, copie em algum lugar a Cadeia de Conexão, o Nome da conta do Cosmos DB e o Nome do Grupo de Recursos retornados; precisaremos dessas informações na próxima seção. Você também pode examinar o JSON retornado pelo script de criação da conta localizado antes da cadeia de conexão. Se você procurar em algum lugar nesse JSON, verá a propriedade "kind": "MongoDB".

    Observação

    Observe que a Cadeia de conexão, o Nome da conta do Cosmos DB e o Nome do grupo de recursos também podem ser encontrados usando o portal do Azure.

Adicionar o código para criar os bancos de dados, a coleção e o documento no arquivo app.cs

Agora vamos adicionar nosso código C# para criar um Banco de Dados, uma Coleção e adicionar um documento à coleção.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir e substitua o conteúdo existente do arquivo app.cs. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. A cadeia de conexão deverá ter essa aparência

    mongodb://learn-account-cosmos-92903170:XvrarRd8LnqWNZiq3ahHXngbZoVRxVO192WahrcdsmHVivBGbRqnHx2cq0oMGnc0DUPAWpyGu7kt7APVH4nqXg==@learn-account-cosmos-92903170.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@learn-account-cosmos-92903170@.

    Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

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

    // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
    // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    // Or replace it with the connection string if you have it.
    string connectionString = 
      @"mongodb://calopezdp420mongodb01:6CKYlfyagNSQ2ZmP8XEmc2Z6gozF6NkIJ6w1WoYFehZ8Z3842jEhz7xRBl7KeGX2QajQt54Y2g9bJ9MZXU8Z9Q==@calopezdp420mongodb01.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@calopezdp420mongodb01@";

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

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

  4. A próxima etapa se conecta ao banco de dados de produtos. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Em seguida, nos conectaremos à coleção de documentos, se ela já existir, e adicionaremos um documento à coleção. Observe que, se a coleção não existir, esse código só criará a coleção se ele também executar uma operação nessa coleção na mesma conexão (por exemplo, como adicionar um documento à coleção) ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

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

  6. Agora, vamos pesquisar o documento que acabamos de inserir e exibi-lo no shell. Adicione o que vem a seguir ao script no editor.

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

  7. O script deve parecer com este:

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

    // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
    // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    // Or replace it with the connection string if you have it.
    string connectionString = 
      @"mongodb://calopezdp420mongodb01:6CKYlfyagNSQ2ZmP8XEmc2Z6gozF6NkIJ6w1WoYFehZ8Z3842jEhz7xRBl7KeGX2QajQt54Y2g9bJ9MZXU8Z9Q==@calopezdp420mongodb01.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@calopezdp420mongodb01@";

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

  8. Vamos continuar e salvar o programa C#. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  9. Agora, vamos executar o Aplicativo C# com o comando a seguir.

    dotnet run

  10. O resultado deverá ser semelhante ao que está abaixo. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

Como você deve ter notado, esse código é o mesmo código que você executaria para criar um banco de dados, uma coleção e um documento em um banco de dados MongoDB. Portanto, a programação relacionada ao Azure Cosmos DB for MongoDB será fácil se você já estiver familiarizado com a criação de aplicativos que se conectam ao MongoDB.

Usar comandos de extensão para gerenciar dados armazenados na API do Azure Cosmos DB para MongoDB

Embora o código acima, exceto pela cadeia de conexão, seja idêntico para a conexão com um servidor MongoDB e a conexão com a conta do Azure Cosmos DB for MongoDB, talvez ele não aproveite os recursos do Azure Cosmos DB. Isso significa que o uso dos métodos de driver padrão para criar nossas coleções, também usará os parâmetros padrão da Conta do Azure Cosmos DB para criar essas coleções. Portanto, não poderemos definir parâmetros de criação, como a taxa de transferência, a chave de fragmentação nem as configurações de dimensionamento automático usando esses métodos.

Usando a API do Azure Cosmos DB para MongoDB, você pode aproveitar os benefícios do Cosmos DB, como distribuição global, fragmentação automática, alta disponibilidade, garantias de latência, automático, criptografia em repouso, backups e muito mais, preservando seus investimentos em seu aplicativo MongoDB. Você pode usar qualquer um dos drivers para cliente do MongoDB open-source para se comunicar com a API do Azure Cosmos DB para MongoDB. A API do Azure Cosmos DB para MongoDB permite o uso de drivers de cliente existentes ao aderir ao protocolo de transmissão do MongoDB.

Vamos criar um código que nos permitirá criar uma coleção e definir sua chave de fragmentação e taxa de transferência.

  1. Se ainda não estiver aberto, abra o Azure Cloud Shell.

  2. Execute o comando a seguir para abrir o editor de código.

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

  3. Copie o código a seguir e substitua o conteúdo existente do arquivo app.cs. Não se esqueça de que você precisará substituir o valor do URI pela cadeia de conexão copiada na etapa 2 da seção anterior. Essa parte do código usa os drivers do MongoDB e usa a cadeia de conexão para o Azure Cosmos DB, assim como você normalmente usaria uma cadeia de conexão para qualquer servidor MongoDB. Em seguida, o código define e abre a conexão com a conta do Azure Cosmos DB.

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

  public class Employees {
    public ObjectId Id { get; set; }  
    public int EmployeeId { get; set; }
    public string email { get; set; }
    public string name { get; set; }
  }

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

    // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
    // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    // Or replace it with the connection string if you have it.
    string connectionString = 
      @"mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@";

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

    // We use the "MongoClient" method and the "settings" value to connect to the account 
    var mongoClient = new MongoClient(settings);

  4. A próxima etapa se conecta ao banco de dados de funcionários. Observe que, se esse banco de dados não existir, o código o criará somente se também criar uma coleção na mesma conexão ou usando comandos de extensão. Adicione o que vem a seguir ao script no editor.

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

  5. Até agora, ele se parece muito com o código da seção anterior. Nesta etapa, aproveitaremos os comandos de extensão e criaremos uma ação personalizada. Essa ação nos permitirá definir a taxa de transferência e a chave de fragmentação da coleção, o que, por sua vez, dará ao Azure Cosmos DB os parâmetros a serem usados ao criar a coleção. Adicione o que vem a seguir ao script no editor.

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

  6. O restante será bastante idêntico ao exemplo anterior: vamos nos conectar à coleção, inserir algumas linhas e, por fim, consultar e gerar uma linha de volta. Adicione o que vem a seguir ao script no editor.

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

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

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

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

  7. O script deve parecer com este:

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

  public class Employees {
    public ObjectId Id { get; set; }  
    public int EmployeeId { get; set; }
    public string email { get; set; }
    public string name { get; set; }
  }

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

    // Remember to replace below "YourAzureCosmosDBAccount" with the name of your Azure Cosmos DB 
    // account name and "YourAzureCosmosDBAccountKEY" with the Azure Cosmos DB account key.
    // Or replace it with the connection string if you have it.
    string connectionString = 
      @"mongodb://YourAzureCosmosDBAccount:YourAzureCosmosDBAccountKEY@YourAzureCosmosDBAccount.mongo.cosmos.azure.com:10255/?ssl=true&retrywrites=false&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@YourAzureCosmosDBAccount@";

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

    // We use the "MongoClient" method and the "settings" value to connect to the account 
    var mongoClient = new MongoClient(settings);

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

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

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

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

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

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

  8. Vamos continuar e salvar o programa C#. Selecione no canto superior direito do editor de código e escolha Salvar (ou Ctrl+S). Agora, selecione Fechar Editor (ou Ctrl+Q) para voltar ao Shell.

  9. Agora, vamos executar o Aplicativo C# com o comando a seguir.

    dotnet run

  10. O resultado deverá ser semelhante ao que está abaixo. Isso significa que criamos o banco de dados, a coleção e adicionamos um documento a ela.

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

  11. No entanto, este último conjunto de resultados só confirmou que realmente criamos um banco de dados, uma coleção e os documentos, mas e quanto à chave de fragmentação e à taxa de transferência, elas realmente mudaram? No Cloud Shell vamos executar os comandos a seguir para verificar se nossas alterações entraram em vigor.

    1. Vamos verificar se nossa chave de fragmentação foi alterada para EmployeeId (o padrão é id). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

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

      O resultado deve incluir a propriedade "shardKey": {"EmployeeId": "Hash"}.

    2. Vamos verificar se nossa taxa de transferência foi alterada para 1000 (o padrão é 400). Não se esqueça de alterar o nome do grupo de recursos e o nome da conta com os nomes que salvamos no início deste laboratório.

      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

      O resultado deve incluir a propriedade "throughput": 1000.

Esse código ilustrou o potencial do uso de comandos estendidos em nosso código, o que nos permite definir os parâmetros de criação do Azure Cosmos DB. Isso nos permite aproveitar o controle de como nossas coleções serão criadas e processadas pelo Azure Cosmos DB.

Depois de concluir este exercício, continue nas perguntas de verificação de conhecimentos deste módulo.