Integrowanie usługi Azure Cosmos DB dla tabel z łącznikiem usługi

Na tej stronie przedstawiono obsługiwane metody uwierzytelniania i klientów oraz pokazano przykładowy kod, którego można użyć do połączenia usługi Azure Cosmos DB for Table z innymi usługami w chmurze przy użyciu łącznika usług. Nadal możesz nawiązać połączenie z usługą Azure Cosmos DB for Table w innych językach programowania bez używania łącznika usługi. Ta strona zawiera również domyślne nazwy zmiennych środowiskowych i wartości uzyskiwane podczas tworzenia połączenia z usługą.

Obsługiwane usługi obliczeniowe

Łącznik usługi może służyć do łączenia następujących usług obliczeniowych z usługą Azure Cosmos DB dla tabeli:

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

Obsługiwane typy uwierzytelniania i typy klientów

W poniższej tabeli pokazano, które kombinacje typów klientów i metod uwierzytelniania są obsługiwane do łączenia usługi obliczeniowej z usługą Azure Cosmos DB dla tabel przy użyciu łącznika usługi Service Connector. Wartość "Tak" wskazuje, że kombinacja jest obsługiwana, a wartość "Nie" wskazuje, że nie jest obsługiwana.

Typ klienta	Tożsamość zarządzana przypisana przez system	Tożsamość zarządzana przypisana przez użytkownika	Wpis tajny/parametry połączenia	Jednostka usługi
.NET	Tak	Tak	Tak	Tak
Java	Tak	Tak	Tak	Tak
Node.js	Tak	Tak	Tak	Tak
Python	Tak	Tak	Tak	Tak
Go	Tak	Tak	Tak	Tak
None	Tak	Tak	Tak	Tak

Ta tabela wskazuje, że obsługiwane są wszystkie kombinacje typów klientów i metod uwierzytelniania w tabeli. Wszystkie typy klientów mogą używać dowolnej metody uwierzytelniania do nawiązywania połączenia z usługą Azure Cosmos DB dla tabel przy użyciu łącznika usługi.

Domyślne nazwy zmiennych środowiskowych lub właściwości aplikacji i przykładowy kod

Użyj poniższych szczegółów połączenia, aby połączyć usługi obliczeniowe z usługą Azure Cosmos DB dla tabeli. Dla każdego z poniższych przykładów zastąp tekst <account-name>zastępczy , , <table-name>, <subscription-ID><resource-group-name><client-ID><account-key>, , <client-secret><tenant-id> własnymi informacjami. Aby uzyskać więcej informacji na temat konwencji nazewnictwa, zapoznaj się z artykułem Dotyczącym wewnętrznych łączników usług.

Tożsamość zarządzana przypisana przez system

Domyślna nazwa zmiennej środowiskowej	opis	Przykładowa wartość
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adres URL umożliwiający pobranie parametry połączenia	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	Zakres tożsamości zarządzanej	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Punkt końcowy zasobu	https://<table-name>.documents.azure.com:443/

Przykładowy kod

Zapoznaj się z poniższymi krokami i kodem, aby nawiązać połączenie z usługą Azure Cosmos DB dla tabeli przy użyciu tożsamości zarządzanej przypisanej przez system.

.NET

1. Instalowanie zależności.

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

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu biblioteki klienta Azure.Identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

Java

1. Dodaj następujące zależności w pliku 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>
   

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu polecenia azure-identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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.credential.*;
   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();
   

Python

1. Instalowanie zależności.

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

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu polecenia azure-identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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) 
   

Przejdź

1. Instalowanie zależności.

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

2. W kodzie pobierz token dostępu przy użyciu metody @azidentity, a następnie użyj go do uzyskania parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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("AZURE_COSMOS_SCOPE")
   
       // Uncomment the following lines corresponding to the authentication type you want to use.
       // For system-assigned identity.
       // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
       // For user-assigned identity.
       // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
       // azidentity.ManagedIdentityCredentialOptions.ID := clientid
       // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
       // cred, err := azidentity.NewManagedIdentityCredential(options)
   
       // For service principal.
       // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
       // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
       // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
       // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
       // Acquire the access token.
       ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
       token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
           Scopes: []string{scope},
       })
   
       // Acquire the connection string.
       client := &http.Client{}
       req, err := http.NewRequest("POST", listConnectionStringUrl, nil)
       req.Header.Add("Authorization", "Bearer " + token.Token)
       resp, err := client.Do(req)
       body, err := ioutil.ReadAll(resp.Body)
       var result map[string]interface{}
       json.Unmarshal(body, &result)
       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)
       }
   }
   

NodeJS

1. Instalowanie zależności

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

2. W kodzie pobierz token dostępu przy użyciu metody @azure/identity, a następnie użyj go do uzyskania parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

Inne

