Integrace služby Azure Cosmos DB pro MongoDB s konektorem služby

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í konektoru služby. Stále se můžete připojit ke službě Azure Cosmos DB for MongoDB v jiných programovacích jazycích bez použití konektoru služby. 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

Konektor služby se dá použít k připojení následujících výpočetních služeb ke službě Azure Cosmos DB pro MongoDB:

• Azure App Service
• Azure Container Apps
• Azure Functions
• Azure Kubernetes Service (AKS)
• 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í konektoru služby. "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
Go	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 pomocí konektoru služby použít některou z metod ověřování.

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 interním článku o konektoru služby.

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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 corresponding to 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 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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.credential.*;
   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 corresponding to the authentication type you want to use.
   // 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 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)
   

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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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("AZURE_COSMOS_SCOPE")
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 corresponding to the authentication type you want to use.  
   // 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é Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB pro MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB s konektorem služby.

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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 corresponding to 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 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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.credential.*;
   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 corresponding to the authentication type you want to use.
   // 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 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)
   

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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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("AZURE_COSMOS_SCOPE")
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 corresponding to the authentication type you want to use.  
   // 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é Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB pro MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB s konektorem služby.

Connection string

Upozorňující

Microsoft doporučuje používat nejbezpečnější dostupný tok ověřování. Ověřovací tok popsaný v tomto postupu vyžaduje velmi vysoký stupeň důvěryhodnosti v aplikaci a nese rizika, která nejsou přítomna v jiných tocích. Tento tok byste měli použít jenom v případě, že jiné bezpečnější toky, jako jsou spravované identity, nejsou přijatelné.

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é konektorem služby a připojte se ke službě Azure Cosmos DB for 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é konektorem služby a připojte se ke službě Azure Cosmos DB for 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 service Connectoru.

Python

1. Nainstalujte závislost.

   pip install pymongo
   

2. Získejte připojovací řetězec z proměnné prostředí přidané konektorem služby a připojte se ke službě Azure Cosmos DB for 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é konektorem služby a připojte se ke službě Azure Cosmos DB for 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é konektorem služby a připojte se ke službě Azure Cosmos DB for 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é Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB pro MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB s konektorem služby.

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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 corresponding to 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 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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.credential.*;
   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 corresponding to the authentication type you want to use.
   // 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 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)
   

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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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("AZURE_COSMOS_SCOPE")
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // 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 konektorem služby a připojte se ke službě Azure Cosmos DB for 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 corresponding to the authentication type you want to use.  
   // 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é Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB pro MongoDB. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro MongoDB s konektorem služby.

Další kroky

Další informace o konektoru Service Connector najdete v následujících kurzech.

Další informace o konceptech konektoru Service Connector