Integrare Azure Cosmos DB for Gremlin con Connettore di servizi

Articolo
10/16/2024

Questa pagina illustra i metodi e i client di autenticazione supportati e il codice di esempio che è possibile usare per connettere Azure Cosmos DB for Apache Gremlin ad altri servizi cloud tramite Connettore di servizi. È comunque possibile connettersi ad Azure Cosmos DB for Gremlin con altri linguaggi di programmazione senza usare Connettore di servizi. Questa pagina mostra anche i nomi e i valori predefiniti delle variabili di ambiente che si ottengono quando si crea la connessione al servizio.

Servizi di calcolo supportati

Connettore di servizi può essere usato per connettere i servizi di calcolo seguenti ad Azure Cosmos DB for Apache Gremlin:

Servizio app di Azure
App contenitore di Azure
Funzioni di Azure
Servizio Azure Kubernetes (AKS)
Azure Spring Apps

Tipi di autenticazione e di client supportati

La tabella seguente illustra le combinazioni di tipi di client e metodi di autenticazione supportate per la connessione del servizio di calcolo ad Azure Cosmos DB for Apache Gremlin tramite Connettore di servizi. Un valore "Sì" indica che la combinazione è supportata, mentre "No" indica che non è supportata.

Tipo client	Identità gestita assegnata dal sistema	Identità gestita assegnata dall'utente	Stringa di segreto/connessione	Entità servizio
.NET	Sì	Sì	Sì	Sì
Java	Sì	Sì	Sì	Sì
Node.js	Sì	Sì	Sì	Sì
PHP	Sì	Sì	Sì	Sì
Python	Sì	Sì	Sì	Sì
Go	Sì	Sì	Sì	Sì
Nessuno	Sì	Sì	Sì	Sì

Questa tabella indica che tutte le combinazioni di tipi client e metodi di autenticazione nella tabella sono supportate. Tutti i tipi di client possono usare uno dei metodi di autenticazione per connettersi ad Azure Cosmos DB for Apache Gremlin tramite Connettore di servizi.

Nomi di variabili di ambiente predefiniti o proprietà dell'applicazione e codice di esempio

Usare i dettagli di connessione seguenti per connettere i servizi di calcolo ad Azure Cosmos DB for Apache Gremlin. Per ogni esempio seguente, sostituire i testi dei segnaposto <Azure-Cosmos-DB-account>, <database>, <collection or graphs>, <username>, <password>, <resource-group-name>, <subscription-ID>, <client-ID>, <client-secret> e <tenant-id> con le informazioni personali. Per altre informazioni sulle convenzioni di denominazione, vedere l'articolo Elementi interni di Service Connector.

Identità gestita assegnata dal sistema

Nome variabile di ambiente predefinito	Descrizione	Valore di esempio
AZURE_COSMOS_LISTKEYURL	URL per ottenere la stringa di connessione	`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	L'ambito dell'identità gestita	`https://management.azure.com/.default`
AZURE_COSMOS_RESOURCEENDPOINT	Endpoint della risorsa	`https://<Azure-Cosmos-DB-account>.documents.azure.com:443/`
AZURE_COSMOS_HOSTNAME	Identificatore di risorsa univoco Gremlin (UFI)	`<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com`
AZURE_COSMOS_PORT	Porta di connessione	443
AZURE_COSMOS_USERNAME	Nome utente	`/dbs/<database>/colls/<collection or graphs>`

Codice di esempio

Fare riferimento alla procedura e al codice seguenti per connettersi ad Azure Cosmos DB for Gremlin tramite un'identità gestita assegnata dal sistema.

Installare le dipendenze.

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

Ottenere un token di accesso per l'identità gestita o l'entità servizio usando la libreria client Azure.Identity. Usare il token di accesso e AZURE_COSMOS_LISTKEYURL per ottenere la password. Ottenere le informazioni di connessione dalle variabili di ambiente aggiunte da Connettore di servizi e connettersi ad Azure Cosmos DB for Apache Gremlin. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

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

Aggiungere le dipendenze seguenti nel file 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>

Ottenere un token di accesso per l'identità gestita o l'entità servizio usando azure-identity. Usare il token di accesso e AZURE_COSMOS_LISTKEYURL per ottenere la password. Ottenere le informazioni di connessione dalle variabili di ambiente aggiunte da Connettore di servizi e connettersi ad Azure Cosmos DB for Apache Gremlin. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

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

Installare le dipendenze.
```
pip install gremlinpython
```

Usare azure-identity per eseguire l'autenticazione con l'identità gestita o l'entità servizio e inviare una richiesta a AZURE_COSMOS_LISTKEYURL per ottenere la password. Ottenere le informazioni di connessione dalle variabili di ambiente aggiunte da Connettore di servizi e connettersi ad Azure Cosmos DB for Apache Gremlin. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

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

Installare le dipendenze.

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

