Connettere un'applicazione Node.js Mongoose ad Azure Cosmos DBConnect a Node.js Mongoose application to Azure Cosmos DB

SI APPLICA A: API di Azure Cosmos DB per MongoDB

Questa esercitazione dimostra come usare il framework Mongoose quando si archiviano dati in Cosmos DB.This tutorial demonstrates how to use the Mongoose Framework when storing data in Cosmos DB. Per questa procedura dettagliata viene usata l'API di Azure Cosmos DB per MongoDB.We use the Azure Cosmos DB's API for MongoDB for this walkthrough. Mongoose è un framework di modellazione a oggetti per MongoDB in Node.js che offre una soluzione semplice e basata su schemi per modellare i dati dell'applicazione.For those of you unfamiliar, Mongoose is an object modeling framework for MongoDB in Node.js and provides a straight-forward, schema-based solution to model your application data.

Cosmos DB è il servizio di database di Microsoft multimodello distribuito a livello globale.Cosmos DB is Microsoft's globally distributed multi-model database service. È possibile creare rapidamente database di documenti, chiave/valore e a grafo ed eseguire query su di essi sfruttando in ognuno dei casi i vantaggi offerti dalle funzionalità di scalabilità orizzontale e distribuzione globale alla base di Cosmos DB.You can quickly create and query document, key/value, and graph databases, all of which benefit from the global distribution and horizontal scale capabilities at the core of Cosmos DB.

PrerequisitiPrerequisites

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.If you don't have an Azure subscription, create a free account before you begin.

È possibile Provare gratuitamente Azure Cosmos DB senza una sottoscrizione di Azure, a titolo gratuito e senza impegno, oppure creare gratuitamente un account Azure Cosmos DB di livello gratuito, con le prime 400 UR/s e 5 GB di spazio di archiviazione.You can Try Azure Cosmos DB for free without an Azure subscription, free of charge and commitments, or create an Azure Cosmos DB free tier account, with the first 400 RU/s and 5 GB of storage for free. È anche possibile usare l'Emulatore di Azure Cosmos DB con l'URI https://localhost:8081.You can also use the Azure Cosmos DB Emulator with a URI of https://localhost:8081. Per la chiave da usare con l'emulatore, vedere Autenticazione delle richieste.For the key to use with the emulator, see Authenticating requests.

Node.js versione v 0.10.29 o successiva.Node.js version v0.10.29 or higher.

Creare un account CosmosCreate a Cosmos account

