Fiók, adatbázis és gyűjtemény létrehozása a MongoDB-hez készült Azure Cosmos DB használatával

8 perc

Az Azure Cosmos DB egy teljes körűen felügyelt, szolgáltatásként nyújtott platform (PaaS). A szolgáltatás használatához először létre kell hoznunk egy Azure Cosmos DB-fiókot az előfizetésünk alatt. A fiók létrehozása után adatbázisokat, gyűjteményeket és dokumentumokat adhat hozzá.

Áttekintünk pár módszert a különböző Azure Cosmos DB for MongoDB modellelemek létrehozására.

Fiók, adatbázis és tároló létrehozása a MongoDB-hez készült Azure Cosmos DB-hez az Azure Portal használatával

Az Azure Cosmos DB-fiók és elemei létrehozásának egyik módja az Azure Portal használata. Ebben a példában az Azure Portal használatával hozunk létre egy Azure Cosmos DB-fiókot a MongoDB-hez készült Azure Cosmos DB használatával. Ezután hozzáadunk egy adatbázist és egy gyűjteményt. Egyelőre ne aggódjon a későbbi modulokban részletesebben ismertetett speciális beállítások kitöltése miatt. Ebben a példában egyszerűen tekintse át az Alapismeretek lapot. Hozzuk létre a fiókunkat és annak elemeit.

Fiók létrehozása a MongoDB-hez készült Azure Cosmos DB-hez

Az Azure Portalon válassza a + Erőforrás létrehozása, az Azure Cosmos DB és a Létrehozás lehetőséget.
Válassza az Azure Cosmos DB for MongoDB lehetőséget.
Adja meg a következő paramétereket.
- Előfizetés – Az aktuális Azure-előfizetés.
- Erőforráscsoport – Új vagy meglévő Azure-erőforráscsoport az Azure Cosmos DB-fiók létrehozásához.
- Fióknév – Az Azure Cosmos DB-fiók egyedi neve. Ennek a névnek egyedinek kell lennie az Azure-ban. A fiók URI-ja mongo.cosmos.azure.com hozzá van fűzve a fiók nevéhez.
- Hely – Az Azure Cosmos DB-fiókot üzemeltető földrajzi hely. Általában a felhasználók vagy alkalmazások közelében kell kiválasztania egy helyet.
- Kapacitás mód – Ahogy az előző leckében is említettük, kiválaszthatja, hogy a fiókja a kiosztott átviteli sebességet vagy a kiszolgáló nélkülit használja. Válassza ki a kiosztott átviteli sebességet ebben a példában.
- Ingyenes szint kedvezmény alkalmazása – Válassza a Nem alkalmaz lehetőséget ebben a példában.
- A fiók teljes átviteli sebességének korlátozása – Hagyja bejelöletlenül a példában.
- Verzió – Válassza a 4.0-s verziót.
Feljegyzés

A támogatott funkciók jobb kihasználása érdekében javasoljuk, hogy a 3.6-os vagy újabb verziót használja, amikor csak lehetséges.
Válassza a Véleményezés + Létrehozás lehetőséget, majd sikeres érvényesítés esetén válassza a Létrehozás lehetőséget.

Feljegyzés

Az Azure Cosmos DB-fiók létrehozása több percet is igénybe vehet.

Adatbázis és tároló létrehozása a MongoDB-hez készült Azure Cosmos DB-hez

Az adatbázis és a tároló létrehozása az Azure Portalon egyenesen előrehaladt, először hozzunk létre egy adatbázist.

A MongoDB-fiókhoz készült Azure Cosmos DB bal oldali menüjében válassza az Adatkezelőt.
Válassza az Új gyűjtemény ikontól jobbra található lekéréses elemet, és válassza az Új adatbázis lehetőséget.
Adjon új nevet az adatbázisnak az adatbázis-azonosító szövegmezője alatt.
Bár megadhatjuk a kiosztott átviteli sebességet az Új adatbázis párbeszédpanelen, a legtöbb esetben a kiosztott átviteli sebességet a tároló szintjén választhatja ki. Vegye ki a pipát az Átviteli sebesség kiosztása jelölőnégyzetből, és kattintson az Ok-ra ebben a példában.

