你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

使用服务连接器集成 Azure Cosmos DB for Gremlin

本页显示了支持的身份验证方法和客户端，还演示了可用于将 Azure Cosmos DB for Apache Gremlin 通过服务连接器连接到其他云服务的示例代码。 即使不使用服务连接器，你可能仍然可以使用其他编程语言连接到 Azure Cosmos DB for Gremlin。 此页面还显示你在创建服务连接时获得的默认环境变量名称和值。

受支持的计算服务

服务连接器可用于将以下计算服务连接到 Azure Cosmos DB for Apache Gremlin：

• Azure 应用程序服务
• Azure Container Apps
• Azure Functions
• Azure Kubernetes 服务 (AKS)
• Azure Spring Apps

受支持的身份验证类型和客户端类型

下表显示了使用服务连接器将计算服务连接到 Azure Cosmos DB for Apache Gremlin 时支持的客户端类型和身份验证方法的组合。 “是”表示支持该组合，“否”表示不支持该组合。

客户端类型	系统分配的托管标识	用户分配的托管标识	机密/连接字符串	服务主体
.NET	是	是	是	是
Java	是	是	是	是
Node.js	是	是	是	是
PHP	是	是	是	是
Python	是	是	是	是
Go	是	是	是	是
无	是	是	是	是

此表支持表中客户端类型和身份验证方法的所有组合都受到支持。 所有客户端类型都可使用任何身份验证方法通过服务连接器连接到 Azure Cosmos DB for Apache Gremlin。

默认环境变量名称或应用程序属性和示例代码

请使用下面的连接详细信息将计算服务连接到 Azure Cosmos DB for Apache Gremlin。 对于下面的每个示例，请将占位符文本 <Azure-Cosmos-DB-account>、<database>、<collection or graphs>、<username>、<password>、<resource-group-name>、<subscription-ID>、<client-ID>、<client-secret> 和 <tenant-id> 替换为你自己的信息。 有关命名约定的详细信息，请参阅服务连接器内部一文。

系统分配的托管标识

默认环境变量名称	说明	示例值
AZURE_COSMOS_LISTKEYURL	用户获取连接字符串的 URL	https://management.azure.com/subscriptions/<subscription-ID>/resourceGroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<Azure-Cosmos-DB-account>/listKeys?api-version=2021-04-15
AZURE_COSMOS_SCOPE	托管标识范围	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	资源终结点	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_HOSTNAME	Gremlin 唯一资源标识符 (UFI)	<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com
AZURE_COSMOS_PORT	连接端口	443
AZURE_COSMOS_USERNAME	用户名	/dbs/<database>/colls/<collection or graphs>

代码示例

请参考以下步骤和代码，使用系统分配的托管标识连接到 Azure Cosmos DB for Gremlin。

.NET

1. 安装依赖项。

   dotnet add package Gremlin.Net
   dotnet add package Azure.Identity
   

2. 使用 Azure.Identity 客户端库获取托管标识或服务主体的访问令牌。 使用访问令牌和 AZURE_COSMOS_LISTKEYURL 获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Threading.Tasks;
   using System;
   using Gremlin.Net.Driver;
   using Azure.Identity;
   
   var gremlinEndpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
   var gremlinPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
   var listKeyUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTKEYURL");
   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 password.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listKeyUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var keys = JsonConvert.DeserializeObject<Dictionary<string, string>>(responseBody);
   var password = keys["primaryMasterKey"];
   
   // Connect to Azure Cosmos DB for Apache Gremlin
   var server = new GremlinServer(
       hostname: gremlinEndpoint,
       port: gremlinPort,
       username: userName,
       password: password,
       enableSsl: true
   );
   
   using var client = new GremlinClient(
       gremlinServer: server,
       messageSerializer: new Gremlin.Net.Structure.IO.GraphSON.GraphSON2MessageSerializer()
   );        
   
   

Java

1. 将以下依赖项添加到 pom.xml 文件：

   <dependency>
     <groupId>org.apache.tinkerpop</groupId>
     <artifactId>gremlin-driver</artifactId>
     <version>3.4.13</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. 使用 azure-identity 获取托管标识或服务主体的访问令牌。 使用访问令牌和 AZURE_COSMOS_LISTKEYURL 获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import org.apache.tinkerpop.gremlin.driver.Client;
   import org.apache.tinkerpop.gremlin.driver.Cluster;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   import com.azure.identity.*;
   import com.azure.core.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   int gremlinPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String username = System.getenv("AZURE_COSMOS_USERNAME");
   String gremlinEndpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listKeyUrl = System.getenv("AZURE_COSMOS_LISTKEYURL");
   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 password.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listKeyUrl))
       .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());
   String gremlinPassword = responseBody.get("primaryMasterKey");
   
   // Connect to Azure Cosmos DB for Apache Gremlin
   Cluster cluster;
   Client client;
   
   cluster = Cluster.addContactPoint​(gremlinEndpoint).port(gremlinPort).credentials(username, password).create();
   

