Een account, database en verzameling maken met behulp van Azure Cosmos DB voor MongoDB

8 minuten

Azure Cosmos DB is een volledig beheerde PaaS (Platform as a Service). Als u deze service wilt gebruiken, moeten we eerst een Azure Cosmos DB-account maken onder ons abonnement. Zodra ons account is gemaakt, kunnen we vervolgens database, verzamelingen en documenten erin toevoegen.

We bekijken een aantal manieren om de verschillende Azure Cosmos DB voor MongoDB-modelelementen te maken.

Een account, database en container maken voor Azure Cosmos DB voor MongoDB met behulp van Azure Portal

Een manier om ons Azure Cosmos DB-account en de bijbehorende elementen te maken, is het gebruik van Azure Portal. In dit voorbeeld gebruiken we Azure Portal om een Azure Cosmos DB-account te maken met behulp van Azure Cosmos DB voor MongoDB. Vervolgens voegen we een database en een verzameling toe. U hoeft zich momenteel geen zorgen te maken over het invullen van geavanceerdere instellingen die we in latere modules in meer detail behandelen. In dit voorbeeld kunt u het tabblad Basisbeginselen bekijken. Laten we ons account en de bijbehorende elementen maken.

Een account maken voor Azure Cosmos DB voor MongoDB

Selecteer en maak een resource in Azure Portal, selecteer Azure Cosmos DB en Maken.
Selecteer Azure Cosmos DB voor MongoDB.
Voer de volgende parameters in.
- Abonnement : uw huidige Azure-abonnement.
- Resourcegroep : een nieuwe of bestaande Azure-resourcegroep waarop u het Azure Cosmos DB-account kunt maken.
- Accountnaam : een unieke naam voor uw Azure Cosmos DB-account. Deze naam moet uniek zijn in Azure. Uw account-URI heeft mongo.cosmos.azure.com toegevoegd aan uw accountnaam.
- Locatie : de geografische locatie die als host fungeert voor uw Azure Cosmos DB-account. Doorgaans moet u een locatie in de buurt van uw gebruikers of toepassingen selecteren.
- Capaciteitsmodus : zoals we in een vorige eenheid hebben besproken, kunt u voor uw account kiezen voor het gebruik van ingerichte doorvoer of serverloos. Selecteer Ingerichte doorvoer voor dit voorbeeld.
- Korting op gratis laag toepassen - Selecteer Niet toepassen op dit voorbeeld.
- Totale accountdoorvoer beperken- Laat dit voorbeeld uitgeschakeld .
- Versie - Selecteer 4.0.
Notitie

Als u beter wilt profiteren van de ondersteunde functies, raden we u aan om waar mogelijk versies 3.6+ te gebruiken.
Selecteer Beoordelen en maken en selecteer Maken bij een geslaagde validatie.

Notitie

Het kan enkele minuten duren voordat uw Azure Cosmos DB-account is gemaakt.

Een database en container maken voor Azure Cosmos DB voor MongoDB

Het maken van een database en container in Azure Portal is eenvoudig. Laten we eerst een database maken.

Selecteer Data Explorer in het linkermenu van het Azure Cosmos DB for MongoDB-account.
Selecteer de vervolgkeuzelijst rechts van het pictogram Nieuwe verzameling en selecteer Nieuwe database.
Geef uw database een nieuwe naam onder het tekstvak Database-id .
Hoewel we de doorvoer inrichten in het dialoogvenster Nieuwe database kunnen definiëren, selecteert u in de meeste gevallen de ingerichte doorvoer op containerniveau. We schakelen het selectievakje Doorvoer inrichten uit en selecteren OK voor dit voorbeeld.

