Intégrer Azure Cosmos DB for Table à l’aide de Service Connector
Article
Cette page présente les méthodes d’authentification et les clients pris en charge, et présente des exemples de code que vous pouvez utiliser pour connecter Azure Cosmos DB pour Table à d’autres services cloud à l’aide du service Connecter or. 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 Connecter or de service peut être utilisé pour connecter les services de calcul suivants à Azure Cosmos DB pour Table :
Azure App Service
Azure Functions
Azure Container Apps
Azure Spring Apps
Types d’authentification et de clients pris en charge
Le tableau ci-dessous montre quelles combinaisons de types de clients et de méthodes d’authentification sont prises en charge pour connecter votre service de calcul à Azure Cosmos DB pour Table à l’aide du Connecter or de service. Un « Oui » indique que la combinaison est prise en charge, tandis qu’une valeur « 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 clients et de méthodes d’authentification dans la table sont prises en charge. Tous les types de clients peuvent utiliser l’une des méthodes d’authentification pour se connecter à Azure Cosmos DB pour Table à l’aide du Connecter or de service.
Noms de 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 vos services de calcul à Azure Cosmos DB pour 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, case activée l’article interne du service Connecter or.
Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB pour Table à l’aide d’une identité managée affectée par le système.
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 obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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 :
Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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();
Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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 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@azidentity, puis utilisez-le pour acquérir le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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)
}
}
Dans le code, obtenez le jeton d’accès à l’aide@azure/identity, puis utilisez-le pour acquérir le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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);
Pour d’autres langages, vous pouvez utiliser l’URL du point de terminaison et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à Azure Cosmos DB pour Table. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Table à Service Connecter or.
Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB pour Table à l’aide d’une identité managée affectée par l’utilisateur.
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 obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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 :
Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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();
Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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 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@azidentity, puis utilisez-le pour acquérir le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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)
}
}
Dans le code, obtenez le jeton d’accès à l’aide@azure/identity, puis utilisez-le pour acquérir le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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);
Pour d’autres langages, vous pouvez utiliser l’URL du point de terminaison et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à Azure Cosmos DB pour Table. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Table à Service Connecter or.
Obtenez le chaîne de connexion à partir de la variable d’environnement ajoutée par service Connecter or.
using Azure.Data.Tables;
using System;
TableServiceClient tableServiceClient = new TableServiceClient(Environment.GetEnvironmentVariable("AZURE_COSMOS_CONNECTIONSTRING"));
Ajoutez la dépendance suivante dans votre fichier pom.xml :
Pour d’autres langages, vous pouvez utiliser l’URL du point de terminaison et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à Azure Cosmos DB pour Table. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Table à Service Connecter or.
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 obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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 :
Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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();
Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTCONNECTIONSTRINGURL obtenez le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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 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@azidentity, puis utilisez-le pour acquérir le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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)
}
}
Dans le code, obtenez le jeton d’accès à l’aide@azure/identity, puis utilisez-le pour acquérir le chaîne de connexion. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour 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);
Pour d’autres langages, vous pouvez utiliser l’URL du point de terminaison et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à Azure Cosmos DB pour Table. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Table à Service Connecter or.
Étapes suivantes
Suivez les tutoriels ci-dessous pour en savoir plus sur Service Connector.