Di seguito viene descritta la procedura per creare un account Cosmos.Let's create a Cosmos account. Se è già disponibile un account da usare, è possibile passare a Configurare l'applicazione Node.js.If you already have an account you want to use, you can skip ahead to Set up your Node.js application. Se si usa l'emulatore Azure Cosmos DB, seguire i passaggi descritti in Azure Cosmos DB emulatore per configurare l'emulatore e andare avanti per configurare l'applicazione Node.js.If you are using the Azure Cosmos DB Emulator, follow the steps at Azure Cosmos DB Emulator to set up the emulator and skip ahead to Set up your Node.js application.

  1. In una nuova finestra del browser accedere al portale di Azure.In a new browser window, sign in to the Azure portal.

  2. Nel menu a sinistra selezionare Crea una risorsa.In the left menu, select Create a resource.

    Creare una risorsa nel portale di Azure

  3. Nella pagina Nuovo selezionare Database > Azure Cosmos DB.On the New page, select Databases > Azure Cosmos DB.

    Riquadro Database nel portale di Azure

  4. Nella pagina Crea account Azure Cosmos DB immettere le impostazioni per il nuovo account Azure Cosmos DB.On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account.

    ImpostazioneSetting ValoreValue DescrizioneDescription
    SubscriptionSubscription Sottoscrizione in usoYour subscription Selezionare la sottoscrizione di Azure da usare per l'account Azure Cosmos DB.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    Gruppo di risorseResource Group Creare un nuovo gruppo di risorseCreate new

    Immettere quindi lo stesso nome specificato nome dell'account.Then enter the same name as Account Name
    Selezionare Crea nuovo.Select Create new. Immettere quindi il nome di un nuovo gruppo di risorse per l'account.Then enter a new resource group name for your account. Per semplicità, usare lo stesso nome usato come nome dell'account Azure Cosmos DB.For simplicity, use the same name as your Azure Cosmos DB account name.
    Nome accountAccount Name Immettere un nome univocoEnter a unique name Immettere un nome univoco per identificare l'account Azure Cosmos DB.Enter a unique name to identify your Azure Cosmos DB account. L'URI dell'account sarà mongo.cosmos.azure.com e verrà aggiunto al nome dell'account univoco.Your account URI will be mongo.cosmos.azure.com appended to your unique account name.

    Il nome dell'account può contenere solo lettere minuscole, numeri e trattini e deve avere una lunghezza compresa tra 3 e 31 caratteri.The account name can use only lowercase letters, numbers, and hyphens (-), and must be between 3 and 31 characters long.
    APIAPI API Azure Cosmos DB per MongoDBAzure Cosmos DB for Mongo DB API L'API determina il tipo di account da creare.The API determines the type of account to create. Azure Cosmos DB offre cinque API: Core (SQL) per i database di documenti, Gremlin per i database a grafo, API Azure Cosmos DB per MongoDB per i database di documenti, Tabella di Azure e Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) for document databases, Gremlin for graph databases, Azure Cosmos DB for Mongo DB API for document databases, Azure Table, and Cassandra. Attualmente, è necessario creare un account separato per ogni API.Currently, you must create a separate account for each API.

    Selezionare l'API Azure Cosmos DB per MongoDB perché in questo argomento di avvio rapido si creerà una raccolta compatibile con MongoDB.Select Azure Cosmos DB for Mongo DB API because in this quickstart you are creating a collection that works with MongoDB.

    Altre informazioni sull'API Azure Cosmos DB per MongoDB.Learn more about Azure Cosmos DB for MongoDB API.
    LocationLocation Selezionare l'area più vicina agli utentiSelect the region closest to your users Selezionare una posizione geografica in cui ospitare l'account Azure Cosmos DB.Select a geographic location to host your Azure Cosmos DB account. Usare la località più vicina agli utenti per offrire loro la massima velocità di accesso ai dati.Use the location that's closest to your users to give them the fastest access to the data.
    Modalità di capacitàCapacity mode Provisioning velocità effettiva o ServerlessProvisioned throughput or Serverless Selezionare Provisioning velocità effettiva per creare un account in modalità Provisioning velocità effettiva.Select Provisioned throughput to create an account in provisioned throughput mode. Selezionare Serverless per creare un account in modalità Serverless.Select Serverless to create an account in serverless mode.

    Nota: L'API MongoDB versione 3.6 è supportata da account serverless.Note: Only MongoDB API version 3.6 is supported by serverless accounts. Se si sceglie la versione 3.2, l'account verrà forzato in modalità Provisioning velocità effettiva.Choosing 3.2 as the version will force the account in provisioned throughput mode.

    Selezionare Rivedi+Crea.Select Review+Create. È possibile ignorare le sezioni Rete e Tag.You can skip the Network and Tags section.

    Pagina del nuovo account per Azure Cosmos DB

  5. La creazione dell'account richiede alcuni minuti.The account creation takes a few minutes. Attendere che nel portale venga visualizzata la pagina Complimenti, l'account dell'API Azure Cosmos DB per MongoDB è pronto.Wait for the portal to display the Congratulations! Your Azure Cosmos DB for Mongo DB API account is ready page.

    Riquadro delle notifiche nel portale di Azure

Creazione di un databaseCreate a database

In questa applicazione vengono illustrati due modi per creare le raccolte in Azure Cosmos DB:In this application we will cover two ways of creating collections in Azure Cosmos DB:

  • Archiviazione di ogni modello a oggetti in una raccolta separata: è consigliabile creare un database con una velocità effettiva dedicata.Storing each object model in a separate collection: We recommend creating a database with dedicated throughput. L'uso di questo modello di capacità offrirà una migliore efficienza dei costi.Using this capacity model will give you better cost efficiency.

    Node.js esercitazione: screenshot del portale di Azure, che illustra come creare un database nel Esplora dati per un account di Azure Cosmos DB, da usare con il modulo Mangusta node

  • Archiviazione di tutti i modelli a oggetti in una singola raccolta di Cosmos DB: se si preferisce archiviare tutti i modelli in una singola raccolta, è possibile creare un nuovo database senza selezionare l'opzione provisioning della velocità effettiva.Storing all object models in a single Cosmos DB collection: If you'd prefer to store all models in a single collection, you can just create a new database without selecting the Provision Throughput option. L'utilizzo di questo modello di capacità creerà ogni raccolta con la propria capacità di velocità effettiva per ogni modello a oggetti.Using this capacity model will create each collection with its own throughput capacity for every object model.

