Skapa ett konto, en databas och en samling med Hjälp av Azure Cosmos DB för MongoDB

Slutförd

Azure Cosmos DB är en fullständigt hanterad paaS (platform-as-a-service). För att kunna använda den här tjänsten måste vi först skapa ett Azure Cosmos DB-konto under vår prenumeration. När vårt konto har skapats kan vi sedan lägga till databas, samlingar och dokument i det.

Vi tar en titt på ett par sätt att skapa olika Azure Cosmos DB för MongoDB-modellelement.

Skapa ett konto, en databas och en container för Azure Cosmos DB för MongoDB med hjälp av Azure Portal

Ett sätt att skapa vårt Azure Cosmos DB-konto och dess element är att använda Azure Portal. I det här exemplet använder vi Azure Portal för att skapa ett Azure Cosmos DB-konto med hjälp av Azure Cosmos DB för MongoDB. Sedan lägger vi till en databas och en samling. För tillfället behöver du inte oroa dig för att fylla i mer avancerade inställningar som vi tar upp mer detaljerat i senare moduler. I det här exemplet kan du bara granska fliken Grundläggande. Nu ska vi skapa vårt konto och dess element.

Skapa ett konto för Azure Cosmos DB för MongoDB

1. I Azure Portal väljer du + Skapa en resurs, väljer Azure Cosmos DB och Skapa.

2. Välj Azure Cosmos DB för MongoDB.

3. Ange följande parametrar.

   • Prenumeration – din aktuella Azure-prenumeration.
   • Resursgrupp – En ny eller befintlig Azure-resursgrupp som du vill skapa Azure Cosmos DB-kontot på.
   • Kontonamn – ett unikt namn för ditt Azure Cosmos DB-konto. Det här namnet måste vara unikt i Hela Azure. Konto-URI:n har mongo.cosmos.azure.com lagts till i ditt kontonamn.
   • Plats – den geografiska plats som är värd för ditt Azure Cosmos DB-konto. Du bör vanligtvis välja en plats nära dina användare eller program.
   • Kapacitetsläge – Som vi beskrev i en tidigare lektion kan du välja att ditt konto ska använda Etablerat dataflöde eller Serverlöst. Välj Etablerat dataflöde för det här exemplet.
   • Använd rabatt på den kostnadsfria nivån – Välj Använd inte för det här exemplet.
   • Begränsa det totala kontodataflödet – Lämna avmarkerat för det här exemplet.
   • Version – Välj 4.0.

   Kommentar

   Om du vill dra bättre nytta av de funktioner som stöds rekommenderar vi att du använder version 3.6+ när det är möjligt.

4. Välj Granska + skapa och välj Skapa vid en lyckad validering.

Kommentar

Det kan ta flera minuter att skapa ditt Azure Cosmos DB-konto.

Skapa en databas och container för Azure Cosmos DB för MongoDB

När du skapar en databas och container i Azure Portal är det enkelt att skapa en databas.

1. På den vänstra menyn för Azure Cosmos DB for MongoDB-kontot väljer du Datautforskaren.

2. Välj pulldown till höger om ikonen Ny samling och välj Ny databas.

   

3. Ge databasen ett nytt namn under textrutan Databas-ID .

4. Vi kan definiera dataflödet Etablera i dialogrutan Ny databas , men i de flesta fall väljer du ditt etablerade dataflöde på containernivå. Nu avmarkerar vi kryssrutan Etablera dataflöde och väljer Ok för det här exemplet.

   

   Vi bör nu lägga märke till vår nya databas under avsnittet MONGO API . Det är dags att skapa vår nya samling.

5. Välj ikonen Ny samling.

6. Ange följande parametrar under dialogrutan Ny samling .

   • Databasnamn – Du märker att du har två alternativ här, Skapa ny eller Använd befintlig. Med det här alternativet kan du skapa en ny databas när du skapar den nya samlingen. Eftersom vi redan har skapat en ny databas i våra tidigare steg väljer du Använd befintlig och väljer databasnamnet från hämtningsalternativen.
   • Samlings-ID – den här parametern är det namn som du ger samlingen.
   • Horisontell partitionering – Vi skulle vanligtvis vilja välja Sharded. Med det här alternativet kan Azure Cosmos DB skapa containrar som är fragmenterade över flera klienter baserat på Shard-nyckeln. Med stora containrar sprider Azure Cosmos DB dina klienter över flera fysiska noder för att uppnå en hög grad av skala. Vi diskuterar horisontell partitionering mer detaljerat under modulen Design . Välj Sharded.
     • Shard-nyckel – Om du väljer Sharded måste du lägga till en Shard-nyckel. Den här nyckeln är partitionsnyckeln som definierar partitioneringsstrategin. I och IoT-samlingen (Sakernas Internet) kan den till exempel vara /deviceid eller kanske /region beroende på vilken partitioneringsstrategi du väljer. Vi diskuterar partitioneringsstrategin i detalj under modulen Design .
     • Kryssrutan Etablera dedikerat dataflöde för den här samlingen – Vanligtvis vill du etablera dataflödet för din samling antingen som autoskalning eller manuell. Med den här inställningen kan du få bättre kontroll över kostnaden för din enskilda samling. Vi diskuterar dataflödet mer detaljerat i modulen Design . Markera kryssrutan för tillfället och välj Autoskalning.
     • Samlingsdataflöde eller Samlings max RU/s – Beroende på om du har valt Manuell eller Autoskalning måste du ange samlingsdataflödet eller samlings max RU/s , eller med andra ord dataflödesläget. Den största skillnaden är att du i manuellt läge debiterar det belopp som ru/s har valt oavsett om du använder dem eller inte. Autoskalning debiterar bara det du använder upp till de maximala RU/s som du har valt. I båda fallen börjar samlingen begränsas när dess dataflöde når det valda värdet. Lämna det fördefinierade värdet för det här exemplet.
     • Analysarkiv – Azure Cosmos DB-analysarkivet ligger utanför de här lektionernas omfång. Mer information om det ämnet finns i artikeln Vad är Azure Cosmos DB-analysarkivet ?
     • Avancerat/indexering – Vi diskuterar index mer detaljerat under modulen Design . Låt kryssrutan vara markerad.

