Integrace služby Azure Cosmos DB pro MongoDB se službou Připojení or

Tato stránka ukazuje podporované metody ověřování a klienty a ukazuje ukázkový kód, který můžete použít k připojení služby Azure Cosmos DB pro MongoDB k jiným cloudovým službám pomocí služby Připojení or. Stále se můžete připojit ke službě Azure Cosmos DB pro MongoDB v jiných programovacích jazycích bez použití služby Připojení or. Tato stránka také zobrazuje výchozí názvy proměnných prostředí a hodnoty (nebo konfiguraci Spring Boot), které získáte při vytváření připojení služby.

Podporované výpočetní služby

Služba Připojení or se dá použít k připojení následujících výpočetních služeb ke službě Azure Cosmos DB for MongoDB:

• Azure App Service
• Azure Functions
• Azure Container Apps
• Azure Spring Apps

Podporované typy ověřování a typy klientů

Následující tabulka ukazuje, které kombinace typů klientů a metod ověřování se podporují pro připojení výpočetní služby ke službě Azure Cosmos DB pro MongoDB pomocí služby Připojení or. "Ano" označuje, že kombinace je podporována, zatímco "Ne" označuje, že není podporována.

Typ klienta	Spravovaná identita přiřazená systémem	Spravovaná identita přiřazená uživatelem	Tajný kód / připojovací řetězec	Instanční objekt
.NET	Ano	Ano	Ano	Yes
Java	Ano	Ano	Ano	Yes
Java – Spring Boot	No	No	Ano	No
Node.js	Ano	Ano	Ano	Yes
Python	Ano	Ano	Ano	Yes
Přejít	Ano	Ano	Ano	Yes
Nic	Ano	Ano	Ano	Yes

Tato tabulka označuje, že jsou podporovány všechny kombinace typů klientů a metod ověřování v tabulce, s výjimkou typu klienta Java – Spring Boot, který podporuje pouze metodu Secret / připojovací řetězec. Všechny ostatní typy klientů můžou k připojení ke službě Azure Cosmos DB for MongoDB použít některou z metod ověřování pomocí služby Připojení or.

Výchozí názvy proměnných prostředí nebo vlastnosti aplikace a ukázkový kód

Pomocí níže uvedených podrobností o připojení připojte výpočetní služby ke službě Azure Cosmos DB. Tato stránka také zobrazuje výchozí názvy proměnných prostředí a hodnoty (nebo konfiguraci Spring Boot), které získáte při vytváření připojení služby a také vzorový kód. V každém příkladu níže nahraďte zástupné texty <mongo-db-admin-user>, <password>, <Azure-Cosmos-DB-API-for-MongoDB-account><subscription-ID>, <resource-group-name>, , <client-secret>a <tenant-id> vlastními informacemi. Další informace o konvencích vytváření názvů najdete v článku o interních informacích o službě Připojení.

Spravovaná identita přiřazená systémem

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adresa URL pro získání připojovací řetězec	https://management.azure.com/subscriptions/<subscription-ID>/resourceGroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<Azure-Cosmos-DB-API-for-MongoDB-account>/listConnectionStrings?api-version=2021-04-15
AZURE_COSMOS_SCOPE	Rozsah spravované identity	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Váš koncový bod prostředku	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Ukázkový kód

Pokud se chcete připojit ke službě Azure Cosmos DB for MongoDB pomocí spravované identity přiřazené systémem, projděte si následující postup a kód.

.NET

1. Instalace závislostí

   dotnet add package MongoDb.Driver
   dotnet add package Azure.Identity
   

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí klientské knihovny Azure.Identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using MongoDB.Driver;
   using Azure.Identity;
   using System.Text.Json;
   
   var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // 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 string[]{ scope }));
   
   // Get the connection string.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listConnectionStringUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Do souboru pom.xml přidejte následující závislosti:

   <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>3.4.2</version>
    </dependency> 
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system 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();
   
   // Get the access token.
   AccessToken accessToken = defaultCredential.getToken(new TokenRequestContext().addScopes(new String[]{ scope })).block();
   String token = accessToken.getToken();
   
   // Get the connection string.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listConnectionStringUrl))
       .header("Authorization", "Bearer " + token)
       .POST()
       .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 mongoClient = new MongoClient(uri);
   

SpringBoot

Typ ověřování není pro Spring Boot podporován.

Python

1. Nainstalujte závislosti.

   pip install pymongo
   pip install azure-identity
   