Python

1. 安装依赖项。

   pip install gremlinpython
   

2. 使用 azure-identity 向托管标识或服务主体进行身份验证，并向 AZURE_COSMOS_LISTKEYURL 发送获取密码的请求。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   from gremlin_python.driver import client, serializer
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   listKeyUrl = os.getenv('AZURE_COSMOS_LISTKEYURL')
   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 password 
   session = requests.Session()
   token = cred.get_token(scope)
   response = session.post(listKeyUrl, headers={"Authorization": "Bearer {}".format(token.token)})
   keys_dict = response.json()
   password = keys_dict['primaryMasterKey']
   
   # Connect to Azure Cosmos DB for Apache Gremlin.
   client = client.Client(
       url=endpoint,
       traversal_source="g",
       username=username,
       password=password,
       message_serializer=serializer.GraphSONSerializersV2d0(),
   )
   

Go

1. 安装依赖项。

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

2. 在代码中，通过 azidentity 获取访问令牌，然后使用该令牌来获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "github.com/go-gremlin/gremlin"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func main() {
       username = os.Getenv("AZURE_COSMOS_USERNAME")
       endpoint = os.getenv("AZURE_COSMOS_RESOURCEENDPOINT")
       port = os.getenv("AZURE_COSMOS_PORT")
       listKeyUrl = os.Getenv("AZURE_COSMOS_LISTKEYURL")
       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", listKeyUrl, 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)
       password, err := result["primaryMasterKey"];
   
       auth := gremlin.OptAuthUserPass(username, password)
        client, err := gremlin.NewClient(endpoint, auth)
   }
   

NodeJS

1. 安装依赖项。

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

2. 在代码中，通过 @azure/identity 获取访问令牌，然后使用该令牌来获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   import gremlin from 'gremlin'
   const axios = require('axios');
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let endoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let listKeyUrl = process.env.AZURE_COSMOS_LISTKEYURL;
   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 password.
   const config = {
       method: 'post',
       url: listKeyUrl,
       headers: { 
         'Authorization': `Bearer ${accessToken.token}`
       }
   };
   const response = await axios(config);
   const keysDict = response.data;
   const password = keysDict['primaryMasterKey'];
   
   const credentials = new gremlin.driver.auth.PlainTextSaslAuthenticator(
     username,
     password
   )
   
   const client = new gremlin.driver.Client(
     endpoint,
     {
       credentials,
       traversalsource: 'g',
       rejectUnauthorized: true,
       mimeType: 'application/vnd.gremlin-v2.0+json'
     }
   )
   
   client.open()
   

PHP

基于托管标识或服务主体获取访问令牌，以便在 AZURE_COSMOS_LISTKEYURL 调用 REST API 来获取 Azure Cosmos DB for Gremlin 的主密钥。

$endpoint = getenv('AZURE_COSMOS_RESOURCEENDPOINT');
$username = getenv('AZURE_COSMOS_USERNAME');
$port = getenv('AZURE_COSMOS_PORT');

$db = new Connection([
    'host' => $endpoint,
    'username' => $username,
    'password' => $password,
    'port' => $port,
    'ssl' => TRUE
]);

其他

对于其他语言，可以使用服务连接器设置为环境变量的 Apache Gremlin 终结点和其他属性连接到 Azure Cosmos DB for Apache Gremlin 资源。 有关环境变量的详细信息，请参阅使用服务连接器集成 Azure Cosmos DB for Apache Gremlin。

用户分配的托管标识

默认环境变量名称	说明	示例值
AZURE_COSMOS_LISTKEYURL	用户获取连接字符串的 URL	https://management.azure.com/subscriptions/<subscription-ID>/resourceGroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<Azure-Cosmos-DB-account>/listKeys?api-version=2021-04-15
AZURE_COSMOS_SCOPE	托管标识范围	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	资源终结点	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_HOSTNAME	Gremlin 唯一资源标识符 (UFI)	<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com
AZURE_COSMOS_PORT	连接端口	443
AZURE_COSMOS_USERNAME	用户名	/dbs/<database>/colls/<collection or graphs>
AZURE_CLIENTID	客户端 ID	<client_ID>

