Tworzenie konta, bazy danych i kolekcji przy użyciu usługi Azure Cosmos DB dla bazy danych MongoDB

8 min

Azure Cosmos DB to w pełni zarządzana platforma jako usługa (PaaS). Aby korzystać z tej usługi, musimy najpierw utworzyć konto usługi Azure Cosmos DB w ramach subskrypcji. Po utworzeniu konta możemy dodać w nim bazę danych, kolekcje i dokumenty.

Przyjrzymy się kilku sposobom tworzenia różnych elementów modelu usługi Azure Cosmos DB dla bazy danych MongoDB.

Tworzenie konta, bazy danych i kontenera dla usługi Azure Cosmos DB dla bazy danych MongoDB przy użyciu witryny Azure Portal

Jednym ze sposobów tworzenia konta usługi Azure Cosmos DB i jego elementów jest użycie witryny Azure Portal. W tym przykładzie użyjemy witryny Azure Portal do utworzenia konta usługi Azure Cosmos DB przy użyciu usługi Azure Cosmos DB dla bazy danych MongoDB. Następnie dodamy bazę danych i kolekcję. Na razie nie martw się o wypełnianie bardziej zaawansowanych ustawień, które bardziej szczegółowo omówimy w kolejnych modułach. W tym przykładzie wystarczy przejrzeć kartę Podstawy. Utwórzmy nasze konto i jego elementy.

Tworzenie konta dla usługi Azure Cosmos DB dla bazy danych MongoDB

W witrynie Azure Portal wybierz pozycję + Utwórz zasób, wybierz pozycję Azure Cosmos DB i utwórz.
Wybierz Azure Cosmos DB dla MongoDB.
Wprowadź następujące parametry.
- Subskrypcja — bieżąca subskrypcja platformy Azure.
- Grupa zasobów — nowa lub istniejąca grupa zasobów platformy Azure do utworzenia konta usługi Azure Cosmos DB.
- Nazwa konta — unikatowa nazwa konta usługi Azure Cosmos DB. Ta nazwa musi być unikatowa na platformie Azure. Identyfikator URI konta mongo.cosmos.azure.com dołączony do nazwy konta.
- Lokalizacja — lokalizacja geograficzna, która hostuje konto usługi Azure Cosmos DB. Zazwyczaj należy wybrać lokalizację znajdującą się blisko użytkowników lub aplikacji.
- Tryb pojemności — jak omówiono w poprzedniej lekcji, możesz wybrać dla swojego konta opcję użycia aprowizowanej przepustowości lub bezserwerowej. W tym przykładzie wybierz Aprowizowana przepływność.
- Zastosuj rabat w warstwie Bezpłatna — wybierz pozycję Nie stosuj dla tego przykładu.
- Ogranicz łączną przepływność konta — pozostaw niezaznaczone dla tego przykładu.
- Wersja — wybierz pozycję 4.0.
Uwaga

Aby lepiej korzystać z obsługiwanych funkcji, zalecamy używanie wersji 3.6 lub nowszej, jeśli jest to możliwe.
Wybierz Przejrzyj i utwórz, a następnie po pomyślnej weryfikacji wybierz Utwórz.

Uwaga

Utworzenie konta usługi Azure Cosmos DB może potrwać kilka minut.

Tworzenie bazy danych i kontenera dla usługi Azure Cosmos DB dla bazy danych MongoDB

Tworzenie bazy danych i kontenera w witrynie Azure Portal jest proste. Najpierw utwórzmy bazę danych.

W menu po lewej stronie konta usługi Azure Cosmos DB dla bazy danych MongoDB wybierz pozycję Eksplorator danych.
Wybierz ściągnięcie po prawej stronie ikony Nowa kolekcja i wybierz pozycję Nowa baza danych.
Nadaj bazie danych nową nazwę w polu tekstowym Identyfikator bazy danych.
Chociaż możemy zdefiniować przepływność aprowizowania w oknie dialogowym Nowa baza danych, w większości przypadków wybrałbyś aprowizowaną przepływność na poziomie kontenera. Usuńmy zaznaczeniepola wyboru udostępnionej przepustowości i wybierzmy OK w tym przykładzie.

