Integrar o Azure Cosmos DB para MongoDB com o Service Connector

Esta página mostra os métodos de autenticação e os clientes suportados e mostra o código de exemplo que pode utilizar para ligar o Azure Cosmos DB para MongoDB a outros serviços na nuvem utilizando o Service Connector. Talvez você ainda consiga se conectar ao Azure Cosmos DB para MongoDB em outras linguagens de programação sem usar o Service Connector. Esta página também mostra nomes e valores de variáveis de ambiente padrão (ou configuração do Spring Boot) que você obtém quando cria a conexão de serviço.

Serviços de computação suportados

O Service Connector pode ser usado para conectar os seguintes serviços de computação ao Azure Cosmos DB para MongoDB:

• Serviço de Aplicações do Azure
• Funções do Azure
• Azure Container Apps
• Azure Spring Apps

Tipos de autenticação e tipos de cliente suportados

A tabela abaixo mostra quais combinações de tipos de cliente e métodos de autenticação são suportadas para conectar seu serviço de computação ao Azure Cosmos DB para MongoDB usando o Service Connector. Um "Sim" indica que a combinação é suportada, enquanto um "Não" indica que ela não é suportada.

Tipo de cliente	Identidade gerida atribuída pelo sistema	Identidade gerida atribuída pelo utilizador	Segredo / cadeia de conexão	Service principal (Principal de serviço)
.NET	Sim	Sim	Sim	Sim
Java	Sim	Sim	Sim	Sim
Java - Arranque primavera	No	No	Sim	No
Node.js	Sim	Sim	Sim	Sim
Python	Sim	Sim	Sim	Sim
Go	Sim	Sim	Sim	Sim
None	Sim	Sim	Sim	Sim

Esta tabela indica que todas as combinações de tipos de cliente e métodos de autenticação na tabela são suportadas, exceto para o tipo de cliente Java - Spring Boot, que suporta apenas o método Secret / connection string. Todos os outros tipos de cliente podem usar qualquer um dos métodos de autenticação para se conectar ao Azure Cosmos DB para MongoDB usando o Service Connector.

Nomes de variáveis de ambiente padrão ou propriedades de aplicativo e código de exemplo

Use os detalhes de conexão abaixo para conectar serviços de computação ao Azure Cosmos DB. Esta página também mostra nomes e valores de variáveis de ambiente padrão (ou configuração do Spring Boot) que você obtém quando cria a conexão de serviço, bem como código de exemplo. Para cada exemplo abaixo, substitua os textos <mongo-db-admin-user>de espaço reservado , , , <password><subscription-ID><Azure-Cosmos-DB-API-for-MongoDB-account>, , <resource-group-name><client-secret>e <tenant-id> com suas próprias informações. Para obter mais informações sobre convenções de nomenclatura, consulte o artigo interno do Service Connector.

Identidade gerida atribuída pelo sistema

Nome da variável de ambiente padrão	Description	Valor de exemplo
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	A URL para obter a cadeia de conexão	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	Seu escopo de identidade gerenciado	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Seu ponto de extremidade de recurso	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Código de exemplo

Consulte as etapas e o código abaixo para se conectar ao Azure Cosmos DB para MongoDB usando uma identidade gerenciada atribuída ao sistema.

.NET

1. Instalar dependências

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

