Intégrer Azure Cosmos DB for MongoDB à l’aide du connecteur de services

Cette page présente les méthodes d’authentification et les clients pris en charge, et contient des exemples de code que vous pouvez utiliser pour connecter Azure Cosmos DB for MongoDB à d’autres services cloud en utilisant le connecteur de services. Vous pouvez toujours vous connecter à Azure Cosmos DB for MongoDB dans d’autres langages de programmation sans utiliser de connecteur de services. Cette page présente également les noms et les valeurs des variables d’environnement par défaut (ou configuration Spring Boot) que vous obtenez lorsque vous créez la connexion de service.

Service de calcul pris en charge

Le connecteur de services peut être utilisé pour connecter les services de calcul suivants à Azure Cosmos DB for MongoDB :

• Azure App Service
• Azure Container Apps
• Azure Functions
• Azure Kubernetes Service (AKS)
• Azure Spring Apps

Types d’authentification et de client pris en charge

Le tableau ci-dessous montre les combinaisons de types de client et de méthodes d’authentification prises en charge pour connecter votre service de calcul à Azure Cosmos DB for MongoDB à l’aide du connecteur de services. « Oui » indique que la combinaison est prise en charge, tandis que « Non » indique qu’elle ne l’est pas.

Type de client	Identité managée affectée par le système	Identité managée affectée par l’utilisateur	Secret / chaîne de connexion	Principal de service
.NET	Oui	Oui	Oui	Oui
Java	Oui	Oui	Oui	Oui
Java - Spring Boot	Non	Non	Oui	Non
Node.js	Oui	Oui	Oui	Oui
Python	Oui	Oui	Oui	Oui
Go	Oui	Oui	Oui	Oui
Aucun	Oui	Oui	Oui	Oui

Ce tableau indique que toutes les combinaisons de types de client et de méthodes d’authentification du tableau sont prises en charge, à l’exception du type de client Java - Spring Boot, qui prend en charge seulement la méthode Secret/chaîne de connexion. Tous les autres types de client peuvent utiliser toutes les méthodes d’authentification pour se connecter à Azure Cosmos DB for MongoDB à l’aide du connecteur de services.

Remarque

Cosmos DB ne prend pas en charge l’authentification en mode natif via une identité managée. Par conséquent, le connecteur de services utilise une identité managée pour récupérer la chaîne de connexion, et la connexion est établie en suivant à l’aide de cette chaîne de connexion.

Noms des variables d’environnement par défaut ou propriétés d’application et exemple de code

Utilisez les détails de connexion ci-dessous pour connecter des services de calcul à Azure Cosmos DB. Cette page présente également les noms et les valeurs des variables d’environnement par défaut (ou configuration Spring Boot) que vous obtenez lorsque vous créez la connexion de service, ainsi qu’un exemple de code. Pour chaque exemple ci-dessous, remplacez le texte des espaces réservés <mongo-db-admin-user>, <password>, <Azure-Cosmos-DB-API-for-MongoDB-account>, <subscription-ID>, <resource-group-name>, <client-secret> et <tenant-id> par vos propres informations. Pour plus d’informations sur les conventions d’affectation de noms, consultez l’article Éléments internes du connecteur de services.

Identité managée affectée par le système

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	URL permettant d’accéder à la chaîne de connexion	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	Étendue de votre identité managée	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB for MongoDB en utilisant une identité managée affectée par le système.

Étant donné que Cosmos DB ne prend pas en charge l’authentification en mode natif via une identité managée, dans l’exemple de code suivant, nous utilisons une identité managée pour récupérer la chaîne de connexion, et la connexion est ensuite établie à l’aide de cette chaîne de connexion.

.NET

1. Installer des dépendances

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

2. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de la bibliothèque cliente Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL pour obtenir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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;
   
   // you can retrieve the endpoint of the resource with the following env variable:
   // 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(new Uri(listConnectionStringUrl), null);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   var connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <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. Obtenez un jeton d’accès pour l’identité managée ou le principal de service avec azure-identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL pour obtenir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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

Le type d’authentification n’est pas pris en charge pour Spring Boot.

Python

1. Installez des dépendances.

   pip install pymongo
   pip install azure-identity
   

2. Dans le code, obtenez le jeton d’accès via azure-identity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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)
   

Go

1. Installez des dépendances.

   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. Dans le code, obtenez le jeton d’accès via azidentity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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. Installer des dépendances

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

2. Dans le code, obtenez le jeton d’accès via @azure/identity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

Autres

Pour les autres langages, vous pouvez utiliser le point de terminaison de ressource MongoDB et d’autres propriétés que le connecteur de services définit dans les variables d’environnement pour vous connecter à Azure Cosmos DB for MongoDB. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for MongoDB au connecteur de services.

Identité managée affectée par l’utilisateur

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	URL permettant d’accéder à la chaîne de connexion	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	Étendue de votre identité managée	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	Votre ID client	<client-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB for MongoDB en utilisant une identité managée affectée par l’utilisateur.

