Integrace služby Azure Cosmos DB for Table s konektorem služby

Tato stránka ukazuje podporované metody ověřování a klienty a ukazuje ukázkový kód, který můžete použít k připojení služby Azure Cosmos DB for Table k jiným cloudovým službám pomocí konektoru služby. Stále se můžete připojit ke službě Azure Cosmos DB for Table v jiných programovacích jazycích bez použití konektoru služby. Tato stránka také zobrazuje výchozí názvy proměnných prostředí a hodnoty, které získáte při vytváření připojení služby.

Podporované výpočetní služby

Konektor služby se dá použít k připojení následujících výpočetních služeb ke službě Azure Cosmos DB for Table:

• Azure App Service
• Azure Functions
• Azure Container Apps
• Azure Spring Apps

Podporované typy ověřování a typy klientů

Následující tabulka ukazuje, které kombinace typů klientů a metod ověřování se podporují pro připojení výpočetní služby ke službě Azure Cosmos DB pro tabulky pomocí konektoru služby. "Ano" označuje, že kombinace je podporována, zatímco "Ne" označuje, že není podporována.

Typ klienta	Spravovaná identita přiřazená systémem	Spravovaná identita přiřazená uživatelem	Tajný kód / připojovací řetězec	Instanční objekt
.NET	Ano	Ano	Ano	Yes
Java	Ano	Ano	Ano	Yes
Node.js	Ano	Ano	Ano	Yes
Python	Ano	Ano	Ano	Yes
Go	Ano	Ano	Ano	Yes
Nic	Ano	Ano	Ano	Yes

Tato tabulka označuje, že jsou podporovány všechny kombinace typů klientů a metod ověřování v tabulce. Všechny typy klientů můžou pro připojení ke službě Azure Cosmos DB pro tabulky pomocí konektoru služby použít některou z metod ověřování.

Výchozí názvy proměnných prostředí nebo vlastnosti aplikace a ukázkový kód

Pomocí níže uvedených podrobností o připojení připojte výpočetní služby ke službě Azure Cosmos DB for Table. V každém příkladu níže nahraďte zástupné texty <account-name>, <table-name>, <account-key>, <resource-group-name><subscription-ID>, , <client-ID>, , , <client-secret>vlastními <tenant-id> informacemi. Další informace o konvencích vytváření názvů najdete v interním článku o konektoru služby.

Spravovaná identita přiřazená systémem

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adresa URL pro získání připojovací řetězec	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	Rozsah spravované identity	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Váš koncový bod prostředku	https://<table-name>.documents.azure.com:443/

Ukázkový kód

Projděte si následující kroky a kód a připojte se ke službě Azure Cosmos DB for Table pomocí spravované identity přiřazené systémem.

.NET

1. Nainstalujte závislosti.

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

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí klientské knihovny Azure.Identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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. Do souboru pom.xml přidejte následující závislosti:

   <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. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

Python

1. Nainstalujte závislosti.

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

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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) 
   

Přejít

1. Nainstalujte závislosti.

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

2. V kódu získejte přístupový token pomocí @azidentitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

NodeJS

1. Instalace závislostí

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

2. V kódu získejte přístupový token pomocí @azure/identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

Další

V jiných jazycích můžete použít adresu URL koncového bodu a další vlastnosti, které Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for Table. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro tabulku s konektorem služby.

Spravovaná identita přiřazená uživatelem

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adresa URL pro získání připojovací řetězec	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	Rozsah spravované identity	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	ID tajného klíče klienta	<client-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Váš koncový bod prostředku	https://<table-name>.documents.azure.com:443/

Ukázkový kód

Projděte si následující kroky a kód a připojte se ke službě Azure Cosmos DB for Table pomocí spravované identity přiřazené uživatelem.

.NET

1. Nainstalujte závislosti.

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

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí klientské knihovny Azure.Identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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. Do souboru pom.xml přidejte následující závislosti:

   <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. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

Python

1. Nainstalujte závislosti.

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

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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) 
   

Přejít

1. Nainstalujte závislosti.

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

2. V kódu získejte přístupový token pomocí @azidentitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

NodeJS

1. Instalace závislostí

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

