Intégrer Azure Cosmos DB for Table à l’aide de Service Connector

Article
10/16/2024

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 Table à d’autres services cloud en utilisant le connecteur de services. Vous pouvez toujours vous connecter à Azure Cosmos DB pour Table dans d’autres langages de programmation sans utiliser Service Connector. Cette page indique également les noms et les valeurs des variables d'environnement par défaut que vous obtenez lorsque vous créez la connexion du 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 Table :

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

Types d’authentification et de clients pris en charge

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

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 du service
.NET	Oui	Oui	Oui	Oui
Java	Oui	Oui	Oui	Oui
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 client et de méthodes d’authentification dans la table sont prises en charge. Tous les types clients peuvent utiliser toutes les méthodes d’authentification pour se connecter à Azure Cosmos DB for Table à l’aide du connecteur de services.

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

Utilisez les détails de connexion ci-dessous pour connecter vos services de calcul à Azure Cosmos DB for Table. Pour chaque exemple ci-dessous, remplacez le texte d’espace réservé <account-name>, <table-name>, <account-key>, <resource-group-name>, <subscription-ID>, <client-ID>, <client-secret>, <tenant-id> par vos propres informations. Pour plus d’informations sur les conventions d’affectation de noms, consultez l’article Services internes du connecteur de services.

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

Nom de variable d’environnement par défaut	Description	Valeur d'exemple
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/<table-name>/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://<table-name>.documents.azure.com:443/`

Exemple de code

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

Installez des dépendances.

dotnet add package Azure.Data.Tables
dotnet add package Azure.Identity

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 Table. 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.Threading.Tasks;
using Azure.Data.Tables;
using Azure.Identity;

var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned identity.
// var tokenProvider = new DefaultAzureCredential();

// For user-assigned identity.
// var tokenProvider = new DefaultAzureCredential(
//     new DefaultAzureCredentialOptions
//     {
//         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
//     }
// );

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
// var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

// Acquire the access token. 
AccessToken accessToken = await tokenProvider.GetTokenAsync(
    new TokenRequestContext(scopes: new string[]{ scope }));

// Get the connection string.
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
var response = await httpClient.POSTAsync(listConnectionStringUrl);
var responseBody = await response.Content.ReadAsStringAsync();
var connectionStrings = JsonConvert.DeserializeObject<Dictionary<string, List<Dictionary<string, string>>>(responseBody);
var connectionString = connectionStrings["connectionStrings"].Find(connStr => connStr["description"] == "Primary Table Connection String")["connectionString"];

// Connect to Azure Cosmos DB for Table
TableServiceClient tableServiceClient = new TableServiceClient(connectionString);

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

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-data-tables</artifactId>
    <version>12.2.1</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.1.5</version>
</dependency>

Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de 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 Table. 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.azure.data.tables.TableClient;
import com.azure.data.tables.TableClientBuilder;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import com.azure.identity.*;
import com.azure.core.credentital.*;
import java.net.http.*;

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;
for (Map<String, String> connStr : connectionStrings){
    if (connStr.get("description") == "Primary Table Connection String"){
        connectionString = connStr.get("connectionString");
        break;
    }
}

// Connect to Azure Cosmos DB for Table
TableClient tableClient = new TableClientBuilder()
    .connectionString(connectionString)
    .buildClient();

Installez des dépendances.

pip install azure-data-tables
pip install azure-identity

import os
from azure.data.tables import TableServiceClient
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 = x["connectionString"] for x in keys_dict["connectionStrings"] if x["description"] == "Primary Table Connection String"

# Connect to Azure Cosmos DB for Table
table_service = TableServiceClient.from_connection_string(conn_str)

Installez des dépendances.

go get github.com/Azure/azure-sdk-for-go/sdk/data/aztables
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Dans le code, obtenez le jeton d’accès à l’aide de @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 Table. 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"

    "github.com/Azure/azure-sdk-for-go/sdk/data/aztables"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)