2. V kódu získejte přístupový token prostřednictvím azure-identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import os
   import pymongo
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # 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)
   

Přejít

1. Nainstalujte závislosti.

   go get go.mongodb.org/mongo-driver/mongo
   go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"
   

2. V kódu získejte přístupový token prostřednictvím azidentitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "go.mongodb.org/mongo-driver/bson"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   endpoint = os.Getenv("AZURE_COSMOS_RESOURCEENDPOINT")
   listConnectionStringUrl = os.Getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL")
   scope = os.Getenv("AZUE_COSMOS_SCOPE")
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
   // For user-assigned identity.
   // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
   // azidentity.ManagedIdentityCredentialOptions.ID := clientid
   // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
   // cred, err := azidentity.NewManagedIdentityCredential(options)
   
   // For service principal.
   // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
   // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
   // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
   // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
   // Acquire the access token.
   ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
   token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
       Scopes: []string{scope},
   })
   
   // Acquire the connection string.
   client := &http.Client{}
   req, err := http.NewRequest("POST", listConnectionStringUrl, nil)
   req.Header.Add("Authorization", "Bearer " + token.Token)
   resp, err := client.Do(req)
   body, err := ioutil.ReadAll(resp.Body)
   var result map[string]interface{}
   json.Unmarshal(body, &result)
   connectionString, err := result["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
   clientOptions := options.Client().ApplyURI(connectionString).SetDirect(true)
   
   c, err := mongo.Connect(ctx, clientOptions)
   

NodeJS

1. Instalace závislostí

   npm install mongodb
   npm install --save @azure/identity
   

2. V kódu získejte přístupový token prostřednictvím @azure/identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   const { MongoClient, ObjectId } = require('mongodb');
   const axios = require('axios');
   
   let endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned 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;
   
   // Acquire the access token.
   var 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'];
   
   const client = new MongoClient(connectionString);
   

Další

V jiných jazycích můžete použít koncový bod prostředku MongoDB a další vlastnosti, které service Připojení or nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB se službou Připojení or.

Spravovaná identita přiřazená uživatelem

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adresa URL pro získání připojovací řetězec	https://management.azure.com/subscriptions/<subscription-ID>/resourceGroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<Azure-Cosmos-DB-API-for-MongoDB-account>/listConnectionStrings?api-version=2021-04-15
AZURE_COSMOS_SCOPE	Rozsah spravované identity	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	ID klienta	<client-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Váš koncový bod prostředku	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Ukázkový kód

Pokud se chcete připojit ke službě Azure Cosmos DB pro MongoDB pomocí spravované identity přiřazené uživatelem, projděte si následující postup a kód.

.NET

1. Instalace závislostí

   dotnet add package MongoDb.Driver
   dotnet add package Azure.Identity
   

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí klientské knihovny Azure.Identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using MongoDB.Driver;
   using Azure.Identity;
   using System.Text.Json;
   
   var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // 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 string[]{ scope }));
   
   // Get the connection string.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listConnectionStringUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Do souboru pom.xml přidejte následující závislosti:

   <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>3.4.2</version>
    </dependency> 
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system 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();
   
   // Get the access token.
   AccessToken accessToken = defaultCredential.getToken(new TokenRequestContext().addScopes(new String[]{ scope })).block();
   String token = accessToken.getToken();
   
   // Get the connection string.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listConnectionStringUrl))
       .header("Authorization", "Bearer " + token)
       .POST()
       .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 mongoClient = new MongoClient(uri);
   

SpringBoot

Typ ověřování není pro Spring Boot podporován.

Python

1. Nainstalujte závislosti.

   pip install pymongo
   pip install azure-identity
   

2. V kódu získejte přístupový token prostřednictvím azure-identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import os
   import pymongo
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # 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)
   

Přejít

1. Nainstalujte závislosti.

   go get go.mongodb.org/mongo-driver/mongo
   go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"
   

2. V kódu získejte přístupový token prostřednictvím azidentitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "go.mongodb.org/mongo-driver/bson"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   endpoint = os.Getenv("AZURE_COSMOS_RESOURCEENDPOINT")
   listConnectionStringUrl = os.Getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL")
   scope = os.Getenv("AZUE_COSMOS_SCOPE")
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
   // For user-assigned identity.
   // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
   // azidentity.ManagedIdentityCredentialOptions.ID := clientid
   // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
   // cred, err := azidentity.NewManagedIdentityCredential(options)
   
   // For service principal.
   // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
   // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
   // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
   // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
   // Acquire the access token.
   ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
   token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
       Scopes: []string{scope},
   })
   
   // Acquire the connection string.
   client := &http.Client{}
   req, err := http.NewRequest("POST", listConnectionStringUrl, nil)
   req.Header.Add("Authorization", "Bearer " + token.Token)
   resp, err := client.Do(req)
   body, err := ioutil.ReadAll(resp.Body)
   var result map[string]interface{}
   json.Unmarshal(body, &result)
   connectionString, err := result["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
   clientOptions := options.Client().ApplyURI(connectionString).SetDirect(true)
   
   c, err := mongo.Connect(ctx, clientOptions)
   

NodeJS

1. Instalace závislostí

   npm install mongodb
   npm install --save @azure/identity
   

2. V kódu získejte přístupový token prostřednictvím @azure/identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   const { MongoClient, ObjectId } = require('mongodb');
   const axios = require('axios');
   
   let endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned 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;
   
   // Acquire the access token.
   var 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'];
   
   const client = new MongoClient(connectionString);
   

Další

V jiných jazycích můžete použít koncový bod prostředku MongoDB a další vlastnosti, které service Připojení or nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB se službou Připojení or.

Connection string

Typ klienta SpringBoot

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
spring.data.mongodb.database	Vaše databáze	<database-name>
spring.data.mongodb.uri	Identifikátor URI databáze	mongodb://<mongo-db-admin-user>:<password>@<mongo-db-server>.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@<mongo-db-server>@

Další typy klientů

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_CONNECTIONSTRING	Rozhraní MongoDB API připojovací řetězec	mongodb://<mongo-db-admin-user>:<password>@<mongo-db-server>.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@<mongo-db-server>@

Ukázkový kód

Pokud se chcete připojit ke službě Azure Cosmos DB for MongoDB pomocí připojovací řetězec, projděte si následující kroky a kód.

.NET

1. Nainstalujte závislost.

   dotnet add package MongoDb.Driver
   

2. Získejte připojovací řetězec z proměnné prostředí přidané službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB.

   using MongoDB.Driver;
   
   var connectionString = Environment.GetEnvironmentVariable("AZURE_COSMOS_CONNECTIONSTRING");
   var client = new MongoClient(connectionString);
   

Java

1. Do souboru pom.xml přidejte následující závislost:

   <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>3.4.2</version>
    </dependency>   
   

2. Získejte připojovací řetězec z proměnné prostředí přidané službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB.

   import com.mongodb.MongoClient;
   import com.mongodb.MongoClientURI;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.Filters;
   
   String connectionString = System.getenv("AZURE_COSMOS_CONNECTIONSTRING");
   MongoClientURI uri = new MongoClientURI(connectionString);
   
   MongoClient mongoClient = null;
   try {
       mongoClient = new MongoClient(uri);        
   } finally {
       if (mongoClient != null) {
           mongoClient.close();
       }
   }
   

SpringBoot

Informace o použití Spring Data s rozhraním API služby Azure Cosmos DB for MongoDB najdete v tématu o nastavení aplikace Spring. Vlastnosti spring.data.mongodb.database konfigurace a spring.data.mongodb.uri jsou nastavené na Spring Apps podle služby Připojení or.

Python

1. Nainstalujte závislost.

   pip install pymongo
   

2. Získejte připojovací řetězec z proměnné prostředí přidané službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB.

   import os
   import pymongo
   
   conn_str = os.environ.get("AZURE_COSMOS_CONNECTIONSTRING")
   client = pymongo.MongoClient(conn_str)
   

Přejít

1. Nainstalujte závislost.

   go get go.mongodb.org/mongo-driver/mongo
   

2. Získejte připojovací řetězec z proměnné prostředí přidané službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB.

   import (
   	"context"
   	"fmt"
   	"log"
   	"os"
   
       "go.mongodb.org/mongo-driver/bson"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
   )
   
   ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
   defer cancel()
   
   mongoDBConnectionString = os.Getenv("AZURE_COSMOS_CONNECTIONSTRING")
   clientOptions := options.Client().ApplyURI(mongoDBConnectionString).SetDirect(true)
   
   c, err := mongo.Connect(ctx, clientOptions)
   if err != nil {
       log.Fatalf("unable to initialize connection %v", err)
   }
   
   err = c.Ping(ctx, nil)
   if err != nil {
       log.Fatalf("unable to connect %v", err)
   }
   

NodeJS

1. Nainstalujte závislost.

   npm install mongodb
   

2. Získejte připojovací řetězec z proměnné prostředí přidané službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB.

   const { MongoClient, ObjectId } = require('mongodb');
   
   const url = process.env.AZURE_COSMOS_CONNECTIONSTRING;
   const client = new MongoClient(url);
   

Další

V jiných jazycích můžete použít koncový bod prostředku MongoDB a další vlastnosti, které service Připojení or nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB se službou Připojení or.

Instanční objekt

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adresa URL pro získání připojovací řetězec	https://management.azure.com/subscriptions/<subscription-ID>/resourceGroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<Azure-Cosmos-DB-API-for-MongoDB-account>/listConnectionStrings?api-version=2021-04-15
AZURE_COSMOS_SCOPE	Rozsah spravované identity	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	ID klienta	<client-ID>
AZURE_COSMOS_CLIENTSECRET	Tajný klíč klienta	<client-secret>
AZURE_COSMOS_TENANTID	ID vašeho tenanta	<tenant-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Váš koncový bod prostředku	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Ukázkový kód

Informace o připojení ke službě Azure Cosmos DB for MongoDB pomocí instančního objektu najdete v následujících krocích a kódu.

.NET

1. Instalace závislostí

   dotnet add package MongoDb.Driver
   dotnet add package Azure.Identity
   

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí klientské knihovny Azure.Identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using MongoDB.Driver;
   using Azure.Identity;
   using System.Text.Json;
   
   var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // 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 string[]{ scope }));
   
   // Get the connection string.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listConnectionStringUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Do souboru pom.xml přidejte následující závislosti:

   <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>3.4.2</version>
    </dependency> 
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system 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();
   
   // Get the access token.
   AccessToken accessToken = defaultCredential.getToken(new TokenRequestContext().addScopes(new String[]{ scope })).block();
   String token = accessToken.getToken();
   
   // Get the connection string.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listConnectionStringUrl))
       .header("Authorization", "Bearer " + token)
       .POST()
       .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 mongoClient = new MongoClient(uri);
   

SpringBoot

Typ ověřování není pro Spring Boot podporován.

Python

1. Nainstalujte závislosti.

   pip install pymongo
   pip install azure-identity
   

2. V kódu získejte přístupový token prostřednictvím azure-identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import os
   import pymongo
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # 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)
   

Přejít

1. Nainstalujte závislosti.

   go get go.mongodb.org/mongo-driver/mongo
   go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"
   

2. V kódu získejte přístupový token prostřednictvím azidentitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "go.mongodb.org/mongo-driver/bson"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   endpoint = os.Getenv("AZURE_COSMOS_RESOURCEENDPOINT")
   listConnectionStringUrl = os.Getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL")
   scope = os.Getenv("AZUE_COSMOS_SCOPE")
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
   // For user-assigned identity.
   // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
   // azidentity.ManagedIdentityCredentialOptions.ID := clientid
   // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
   // cred, err := azidentity.NewManagedIdentityCredential(options)
   
   // For service principal.
   // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
   // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
   // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
   // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
   // Acquire the access token.
   ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
   token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
       Scopes: []string{scope},
   })
   
   // Acquire the connection string.
   client := &http.Client{}
   req, err := http.NewRequest("POST", listConnectionStringUrl, nil)
   req.Header.Add("Authorization", "Bearer " + token.Token)
   resp, err := client.Do(req)
   body, err := ioutil.ReadAll(resp.Body)
   var result map[string]interface{}
   json.Unmarshal(body, &result)
   connectionString, err := result["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
   clientOptions := options.Client().ApplyURI(connectionString).SetDirect(true)
   
   c, err := mongo.Connect(ctx, clientOptions)
   

NodeJS

1. Instalace závislostí

   npm install mongodb
   npm install --save @azure/identity
   

2. V kódu získejte přístupový token prostřednictvím @azure/identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or a připojte se ke službě Azure Cosmos DB pro MongoDB. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   const { MongoClient, ObjectId } = require('mongodb');
   const axios = require('axios');
   
   let endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned 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;
   
   // Acquire the access token.
   var 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'];
   
   const client = new MongoClient(connectionString);
   

Další

V jiných jazycích můžete použít koncový bod prostředku MongoDB a další vlastnosti, které service Připojení or nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB se službou Připojení or.

Další kroky

Další informace o službě service Připojení or najdete v následujících kurzech.

Další informace o konceptech služby Připojení or