2. Obtenha um token de acesso para a identidade gerenciada ou a entidade de serviço usando a biblioteca de cliente Azure.Identity. Use o token de acesso e AZURE_COSMOS_LISTCONNECTIONSTRINGURL para obter a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using MongoDB.Driver;
   using Azure.Identity;
   using System.Text.Json;
   
   var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // var tokenProvider = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // var tokenProvider = new DefaultAzureCredential(
   //     new DefaultAzureCredentialOptions
   //     {
   //         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
   //     }
   // );
   
   // For service principal.
   // var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
   // var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
   // var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
   // var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
   // Acquire the access token. 
   AccessToken accessToken = await tokenProvider.GetTokenAsync(
       new TokenRequestContext(scopes: new string[]{ scope }));
   
   // Get the connection string.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listConnectionStringUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Adicione as seguintes dependências no arquivo 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. Obtenha um token de acesso para a identidade gerenciada ou a entidade de serviço usando azure-identityo . Use o token de acesso e AZURE_COSMOS_LISTCONNECTIONSTRINGURL para obter a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import com.mongodb.MongoClient;
   import com.mongodb.MongoClientURI;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.Filters;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   import com.azure.identity.*;
   import com.azure.core.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system managed identity.
   // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
   
   // For user assigned managed identity.
   // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
   //     .managedIdentityClientId(System.getenv("AZURE_COSMOS_CLIENTID"))
   //     .build();
   
   // For service principal.
   // ClientSecretCredential defaultCredential = new ClientSecretCredentialBuilder()
   //   .clientId(System.getenv("<AZURE_COSMOS_CLIENTID>"))
   //   .clientSecret(System.getenv("<AZURE_COSMOS_CLIENTSECRET>"))
   //   .tenantId(System.getenv("<AZURE_COSMOS_TENANTID>"))
   //   .build();
   
   // Get the access token.
   AccessToken accessToken = defaultCredential.getToken(new TokenRequestContext().addScopes(new String[]{ scope })).block();
   String token = accessToken.getToken();
   
   // Get the connection string.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listConnectionStringUrl))
       .header("Authorization", "Bearer " + token)
       .POST()
       .build();
   HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
   JSONParser parser = new JSONParser();
   JSONObject responseBody = parser.parse(response.body());
   List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
   String connectionString = connectionStrings.get(0).get("connectionString");
   
   // Connect to Azure Cosmos DB for MongoDB
   MongoClientURI uri = new MongoClientURI(connectionString);
   MongoClient mongoClient = new MongoClient(uri);
   

SpringBoot

O tipo de autenticação não é suportado para o Spring Boot.

Python

1. Instale dependências.

   pip install pymongo
   pip install azure-identity
   

2. No código, obtenha o token de acesso via e, em azure-identityseguida, use-o para adquirir a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import os
   import pymongo
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity
   # cred = ManagedIdentityCredential()
   
   # For user-assigned managed identity
   # managed_identity_client_id = os.getenv('AZURE_COSMOS_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)
   
   # For service principal
   # tenant_id = os.getenv('AZURE_COSMOS_TENANTID')
   # client_id = os.getenv('AZURE_COSMOS_CLIENTID')
   # client_secret = os.getenv('AZURE_COSMOS_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # Get the connection string
   session = requests.Session()
   token = cred.get_token(scope)
   response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
   keys_dict = response.json()
   conn_str = keys_dict["connectionStrings"][0]["connectionString"]
   
   # Connect to Azure Cosmos DB for MongoDB
   client = pymongo.MongoClient(conn_str)
   

Ir

1. Instale dependências.

   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. No código, obtenha o token de acesso via e, em azidentityseguida, use-o para adquirir a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

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

NodeJS

1. Instalar dependências

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

2. No código, obtenha o token de acesso via e, em seguida, use-o para adquirir a cadeia de @azure/identityconexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   const { MongoClient, ObjectId } = require('mongodb');
   const axios = require('axios');
   
   let endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // const clientId = process.env.AZURE_COSMOS_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //     managedIdentityClientId: clientId
   // });
   
   // For service principal.
   // const tenantId = process.env.AZURE_COSMOS_TENANTID;
   // const clientId = process.env.AZURE_COSMOS_CLIENTID;
   // const clientSecret = process.env.AZURE_COSMOS_CLIENTSECRET;
   
   // Acquire the access token.
   var accessToken = await credential.getToken(scope);
   
   // Get the connection string.
   const config = {
       method: 'post',
       url: listConnectionStringUrl,
       headers: { 
         'Authorization': `Bearer ${accessToken.token}`
       }
   };
   const response = await axios(config);
   const keysDict = response.data;
   const connectionString = keysDict['connectionStrings'][0]['connectionString'];
   
   const client = new MongoClient(connectionString);
   

Outro

Para outros idiomas, você pode usar o ponto de extremidade de recurso do MongoDB e outras propriedades que o Service Connector define para as variáveis de ambiente para se conectar ao Azure Cosmos DB para MongoDB. Para obter detalhes sobre variáveis de ambiente, consulte Integrar o Azure Cosmos DB para MongoDB com o Service Connector.

Identidade gerida atribuída pelo utilizador

Nome da variável de ambiente padrão	Description	Valor de exemplo
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	A URL para obter a cadeia de conexão	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	Seu escopo de identidade gerenciado	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	O seu ID de cliente	<client-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Seu ponto de extremidade de recurso	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Código de exemplo

Consulte as etapas e o código abaixo para se conectar ao Azure Cosmos DB para MongoDB usando uma identidade gerenciada atribuída pelo usuário.

.NET

1. Instalar dependências

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

