Vytvoření účtu, databáze a kolekce pomocí služby Azure Cosmos DB pro MongoDB

8 min

Azure Cosmos DB je plně spravovaná platforma jako služba (PaaS). Abychom mohli tuto službu použít, musíme nejprve vytvořit účet služby Azure Cosmos DB v rámci našeho předplatného. Po vytvoření účtu pak můžeme do něj přidat databázi, kolekce a dokumenty.

Podíváme se na několik způsobů, jak vytvořit různé prvky modelu Azure Cosmos DB pro MongoDB.

Vytvoření účtu, databáze a kontejneru pro Azure Cosmos DB pro MongoDB pomocí webu Azure Portal

Jedním ze způsobů, jak vytvořit účet služby Azure Cosmos DB a jeho prvky, je použití webu Azure Portal. V tomto příkladu pomocí webu Azure Portal vytvoříme účet služby Azure Cosmos DB pomocí služby Azure Cosmos DB pro MongoDB. Pak přidáme databázi a kolekci. V tuto chvíli si nedělejte starosti s vyplněním pokročilejších nastavení, která probereme podrobněji v dalších modulech. V tomto příkladu stačí jen zkontrolovat kartu Základy. Pojďme vytvořit náš účet a jeho prvky.

Vytvoření účtu pro Azure Cosmos DB pro MongoDB

Na webu Azure Portal vyberte + Vytvořit prostředek, vyberte Azure Cosmos DB a Vytvořit.
Vyberte Azure Cosmos DB pro MongoDB.
Zadejte následující parametry.
- Předplatné – Vaše aktuální předplatné Azure.
- Skupina prostředků – Nová nebo existující skupina prostředků Azure pro vytvoření účtu Azure Cosmos DB.
- Název účtu – jedinečný název vašeho účtu služby Azure Cosmos DB. Tento název musí být jedinečný v rámci Azure. Identifikátor URI vašeho účtu mongo.cosmos.azure.com připojený k názvu vašeho účtu.
- Umístění – zeměpisné umístění, které je hostitelem vašeho účtu služby Azure Cosmos DB. Obvykle byste měli vybrat umístění blízko uživatelům nebo aplikacím.
- Režim kapacity – jak jsme probrali v předchozí lekci, můžete pro svůj účet vybrat zřízenou propustnost nebo bezserverovou verzi. V tomto příkladu vyberte Zřízenou propustnost .
- Použít slevu Free Tier – v tomto příkladu vyberte Neaplikovat.
- Omezit celkovou propustnost účtu – V tomto příkladu ponechejte nezaškrtnutou možnost.
- Verze – Vyberte 4.0.
Poznámka:

Pokud chcete lépe využít podporované funkce, doporučujeme používat verze 3.6 nebo novější, kdykoli je to možné.
Vyberte Zkontrolovat a vytvořit a při úspěšném ověření vyberte Vytvořit.

Poznámka:

Vytvoření účtu služby Azure Cosmos DB může trvat několik minut.

Vytvoření databáze a kontejneru pro Azure Cosmos DB pro MongoDB

Vytvoření databáze a kontejneru na webu Azure Portal je jednoduché. Nejprve vytvoříme databázi.

V levé nabídce účtu Azure Cosmos DB pro MongoDB vyberte Data Explorer.
Vyberte rozevírací seznam napravo od ikony Nová kolekce a vyberte Nová databáze.
Do textového pole ID databáze zadejte nový název databáze.
I když bychom mohli definovat zřizovanou propustnost v dialogovém okně Nová databáze, ve většině případů vyberete zřizovanou propustnost na úrovni kontejneru. Odškrtněme políčko Zřídit propustnost a pro tento příklad vyberte Ok.

Nyní bychom si měli všimnout nové databáze v části MONGO API. Je čas vytvořit novou kolekci.
Vyberte ikonu Nová kolekce.
Do dialogového okna Nová kolekce zadejte následující parametry.
- Název databáze – Všimněte si, že tady máte dvě možnosti, Vytvořit novou nebo Použít existující. Tato možnost umožňuje vytvořit novou databázi v době, kdy vytváříte novou kolekci. Vzhledem k tomu, že jsme už v předchozích krocích vytvořili novou databázi, vyberte Použít existující a vyberte název databáze z možností pro stažení.
- ID kolekce – Tento parametr je název, který dáváte kolekci.
- Horizontální dělení – Obvykle bychom chtěli vybrat horizontální dělení. Tato možnost umožňuje službě Azure Cosmos DB vytvářet kontejnery, které jsou horizontálně dělené napříč více tenanty na základě klíče shardování. S velkými kontejnery služba Azure Cosmos DB rozloží vaše tenanty do několika fyzických uzlů, aby dosáhla vysokého stupně škálování. Horizontální dělení probereme podrobněji v modulu Návrh . Vyberte Sharded.
  - Klíč shardu – Výběr shardovaného vyžaduje, abyste přidali klíč shardu. Tento klíč je klíč oddílu, který definuje strategii dělení. Například v kolekci IoT (Internet věcí) může být /deviceid nebo /region v závislosti na zvolené strategii dělení. Strategii dělení probereme podrobněji v modulu Návrh .
  - Zaškrtávací políčko pro přidělení vyhrazené propustnosti této kolekci – obvykle chcete nastavit propustnost kolekce buď jako automatické škálování, nebo ruční. Toto nastavení vám umožní mít lepší kontrolu nad náklady na jednotlivé kolekce. Propustnost probereme podrobněji v modulu Návrh . Prozatím zaškrtněte políčko a vyberte Automatické škálování.
  - Propustnost kolekce nebo maximální počet RU/s kolekce – V závislosti na tom, jestli jste vybrali ruční nebo automatické škálování, musíte zadat propustnost kolekce nebo maximální počet RU/s kolekce, jinak řečeno režim propustnosti. Hlavní rozdíl spočívá v tom, že v ručním režimu se vám účtuje částka, kterou jste zvolili RU/s bez ohledu na to, jestli je používáte nebo ne. Automatické škálování účtuje jenom to, co použijete až na maximální počet RU/s, které jste vybrali. V obou případech se vaše kolekce začne omezovat, jakmile její propustnost dosáhne vybrané hodnoty. Pro tento příklad ponechte předdefinovanou hodnotu.
  - Analytické úložiště – Analytické úložiště Azure Cosmos DB je nad rámec těchto lekcí. Další informace o tomto tématu najdete v článku o analytickém úložišti Azure Cosmos DB.
  - Rozšířené/indexování – podrobněji probereme indexy v modulu Návrh . Políčko nechte zaškrtnuté.