代码示例

请参考以下步骤和代码，使用用户分配的托管标识连接到 Azure Cosmos DB for Gremlin。

.NET

1. 安装依赖项。

   dotnet add package Gremlin.Net
   dotnet add package Azure.Identity
   

2. 使用 Azure.Identity 客户端库获取托管标识或服务主体的访问令牌。 使用访问令牌和 AZURE_COSMOS_LISTKEYURL 获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Threading.Tasks;
   using System;
   using Gremlin.Net.Driver;
   using Azure.Identity;
   
   var gremlinEndpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
   var gremlinPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
   var listKeyUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTKEYURL");
   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 password.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listKeyUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var keys = JsonConvert.DeserializeObject<Dictionary<string, string>>(responseBody);
   var password = keys["primaryMasterKey"];
   
   // Connect to Azure Cosmos DB for Apache Gremlin
   var server = new GremlinServer(
       hostname: gremlinEndpoint,
       port: gremlinPort,
       username: userName,
       password: password,
       enableSsl: true
   );
   
   using var client = new GremlinClient(
       gremlinServer: server,
       messageSerializer: new Gremlin.Net.Structure.IO.GraphSON.GraphSON2MessageSerializer()
   );        
   
   

Java

1. 将以下依赖项添加到 pom.xml 文件：

   <dependency>
     <groupId>org.apache.tinkerpop</groupId>
     <artifactId>gremlin-driver</artifactId>
     <version>3.4.13</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. 使用 azure-identity 获取托管标识或服务主体的访问令牌。 使用访问令牌和 AZURE_COSMOS_LISTKEYURL 获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import org.apache.tinkerpop.gremlin.driver.Client;
   import org.apache.tinkerpop.gremlin.driver.Cluster;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   import com.azure.identity.*;
   import com.azure.core.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   int gremlinPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String username = System.getenv("AZURE_COSMOS_USERNAME");
   String gremlinEndpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listKeyUrl = System.getenv("AZURE_COSMOS_LISTKEYURL");
   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 password.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listKeyUrl))
       .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());
   String gremlinPassword = responseBody.get("primaryMasterKey");
   
   // Connect to Azure Cosmos DB for Apache Gremlin
   Cluster cluster;
   Client client;
   
   cluster = Cluster.addContactPoint​(gremlinEndpoint).port(gremlinPort).credentials(username, password).create();
   

Python

1. 安装依赖项。

   pip install gremlinpython
   

2. 使用 azure-identity 向托管标识或服务主体进行身份验证，并向 AZURE_COSMOS_LISTKEYURL 发送获取密码的请求。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   from gremlin_python.driver import client, serializer
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   listKeyUrl = os.getenv('AZURE_COSMOS_LISTKEYURL')
   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 password 
   session = requests.Session()
   token = cred.get_token(scope)
   response = session.post(listKeyUrl, headers={"Authorization": "Bearer {}".format(token.token)})
   keys_dict = response.json()
   password = keys_dict['primaryMasterKey']
   
   # Connect to Azure Cosmos DB for Apache Gremlin.
   client = client.Client(
       url=endpoint,
       traversal_source="g",
       username=username,
       password=password,
       message_serializer=serializer.GraphSONSerializersV2d0(),
   )
   

Go

1. 安装依赖项。

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

2. 在代码中，通过 azidentity 获取访问令牌，然后使用该令牌来获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "github.com/go-gremlin/gremlin"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func main() {
       username = os.Getenv("AZURE_COSMOS_USERNAME")
       endpoint = os.getenv("AZURE_COSMOS_RESOURCEENDPOINT")
       port = os.getenv("AZURE_COSMOS_PORT")
       listKeyUrl = os.Getenv("AZURE_COSMOS_LISTKEYURL")
       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", listKeyUrl, 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)
       password, err := result["primaryMasterKey"];
   
       auth := gremlin.OptAuthUserPass(username, password)
        client, err := gremlin.NewClient(endpoint, auth)
   }
   

NodeJS

1. 安装依赖项。

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