Teraz powinniśmy zauważyć nową bazę danych w sekcji interfejsu API MONGO. Nadszedł czas, aby utworzyć nową kolekcję.
Wybierz ikonę Nowa kolekcja .
Wprowadź następujące parametry w oknie dialogowym Nowa kolekcja .
- Nazwa bazy danych — w tym miejscu masz dwie opcje: Utwórz nową lub Użyj istniejącej. Ta opcja umożliwia utworzenie nowej bazy danych w momencie tworzenia nowej kolekcji. Ponieważ w poprzednich krokach utworzyliśmy nową bazę danych, wybierz pozycję Użyj istniejącej i wybierz nazwę bazy danych z opcji ściągania.
- Identyfikator kolekcji — ten parametr jest nazwą nadaną kolekcji.
- Fragmentowanie — zwykle chcemy wybrać fragmentowanie. Ta opcja umożliwia usłudze Azure Cosmos DB tworzenie kontenerów podzielonych na fragmenty w wielu dzierżawach na podstawie klucza fragmentu. Dzięki dużym kontenerom usługa Azure Cosmos DB rozprowadza dzierżawców w wielu węzłach fizycznych, aby osiągnąć wysoki poziom skalowalności. Bardziej szczegółowo omawiamy fragmentowanie w module Projektowanie . Wybierz pozycję Podzielone na fragmenty.
  - Klucz fragmentacji — wybranie opcji shardowane wymaga dodania klucza fragmentacji. Ten klucz jest kluczem partycji, który definiuje strategię partycjonowania. Na przykład w kolekcji IoT (Internet of Things) może to być /deviceid lub /region w zależności od wybranej strategii partycjonowania. Bardziej szczegółowo omawiamy strategię partycjonowania w module Projektowanie .
  - Konfigurowanie dedykowanej przepustowości dla tej kolekcji — zwykle chcesz ustawić przepustowość kolekcji jako autoskalowanie lub ręczne. To ustawienie umożliwia lepszą kontrolę nad kosztami poszczególnych kolekcji. Bardziej szczegółowo omawiamy przepływność w module Projektowanie . Na razie zaznacz pole wyboru i wybierz pozycję Autoskaluj.
  - Przepływność kolekcji lub Maksymalna liczba jednostek RU/s kolekcji — w zależności od tego, czy wybrano opcję Ręczne lub Automatyczne skalowanie, musisz wprowadzić odpowiednio przepływność kolekcji lub maksymalną liczbę JEDNOSTEK RU/s kolekcji lub inaczej tryb przepływności. Główną różnicą jest to, że w trybie ręcznym naliczane są opłaty za wybraną ilość jednostek RU/s, niezależnie od tego, czy są używane, czy nie. Autoskalowanie nalicza opłaty tylko za użycie do wybranej maksymalnej liczby RU/s. W obu przypadkach kolekcja rozpoczyna ograniczanie przepustowości, gdy jej przepływność osiągnie wybraną wartość. Pozostaw wstępnie zdefiniowaną wartość dla tego przykładu.
  - Magazyn analityczny — magazyn analityczny usługi Azure Cosmos DB wykracza poza zakres tych lekcji. Aby uzyskać więcej informacji na temat tego tematu, zapoznaj się z artykułem Co to jest magazyn analityczny usługi Azure Cosmos DB.
  - Zaawansowane/indeksowanie — bardziej szczegółowo omawiamy indeksy w module Projektowanie . Pozostaw zaznaczone pole wyboru.

Teraz powinniśmy mieć bazę danych i jedną kolekcję, z którymi możemy się połączyć. W następnej lekcji bardziej szczegółowo omówimy nawiązywanie połączenia z kontem usługi Azure Cosmos DB dla bazy danych MongoDB. Przed tym przejrzyjmy inny sposób tworzenia baz danych i kolekcji usługi Azure Cosmos DB dla bazy danych MongoDB.

Tworzenie bazy danych i kolekcji dla usługi Azure Cosmos DB dla bazy danych MongoDB lub nawiązywanie z nią połączenia

Powinno być możliwe utworzenie lub nawiązanie połączenia z kontem usługi Azure Cosmos DB dla bazy danych MongoDB przy użyciu sterownika Java, Python, Node.js, .NET lub innego języka programowania za pomocą sterownika Bazy danych MongoDB. Przedstawimy niektóre funkcje, których można użyć do utworzenia tych elementów przy użyciu niektórych różnych języków. Na początku tego modułu stwierdziliśmy, że deweloperzy mogą nadal korzystać ze sterowników, zestawów SDK i narzędzi bazy danych MongoDB, które znają w celu nawiązania połączenia z usługą Azure Cosmos DB i tworzenia aplikacji. Używamy tych sterowników i ich właściwości i metod do programowania dostępu i operacji względem naszego konta usługi Azure Cosmos DB dla bazy danych MongoDB.