Teď bychom měli mít databázi a jednu kolekci pro připojení. V další lekci se podrobněji podíváme na připojení k účtu Azure Cosmos DB for MongoDB. Před tím se podíváme na jiný způsob vytváření databází a kolekcí Azure Cosmos DB pro MongoDB.

Vytvořte nebo se připojte k databázi a kolekci pro Azure Cosmos DB pro MongoDB.

Pomocí ovladače MongoDB v Javě, Pythonu, Node.js, .NET nebo jiném programovacím jazyce byste měli být schopni vytvořit nebo připojit ke svému účtu Azure Cosmos DB for MongoDB. Představme si některé funkce, které byste použili k vytvoření těchto prvků pomocí některých různých jazyků. Na začátku tohoto modulu jsme uvedli, že vývojáři můžou dál používat ovladače MongoDB, sady SDK a nástroje, které znají pro připojení ke službě Azure Cosmos DB a vytváření aplikací. Tyto ovladače a jejich vlastnosti a metody používáme k programování přístupu a operací s účtem Azure Cosmos DB for MongoDB.

Vytvoření databáze služby Azure Cosmos DB pro MongoDB nebo připojení k databázi

Pomocí svého oblíbeného vývojového nástroje můžete vytvořit aplikaci Azure Cosmos DB for MongoDB. K vytvoření databází a kolekcí používáme ovladač MongoDB pro každý příslušný programovací jazyk. Pojďme se podívat na kód pro připojení k účtům Azure Cosmos DB for MongoDB a připojení k databázi produktů .

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

Je to jednoduché, když se připojíme pomocí ovladače, buď vytvoříme novou databázi, nebo odkazujeme na existující databázi s GetDatabase nebo podobnými metodami v závislosti na jazyce. Naše aplikace teď může použít proměnnou ProductDatabase k odkazování na požadovanou databázi. Vytvoření nebo připojení ke kolekci je stejně jednoduché, jako kdybyste vytvořili novou databázi.

Vytvoření kolekce pro Azure Cosmos DB pro MongoDB

K vytvoření nebo přístupu k existující kolekci používáme metodu získání kolekce nebo odkaz v závislosti na programovacím jazyce. Pojďme do předchozího příkladu přidat kód pro vytvoření nebo připojení ke kolekci a přidání jedné položky do této kolekce.

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

V další lekci uvidíme, jak přesně jsme vytvořili náš připojovací řetězec.

Použití příkazů rozšíření MongoDB ke správě dat uložených v rozhraní API služby Azure Cosmos DB pro MongoDB

Jak jsme si probrali dříve, azure Cosmos DB pro MongoDB nám umožňuje používat stejné ovladače a kód, které jsme použili pro přístup k našim účtům Azure Cosmos DB, a vytvářet objekty na serveru MongoDB. Tento kód ale použijete k vytvoření našich databází a kolekcí s použitím výchozích parametrů pro vytvoření Azure Cosmos DB. Abychom mohli využívat funkce služby Azure Cosmos DB, musíme mít možnost řídit parametry vytváření databází a kolekcí, jako je propustnost, automatické škálování, přiřazování klíčů horizontálních oddílů a definování indexů. Azure Cosmos DB pro MongoDB nám tuto možnost poskytuje pomocí rozšířených příkazů k definování těchto parametrů. Tyto příkazy nám umožňují kódovat přesnější pokyny k vytváření nebo úpravám databází a kolekcí speciálně pro službu Azure Cosmos DB.

Azure Cosmos DB pro MongoDB poskytuje příkazy rozšíření pro následující typy požadavků:

Vytvoření databáze
Aktualizace databáze
Získání databáze
Vytvoření kolekce
Aktualizace kolekce
Získání kolekce

Ovladače MongoDB poskytují funkci pro spuštění příkazu v databázi, kterou používáme k odesílání rozšířených příkazů do služby Azure Cosmos DB. Podívejme se na kód, který vytvoří kolekci zařízení IoT s propustností 2000 RU (jednotky žádostí) a šardovacím klíčem 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""}");

Podobným způsobem můžeme upravit kolekci nebo vytvořit nebo upravit databázi. Další informace najdete v článku Použití příkazů rozšíření MongoDB ke správě dat uložených v rozhraní API služby Azure Cosmos DB pro MongoDB.

Váš názor

Byla tato stránka užitečná?