2. 在代码中，通过 @azure/identity 获取访问令牌，然后使用该令牌来获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   import gremlin from 'gremlin'
   const axios = require('axios');
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let endoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let listKeyUrl = process.env.AZURE_COSMOS_LISTKEYURL;
   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 password.
   const config = {
       method: 'post',
       url: listKeyUrl,
       headers: { 
         'Authorization': `Bearer ${accessToken.token}`
       }
   };
   const response = await axios(config);
   const keysDict = response.data;
   const password = keysDict['primaryMasterKey'];
   
   const credentials = new gremlin.driver.auth.PlainTextSaslAuthenticator(
     username,
     password
   )
   
   const client = new gremlin.driver.Client(
     endpoint,
     {
       credentials,
       traversalsource: 'g',
       rejectUnauthorized: true,
       mimeType: 'application/vnd.gremlin-v2.0+json'
     }
   )
   
   client.open()
   

PHP

基于托管标识或服务主体获取访问令牌，以便在 AZURE_COSMOS_LISTKEYURL 调用 REST API 来获取 Azure Cosmos DB for Gremlin 的主密钥。

$endpoint = getenv('AZURE_COSMOS_RESOURCEENDPOINT');
$username = getenv('AZURE_COSMOS_USERNAME');
$port = getenv('AZURE_COSMOS_PORT');

$db = new Connection([
    'host' => $endpoint,
    'username' => $username,
    'password' => $password,
    'port' => $port,
    'ssl' => TRUE
]);

其他

对于其他语言，可以使用服务连接器设置为环境变量的 Apache Gremlin 终结点和其他属性连接到 Azure Cosmos DB for Apache Gremlin 资源。 有关环境变量的详细信息，请参阅使用服务连接器集成 Azure Cosmos DB for Apache Gremlin。

连接字符串

警告

Microsoft 建议使用最安全的可用身份验证流。 本过程中介绍的身份验证流程需要非常高的信任度，并携带其他流中不存在的风险。 请仅在无法使用其他更安全的流（例如托管标识）时才使用此流。

默认环境变量名称	说明	示例值
AZURE_COSMOS_HOSTNAME	Gremlin 唯一资源标识符 (UFI)	<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com
AZURE_COSMOS_PORT	连接端口	443
AZURE_COSMOS_USERNAME	用户名	/dbs/<database>/colls/<collection or graphs>
AZURE_COSMOS_PASSWORD	您的密码	<password>

代码示例

请参考以下步骤和代码，使用连接字符串连接到 Azure Cosmos DB for Gremlin。

.NET

1. 安装依赖项。

   dotnet add package Gremlin.Net
   

2. 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。

   using System;
   using Gremlin.Net.Driver;
   
   var gremlinEndpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
   var password = Environment.GetEnvironmentVariable("AZURE_COSMOS_PASSWORD");
   var gremlinPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
   
   var server = new GremlinServer(
       hostname: gremlinEndpoint,
       port: gremlinPort,
       username: userName,
       password: password,
       enableSsl: true
   );
   
   using var client = new GremlinClient(
       gremlinServer: server,
       messageSerializer: new Gremlin.Net.Structure.IO.GraphSON.GraphSON2MessageSerializer()
   );
   

Java

1. 在 pom.xml 文件中添加以下依赖项：

   <dependency>
     <groupId>org.apache.tinkerpop</groupId>
     <artifactId>gremlin-driver</artifactId>
     <version>3.4.13</version>
   </dependency>
   

2. 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。

   import org.apache.tinkerpop.gremlin.driver.Client;
   import org.apache.tinkerpop.gremlin.driver.Cluster;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   
   int gremlinPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String username = System.getenv("AZURE_COSMOS_USERNAME");
   String gremlinEndpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String password = System.getenv("AZURE_COSMOS_PASSWORD");
   
   Cluster cluster;
   Client client;
   
   cluster = Cluster.addContactPoint​(gremlinEndpoint).port(gremlinPort).credentials(username, password).create();
   

Python

1. 安装依赖项。

   pip install gremlinpython
   

2. 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。

   import os
   from gremlin_python.driver import client, serializer
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   password = os.getenv('AZURE_COSMOS_PASSWORD')
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   
   client = client.Client(
       url=endpoint,
       traversal_source="g",
       username=username,
       password=password,
       message_serializer=serializer.GraphSONSerializersV2d0(),
   )
   

Go

1. 安装依赖项。

   go get github.com/go-gremlin/gremlin
   

2. 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。

   username = os.Getenv("AZURE_COSMOS_USERNAME")
   password = os.getenv("AZURE_COSMOS_PASSWORD")
   endpoint = os.getenv("AZURE_COSMOS_RESOURCEENDPOINT")
   port = os.getenv("AZURE_COSMOS_PORT")
   
   auth := gremlin.OptAuthUserPass(username, password)
    client, err := gremlin.NewClient(endpoint, auth)
   