2. Obtenha um token de acesso para a identidade gerenciada ou a entidade de serviço usando a biblioteca de cliente Azure.Identity. Use o token de acesso e AZURE_COSMOS_LISTCONNECTIONSTRINGURL para obter a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using MongoDB.Driver;
   using Azure.Identity;
   using System.Text.Json;
   
   var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // var tokenProvider = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // var tokenProvider = new DefaultAzureCredential(
   //     new DefaultAzureCredentialOptions
   //     {
   //         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
   //     }
   // );
   
   // For service principal.
   // var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
   // var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
   // var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
   // var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
   // Acquire the access token. 
   AccessToken accessToken = await tokenProvider.GetTokenAsync(
       new TokenRequestContext(scopes: new string[]{ scope }));
   
   // Get the connection string.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listConnectionStringUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Adicione as seguintes dependências no arquivo 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. Obtenha um token de acesso para a identidade gerenciada ou a entidade de serviço usando azure-identityo . Use o token de acesso e AZURE_COSMOS_LISTCONNECTIONSTRINGURL para obter a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import com.mongodb.MongoClient;
   import com.mongodb.MongoClientURI;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.Filters;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   import com.azure.identity.*;
   import com.azure.core.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system managed identity.
   // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
   
   // For user assigned managed identity.
   // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
   //     .managedIdentityClientId(System.getenv("AZURE_COSMOS_CLIENTID"))
   //     .build();
   
   // For service principal.
   // ClientSecretCredential defaultCredential = new ClientSecretCredentialBuilder()
   //   .clientId(System.getenv("<AZURE_COSMOS_CLIENTID>"))
   //   .clientSecret(System.getenv("<AZURE_COSMOS_CLIENTSECRET>"))
   //   .tenantId(System.getenv("<AZURE_COSMOS_TENANTID>"))
   //   .build();
   
   // Get the access token.
   AccessToken accessToken = defaultCredential.getToken(new TokenRequestContext().addScopes(new String[]{ scope })).block();
   String token = accessToken.getToken();
   
   // Get the connection string.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listConnectionStringUrl))
       .header("Authorization", "Bearer " + token)
       .POST()
       .build();
   HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
   JSONParser parser = new JSONParser();
   JSONObject responseBody = parser.parse(response.body());
   List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
   String connectionString = connectionStrings.get(0).get("connectionString");
   
   // Connect to Azure Cosmos DB for MongoDB
   MongoClientURI uri = new MongoClientURI(connectionString);
   MongoClient mongoClient = new MongoClient(uri);
   

SpringBoot

O tipo de autenticação não é suportado para o Spring Boot.

Python

1. Instale dependências.

   pip install pymongo
   pip install azure-identity
   

2. No código, obtenha o token de acesso via e, em azure-identityseguida, use-o para adquirir a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import os
   import pymongo
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity
   # cred = ManagedIdentityCredential()
   
   # For user-assigned managed identity
   # managed_identity_client_id = os.getenv('AZURE_COSMOS_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)
   
   # For service principal
   # tenant_id = os.getenv('AZURE_COSMOS_TENANTID')
   # client_id = os.getenv('AZURE_COSMOS_CLIENTID')
   # client_secret = os.getenv('AZURE_COSMOS_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # Get the connection string
   session = requests.Session()
   token = cred.get_token(scope)
   response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
   keys_dict = response.json()
   conn_str = keys_dict["connectionStrings"][0]["connectionString"]
   
   # Connect to Azure Cosmos DB for MongoDB
   client = pymongo.MongoClient(conn_str)
   

Ir

1. Instale dependências.

   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. No código, obtenha o token de acesso via e, em azidentityseguida, use-o para adquirir a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

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

NodeJS

1. Instalar dependências

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

2. No código, obtenha o token de acesso via e, em seguida, use-o para adquirir a cadeia de @azure/identityconexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   const { MongoClient, ObjectId } = require('mongodb');
   const axios = require('axios');
   
   let endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // const clientId = process.env.AZURE_COSMOS_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //     managedIdentityClientId: clientId
   // });
   
   // For service principal.
   // const tenantId = process.env.AZURE_COSMOS_TENANTID;
   // const clientId = process.env.AZURE_COSMOS_CLIENTID;
   // const clientSecret = process.env.AZURE_COSMOS_CLIENTSECRET;
   
   // Acquire the access token.
   var accessToken = await credential.getToken(scope);
   
   // Get the connection string.
   const config = {
       method: 'post',
       url: listConnectionStringUrl,
       headers: { 
         'Authorization': `Bearer ${accessToken.token}`
       }
   };
   const response = await axios(config);
   const keysDict = response.data;
   const connectionString = keysDict['connectionStrings'][0]['connectionString'];
   
   const client = new MongoClient(connectionString);
   