Dopo aver creato il database, il nome verrà usato nella variabile di COSMOSDB_DBNAME ambiente riportata di seguito.After you create the database, you'll use the name in the COSMOSDB_DBNAME environment variable below.

Configurare l'applicazione Node.jsSet up your Node.js application

Nota

Se si desidera solo esaminare il codice di esempio senza configurare l'applicazione, clonare l'esempio usato per questa esercitazione e compilare l'applicazione Node.js Mongoose in Azure Cosmos DB.If you'd like to just walkthrough the sample code instead of setup the application itself, clone the sample used for this tutorial and build your Node.js Mongoose application on Azure Cosmos DB.

  1. Per creare un'applicazione Node.js nella cartella scelta, eseguire questo comando in un prompt dei comandi del nodo.To create a Node.js application in the folder of your choice, run the following command in a node command prompt.

    npm init

    Rispondere alle domande e il progetto sarà pronto per l'utilizzo.Answer the questions and your project will be ready to go.

  2. Aggiungere un nuovo file alla cartella e denominarlo index.js.Add a new file to the folder and name it index.js.

  3. Installare i pacchetti necessari usando una delle opzioni npm install seguenti:Install the necessary packages using one of the npm install options:

    • Mongoose: npm install mongoose@5 --saveMongoose: npm install mongoose@5 --save

      Nota

      La connessione di esempio Mongoose riportata di seguito si basa su Mongoose 5+, che è stata modificata rispetto alle versioni precedenti.The Mongoose example connection below is based on Mongoose 5+, which has changed since earlier versions.

    • Dotenv (se si desidera caricare i segreti da un file con estensione env):npm install dotenv --saveDotenv (if you'd like to load your secrets from an .env file): npm install dotenv --save

      Nota

      Il flag --save aggiunge la dipendenza al file package.json.The --save flag adds the dependency to the package.json file.

  4. Importare le dipendenze nel file index.js.Import the dependencies in your index.js file.

    var mongoose = require('mongoose');
    var env = require('dotenv').config();   //Use the .env file to load the variables
    
  5. Aggiungere la stringa di connessione Cosmos DB e il nome Cosmos DB al file .env.Add your Cosmos DB connection string and Cosmos DB Name to the .env file. Sostituire i segnaposto {Cosmos-account-name} e {dbname} con il nome dell'account Cosmos e il nome del database, senza i simboli delle parentesi graffe.Replace the placeholders {cosmos-account-name} and {dbname} with your own Cosmos account name and database name, without the brace symbols.

    # You can get the following connection details from the Azure portal. You can find the details on the Connection string pane of your Azure Cosmos account.
    
    COSMOSDB_USER = "<Azure Cosmos account's user name, usually the database account name>"
    COSMOSDB_PASSWORD = "<Azure Cosmos account password, this is one of the keys specified in your account>"
    COSMOSDB_DBNAME = "<Azure Cosmos database name>"
    COSMOSDB_HOST= "<Azure Cosmos Host name>"
    COSMOSDB_PORT=10255
    
  6. Connettersi a Cosmos DB tramite il framework Mongoose, aggiungendo il codice seguente alla fine di index.js.Connect to Cosmos DB using the Mongoose framework by adding the following code to the end of index.js.

    mongoose.connect("mongodb://"+process.env.COSMOSDB_HOST+":"+process.env.COSMOSDB_PORT+"/"+process.env.COSMOSDB_DBNAME+"?ssl=true&replicaSet=globaldb", {
      auth: {
        user: process.env.COSMOSDB_USER,
        password: process.env.COSMOSDB_PASSWORD
      },
    useNewUrlParser: true,
    useUnifiedTopology: true,
    retryWrites: false
    })
    .then(() => console.log('Connection to CosmosDB successful'))
    .catch((err) => console.error(err));
    

    Nota

    In questo caso, le variabili di ambiente vengono caricate usando process.env. {variableName} mediante il pacchetto npm 'dotenv'.Here, the environment variables are loaded using process.env.{variableName} using the 'dotenv' npm package.

    Dopo aver eseguito la connessione ad Azure Cosmos DB, è possibile avviare la configurazione dei modelli a oggetti in Mongoose.Once you are connected to Azure Cosmos DB, you can now start setting up object models in Mongoose.

Procedure consigliate per l'uso di mangusta con Cosmos DBBest practices for using Mongoose with Cosmos DB

Per ogni modello creato, Mongoose crea una nuova raccolta.For every model you create, Mongoose creates a new collection. Questa operazione è consigliata con l' opzione velocità effettiva a livello di database, descritta in precedenza.This is best addressed using the Database Level Throughput option, which was previously discussed. Per usare una singola raccolta, è necessario usare i discriminatoriMangusta.To use a single collection, you need to use Mongoose Discriminators. che rappresentano un meccanismo di ereditarietà degli schemi.Discriminators are a schema inheritance mechanism. I discriminatori consentono di disporre di più modelli con schemi sovrapposti nella stessa raccolta MongoDB sottostante.They enable you to have multiple models with overlapping schemas on top of the same underlying MongoDB collection.

È possibile archiviare vari modelli di dati nella stessa raccolta e quindi usare una clausola di filtro in fase di query per visualizzare solo i dati necessari.You can store the various data models in the same collection and then use a filter clause at query time to pull down only the data needed. Esaminiamo ogni modello.Let's walk through each of the models.

Una raccolta per modello a oggettiOne collection per object model

Questa sezione illustra come eseguire tale operazione con l'API di Azure Cosmos DB per MongoDB.This section explores how to achieve this with Azure Cosmos DB's API for MongoDB. Questo metodo è l'approccio consigliato perché consente di controllare i costi e la capacità.This method is our recommended approach since it allows you to control cost and capacity. Di conseguenza, la quantità di unità richiesta nel database non dipende dal numero di modelli a oggetti.As a result, the amount of Request Units on the database does not depend on the number of object models. Si tratta del modello operativo predefinito per mangusta, quindi è possibile che si abbia familiarità con questo.This is the default operating model for Mongoose, so, you might be familiar with this.

  1. Aprire di nuovo index.js.Open your index.js again.

  2. Creare la definizione dello schema per 'Family' (Famiglia).Create the schema definition for 'Family'.

    const Family = mongoose.model('Family', new mongoose.Schema({
        lastName: String,
        parents: [{
            familyName: String,
            firstName: String,
            gender: String
        }],
        children: [{
            familyName: String,
            firstName: String,
            gender: String,
            grade: Number
        }],
        pets:[{
            givenName: String
        }],
        address: {
            country: String,
            state: String,
            city: String
        }
    }));
    
  3. Creare un oggetto per 'Family' (Famiglia).Create an object for 'Family'.

    const family = new Family({
        lastName: "Volum",
        parents: [
            { firstName: "Thomas" },
            { firstName: "Mary Kay" }
        ],
        children: [
            { firstName: "Ryan", gender: "male", grade: 8 },
            { firstName: "Patrick", gender: "male", grade: 7 }
        ],
        pets: [
            { givenName: "Buddy" }
        ],
        address: { country: "USA", state: "WA", city: "Seattle" }
    });
    
  4. Salvare infine l'oggetto in Cosmos DB.Finally, let's save the object to Cosmos DB. Verrà creata una raccolta.This creates a collection underneath the covers.

    family.save((err, saveFamily) => {
        console.log(JSON.stringify(saveFamily));
    });
    
  5. Creare a questo punto un altro schema e un altro oggetto,Now, let's create another schema and object. ad esempio 'Vacation Destinations' (Destinazioni vacanze) che può essere interessante per le famiglie.This time, let's create one for 'Vacation Destinations' that the families might be interested in.

    1. Come in precedenza, creare lo schema.Just like last time, let's create the scheme

      const VacationDestinations = mongoose.model('VacationDestinations', new mongoose.Schema({
       name: String,
       country: String
      }));
      
    2. Creare un oggetto di esempio e salvarlo. È possibile aggiungere più oggetti a questo schema.Create a sample object (You can add multiple objects to this schema) and save it.

      const vacaySpot = new VacationDestinations({
       name: "Honolulu",
       country: "USA"
      });
      
      vacaySpot.save((err, saveVacay) => {
       console.log(JSON.stringify(saveVacay));
      });
      
  6. Nel portale di Azure saranno a questo punto disponibili due raccolte create in Cosmos DB.Now, going into the Azure portal, you notice two collections created in Cosmos DB.

     EsercitazioneNode.js-screenshot del portale di Azure, che mostra un account di Azure Cosmos DB con più nomi di raccolta evidenziati-database nodo

  7. È infine possibile leggere i dati da Cosmos DB.Finally, let's read the data from Cosmos DB. Poiché è stato usato il modello di funzionamento predefinito di Mongoose, le letture avvengono come di consueto in Mongoose.Since we're using the default Mongoose operating model, the reads are the same as any other reads with Mongoose.

    Family.find({ 'children.gender' : "male"}, function(err, foundFamily){
        foundFamily.forEach(fam => console.log("Found Family: " + JSON.stringify(fam)));
    });
    

Utilizzo dei discriminatori di Mongoose per archiviare i dati in una singola raccoltaUsing Mongoose discriminators to store data in a single collection

Per questo metodo si usano i discriminatori di Mongoose per ottimizzare i costi di ogni raccolta.In this method, we use Mongoose Discriminators to help optimize for the costs of each collection. I discriminatori consentono di definire una chiave ('Key') di differenziazione, che consente di eseguire operazioni di archiviazione, differenziazione e filtro su modelli a oggetti diversi.Discriminators allow you to define a differentiating 'Key', which allows you to store, differentiate and filter on different object models.

In questo caso, si creerà un modello a oggetti di base, si definirà una chiave di differenziazione e si aggiungeranno 'Family' e 'VacationDestinations' come estensione del modello di base.Here, we create a base object model, define a differentiating key and add 'Family' and 'VacationDestinations' as an extension to the base model.

  1. Definire la configurazione di base e la chiave discriminatore.Let's set up the base config and define the discriminator key.

    const baseConfig = {
        discriminatorKey: "_type", //If you've got a lot of different data types, you could also consider setting up a secondary index here.
        collection: "alldata"   //Name of the Common Collection
    };
    
  2. Definire quindi il modello a oggetti comune.Next, let's define the common object model

    const commonModel = mongoose.model('Common', new mongoose.Schema({}, baseConfig));
    
  3. Definire a questo punto il modello 'Family'.We now define the 'Family' model. Si noti che in questo caso viene usato commonModel.discriminator anziché mongoose.model.Notice here that we're using commonModel.discriminator instead of mongoose.model. Si aggiungerà inoltre la configurazione di base allo schema mongoose.Additionally, we're also adding the base config to the mongoose schema. La chiave discriminatore (discriminatorKey) in questo caso è FamilyType.So, here, the discriminatorKey is FamilyType.

    const Family_common = commonModel.discriminator('FamilyType', new     mongoose.Schema({
        lastName: String,
        parents: [{
            familyName: String,
            firstName: String,
            gender: String
        }],
        children: [{
            familyName: String,
            firstName: String,
           gender: String,
            grade: Number
        }],
        pets:[{
            givenName: String
        }],
        address: {
            country: String,
            state: String,
            city: String
        }
    }, baseConfig));
    
  4. Analogamente, procedere con l'aggiunta di un altro schema, questa volta per 'VacationDestinations'.Similarly, let's add another schema, this time for the 'VacationDestinations'. La chiave discriminatore (discriminatorKey) in questo caso è VacationDestinationsType.Here, the DiscriminatorKey is VacationDestinationsType.

    const Vacation_common = commonModel.discriminator('VacationDestinationsType', new mongoose.Schema({
        name: String,
        country: String
    }, baseConfig));
    
  5. Creare infine gli oggetti per il modello ed eseguire il salvataggio.Finally, let's create objects for the model and save it.

    1. Aggiungere uno o più oggetti al modello 'Family'.Let's add object(s) to the 'Family' model.

      const family_common = new Family_common({
       lastName: "Volum",
       parents: [
           { firstName: "Thomas" },
           { firstName: "Mary Kay" }
       ],
       children: [
           { firstName: "Ryan", gender: "male", grade: 8 },
           { firstName: "Patrick", gender: "male", grade: 7 }
       ],
       pets: [
           { givenName: "Buddy" }
       ],
       address: { country: "USA", state: "WA", city: "Seattle" }
      });
      
      family_common.save((err, saveFamily) => {
       console.log("Saved: " + JSON.stringify(saveFamily));
      });
      
    2. Successivamente, aggiungere uno o più oggetti al modello 'VacationDestinations' ed eseguire il salvataggio.Next, let's add object(s) to the 'VacationDestinations' model and save it.

      const vacay_common = new Vacation_common({
       name: "Honolulu",
       country: "USA"
      });
      
      vacay_common.save((err, saveVacay) => {
       console.log("Saved: " + JSON.stringify(saveVacay));
      });
      
  6. Passando di nuovo al portale di Azure, si noterà che è disponibile una sola raccolta denominata alldata con i dati di 'Family' e 'VacationDestinations'.Now, if you go back to the Azure portal, you notice that you have only one collection called alldata with both 'Family' and 'VacationDestinations' data.

     EsercitazioneNode.js-screenshot del portale di Azure, che mostra un account Azure Cosmos DB, con il nome della raccolta evidenziato-database nodo

  7. Si noti inoltre che ogni oggetto dispone di un altro attributo denominato __type, che consente la differenziazione dei due diversi modelli a oggetti.Also, notice that each object has another attribute called as __type, which help you differentiate between the two different object models.

  8. Leggere infine i dati archiviati in Azure Cosmos DB.Finally, let's read the data that is stored in Azure Cosmos DB. Mongoose filtrerà i dati in base al modello.Mongoose takes care of filtering data based on the model. Non sarà pertanto necessario eseguire altre operazioni durante la lettura dei dati.So, you have to do nothing different when reading data. Sarà sufficiente specificare il modello (in questo caso, Family_common) e Mongoose gestirà l'applicazione dei filtri in base a 'DiscriminatorKey'.Just specify your model (in this case, Family_common) and Mongoose handles filtering on the 'DiscriminatorKey'.

    Family_common.find({ 'children.gender' : "male"}, function(err, foundFamily){
        foundFamily.forEach(fam => console.log("Found Family (using discriminator): " + JSON.stringify(fam)));
    });
    

Usare i discriminatori di Mongoose è molto facile.As you can see, it is easy to work with Mongoose discriminators. In presenza di un'app che usa il framework Mongoose, pertanto, questa esercitazione è utile per rendere l'applicazione operativa usando l'API di Azure Cosmos per MongoDB, senza dover apportare troppe modifiche.So, if you have an app that uses the Mongoose framework, this tutorial is a way for you to get your application up and running using Azure Cosmos's API for MongoDB without requiring too many changes.

Pulire le risorseClean up resources

Dopo aver completato le operazioni con l'app e l'account Azure Cosmos DB, è possibile eliminare le risorse di Azure create in modo da non incorrere in altri costi.When you're done with your app and Azure Cosmos DB account, you can delete the Azure resources you created so you don't incur more charges. Per eliminare le risorse:To delete the resources:

  1. Nella barra di ricerca del portale di Azure cercare e selezionare Gruppi di risorse.In the Azure portal Search bar, search for and select Resource groups.

  2. Selezionare nell'elenco il gruppo di risorse creato in questa guida di avvio rapido.From the list, select the resource group you created for this quickstart.

    Selezionare il gruppo di risorse da eliminare

  3. Nella pagina Panoramica del gruppo di risorse selezionare Elimina gruppo di risorse.On the resource group Overview page, select Delete resource group.

    Eliminare il gruppo di risorse.

  4. Nella finestra successiva immettere il nome del gruppo di risorse da eliminare e quindi selezionare Elimina.In the next window, enter the name of the resource group to delete, and then select Delete.

Passaggi successiviNext steps

  • Informazioni su come usare Studio 3T con l'API di Azure Cosmos DB per MongoDB.Learn how to use Studio 3T with Azure Cosmos DB's API for MongoDB.
  • Informazioni su come usare Robo 3T con l'API di Azure Cosmos DB per MongoDB.Learn how to use Robo 3T with Azure Cosmos DB's API for MongoDB.
  • Esplorare gli esempi di MongoDB con l'API di Azure Cosmos DB per MongoDB.Explore MongoDB samples with Azure Cosmos DB's API for MongoDB.