NodeJS

1. 安装依赖项。

   npm install gremlin
   

2. 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。

   import gremlin from 'gremlin'
   
   const username = process.env.AZURE_COSMOS_USERNAME;
   const password = process.env.AZURE_COSMOS_PASSWORD;
   const endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   const port = process.env.AZURE_COSMOS_PORT;
   
   const credentials = new gremlin.driver.auth.PlainTextSaslAuthenticator(
      username,
      password
    )
   
   const client = new gremlin.driver.Client(
      endpoint,
      {
        credentials,
        traversalsource: 'g',
        rejectUnauthorized: true,
        mimeType: 'application/vnd.gremlin-v2.0+json'
      }
    )
   
    client.open()
   

PHP

从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。

$endpoint = getenv('AZURE_COSMOS_RESOURCEENDPOINT');
$username = getenv('AZURE_COSMOS_USERNAME');
$password = getenv('AZURE_COSMOS_PASSWORD');
$port = getenv('AZURE_COSMOS_PORT');

$db = new Connection([
    'host' => $endpoint,
    'username' => $username,
    'password' => $password,
    'port' => $port,
    'ssl' => TRUE
]);

其他

对于其他语言，可以使用服务连接器设置为环境变量的 Apache Gremlin 终结点和其他属性连接到 Azure Cosmos DB for Apache Gremlin 资源。 有关环境变量的详细信息，请参阅使用服务连接器集成 Azure Cosmos DB for Apache Gremlin。

服务主体

默认环境变量名称	说明	示例值
AZURE_COSMOS_LISTKEYURL	用户获取连接字符串的 URL	https://management.azure.com/subscriptions/<subscription-ID>/resourceGroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<Azure-Cosmos-DB-account>/listKeys?api-version=2021-04-15
AZURE_COSMOS_SCOPE	托管标识范围	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	资源终结点	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_HOSTNAME	Gremlin 唯一资源标识符 (UFI)	<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com
AZURE_COSMOS_PORT	Gremlin 连接端口	10350
AZURE_COSMOS_USERNAME	用户名	</dbs/<database>/colls/<collection or graphs>
AZURE_COSMOS_CLIENTID	客户端 ID	<client-ID>
AZURE_COSMOS_CLIENTSECRET	客户端密码	<client-secret>
AZURE_COSMOS_TENANTID	租户 ID	<tenant-ID>

代码示例

请参考以下步骤和代码，使用服务主体连接到 Azure Cosmos DB for Gremlin。

.NET

1. 安装依赖项。

   dotnet add package Gremlin.Net
   dotnet add package Azure.Identity
   

2. 使用 Azure.Identity 客户端库获取托管标识或服务主体的访问令牌。 使用访问令牌和 AZURE_COSMOS_LISTKEYURL 获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Threading.Tasks;
   using System;
   using Gremlin.Net.Driver;
   using Azure.Identity;
   
   var gremlinEndpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
   var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
   var gremlinPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
   var listKeyUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTKEYURL");
   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 password.
   var httpClient = new HttpClient();
   httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
   var response = await httpClient.POSTAsync(listKeyUrl);
   var responseBody = await response.Content.ReadAsStringAsync();
   var keys = JsonConvert.DeserializeObject<Dictionary<string, string>>(responseBody);
   var password = keys["primaryMasterKey"];
   
   // Connect to Azure Cosmos DB for Apache Gremlin
   var server = new GremlinServer(
       hostname: gremlinEndpoint,
       port: gremlinPort,
       username: userName,
       password: password,
       enableSsl: true
   );
   
   using var client = new GremlinClient(
       gremlinServer: server,
       messageSerializer: new Gremlin.Net.Structure.IO.GraphSON.GraphSON2MessageSerializer()
   );        
   
   

Java