Nu bör vi ha en databas och en samling att ansluta till. I nästa lektion går vi in på mer information om hur du ansluter till ett Azure Cosmos DB för MongoDB-konto. Innan det ska vi gå igenom ett annat sätt att skapa våra Azure Cosmos DB för MongoDB-databaser och samlingar.

Skapa eller ansluta till en databas och samling för Azure Cosmos DB for MongoDB

Du bör kunna skapa eller ansluta till ditt Azure Cosmos DB for MongoDB-konto med hjälp av Java, Python, Node.js, .NET eller annat programmeringsspråk med en MongoDB-drivrutin. Nu ska vi introducera några funktioner som du använder för att skapa dessa element med hjälp av några av de olika språken. I början av den här modulen uppgav vi att utvecklarna kan fortsätta använda MongoDB-drivrutiner, SDK:er och verktyg som de är bekanta med för att ansluta till Azure Cosmos DB och skapa appar. Vi använder dessa drivrutiner och deras egenskaper och metoder för att programmera vår åtkomst och våra åtgärder mot vårt Azure Cosmos DB for MongoDB-konto.

Skapa eller ansluta till en databas för Azure Cosmos DB för MongoDB

Du kan använda ditt favoritutvecklingsverktyg för att skapa ditt Azure Cosmos DB for MongoDB-program. Vi använder MongoDB-drivrutinen för varje programmeringsspråk för att skapa våra databaser och samlingar. Nu ska vi granska koden för att ansluta till Azure Cosmos DB för MongoDB-konton och ansluta till produktdatabasen.

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

C#

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

Det är så enkelt att när vi ansluter med drivrutinen skapar vi antingen en ny databas eller pekar på en befintlig med GetDatabase eller liknande metoder beroende på språket. Vårt program kan nu använda variabeln ProductDatabase för att referera till den önskade databasen. Att skapa eller ansluta till en samling är lika enkelt som att skapa en ny databas.

Skapa en samling för Azure Cosmos DB för MongoDB

För att skapa eller komma åt en befintlig samling använder vi en get-samlingsmetod eller referens beroende på programmeringsspråket. Nu ska vi lägga till kod i föregående exempel för att skapa/ansluta till en samling och lägga till en post i samlingen.

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

C#

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

I nästa lektion får vi se exakt hur vi skapade våra anslutningssträng.

Använda MongoDB-tilläggskommandon för att hantera data som lagras i Azure Cosmos DB:s API för MongoDB

Som vi beskrev tidigare ger Azure Cosmos DB for MongoDB oss möjlighet att använda samma drivrutiner och kod som vi använde för att komma åt och skapa våra objekt på en MongoDB-server för vårt Azure Cosmos DB-konto. Om du använder den koden för att skapa våra databaser och samlingar använder du standardparametrarna för skapande av Azure Cosmos DB. För att kunna dra nytta av Azure Cosmos DB-funktioner måste vi kunna styra parametrarna för databas- och samlingsskapande som dataflöde, automatisk skalning, tilldelning av shardnycklar och definition av index. Azure Cosmos DB for MongoDB ger oss den här möjligheten genom att använda utökade kommandon för att definiera dessa parametrar. Med de här kommandona kan vi koda mer exakta instruktioner om hur du skapar eller ändrar våra databaser och samlingar specifikt för Azure Cosmos DB.

Azure Cosmos DB for MongoDB tillhandahåller tilläggskommandon för följande typer av begäranden:

• Skapa databas
• Uppdatera databas
• Hämta databas
• Skapa samling
• Uppdatera samling
• Hämta samling

MongoDB-drivrutinerna tillhandahåller en funktion för att köra ett kommando mot en databas som vi använder den här funktionen för att skicka våra utökade kommandon till Azure Cosmos DB. Låt oss ta en titt på koden för att skapa en IoT-enhetssamling med ett dataflöde på 2 000 RU:er (enheter för begäran) och en shardnyckel för 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"})

C#

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

På liknande sätt kan vi ändra en samling eller skapa eller ändra en databas. Mer information finns i artikeln Använda MongoDB-tilläggskommandon för att hantera data som lagras i Azure Cosmos DB:s API för MongoDB.