W przypadku innych języków można użyć adresu URL punktu końcowego i innych właściwości, które łącznik usługi ustawia na zmienne środowiskowe w celu nawiązania połączenia z usługą Azure Cosmos DB dla tabeli. Aby uzyskać szczegółowe informacje o zmiennej środowiskowej, zobacz Integrowanie usługi Azure Cosmos DB dla tabeli z łącznikiem usługi.

Tożsamość zarządzana przypisana przez użytkownika

Domyślna nazwa zmiennej środowiskowej	opis	Przykładowa wartość
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adres URL umożliwiający pobranie parametry połączenia	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	Zakres tożsamości zarządzanej	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	Identyfikator wpisu tajnego klienta	<client-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Punkt końcowy zasobu	https://<table-name>.documents.azure.com:443/

Przykładowy kod

Zapoznaj się z poniższymi krokami i kodem, aby nawiązać połączenie z usługą Azure Cosmos DB dla tabeli przy użyciu tożsamości zarządzanej przypisanej przez użytkownika.

.NET

1. Instalowanie zależności.

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

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu biblioteki klienta Azure.Identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

Java

1. Dodaj następujące zależności w pliku 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>
   

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu polecenia azure-identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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.credential.*;
   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();
   

Python

1. Instalowanie zależności.

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

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu polecenia azure-identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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) 
   

Przejdź

1. Instalowanie zależności.

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

2. W kodzie pobierz token dostępu przy użyciu metody @azidentity, a następnie użyj go do uzyskania parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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("AZURE_COSMOS_SCOPE")
   
       // Uncomment the following lines corresponding to the authentication type you want to use.
       // For system-assigned identity.
       // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
       // For user-assigned identity.
       // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
       // azidentity.ManagedIdentityCredentialOptions.ID := clientid
       // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
       // cred, err := azidentity.NewManagedIdentityCredential(options)
   
       // For service principal.
       // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
       // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
       // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
       // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
       // Acquire the access token.
       ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
       token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
           Scopes: []string{scope},
       })
   
       // Acquire the connection string.
       client := &http.Client{}
       req, err := http.NewRequest("POST", listConnectionStringUrl, nil)
       req.Header.Add("Authorization", "Bearer " + token.Token)
       resp, err := client.Do(req)
       body, err := ioutil.ReadAll(resp.Body)
       var result map[string]interface{}
       json.Unmarshal(body, &result)
       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)
       }
   }
   

NodeJS

1. Instalowanie zależności

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

2. W kodzie pobierz token dostępu przy użyciu metody @azure/identity, a następnie użyj go do uzyskania parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

Inne

W przypadku innych języków można użyć adresu URL punktu końcowego i innych właściwości, które łącznik usługi ustawia na zmienne środowiskowe w celu nawiązania połączenia z usługą Azure Cosmos DB dla tabeli. Aby uzyskać szczegółowe informacje o zmiennej środowiskowej, zobacz Integrowanie usługi Azure Cosmos DB dla tabeli z łącznikiem usługi.

Connection string

Domyślna nazwa zmiennej środowiskowej	opis	Przykładowa wartość
AZURE_COSMOS_CONNECTIONSTRING	Usługa Azure Cosmos DB dla parametry połączenia tabel	DefaultEndpointsProtocol=https;AccountName=<account-name>;AccountKey=<account-key>;TableEndpoint=https://<table-name>.table.cosmos.azure.com:443/;

Ostrzeżenie

Firma Microsoft zaleca korzystanie z najbezpieczniejszego dostępnego przepływu uwierzytelniania. Przepływ uwierzytelniania opisany w tej procedurze wymaga bardzo wysokiego poziomu zaufania w aplikacji i niesie ze sobą ryzyko, które nie występują w innych przepływach. Tego przepływu należy używać tylko wtedy, gdy inne bezpieczniejsze przepływy, takie jak tożsamości zarządzane, nie są opłacalne.

Przykładowy kod

Zapoznaj się z poniższymi krokami i kodem, aby nawiązać połączenie z usługą Azure Cosmos DB for Table przy użyciu parametry połączenia.

.NET

1. Zainstaluj zależność.

   dotnet add package Azure.Data.Tables
   

2. Pobierz parametry połączenia ze zmiennej środowiskowej dodanej przez łącznik usługi.

   using Azure.Data.Tables;
   using System; 
   
   TableServiceClient tableServiceClient = new TableServiceClient(Environment.GetEnvironmentVariable("AZURE_COSMOS_CONNECTIONSTRING"));
   

Java

1. Dodaj następującą zależność w pliku pom.xml :

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

2. Pobierz parametry połączenia ze zmiennej środowiskowej dodanej przez łącznik usługi.

   import com.azure.data.tables.TableClient;
   import com.azure.data.tables.TableClientBuilder;
   
   String connectionStr = System.getenv("AZURE_COSMOS_CONNECTIONSTRING");
   
   TableClient tableClient = new TableClientBuilder()
       .connectionString(connectionStr)
       .buildClient();
   

Python

1. Zainstaluj zależność.

   pip install azure-data-tables
   