Étant donné que Cosmos DB ne prend pas en charge l’authentification en mode natif via une identité managée, dans l’exemple de code suivant, nous utilisons une identité managée pour récupérer la chaîne de connexion, et la connexion est ensuite établie à l’aide de cette chaîne de connexion.

.NET

1. Installer des dépendances

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

2. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de la bibliothèque cliente Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL pour obtenir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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;
   
   // you can retrieve the endpoint of the resource with the following env variable:
   // 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(new Uri(listConnectionStringUrl), null);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   var connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <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. Obtenez un jeton d’accès pour l’identité managée ou le principal de service avec azure-identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL pour obtenir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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

Le type d’authentification n’est pas pris en charge pour Spring Boot.

Python

1. Installez des dépendances.

   pip install pymongo
   pip install azure-identity
   

2. Dans le code, obtenez le jeton d’accès via azure-identity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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)
   

Go

1. Installez des dépendances.

   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. Dans le code, obtenez le jeton d’accès via azidentity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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. Installer des dépendances

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

2. Dans le code, obtenez le jeton d’accès via @azure/identity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

Autres

Pour les autres langages, vous pouvez utiliser le point de terminaison de ressource MongoDB et d’autres propriétés que le connecteur de services définit dans les variables d’environnement pour vous connecter à Azure Cosmos DB for MongoDB. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for MongoDB au connecteur de services.

Chaîne de connexion

Avertissement

Microsoft vous recommande d’utiliser le flux d’authentification le plus sécurisé disponible. Le flux d’authentification décrit dans cette procédure demande un très haut niveau de confiance dans l’application et comporte des risques qui ne sont pas présents dans d’autres flux. Utilisez ce flux seulement si d’autres flux plus sécurisés, tels que les identités managées, ne sont pas viables.

Type de client Spring Boot

Nom de variable d’environnement par défaut	Description	Exemple de valeur
spring.data.mongodb.database	Votre base de données	<database-name>
spring.data.mongodb.uri	URI de votre base de données	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>@

Autres types de clients

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_CONNECTIONSTRING	Chaîne de connexion de l’API MongoDB	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>@

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB for MongoDB en utilisant une chaîne de connexion.

.NET

1. Installez la dépendance.

   dotnet add package MongoDb.Driver
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB.

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

Java

1. Ajoutez la dépendance suivante dans votre fichier pom.xml :

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

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à 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

Reportez-vous à Utiliser Spring Data avec l’API Azure Cosmos DB for MongoDB pour configurer votre application Spring. Les propriétés de configuration spring.data.mongodb.database et spring.data.mongodb.uri sont définies sur Spring Apps par le connecteur de services.

Python

1. Installez la dépendance.

   pip install pymongo
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB.

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

Go

1. Installez la dépendance.

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

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à 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. Installez la dépendance.

   npm install mongodb
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB.

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

Autres

Pour d’autres langages, vous pouvez utiliser le point de terminaison de ressource MongoDB et d’autres propriétés que le connecteur de services définit sur les variables d’environnement pour vous connecter à Azure Cosmos DB for MongoDB. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for MongoDB au connecteur de services.

Principal de service

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	URL permettant d’accéder à la chaîne de connexion	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	Étendue de votre identité managée	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	Votre ID client	<client-ID>
AZURE_COSMOS_CLIENTSECRET	Votre clé secrète client	<client-secret>
AZURE_COSMOS_TENANTID	Votre ID de locataire	<tenant-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB for MongoDB en utilisant un principal de service.

.NET

1. Installer des dépendances

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

2. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de la bibliothèque cliente Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL pour obtenir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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;
   
   // you can retrieve the endpoint of the resource with the following env variable:
   // 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(new Uri(listConnectionStringUrl), null);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   var connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <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. Obtenez un jeton d’accès pour l’identité managée ou le principal de service avec azure-identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL pour obtenir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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

Le type d’authentification n’est pas pris en charge pour Spring Boot.

Python

1. Installez des dépendances.

   pip install pymongo
   pip install azure-identity
   

2. Dans le code, obtenez le jeton d’accès via azure-identity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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)
   

Go

1. Installez des dépendances.

   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. Dans le code, obtenez le jeton d’accès via azidentity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   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. Installer des dépendances

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

2. Dans le code, obtenez le jeton d’accès via @azure/identity, puis utilisez-le pour acquérir la chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for MongoDB. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

Autres

Pour les autres langages, vous pouvez utiliser le point de terminaison de ressource MongoDB et d’autres propriétés que le connecteur de services définit dans les variables d’environnement pour vous connecter à Azure Cosmos DB for MongoDB. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for MongoDB au connecteur de services.

Étapes suivantes

Suivez les tutoriels ci-dessous pour en savoir plus sur Service Connector.

En savoir plus sur les concepts Service Connector