We moeten nu onze nieuwe database zien in de sectie MONGO-API . Het is tijd om onze nieuwe verzameling te maken.
Selecteer het pictogram Nieuwe verzameling .
Voer de volgende parameters in onder het dialoogvenster Nieuwe verzameling .
- Databasenaam : u ziet dat u hier twee opties hebt, Nieuwe maken of Bestaande gebruiken. Met deze optie kunt u een nieuwe database maken op het moment dat u de nieuwe verzameling maakt. Omdat we in onze vorige stappen al een nieuwe database hebben gemaakt, selecteert u Bestaande gebruiken en kiest u de naam van de database in de pulldown-opties.
- Verzamelings-id : deze parameter is de naam die u aan uw verzameling geeft.
- Sharding: meestal willen we Sharded selecteren. Met deze optie kan Azure Cosmos DB containers maken die zijn verdeeld over meerdere tenants op basis van de Shard-sleutel. Met grote containers verspreidt Azure Cosmos DB uw tenants over meerdere fysieke knooppunten om een hoge schaal te bereiken. We bespreken sharding in meer detail in de ontwerpmodule . Selecteer Sharded.
  - Shardsleutel: als u Sharded selecteert, moet u een Shard-sleutel toevoegen. Deze sleutel is de partitiesleutel die uw partitioneringsstrategie definieert. In de verzameling IoT (Internet of Things) kan het bijvoorbeeld /deviceid of een /regio zijn, afhankelijk van de partitioneringsstrategie die u kiest. We bespreken partitioneringsstrategie in meer detail in de ontwerpmodule .
  - Het selectievakje Toegewezen doorvoer inrichten voor deze verzameling : meestal wilt u de doorvoer van uw verzameling inrichten als automatisch schalen of handmatig. Met deze instelling kunt u de kosten van uw afzonderlijke verzameling beter beheren. We bespreken de doorvoer in meer detail in de ontwerpmodule . Schakel voorlopig het selectievakje in en selecteer Automatisch schalen.
  - Verzamelingsdoorvoer of Maximale RU/s voor verzameling: afhankelijk van of u handmatige of automatische schaalaanpassing hebt geselecteerd, moet u respectievelijk de verzamelingsdoorvoer of het maximum aantal RU/s verzamelen, of met andere woorden de doorvoermodus. Het belangrijkste verschil is dat in de handmatige modus kosten in rekening worden gebracht voor het bedrag dat de RU/s hebben gekozen, ongeacht of u ze gebruikt of niet. Automatisch schalen brengt alleen kosten in rekening voor wat u gebruikt tot het maximum aantal RU/s dat u hebt geselecteerd. In beide gevallen wordt de verzameling beperkt zodra de doorvoer de geselecteerde waarde heeft bereikt. Laat de vooraf gedefinieerde waarde voor dit voorbeeld staan.
  - Analytische opslag : de analytische opslag van Azure Cosmos DB valt buiten het bereik van deze lessen. Raadpleeg het artikel wat is analytische opslag van Azure Cosmos DB voor meer informatie over dat onderwerp.
  - Geavanceerd/indexeren : we bespreken indexen in meer detail onder de module Ontwerpen . Laat het selectievakje ingeschakeld.

We moeten nu een database en één verzameling hebben om verbinding mee te maken. In de volgende les gaan we dieper in op het maken van verbinding met een Azure Cosmos DB voor MongoDB-account. Daarvoor gaan we een andere manier bekijken om onze Azure Cosmos DB voor MongoDB-databases en -verzamelingen te maken.

Een database en verzameling voor Azure Cosmos DB voor MongoDB maken of er verbinding mee maken

U moet uw Azure Cosmos DB voor MongoDB-account kunnen maken of er verbinding mee kunnen maken met behulp van java, Python, Node.js, .NET of een andere programmeertaal met een MongoDB-stuurprogramma. Laten we enkele functies introduceren die u zou gebruiken om deze elementen te maken met behulp van een aantal van de verschillende talen. Aan het begin van deze module hebben we aangegeven dat de ontwikkelaars mongoDB-stuurprogramma's, SDK's en hulpprogramma's waarmee ze bekend zijn, kunnen blijven gebruiken om verbinding te maken met Azure Cosmos DB en apps te maken. We gebruiken deze stuurprogramma's en hun eigenschappen en methoden om onze toegang en bewerkingen te programmeren voor ons Azure Cosmos DB voor MongoDB-account.

Een database voor Azure Cosmos DB voor MongoDB maken of er verbinding mee maken

U kunt uw favoriete ontwikkelhulpprogramma gebruiken om uw Azure Cosmos DB voor MongoDB-toepassing te maken. We gebruiken het MongoDB-stuurprogramma voor elke respectieve programmeertaal om onze databases en verzamelingen te maken. Laten we de code bekijken om verbinding te maken met de Azure Cosmos DB voor MongoDB-accounts en om verbinding te maken met de productendatabase .

Node.js

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
const { MongoClient, ObjectId } = require('mongodb');
import axios from "axios";

async function main() {
  // Environment variables
  const endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
  const listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
  const scope = process.env.AZURE_COSMOS_SCOPE;

  // Uncomment the corresponding lines for the authentication type you want to use.
  // For system-assigned managed identity.
  // const credential = new DefaultAzureCredential();

  // For user-assigned managed identity.
  // const clientId = process.env.AZURE_COSMOS_CLIENTID;
  // const credential = new DefaultAzureCredential({
  //     managedIdentityClientId: clientId
  // });

  // For service principal.
  // const tenantId = process.env.AZURE_COSMOS_TENANTID;
  // const clientId = process.env.AZURE_COSMOS_CLIENTID;
  // const clientSecret = process.env.AZURE_COSMOS_CLIENTSECRET;
  // const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

  // Acquire the access token
  const accessToken = await credential.getToken(scope);

  // Get the connection string
  const config = {
    method: 'post',
    url: listConnectionStringUrl,
    headers: {
        'Authorization': 'Bearer ${accessToken.token}'
    }
  };
  const response = await axios(config);
  const keysDict = response.data;
  const connectionString = keysDict['connectionStrings'][0]['connectionString'];

  // Connect to Azure Cosmos DB for MongoDB
  const client = new MongoClient(connectionString);

  try {
    // Open the connection
    await client.connect();

    // Connect to the database "products"
    const ProductDatabase = client.db('products');

    // Add code to connect to a collection and add an entry here
  } catch (err) {
    console.error("An error occurred:", err);
  } finally {
    // Close the connection
    await client.close();
  }
}