2. Pobierz parametry połączenia ze zmiennej środowiskowej dodanej przez łącznik usługi.

   import os
   from azure.data.tables import TableServiceClient
   
   conn_str = os.environ["AZURE_COSMOS_CONNECTIONSTRING"]
   table_service = TableServiceClient.from_connection_string(conn_str) 
   

Przejdź

1. Zainstaluj zależność.

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

2. Pobierz parametry połączenia ze zmiennej środowiskowej dodanej przez łącznik usługi.

   import (
       "github.com/Azure/azure-sdk-for-go/sdk/data/aztables"
   )
   
   func main() {
       connStr := os.Getenv("AZURE_COSMOS_CONNECTIONSTRING")
       serviceClient, err := aztables.NewServiceClientFromConnectionString(connStr, nil)
       if err != nil {
           panic(err)
       }
   }
   

NodeJS

1. Zainstaluj zależność.

   npm install @azure/data-tables
   

2. Pobierz parametry połączenia ze zmiennej środowiskowej dodanej przez łącznik usługi.

   const { TableClient } = require("@azure/data-tables");
   
   const serviceClient = TableClient.fromConnectionString(process.env.AZURE_COSMOS_CONNECTIONSTRING);
   

Inne

W przypadku innych języków można użyć adresu URL punktu końcowego i innych właściwości, które łącznik usługi ustawia na zmienne środowiskowe w celu nawiązania połączenia z usługą Azure Cosmos DB dla tabeli. Aby uzyskać szczegółowe informacje o zmiennej środowiskowej, zobacz Integrowanie usługi Azure Cosmos DB dla tabeli z łącznikiem usługi.

Jednostka usługi

Domyślna nazwa zmiennej środowiskowej	opis	Przykładowa wartość
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adres URL umożliwiający pobranie parametry połączenia	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	Zakres tożsamości zarządzanej	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	Identyfikator wpisu tajnego klienta	<client-ID>
AZURE_COSMOS_CLIENTSECRET	Klucz tajny klienta	<client-secret>
AZURE_COSMOS_TENANTID	Identyfikator dzierżawy	<tenant-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Punkt końcowy zasobu	https://<table-name>.documents.azure.com:443/

Przykładowy kod

Zapoznaj się z poniższymi krokami i kodem, aby nawiązać połączenie z usługą Azure Cosmos DB for Table przy użyciu jednostki usługi.

.NET

1. Instalowanie zależności.

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

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu biblioteki klienta Azure.Identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

Java

1. Dodaj następujące zależności w pliku 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>
   

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu polecenia azure-identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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.credential.*;
   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();
   

Python

1. Instalowanie zależności.

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

2. Uzyskaj token dostępu dla tożsamości zarządzanej lub jednostki usługi przy użyciu polecenia azure-identity. Użyj tokenu dostępu i AZURE_COSMOS_LISTCONNECTIONSTRINGURL pobierz parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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) 
   

Przejdź

1. Instalowanie zależności.

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

2. W kodzie pobierz token dostępu przy użyciu metody @azidentity, a następnie użyj go do uzyskania parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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("AZURE_COSMOS_SCOPE")
   
       // Uncomment the following lines corresponding to the authentication type you want to use.
       // For system-assigned identity.
       // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
       // For user-assigned identity.
       // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
       // azidentity.ManagedIdentityCredentialOptions.ID := clientid
       // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
       // cred, err := azidentity.NewManagedIdentityCredential(options)
   
       // For service principal.
       // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
       // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
       // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
       // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
       // Acquire the access token.
       ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
       token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
           Scopes: []string{scope},
       })
   
       // Acquire the connection string.
       client := &http.Client{}
       req, err := http.NewRequest("POST", listConnectionStringUrl, nil)
       req.Header.Add("Authorization", "Bearer " + token.Token)
       resp, err := client.Do(req)
       body, err := ioutil.ReadAll(resp.Body)
       var result map[string]interface{}
       json.Unmarshal(body, &result)
       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)
       }
   }
   

NodeJS

1. Instalowanie zależności

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

2. W kodzie pobierz token dostępu przy użyciu metody @azure/identity, a następnie użyj go do uzyskania parametry połączenia. Uzyskaj informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi i połącz się z usługą Azure Cosmos DB dla tabeli. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

Inne

W przypadku innych języków można użyć adresu URL punktu końcowego i innych właściwości, które łącznik usługi ustawia na zmienne środowiskowe w celu nawiązania połączenia z usługą Azure Cosmos DB dla tabeli. Aby uzyskać szczegółowe informacje o zmiennej środowiskowej, zobacz Integrowanie usługi Azure Cosmos DB dla tabeli z łącznikiem usługi.

Następne kroki

Postępuj zgodnie z samouczkami wymienionymi poniżej, aby dowiedzieć się więcej o łączniku usługi.

Dowiedz się więcej o pojęciach dotyczących łącznika usług