func main() {
    endpoint = os.Getenv("AZURE_COSMOS_RESOURCEENDPOINT")
    listConnectionStringUrl = os.Getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL")
    scope = os.Getenv("AZUE_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)
    connStr := ""
    for i := range result["connectionStrings"]{
        if result["connectionStrings"][i]["description"] == "Primary Table Connection String" {
            connStr, err := result["connectionStrings"][i]["connectionString"]
            break
        }
    }

    serviceClient, err := aztables.NewServiceClientFromConnectionString(connStr, nil)
    if err != nil {
        panic(err)
    }
}

Installer les dépendances

npm install @azure/data-tables
npm install --save @azure/identity

Dans le code, obtenez le jeton d’accès à l’aide de @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 Table. 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 { TableClient } = require("@azure/data-tables");
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"].find(connStr => connStr["description"] == "Primary Table Connection String")["connectionString"];

// Connect to Azure Cosmos DB for Table
const serviceClient = TableClient.fromConnectionString(connectionString);

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

Nom de variable d’environnement par défaut	Description	Valeur d'exemple
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/<table-name>/listConnectionStrings?api-version=2021-04-15`
AZURE_COSMOS_SCOPE	Étendue de votre identité managée	`https://management.azure.com/.default`
AZURE_COSMOS_CLIENTID	ID de votre clé secrète client	`<client-ID>`
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	`https://<table-name>.documents.azure.com:443/`

Exemple de code

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

Installez des dépendances.

dotnet add package Azure.Data.Tables
dotnet add package Azure.Identity

using System;
using System.Security.Authentication;
using System.Net.Security;
using System.Net.Http;
using System.Security.Authentication;
using System.Threading.Tasks;
using Azure.Data.Tables;
using Azure.Identity;

var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned identity.
// var tokenProvider = new DefaultAzureCredential();

// For user-assigned identity.
// var tokenProvider = new DefaultAzureCredential(
//     new DefaultAzureCredentialOptions
//     {
//         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
//     }
// );

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
// var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

// Acquire the access token. 
AccessToken accessToken = await tokenProvider.GetTokenAsync(
    new TokenRequestContext(scopes: new string[]{ scope }));

// Get the connection string.
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
var response = await httpClient.POSTAsync(listConnectionStringUrl);
var responseBody = await response.Content.ReadAsStringAsync();
var connectionStrings = JsonConvert.DeserializeObject<Dictionary<string, List<Dictionary<string, string>>>(responseBody);
var connectionString = connectionStrings["connectionStrings"].Find(connStr => connStr["description"] == "Primary Table Connection String")["connectionString"];

// Connect to Azure Cosmos DB for Table
TableServiceClient tableServiceClient = new TableServiceClient(connectionString);

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

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-data-tables</artifactId>
    <version>12.2.1</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.1.5</version>
</dependency>

import com.azure.data.tables.TableClient;
import com.azure.data.tables.TableClientBuilder;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import com.azure.identity.*;
import com.azure.core.credentital.*;
import java.net.http.*;

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;
for (Map<String, String> connStr : connectionStrings){
    if (connStr.get("description") == "Primary Table Connection String"){
        connectionString = connStr.get("connectionString");
        break;
    }
}

// Connect to Azure Cosmos DB for Table
TableClient tableClient = new TableClientBuilder()
    .connectionString(connectionString)
    .buildClient();

Installez des dépendances.

pip install azure-data-tables
pip install azure-identity

import os
from azure.data.tables import TableServiceClient
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 = x["connectionString"] for x in keys_dict["connectionStrings"] if x["description"] == "Primary Table Connection String"

# Connect to Azure Cosmos DB for Table
table_service = TableServiceClient.from_connection_string(conn_str)

Installez des dépendances.

go get github.com/Azure/azure-sdk-for-go/sdk/data/aztables
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

import (
    "fmt"
    "os"
    "context"
    "log"
    "io/ioutil"
    "encoding/json"

    "github.com/Azure/azure-sdk-for-go/sdk/data/aztables"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)

func main() {
    endpoint = os.Getenv("AZURE_COSMOS_RESOURCEENDPOINT")
    listConnectionStringUrl = os.Getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL")
    scope = os.Getenv("AZUE_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)
    connStr := ""
    for i := range result["connectionStrings"]{
        if result["connectionStrings"][i]["description"] == "Primary Table Connection String" {
            connStr, err := result["connectionStrings"][i]["connectionString"]
            break
        }
    }

    serviceClient, err := aztables.NewServiceClientFromConnectionString(connStr, nil)
    if err != nil {
        panic(err)
    }
}

Installer les dépendances

npm install @azure/data-tables
npm install --save @azure/identity

import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
const { TableClient } = require("@azure/data-tables");
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"].find(connStr => connStr["description"] == "Primary Table Connection String")["connectionString"];

// Connect to Azure Cosmos DB for Table
const serviceClient = TableClient.fromConnectionString(connectionString);

Connection string

Nom de variable d’environnement par défaut	Description	Valeur d'exemple
AZURE_COSMOS_CONNECTIONSTRING	Chaîne de connexion d’Azure Cosmos DB pour table	`DefaultEndpointsProtocol=https;AccountName=<account-name>;AccountKey=<account-key>;TableEndpoint=https://<table-name>.table.cosmos.azure.com:443/;`

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 degré de confiance très élevé dans l'application et comporte des risques qui ne sont pas présents dans d'autres flux. Vous ne devez utiliser ce flux que si d’autres flux plus sécurisés, tels que les identités managées, ne sont pas viables.

Exemple de code

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

Installez la dépendance.
```
dotnet add package Azure.Data.Tables
```