Most a MONGO API szakaszban kell észrevennünk az új adatbázist. Itt az ideje, hogy létrehozzuk az új gyűjteményt.
Válassza az Új gyűjtemény ikont.
Adja meg az alábbi paramétereket az Új gyűjtemény párbeszédpanelen.
- Adatbázis neve – Láthatja, hogy itt két lehetősége van, új létrehozása vagy meglévő használata. Ezzel a beállítással új adatbázist hozhat létre az új gyűjtemény létrehozásakor. Mivel az előző lépésekben már létrehozott egy új adatbázist, válassza a Meglévő használata lehetőséget, és válassza ki az adatbázis nevét a lekéréses beállítások közül.
- Gyűjteményazonosító – Ez a paraméter a gyűjteménynek adott név.
- Darabolás – Általában a szilánkosítást szeretnénk választani. Ez a beállítás lehetővé teszi, hogy az Azure Cosmos DB több bérlőre kiterjedő tárolókat hozzon létre a shard kulcs alapján. Nagy tárolók esetén az Azure Cosmos DB több fizikai csomóponton is elterjeszti a bérlőket a nagy léptékű skálázás érdekében. A skálázást részletesebben tárgyaljuk a Tervezési modulban. Válassza a Sharded lehetőséget.
  - Szelet kulcs – A shard kiválasztásához hozzá kell adnia egy szelet kulcsot. Ez a kulcs határozza meg a particionálási stratégiát. Az IoT -gyűjteményben például /deviceid vagy /region lehet a választott particionálási stratégiától függően. A particionálási stratégiát részletesebben a Tervezési modulban tárgyaljuk.
  - Dedikált átviteli sebesség kiépítése ehhez a gyűjteményhez jelölőnégyzet – Általában automatikus skálázásként vagy manuálisként szeretné kiépíteni a gyűjtemény átviteli sebességét. Ezzel a beállítással jobban szabályozhatja az egyes gyűjtemények költségeit. Az átviteli sebességről részletesebben a Tervezési modulban olvashat. Egyelőre jelölje be a jelölőnégyzetet, és válassza az Automatikus skálázás lehetőséget.
  - Gyűjtemény átviteli sebessége vagy gyűjtemény maximális RU/s - Attól függően, hogy a Manuális vagy az Automatikus skálázás lehetőséget választotta-e, be kell adnia a Gyűjtemény átviteli sebességét vagy a Gyűjtemény maximális RU/s-ját, vagy más szóval az átviteli módot. A fő különbség az, hogy manuális módban a választott RU/s összeget számítja fel, függetlenül attól, hogy használja-e őket. Az automatikus skálázás csak a kiválasztott maximális RU/s értékig számítja fel a használatot. Mindkét esetben a gyűjtemény szabályozni kezd, amint az átviteli sebesség eléri a kiválasztott értéket. Hagyja meg az előre definiált értéket ebben a példában.
  - Elemzési tár – Az Azure Cosmos DB elemzési tára túlmutat ezen leckék hatókörén. A témakörről további információt az Azure Cosmos DB elemzési tár cikkében talál.
  - Speciális/Indexelés – Részletesebben tárgyaljuk az indexeket a Tervezési modulban. Hagyja bejelölve a jelölőnégyzetet.

Most már rendelkeznie kell egy adatbázissal és egy gyűjteményrel, amelyhez csatlakozni kell. A következő leckében részletesebben foglalkozunk az Azure Cosmos DB MongoDB-fiókhoz való csatlakozással. Előtte tekintsük át az Azure Cosmos DB mongoDB-adatbázisokhoz és -gyűjteményekhez való létrehozásának egy másik módját.

Adatbázis és gyűjtemény létrehozása vagy csatlakoztatása a MongoDB-hez készült Azure Cosmos DB-hez

A MongoDB-hez készült Azure Cosmos DB-fiókjához a Java, a Python, a Node.js, a .NET vagy más programozási nyelv használatával mongoDB-illesztővel kell tudnia létrehozni vagy csatlakozni. Lássunk be néhány olyan függvényt, amellyel ezeket az elemeket a különböző nyelvek használatával hozhatja létre. A modul elején leszögeztük, hogy a fejlesztők továbbra is használhatják a MongoDB-illesztőprogramokat, az SDK-kat és azokat az eszközöket, amelyekkel az Azure Cosmos DB-hez csatlakozhatnak, és alkalmazásokat hozhatnak létre. Ezeket az illesztőprogramokat és azok tulajdonságait és módszereit használva programozza a hozzáférésünket és a műveleteket a MongoDB-hez készült Azure Cosmos DB-fiókon.