Outro

Para outros idiomas, você pode usar o ponto de extremidade de recurso do MongoDB e outras propriedades que o Service Connector define para as variáveis de ambiente para se conectar ao Azure Cosmos DB para MongoDB. Para obter detalhes sobre variáveis de ambiente, consulte Integrar o Azure Cosmos DB para MongoDB com o Service Connector.

Connection string

Tipo de cliente SpringBoot

Nome da variável de ambiente padrão	Description	Valor de exemplo
spring.data.mongodb.banco de dados	A sua base de dados	<database-name>
primavera.data.mongodb.uri	O URI do banco de dados	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>@

Outros tipos de clientes

Nome da variável de ambiente padrão	Description	Valor de exemplo
AZURE_COSMOS_CONNECTIONSTRING	Cadeia de conexão da API do 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>@

Código de exemplo

Consulte as etapas e o código abaixo para se conectar ao Azure Cosmos DB para MongoDB usando uma cadeia de conexão.

.NET

1. Instalar dependência.

   dotnet add package MongoDb.Driver
   

2. Obtenha a cadeia de conexão da variável de ambiente adicionada pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB.

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

Java

1. Adicione a seguinte dependência no arquivo pom.xml :

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

2. Obtenha a cadeia de conexão da variável de ambiente adicionada pelo Service Connector e conecte-se ao Azure Cosmos DB para 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

Consulte Usar dados do Spring com a API do Azure Cosmos DB para MongoDB para configurar seu aplicativo Spring. As propriedades spring.data.mongodb.database de configuração e spring.data.mongodb.uri são definidas como Spring Apps by Service Connector.

Python

1. Instalar dependência.

   pip install pymongo
   

2. Obtenha a cadeia de conexão da variável de ambiente adicionada pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB.

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

Ir

1. Instalar dependência.

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

2. Obtenha a cadeia de conexão da variável de ambiente adicionada pelo Service Connector e conecte-se ao Azure Cosmos DB para 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. Instalar dependência.

   npm install mongodb
   

2. Obtenha a cadeia de conexão da variável de ambiente adicionada pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB.

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

Outro

Para outros idiomas, você pode usar o ponto de extremidade de recurso do MongoDB e outras propriedades que o Service Connector define para as variáveis de ambiente para se conectar ao Azure Cosmos DB para MongoDB. Para obter detalhes sobre variáveis de ambiente, consulte Integrar o Azure Cosmos DB para MongoDB com o Service Connector.

Service principal (Principal de serviço)

Nome da variável de ambiente padrão	Description	Valor de exemplo
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	A URL para obter a cadeia de conexão	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	Seu escopo de identidade gerenciado	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	O seu ID de cliente	<client-ID>
AZURE_COSMOS_CLIENTSECRET	O segredo do seu cliente	<client-secret>
AZURE_COSMOS_TENANTID	O seu ID de inquilino	<tenant-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Seu ponto de extremidade de recurso	https://<Azure-Cosmos-DB-API-for-MongoDB-account>.documents.azure.com:443/

Código de exemplo

Consulte as etapas e o código abaixo para se conectar ao Azure Cosmos DB para MongoDB usando uma entidade de serviço.

.NET

1. Instalar dependências

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

2. Obtenha um token de acesso para a identidade gerenciada ou a entidade de serviço usando a biblioteca de cliente Azure.Identity. Use o token de acesso e AZURE_COSMOS_LISTCONNECTIONSTRINGURL para obter a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using MongoDB.Driver;
   using Azure.Identity;
   using System.Text.Json;
   
   var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // var tokenProvider = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // var tokenProvider = new DefaultAzureCredential(
   //     new DefaultAzureCredentialOptions
   //     {
   //         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
   //     }
   // );
   
   // For service principal.
   // var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
   // var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
   // var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
   // var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
   // Acquire the access token. 
   AccessToken accessToken = await tokenProvider.GetTokenAsync(
       new TokenRequestContext(scopes: new string[]{ scope }));
   
   // Get the connection string.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listConnectionStringUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
   string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];
   
   // Connect to Azure Cosmos DB for MongoDB
   var client = new MongoClient(connectionString);
   

Java