main().catch((err) => console.error("Unhandled error:", err));

Java

package com.fabrikam;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import com.azure.identity.*;
import com.azure.core.credential.*;
import java.net.http.*;
import java.net.URI;

public class App {
  public static void main(String[] args) {
    // Environment variables
    String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
    String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
    String scope = System.getenv("AZURE_COSMOS_SCOPE");

    // Uncomment the corresponding lines for the authentication type you want to use.
    // For system-assigned managed identity.
    // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

    // For user-assigned managed identity.
    // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
    //     .managedIdentityClientId(System.getenv("AZURE_COSMOS_CLIENTID"))
    //     .build();

    // For service principal.
    // ClientSecretCredential defaultCredential = new ClientSecretCredentialBuilder()
    //     .clientId(System.getenv("AZURE_COSMOS_CLIENTID"))
    //     .clientSecret(System.getenv("AZURE_COSMOS_CLIENTSECRET"))
    //     .tenantId(System.getenv("AZURE_COSMOS_TENANTID"))
    //     .build();

    MongoClient mongoClient = null;

    try {
      // Acquire the access token
      AccessToken accessToken = defaultCredential
          .getToken(new TokenRequestContext().addScopes(scope))
          .block();
      String token = accessToken.getToken();

      // Retrieve the connection string
      HttpClient client = HttpClient.newBuilder().build();
      HttpRequest request = HttpRequest.newBuilder()
          .uri(new URI(listConnectionStringUrl))
          .header("Authorization", "Bearer " + token)
          .POST(HttpRequest.BodyPublishers.noBody())
          .build();
      HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

      JSONParser parser = new JSONParser();
      JSONObject responseBody = parser.parse(response.body());
      List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
      String connectionString = connectionStrings.get(0).get("connectionString");

      // Connect to Azure Cosmos DB for MongoDB
      MongoClientURI uri = new MongoClientURI(connectionString);
      mongoClient = new MongoClient(uri);

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

      // Add code to connect to a collection and add an entry here

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (mongoClient != null) {
        mongoClient.close();
      }
    }
  }
}

Python

import os
import pymongo
import requests
from azure.identity import ManagedIdentityCredential, ClientSecretCredential

# Environment variables
endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
scope = os.getenv('AZURE_COSMOS_SCOPE')

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity
# cred = ManagedIdentityCredential()

# For user-assigned managed identity
# managed_identity_client_id = os.getenv('AZURE_COSMOS_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# For service principal
# tenant_id = os.getenv('AZURE_COSMOS_TENANTID')
# client_id = os.getenv('AZURE_COSMOS_CLIENTID')
# client_secret = os.getenv('AZURE_COSMOS_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Get the connection string
session = requests.Session()
token = cred.get_token(scope)
response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
keys_dict = response.json()
conn_str = keys_dict["connectionStrings"][0]["connectionString"]

# Connect to Azure Cosmos DB for MongoDB
client = pymongo.MongoClient(conn_str)

# To connect to the database, use the connection variable ("client" in this case), and the database name
ProductDatabase = client["products"]

# Add code to connect to a collection and add an entry here

using MongoDB.Driver;
using Azure.Identity;
using Azure.Core;
using System;
using System.Net.Http;
using System.Text.Json;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Products
{
  public int ProductId { get; set; }
  public string name { get; set; }
}

class test
{
  public static async Task Main(string[] args)
  {
      // Environment variables
      var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
      var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
      var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");

      // Uncomment the corresponding lines for the authentication type you want to use.
      // For system-assigned identity.
      // var tokenProvider = new DefaultAzureCredential();

      // For user-assigned identity.
      // var tokenProvider = new DefaultAzureCredential(
      //     new DefaultAzureCredentialOptions
      //     {
      //         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID")
      //     });

      // For service principal.
      // var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
      // var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
      // var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
      // var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

      // Acquire the access token.
      AccessToken accessToken = await tokenProvider.GetTokenAsync(
          new TokenRequestContext(scopes: new[] { scope }));

      // Get the connection string.
      using var httpClient = new HttpClient();
      httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
      var response = await httpClient.PostAsync(listConnectionStringUrl, null);
      response.EnsureSuccessStatusCode();
      var responseBody = await response.Content.ReadAsStringAsync();

      // Parse the connection string.
      var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
      string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];