Adatbázis létrehozása vagy csatlakoztatása a MongoDB-hez készült Azure Cosmos DB-hez

Kedvenc fejlesztőeszközével létrehozhatja a MongoDB-hez készült Azure Cosmos DB-alkalmazást. Az adatbázisok és gyűjtemények létrehozásához a MongoDB-illesztőt használjuk az egyes programozási nyelvekhez. Tekintsük át a MongoDB-fiókokhoz készült Azure Cosmos DB-fiókokhoz való csatlakozáshoz és a termékek adatbázisához való csatlakozáshoz szükséges kódot.

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

Ilyen egyszerű, ha az illesztővel csatlakozunk, vagy létrehozunk egy új adatbázist, vagy egy meglévőre mutatunk a GetDatabase használatával, vagy a nyelvtől függően hasonló módszereket használunk. Az alkalmazás mostantól a ProductDatabase változóval hivatkozhat a kívánt adatbázisra. A gyűjtemény létrehozása vagy az azokhoz való csatlakozás ugyanolyan egyszerű, mint egy új adatbázis létrehozása.

Azure Cosmos DB-adatbázis gyűjtemény létrehozása a MongoDB-hez

Meglévő gyűjtemény létrehozásához vagy eléréséhez a programozási nyelvtől függően get collection metódust vagy hivatkozást használunk. Adjunk hozzá néhány kódot az előző példához, hogy létrehozzunk/kapcsolódjunk egy gyűjteményhez, és adjunk hozzá egy bejegyzést a gyűjteményhez.

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

A következő leckében látni fogjuk, hogy pontosan hogyan hoztuk létre a kapcsolati sztringet.

MongoDB-bővítményparancsok használata az Azure Cosmos DB MongoDB-hez készült API-jában tárolt adatok kezeléséhez

Ahogy korábban már említettük, az Azure Cosmos DB for MongoDB lehetővé teszi számunkra, hogy ugyanazokat az illesztőprogramokat és kódot használjuk, mint az objektumok elérése és létrehozása egy MongoDB-kiszolgálón az Azure Cosmos DB-fiókhoz. Az adatbázisok és gyűjtemények létrehozásához használt kód azonban az alapértelmezett Azure Cosmos DB létrehozási paramétereket használja. Az Azure Cosmos DB funkcióinak kihasználásához szabályozni kell az adatbázis- és gyűjteménylétrehozási paramétereket, például az átviteli sebességet, az automatikus skálázást, a szegmenskulcsok hozzárendelését és az indexek definiálását. A MongoDB-hez készült Azure Cosmos DB ezt a lehetőséget nyújtja, ha kiterjesztett parancsokkal definiálja ezeket a paramétereket. Ezek a parancsok lehetővé teszik, hogy pontosabb utasításokat kódjunk az adatbázisok és gyűjtemények kifejezetten az Azure Cosmos DB-hez való létrehozásához vagy módosításához.

Az Azure Cosmos DB for MongoDB bővítményparancsokat biztosít a következő kéréstípusokhoz:

Adatbázis létrehozása
Adatbázis frissítése
Adatbázis lekérése
Gyűjtemény létrehozása
Frissítési gyűjtemény
Gyűjtemény lekérése

A MongoDB-illesztőprogramok egy olyan függvényt biztosítanak, amely parancsokat futtat egy adatbázison, a függvény használatával kiterjesztett parancsokat küldünk az Azure Cosmos DB-nek. Nézzük meg a kódot, amely létrehozza a 2000 RU átvitellel rendelkező IoT-eszközgyűjteményt a DeviceId partíciós kulcsával.

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

Hasonló módon módosíthatjunk egy gyűjteményt, vagy létrehozhatunk vagy módosíthatunk egy adatbázist. További információkért tekintse át a MongoDB-bővítményparancsok használatát az Azure Cosmos DB Api for MongoDB-cikkben tárolt adatok kezeléséhez.

Visszajelzés

Hasznosnak találta ezt az oldalt?