Nel codice, ottenere il token di accesso tramite azidentity, quindi usarlo per acquisire la password. Ottenere le informazioni di connessione dalle variabili di ambiente aggiunte da Connettore di servizi e connettersi ad Azure Cosmos DB for Apache Gremlin. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

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("AZURE_COSMOS_SCOPE")

    // Uncomment the following lines corresponding to the authentication type you want to use.
    // For system-assigned identity.
    // cred, err := azidentity.NewDefaultAzureCredential(nil)

    // For user-assigned identity.
    // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
    // azidentity.ManagedIdentityCredentialOptions.ID := clientid
    // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
    // cred, err := azidentity.NewManagedIdentityCredential(options)

    // For service principal.
    // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
    // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
    // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
    // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

    // Acquire the access token.
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
        Scopes: []string{scope},
    })

    // Acquire the connection string.
    client := &http.Client{}
    req, err := http.NewRequest("POST", 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)
}

Installare le dipendenze.

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

Nel codice, ottenere il token di accesso tramite @azure/identity, quindi usarlo per acquisire la password. Ottenere le informazioni di connessione dalle variabili di ambiente aggiunte da Connettore di servizi e connettersi ad Azure Cosmos DB for Apache Gremlin. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
import gremlin from 'gremlin'
const axios = require('axios');

let username = process.env.AZURE_COSMOS_USERNAME;
let endpoint = 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()

Ottenere un token di accesso con un'identità gestita o un'entità servizio per acquisire la chiave primaria di Azure Cosmos DB per Gremlin chiamando l'API REST all'indirizzo 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
]);

Identità gestita assegnata dall'utente

Nome variabile di ambiente predefinito	Descrizione	Valore di esempio
AZURE_COSMOS_LISTKEYURL	URL per ottenere la stringa di connessione	`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	L'ambito dell'identità gestita	`https://management.azure.com/.default`
AZURE_COSMOS_RESOURCEENDPOINT	Endpoint della risorsa	`https://<Azure-Cosmos-DB-account>.documents.azure.com:443/`
AZURE_COSMOS_HOSTNAME	Identificatore di risorsa univoco Gremlin (UFI)	`<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com`
AZURE_COSMOS_PORT	Porta di connessione	443
AZURE_COSMOS_USERNAME	Nome utente	`/dbs/<database>/colls/<collection or graphs>`
AZURE_CLIENTID	L’ID client	`<client_ID>`

Codice di esempio

Fare riferimento alla procedura e al codice seguenti per connettersi ad Azure Cosmos DB for Gremlin tramite un'identità gestita assegnata dall’utente.

Installare le dipendenze.

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

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

Aggiungere le dipendenze seguenti nel file 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>

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

Installare le dipendenze.
```
pip install gremlinpython
```

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

Installare le dipendenze.

go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
go get github.com/go-gremlin/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("AZURE_COSMOS_SCOPE")

    // Uncomment the following lines corresponding to the authentication type you want to use.
    // For system-assigned identity.
    // cred, err := azidentity.NewDefaultAzureCredential(nil)

    // For user-assigned identity.
    // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
    // azidentity.ManagedIdentityCredentialOptions.ID := clientid
    // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
    // cred, err := azidentity.NewManagedIdentityCredential(options)

    // For service principal.
    // clientid := os.Getenv("AZURE_COSMOS_CLIENTID")
    // tenantid := os.Getenv("AZURE_COSMOS_TENANTID")
    // clientsecret := os.Getenv("AZURE_COSMOS_CLIENTSECRET")
    // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

    // Acquire the access token.
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
        Scopes: []string{scope},
    })

    // Acquire the connection string.
    client := &http.Client{}
    req, err := http.NewRequest("POST", 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)
}

Installare le dipendenze.

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

import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
import gremlin from 'gremlin'
const axios = require('axios');

let username = process.env.AZURE_COSMOS_USERNAME;
let endpoint = 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()

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

Stringa di connessione

Avviso

Microsoft consiglia di usare il flusso di autenticazione più sicuro disponibile. Il flusso di autenticazione descritto in questa procedura richiede un livello di attendibilità molto elevato nell'applicazione e comporta rischi che non sono presenti in altri flussi. Si consiglia di usare questo flusso solo quando altri flussi più sicuri, come le identità gestite, non sono validi.

Nome variabile di ambiente predefinito	Descrizione	Valore di esempio
AZURE_COSMOS_HOSTNAME	Identificatore di risorsa univoco Gremlin (UFI)	`<Azure-Cosmos-DB-account>.gremlin.cosmos.azure.com`
AZURE_COSMOS_PORT	Porta di connessione	443
AZURE_COSMOS_USERNAME	Nome utente	`/dbs/<database>/colls/<collection or graphs>`
AZURE_COSMOS_PASSWORD	Password	`<password>`

Codice di esempio

Fare riferimento alla procedura e al codice seguenti per connettersi ad Azure Cosmos DB for Gremlin tramite una stringa di connessione.

Installare la dipendenza.
```
dotnet add package Gremlin.Net
```