      // Initialize the MongoClient with the connection string.
      var mongoClient = new MongoClient(connectionString);

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

      // Add code to connect to a collection and add an entry here.
  }
}

Zodra we verbinding maken met het stuurprogramma, maken we een nieuwe database of wijzen we op een bestaande database met de GetDatabase of vergelijkbare methoden, afhankelijk van de taal. Onze toepassing kan nu de variabele ProductDatabase gebruiken om te verwijzen naar de gewenste database. Het maken of verbinden met een verzameling is net zo eenvoudig als het maken van een nieuwe database.

Een verzameling maken voor Azure Cosmos DB voor MongoDB

Als u een bestaande verzameling wilt maken of openen, gebruiken we een get-verzamelingsmethode of -verwijzing, afhankelijk van de programmeertaal. Laten we code toevoegen aan het vorige voorbeeld om een verzameling te maken/er verbinding mee te maken en één vermelding toe te voegen aan die verzameling.

Node.js

          // Add code to connect to a collection and add and find an entry here 
          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);

Java

          // Add code to connect to a collection and add and find an entry here 
          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());

Python

# Add code to connect to a collection and add an entry here 
collection = ProductDatabase["products"]
collection.insert_one({ "ProductId": 1, "name": "bread" })

    // Add code to connect to a collection and add an entry here 
    var ProductCollection = ProductDatabase.GetCollection<Products>("products");

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

In de volgende les zien we hoe we onze verbindingsreeks precies hebben gemaakt.

MongoDB-extensieopdrachten gebruiken om gegevens te beheren die zijn opgeslagen in de API van Azure Cosmos DB voor MongoDB

Zoals we eerder hebben besproken, biedt Azure Cosmos DB voor MongoDB ons de mogelijkheid om dezelfde stuurprogramma's en code te gebruiken die we hebben gebruikt voor toegang tot en het maken van onze objecten in een MongoDB-server voor ons Azure Cosmos DB-account. Als u deze code gebruikt om onze databases en verzamelingen te maken, worden echter de standaardparameters voor het maken van Azure Cosmos DB gebruikt. Als u gebruik wilt maken van Azure Cosmos DB-functies, moeten we de parameters voor het maken van databases en verzamelingen kunnen beheren, zoals doorvoer, automatisch schalen, het toewijzen van shardsleutels en het definiëren van indexen. Azure Cosmos DB voor MongoDB biedt ons deze mogelijkheid door uitgebreide opdrachten te gebruiken om deze parameters te definiëren. Met deze opdrachten kunnen we nauwkeurigere instructies schrijven voor het maken of wijzigen van onze databases en verzamelingen voor Azure Cosmos DB.

Azure Cosmos DB voor MongoDB biedt extensieopdrachten voor de volgende aanvraagtypen:

Database maken
Database bijwerken
Database ophalen
Verzameling maken
Verzameling bijwerken
Verzameling ophalen

De MongoDB-stuurprogramma's bieden een functie om een opdracht uit te voeren op een database die we met deze functie gebruiken om onze uitgebreide opdrachten naar Azure Cosmos DB te verzenden. Laten we eens kijken naar de code voor het maken van een IoT-apparaatverzameling met een doorvoer van 2000 RU's (aanvraageenheden) en een shardsleutel van DeviceId.

Node.js

    // create the Devices collection with a throughput of 2000 RUs and with DeviceId as the sharding key
    var result = IOTDatabase.command({customAction: "CreateCollection", collection: "Devices", offerThroughput: 2000, shardKey: "DeviceId"});

Java

      // create the Devices collection with a throughput of 2000 RUs and with DeviceId as the sharding key
      Document DevCollectionDef = new Document();
      DevCollectionDef.append("customAction", "CreateCollection");
      DevCollectionDef.append("collection", "Devices");
      DevCollectionDef.append("offerThroughput", 2000);
      DevCollectionDef.append("shardKey", "DeviceId");

      Document result = IOTDatabase.runCommand(DevCollectionDef);

Python

      # create the Devices collection with a throughput of 2000 RUs and with DeviceId as the sharding key
      IOTDatabase.command({'customAction': "CreateCollection", 'collection': "Devices", 'offerThroughput': 2000, 'shardKey': "DeviceId"})

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

Op vergelijkbare wijze kunnen we een verzameling wijzigen of een database maken of wijzigen. Raadpleeg de mongoDB-extensieopdrachten gebruiken om gegevens te beheren die zijn opgeslagen in de API van Azure Cosmos DB voor MongoDB voor meer informatie.

Feedback

Is deze pagina nuttig?