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

1. Installez des dépendances.

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

2. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de la bibliothèque de client Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Threading.Tasks;
   using 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()
   );        
   
   

1. Ajoutez les dépendances suivantes dans votre fichier 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. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de azure-identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

1. Installez des dépendances.

   pip install gremlinpython
   

2. Utilisez azure-identity pour vous authentifier avec l’identité managée ou le principal de service et envoyer une demande à AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

1. Installez des dépendances.

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

2. Dans le code, obtenez le jeton d’accès avec azidentity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "github.com/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)
   }
   

1. Installez des dépendances.

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

2. Dans le code, obtenez le jeton d’accès avec @azure/identity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   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()
   

Obtenez un jeton d’accès avec une identité managée ou un principal de service pour acquérir la clé primaire d’Azure Cosmos DB for Gremlin en appelant l’API REST sur AZURE_COSMOS_LISTKEYURL.

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

Pour les autres langages, vous pouvez utiliser le point de terminaison Apache Gremlin et d’autres propriétés que le connecteur de services définit sur les variables d’environnement pour vous connecter à une ressource Azure Cosmos DB for Apache Gremlin. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for Apache Gremlin au connecteur de services.

1. Installez des dépendances.

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

2. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de la bibliothèque de client Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Threading.Tasks;
   using 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()
   );        
   
   

1. Ajoutez les dépendances suivantes dans votre fichier 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. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de azure-identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

1. Installez des dépendances.

   pip install gremlinpython
   

2. Utilisez azure-identity pour vous authentifier avec l’identité managée ou le principal de service et envoyer une demande à AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

1. Installez des dépendances.

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

2. Dans le code, obtenez le jeton d’accès avec azidentity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "github.com/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)
   }
   

1. Installez des dépendances.

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

2. Dans le code, obtenez le jeton d’accès avec @azure/identity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   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()
   

Obtenez un jeton d’accès avec une identité managée ou un principal de service pour acquérir la clé primaire d’Azure Cosmos DB for Gremlin en appelant l’API REST sur AZURE_COSMOS_LISTKEYURL.

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

Pour les autres langages, vous pouvez utiliser le point de terminaison Apache Gremlin et d’autres propriétés que le connecteur de services définit sur les variables d’environnement pour vous connecter à une ressource Azure Cosmos DB for Apache Gremlin. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for Apache Gremlin au connecteur de services.

1. Installez la dépendance.

   dotnet add package Gremlin.Net
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à 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()
   );
   

1. Ajoutez la dépendance suivante dans votre fichier pom.xml :

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

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à 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();
   

1. Installez la dépendance.

   pip install gremlinpython
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à 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(),
   )
   

1. Installez la dépendance.

   go get github.com/go-gremlin/gremlin
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à 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)
   

1. Installez la dépendance.

   npm install gremlin
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à 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()
   

Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à 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
]);

Pour les autres langages, vous pouvez utiliser le point de terminaison Apache Gremlin et d’autres propriétés que le connecteur de services définit sur les variables d’environnement pour vous connecter à une ressource Azure Cosmos DB for Apache Gremlin. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for Apache Gremlin au connecteur de services.

1. Installez des dépendances.

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

2. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de la bibliothèque de client Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Net.Http;
   using System.Security.Authentication;
   using System.Threading.Tasks;
   using 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()
   );        
   
   

1. Ajoutez les dépendances suivantes dans votre fichier 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. Obtenez un jeton d’accès pour l’identité managée ou le principal de service à l’aide de azure-identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

1. Installez des dépendances.

   pip install gremlinpython
   

2. Utilisez azure-identity pour vous authentifier avec l’identité managée ou le principal de service et envoyer une demande à AZURE_COSMOS_LISTKEYURL pour obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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

1. Installez des dépendances.

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

2. Dans le code, obtenez le jeton d’accès avec azidentity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   import (
       "fmt"
       "os"
       "context"
       "log"
       "io/ioutil"
       "encoding/json"
   
       "github.com/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)
   }
   

1. Installez des dépendances.

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

2. Dans le code, obtenez le jeton d’accès avec @azure/identity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services et connectez-vous à Azure Cosmos DB for Apache Gremlin. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   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()
   

Obtenez un jeton d’accès avec une identité managée ou un principal de service pour acquérir la clé primaire d’Azure Cosmos DB for Gremlin en appelant l’API REST sur AZURE_COSMOS_LISTKEYURL.

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

Pour les autres langages, vous pouvez utiliser le point de terminaison Apache Gremlin et d’autres propriétés que le connecteur de services définit sur les variables d’environnement pour vous connecter à une ressource Azure Cosmos DB for Apache Gremlin. Pour plus d’informations sur les variables d’environnement, consultez Intégrer Azure Cosmos DB for Apache Gremlin au connecteur de services.