1. 将以下依赖项添加到 pom.xml 文件：

   <dependency>
     <groupId>org.apache.tinkerpop</groupId>
     <artifactId>gremlin-driver</artifactId>
     <version>3.4.13</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. 使用 azure-identity 获取托管标识或服务主体的访问令牌。 使用访问令牌和 AZURE_COSMOS_LISTKEYURL 获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import org.apache.tinkerpop.gremlin.driver.Client;
   import org.apache.tinkerpop.gremlin.driver.Cluster;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   import com.azure.identity.*;
   import com.azure.core.credentital.*;
   import java.net.http.*;
   import java.net.URI;
   
   int gremlinPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String username = System.getenv("AZURE_COSMOS_USERNAME");
   String gremlinEndpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
   String listKeyUrl = System.getenv("AZURE_COSMOS_LISTKEYURL");
   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 password.
   HttpClient client = HttpClient.newBuilder().build();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(new URI(listKeyUrl))
       .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());
   String gremlinPassword = responseBody.get("primaryMasterKey");
   
   // Connect to Azure Cosmos DB for Apache Gremlin
   Cluster cluster;
   Client client;
   
   cluster = Cluster.addContactPoint​(gremlinEndpoint).port(gremlinPort).credentials(username, password).create();
   

Python

1. 安装依赖项。

   pip install gremlinpython
   

2. 使用 azure-identity 向托管标识或服务主体进行身份验证，并向 AZURE_COSMOS_LISTKEYURL 发送获取密码的请求。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   from gremlin_python.driver import client, serializer
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   listKeyUrl = os.getenv('AZURE_COSMOS_LISTKEYURL')
   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 password 
   session = requests.Session()
   token = cred.get_token(scope)
   response = session.post(listKeyUrl, headers={"Authorization": "Bearer {}".format(token.token)})
   keys_dict = response.json()
   password = keys_dict['primaryMasterKey']
   
   # Connect to Azure Cosmos DB for Apache Gremlin.
   client = client.Client(
       url=endpoint,
       traversal_source="g",
       username=username,
       password=password,
       message_serializer=serializer.GraphSONSerializersV2d0(),
   )
   

Go

1. 安装依赖项。

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

2. 在代码中，通过 azidentity 获取访问令牌，然后使用该令牌来获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "github.com/go-gremlin/gremlin"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func main() {
       username = os.Getenv("AZURE_COSMOS_USERNAME")
       endpoint = os.getenv("AZURE_COSMOS_RESOURCEENDPOINT")
       port = os.getenv("AZURE_COSMOS_PORT")
       listKeyUrl = os.Getenv("AZURE_COSMOS_LISTKEYURL")
       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", listKeyUrl, 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)
       password, err := result["primaryMasterKey"];
   
       auth := gremlin.OptAuthUserPass(username, password)
        client, err := gremlin.NewClient(endpoint, auth)
   }
   

NodeJS

1. 安装依赖项。

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

2. 在代码中，通过 @azure/identity 获取访问令牌，然后使用该令牌来获取密码。 从服务连接器添加的环境变量中获取连接信息，并连接到 Azure Cosmos DB for Apache Gremlin。 使用下面的代码时，请对要使用的身份验证类型的代码片段的一部分取消评论。

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   import gremlin from 'gremlin'
   const axios = require('axios');
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let endoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let listKeyUrl = process.env.AZURE_COSMOS_LISTKEYURL;
   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 password.
   const config = {
       method: 'post',
       url: listKeyUrl,
       headers: { 
         'Authorization': `Bearer ${accessToken.token}`
       }
   };
   const response = await axios(config);
   const keysDict = response.data;
   const password = keysDict['primaryMasterKey'];
   
   const credentials = new gremlin.driver.auth.PlainTextSaslAuthenticator(
     username,
     password
   )
   
   const client = new gremlin.driver.Client(
     endpoint,
     {
       credentials,
       traversalsource: 'g',
       rejectUnauthorized: true,
       mimeType: 'application/vnd.gremlin-v2.0+json'
     }
   )
   
   client.open()
   

PHP

基于托管标识或服务主体获取访问令牌，以便在 AZURE_COSMOS_LISTKEYURL 调用 REST API 来获取 Azure Cosmos DB for Gremlin 的主密钥。

$endpoint = getenv('AZURE_COSMOS_RESOURCEENDPOINT');
$username = getenv('AZURE_COSMOS_USERNAME');
$port = getenv('AZURE_COSMOS_PORT');

$db = new Connection([
    'host' => $endpoint,
    'username' => $username,
    'password' => $password,
    'port' => $port,
    'ssl' => TRUE
]);

其他

对于其他语言，可以使用服务连接器设置为环境变量的 Apache Gremlin 终结点和其他属性连接到 Azure Cosmos DB for Apache Gremlin 资源。 有关环境变量的详细信息，请参阅使用服务连接器集成 Azure Cosmos DB for Apache Gremlin。

后续步骤

参考下面列出的教程来详细了解服务连接器。

了解服务连接器的概念