2. V kódu získejte přístupový token pomocí @azure/identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

Další

V jiných jazycích můžete použít adresu URL koncového bodu a další vlastnosti, které Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for Table. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro tabulku s konektorem služby.

Connection string

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_CONNECTIONSTRING	Azure Cosmos DB for Table připojovací řetězec	DefaultEndpointsProtocol=https;AccountName=<account-name>;AccountKey=<account-key>;TableEndpoint=https://<table-name>.table.cosmos.azure.com:443/;

Upozorňující

Microsoft doporučuje používat nejbezpečnější dostupný tok ověřování. Ověřovací tok popsaný v tomto postupu vyžaduje velmi vysoký stupeň důvěryhodnosti v aplikaci a nese rizika, která nejsou přítomna v jiných tocích. Tento tok byste měli použít jenom v případě, že jiné bezpečnější toky, jako jsou spravované identity, nejsou přijatelné.

Ukázkový kód

Informace o připojení ke službě Azure Cosmos DB for Table pomocí připojovací řetězec najdete v následujících krocích a kódu.

.NET

1. Nainstalujte závislost.

   dotnet add package Azure.Data.Tables
   

2. Získejte připojovací řetězec z proměnné prostředí přidané konektorem služby.

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

Java

1. Do souboru pom.xml přidejte následující závislost:

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

2. Získejte připojovací řetězec z proměnné prostředí přidané konektorem služby.

   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. Nainstalujte závislost.

   pip install azure-data-tables
   

2. Získejte připojovací řetězec z proměnné prostředí přidané konektorem služby.

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

Přejít

1. Nainstalujte závislost.

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

2. Získejte připojovací řetězec z proměnné prostředí přidané konektorem služby.

   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. Nainstalujte závislost.

   npm install @azure/data-tables
   

2. Získejte připojovací řetězec z proměnné prostředí přidané konektorem služby.

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

Další

V jiných jazycích můžete použít adresu URL koncového bodu a další vlastnosti, které Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for Table. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro tabulku s konektorem služby.

Instanční objekt

Výchozí název proměnné prostředí	Popis	Příklad hodnoty
AZURE_COSMOS_LISTCONNECTIONSTRINGURL	Adresa URL pro získání připojovací řetězec	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	Rozsah spravované identity	https://management.azure.com/.default
AZURE_COSMOS_CLIENTID	ID tajného klíče klienta	<client-ID>
AZURE_COSMOS_CLIENTSECRET	Tajný klíč klienta	<client-secret>
AZURE_COSMOS_TENANTID	ID vašeho tenanta	<tenant-ID>
AZURE_COSMOS_RESOURCEENDPOINT	Váš koncový bod prostředku	https://<table-name>.documents.azure.com:443/

Ukázkový kód

Informace o připojení ke službě Azure Cosmos DB for Table pomocí instančního objektu najdete v následujících krocích a kódu.

.NET

1. Nainstalujte závislosti.

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

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí klientské knihovny Azure.Identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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. Do souboru pom.xml přidejte následující závislosti:

   <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. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

Python

1. Nainstalujte závislosti.

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

2. Získejte přístupový token pro spravovanou identitu nebo instanční objekt pomocí azure-identity. Použijte přístupový token a AZURE_COSMOS_LISTCONNECTIONSTRINGURL získejte připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

   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) 
   

Přejít

1. Nainstalujte závislosti.

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

2. V kódu získejte přístupový token pomocí @azidentitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

NodeJS

1. Instalace závislostí

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

2. V kódu získejte přístupový token pomocí @azure/identitya pak ho použijte k získání připojovací řetězec. Získejte informace o připojení z proměnných prostředí přidaných konektorem služby a připojte se ke službě Azure Cosmos DB for Table. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

Další

V jiných jazycích můžete použít adresu URL koncového bodu a další vlastnosti, které Konektor služby nastaví na proměnné prostředí pro připojení ke službě Azure Cosmos DB for Table. Podrobnosti o proměnné prostředí najdete v tématu Integrace služby Azure Cosmos DB pro tabulku s konektorem služby.

Další kroky

Další informace o konektoru Service Connector najdete v následujících kurzech.

Další informace o konceptech konektoru Service Connector