Tworzenie bazy danych dla usługi Azure Cosmos DB dla bazy danych MongoDB lub nawiązywanie z nią połączenia

Możesz użyć ulubionego narzędzia programistycznego, aby utworzyć aplikację usługi Azure Cosmos DB dla bazy danych MongoDB. Do tworzenia baz danych i kolekcji używamy sterownika MongoDB dla każdego odpowiedniego języka programowania. Przejrzyjmy kod, aby nawiązać połączenie z kontami MongoDB w Azure Cosmos DB i z bazą danych produktów.

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

Jest to proste, gdy połączymy się przy użyciu sterownika, tworzymy nową bazę danych lub wskazujemy istniejącą za pomocą metody GetDatabase lub podobnych metod w zależności od języka. Nasza aplikacja może teraz używać zmiennej ProductDatabase do odwołowania się do żądanej bazy danych. Tworzenie lub nawiązywanie połączenia z kolekcją jest tak proste, jak tworzenie nowej bazy danych.

Tworzenie kolekcji dla usługi Azure Cosmos DB dla bazy danych MongoDB

Aby utworzyć istniejącą kolekcję lub uzyskać do nich dostęp, użyjemy metody get collection lub odwołania w zależności od języka programowania. Dodajmy kod do poprzedniego przykładu w celu utworzenia/nawiązania połączenia z kolekcją i dodania jednego wpisu do tej kolekcji.

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

W następnej lekcji zobaczymy, jak dokładnie stworzyliśmy nasz łańcuch połączeń.

Zarządzanie danymi przechowywanymi w interfejsie API usługi Azure Cosmos DB dla bazy danych MongoDB za pomocą poleceń rozszerzenia MongoDB

Jak wspomniano wcześniej, usługa Azure Cosmos DB dla bazy danych MongoDB daje nam możliwość używania tych samych sterowników i kodu, który użyliśmy do uzyskiwania dostępu do obiektów i tworzenia ich na serwerze MongoDB dla naszego konta usługi Azure Cosmos DB. Jednak użycie tego kodu do utworzenia naszych baz danych i kolekcji używa domyślnych parametrów tworzenia usługi Azure Cosmos DB. Aby korzystać z funkcji usługi Azure Cosmos DB, musimy mieć możliwość kontrolowania parametrów tworzenia bazy danych i kolekcji, takich jak przepływność, skalowanie automatyczne, przypisywanie kluczy fragmentów i definiowanie indeksów. Usługa Azure Cosmos DB dla bazy danych MongoDB umożliwia definiowanie tych parametrów przy użyciu rozszerzonych poleceń. Te polecenia pozwalają nam kodować bardziej precyzyjne instrukcje dotyczące tworzenia lub modyfikowania baz danych i kolekcji specjalnie dla usługi Azure Cosmos DB.

Usługa Azure Cosmos DB dla bazy danych MongoDB udostępnia polecenia rozszerzenia dla następujących typów żądań:

Tworzenie bazy danych
Aktualizowanie bazy danych
Pobieranie bazy danych
Tworzenie kolekcji
Aktualizowanie kolekcji
Pobierz kolekcję

Sterowniki bazy danych MongoDB udostępniają funkcję do uruchamiania polecenia względem bazy danych, która jest używana do wysyłania naszych rozszerzonych poleceń do usługi Azure Cosmos DB. Przyjrzyjmy się kodowi, aby utworzyć kolekcję urządzeń IoT z przepływnością 2000 jednostek RU (jednostek żądań) i kluczem fragmentu identyfikatora 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""}");

W podobny sposób możemy zmodyfikować kolekcję lub utworzyć lub zmodyfikować bazę danych. Aby uzyskać więcej informacji, zapoznaj się z artykułem Use MongoDB extension commands to manage data stored in Azure Cosmos DB's API for MongoDB (Zarządzanie danymi przechowywanymi w interfejsie API usługi Azure Cosmos DB dla bazy danych MongoDB ).

Sprzężenie zwrotne

Czy ta strona była pomocna?