1. Adicione as seguintes dependências no arquivo 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. Obtenha um token de acesso para a identidade gerenciada ou a entidade de serviço usando azure-identityo . Use o token de acesso e AZURE_COSMOS_LISTCONNECTIONSTRINGURL para obter a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import com.mongodb.MongoClient;
   import com.mongodb.MongoClientURI;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.Filters;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   import com.azure.identity.*;
   import com.azure.core.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // For system managed identity.
   // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
   
   // For user assigned managed identity.
   // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
   //     .managedIdentityClientId(System.getenv("AZURE_COSMOS_CLIENTID"))
   //     .build();
   
   // For service principal.
   // ClientSecretCredential defaultCredential = new ClientSecretCredentialBuilder()
   //   .clientId(System.getenv("<AZURE_COSMOS_CLIENTID>"))
   //   .clientSecret(System.getenv("<AZURE_COSMOS_CLIENTSECRET>"))
   //   .tenantId(System.getenv("<AZURE_COSMOS_TENANTID>"))
   //   .build();
   
   // Get the access token.
   AccessToken accessToken = defaultCredential.getToken(new TokenRequestContext().addScopes(new String[]{ scope })).block();
   String token = accessToken.getToken();
   
   // Get the connection string.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listConnectionStringUrl))
       .header("Authorization", "Bearer " + token)
       .POST()
       .build();
   HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
   JSONParser parser = new JSONParser();
   JSONObject responseBody = parser.parse(response.body());
   List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
   String connectionString = connectionStrings.get(0).get("connectionString");
   
   // Connect to Azure Cosmos DB for MongoDB
   MongoClientURI uri = new MongoClientURI(connectionString);
   MongoClient mongoClient = new MongoClient(uri);
   

SpringBoot

O tipo de autenticação não é suportado para o Spring Boot.

Python

1. Instale dependências.

   pip install pymongo
   pip install azure-identity
   

2. No código, obtenha o token de acesso via e, em azure-identityseguida, use-o para adquirir a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import os
   import pymongo
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity
   # cred = ManagedIdentityCredential()
   
   # For user-assigned managed identity
   # managed_identity_client_id = os.getenv('AZURE_COSMOS_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)
   
   # For service principal
   # tenant_id = os.getenv('AZURE_COSMOS_TENANTID')
   # client_id = os.getenv('AZURE_COSMOS_CLIENTID')
   # client_secret = os.getenv('AZURE_COSMOS_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # Get the connection string
   session = requests.Session()
   token = cred.get_token(scope)
   response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
   keys_dict = response.json()
   conn_str = keys_dict["connectionStrings"][0]["connectionString"]
   
   # Connect to Azure Cosmos DB for MongoDB
   client = pymongo.MongoClient(conn_str)
   

Ir

1. Instale dependências.

   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. No código, obtenha o token de acesso via e, em azidentityseguida, use-o para adquirir a cadeia de conexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

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

NodeJS

1. Instalar dependências

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

2. No código, obtenha o token de acesso via e, em seguida, use-o para adquirir a cadeia de @azure/identityconexão. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB para MongoDB. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   const { MongoClient, ObjectId } = require('mongodb');
   const axios = require('axios');
   
   let endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // const clientId = process.env.AZURE_COSMOS_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //     managedIdentityClientId: clientId
   // });
   
   // For service principal.
   // const tenantId = process.env.AZURE_COSMOS_TENANTID;
   // const clientId = process.env.AZURE_COSMOS_CLIENTID;
   // const clientSecret = process.env.AZURE_COSMOS_CLIENTSECRET;
   
   // Acquire the access token.
   var accessToken = await credential.getToken(scope);
   
   // Get the connection string.
   const config = {
       method: 'post',
       url: listConnectionStringUrl,
       headers: { 
         'Authorization': `Bearer ${accessToken.token}`
       }
   };
   const response = await axios(config);
   const keysDict = response.data;
   const connectionString = keysDict['connectionStrings'][0]['connectionString'];
   
   const client = new MongoClient(connectionString);
   

Outro

Para outros idiomas, você pode usar o ponto de extremidade de recurso do MongoDB e outras propriedades que o Service Connector define para as variáveis de ambiente para se conectar ao Azure Cosmos DB para MongoDB. Para obter detalhes sobre variáveis de ambiente, consulte Integrar o Azure Cosmos DB para MongoDB com o Service Connector.

Próximos passos

Siga os tutoriais listados abaixo para saber mais sobre o Service Connector.

Saiba mais sobre os conceitos do Service Connector