Intégrer Azure Cosmos DB pour Cassandra à Service Connecter or

Cette page présente les méthodes d’authentification et les clients pris en charge, et présente des exemples de code que vous pouvez utiliser pour connecter Azure Cosmos DB pour Apache Cassandra à d’autres services cloud à l’aide du service Connecter or. Vous pouvez toujours vous connecter à Azure Cosmos DB for Cassandra dans d’autres langages de programmation sans utiliser le connecteur de services. Cette page présente également les noms et les valeurs des variables d’environnement par défaut (ou configuration Spring Boot) que vous obtenez lorsque vous créez des connexions de service.

Service de calcul pris en charge

Le Connecter or de service peut être utilisé pour connecter les services de calcul suivants à Azure Cosmos DB pour Apache Cassandra :

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

Types d’authentification et de clients pris en charge

Le tableau ci-dessous montre quelles combinaisons de types clients et de méthodes d’authentification sont prises en charge pour connecter votre service de calcul à Azure Cosmos DB pour Apache Cassandra à l’aide de Service Connecter or. Un « Oui » indique que la combinaison est prise en charge, tandis qu’une valeur « Non » indique qu’elle n’est pas prise en charge.

Type de client	Identité managée affectée par le système	Identité managée affectée par l’utilisateur	Secret / chaîne de connexion	Principal du service
.NET	Oui	Oui	Oui	Oui
Go	Oui	Oui	Oui	Oui
Java	Oui	Oui	Oui	Oui
Java - Spring Boot	Non	Non	Oui	Non
Node.js	Oui	Oui	Oui	Oui
Python	Oui	Oui	Oui	Oui
Aucun	Oui	Oui	Oui	Oui

Ce tableau indique que toutes les combinaisons de types clients et de méthodes d’authentification dans la table sont prises en charge, à l’exception du type de client Java - Spring Boot, qui prend uniquement en charge la méthode Secret /chaîne de connexion. Tous les autres types de clients peuvent utiliser l’une des méthodes d’authentification pour se connecter à Azure Cosmos DB pour Apache Cassandra à l’aide de Service Connecter or.

Noms de variables d’environnement par défaut ou propriétés d’application et exemple de code

Référencez les détails de connexion et l’exemple de code dans les tableaux suivants, en fonction du type d’authentification et du type de client de votre connexion, pour connecter vos services de calcul à Azure Cosmos DB pour Apache Cassandra. Pour plus d’informations sur les conventions d’affectation de noms, case activée l’article interne du service Connecter or.

Identité managée affectée par le système

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_LISTKEYURL	URL permettant d’accéder à la chaîne de connexion	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	Étendue de votre identité managée	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_CONTACTPOINT	Point de contact Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Port de connexion Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espace de clés Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nom d’utilisateur Cassandra	<username>

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB pour Cassandra à l’aide d’une identité managée affectée par le système.

.NET

1. Installer des dépendances

   dotnet add package CassandraCSharpDriver --version 3.19.3
   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 cliente Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL obtenez le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using Cassandra;
   using Azure.Identity;
   
   public class Program
   {
   	public static async Task Main()
   	{
           var cassandraContactPoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_CONTACTPOINT");
           var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
           var cassandraPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
           var cassandraKeyspace = Environment.GetEnvironmentVariable("AZURE_COSMOS_KEYSPACE");
           var listKeyUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTKEYURL");
           var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
           // Uncomment the following lines according to the authentication type.
           // 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 Cassandra
           var options = new Cassandra.SSLOptions(SslProtocols.Tls12, true, ValidateServerCertificate);
           options.SetHostNameResolver((ipAddress) => cassandraContactPoint);
           Cluster cluster = Cluster
               .Builder()
               .WithCredentials(userName, password)
               .WithPort(cassandraPort)
               .AddContactPoint(cassandraContactPoint).WithSSL(options).Build();
           ISession session = await cluster.ConnectAsync();
       }
   
       public static bool ValidateServerCertificate
   	(
           object sender,
           X509Certificate certificate,
           X509Chain chain,
           SslPolicyErrors sslPolicyErrors
       )
       {
           if (sslPolicyErrors == SslPolicyErrors.None)
               return true;
   
           Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
           // Do not allow this client to communicate with unauthenticated servers.
           return false;
       }
   }
   
   

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-core</artifactId>
       <version>4.5.1</version>
   </dependency>  
   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-query-builder</artifactId>
       <version>4.0.0</version>
   </dependency>       
   <dependency>
       <groupId>com.datastax.cassandra</groupId>
       <artifactId>cassandra-driver-extras</artifactId>
       <version>3.1.4</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 azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL obtenez le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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 com.datastax.oss.driver.api.core.CqlSession;
   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 cassandraPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String cassandraUsername = System.getenv("AZURE_COSMOS_USERNAME");
   String cassandraHost = System.getenv("AZURE_COSMOS_CONTACTPOINT");
   String cassandraKeyspace = System.getenv("AZURE_COSMOS_KEYSPACE");
   String listKeyUrl = System.getenv("AZURE_COSMOS_LISTKEYURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // 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 cassandraPassword = responseBody.get("primaryMasterKey");
   
   // Connect to Azure Cosmos DB for Cassandra
   final SSLContext sc = SSLContext.getInstance("TLSv1.2");
   CqlSession session = CqlSession.builder().withSslContext(sc)
       .addContactPoint(new InetSocketAddress(cassandraHost, cassandraPort)).withLocalDatacenter('datacenter1')
       .withAuthCredentials(cassandraUsername, cassandraPassword).build();
   

SpringBoot

Le type d’authentification n’est pas pris en charge pour Spring Boot.

Python

1. Installer des dépendances

   pip install Cassandra-driver 
   pip install pyopenssl
   pip install azure-identity
   

2. Permet azure-identity de s’authentifier auprès de l’identité managée ou du principal du service et d’envoyer une demande pour AZURE_COSMOS_LISTKEYURL obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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 cassandra.cluster import Cluster
   from ssl import PROTOCOL_TLSv1_2, SSLContext, CERT_NONE
   from cassandra.auth import PlainTextAuthProvider
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   contactPoint = os.getenv('AZURE_COSMOS_CONTACTPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   keyspace = os.getenv('AZURE_COSMOS_KEYSPACE')
   listKeyUrl = os.getenv('AZURE_COSMOS_LISTKEYURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # 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 Cassandra.
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contanctPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

Go

1. Installez des dépendances.

   go get github.com/gocql/gocql
   go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"
   

2. Dans le code, obtenez un jeton d’accès via azidentity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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/gocql/gocql"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func GetSession() *gocql.Session {
       cosmosCassandraContactPoint = os.Getenv("AAZURE_COSMOS_CONTACTPOINT")
       cosmosCassandraPort = os.Getenv("AZURE_COSMOS_PORT")
       cosmosCassandraUser = os.Getenv("AZURE_COSMOS_USERNAME")
       cosmosCassandraKeyspace = os.Getenv("AZURE_COSMOS_KEYSPACE")
       listKeyUrl = os.Getenv("AZURE_COSMOS_LISTKEYURL")
       scope = os.Getenv("AZUE_COSMOS_SCOPE")
   
       // Uncomment the following lines according to the authentication type.
       // 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 password.
       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)
       cosmosCassandraPassword, err := result["primaryMasterKey"]
   
       // Connect to Azure Cosmos DB for Cassandra
       clusterConfig := gocql.NewCluster(cosmosCassandraContactPoint)
       port, err := strconv.Atoi(cosmosCassandraPort)
       clusterConfig.Port = port
        clusterConfig.ProtoVersion = 4
       clusterConfig.Authenticator = gocql.PasswordAuthenticator{Username: cosmosCassandraUser, Password: cosmosCassandraPassword}
       clusterConfig.SslOpts = &gocql.SslOptions{Config: &tls.Config{MinVersion: tls.VersionTLS12}}
   
       session, err := clusterConfig.CreateSession()
       return session
   }
   
   func main() {
       session := utils.GetSession(cosmosCassandraContactPoint, cosmosCassandraPort, cosmosCassandraUser, cosmosCassandraPassword)
       defer session.Close()
       ...
   }
   

NodeJS

1. Installer des dépendances

   npm install cassandra-driver
   npm install --save @azure/identity
   

2. Dans le code, obtenez le jeton d’accès via @azure/identity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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";
   const cassandra = require("cassandra-driver");
   const axios = require('axios');
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let contactPoint = process.env.AZURE_COSMOS_CONTACTPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let keyspace = process.env.AZURE_COSMOS_KEYSPACE;
   let listKeyUrl = process.env.AZURE_COSMOS_LISTKEYURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // 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'];
   
   let authProvider = new cassandra.auth.PlainTextAuthProvider(
       username,
       password
   );
   
   let client = new cassandra.Client({
       contactPoints: [`${contactPoint}:${port}`],
       authProvider: authProvider,
       localDataCenter: 'datacenter1',
       sslOptions: {
           secureProtocol: "TLSv1_2_method"
       },
   });
   
   client.connect();
   

Autres

Pour d’autres langages, vous pouvez utiliser le point de contact Cassandra et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à la ressource Azure Cosmos DB pour Cassandra. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Cassandra à Service Connecter or.

Identité managée affectée par l’utilisateur

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_LISTKEYURL	URL permettant d’accéder à la chaîne de connexion	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	Étendue de votre identité managée	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_CONTACTPOINT	Point de contact Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Port de connexion Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espace de clés Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nom d’utilisateur Cassandra	<username>
AZURE_COSMOS_CLIENTID	Votre ID client	<client-ID>

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB pour Cassandra à l’aide d’une identité managée affectée par l’utilisateur.

.NET

1. Installer des dépendances

   dotnet add package CassandraCSharpDriver --version 3.19.3
   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 cliente Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL obtenez le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using Cassandra;
   using Azure.Identity;
   
   public class Program
   {
   	public static async Task Main()
   	{
           var cassandraContactPoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_CONTACTPOINT");
           var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
           var cassandraPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
           var cassandraKeyspace = Environment.GetEnvironmentVariable("AZURE_COSMOS_KEYSPACE");
           var listKeyUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTKEYURL");
           var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
           // Uncomment the following lines according to the authentication type.
           // 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 Cassandra
           var options = new Cassandra.SSLOptions(SslProtocols.Tls12, true, ValidateServerCertificate);
           options.SetHostNameResolver((ipAddress) => cassandraContactPoint);
           Cluster cluster = Cluster
               .Builder()
               .WithCredentials(userName, password)
               .WithPort(cassandraPort)
               .AddContactPoint(cassandraContactPoint).WithSSL(options).Build();
           ISession session = await cluster.ConnectAsync();
       }
   
       public static bool ValidateServerCertificate
   	(
           object sender,
           X509Certificate certificate,
           X509Chain chain,
           SslPolicyErrors sslPolicyErrors
       )
       {
           if (sslPolicyErrors == SslPolicyErrors.None)
               return true;
   
           Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
           // Do not allow this client to communicate with unauthenticated servers.
           return false;
       }
   }
   
   

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-core</artifactId>
       <version>4.5.1</version>
   </dependency>  
   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-query-builder</artifactId>
       <version>4.0.0</version>
   </dependency>       
   <dependency>
       <groupId>com.datastax.cassandra</groupId>
       <artifactId>cassandra-driver-extras</artifactId>
       <version>3.1.4</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 azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL obtenez le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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 com.datastax.oss.driver.api.core.CqlSession;
   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 cassandraPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String cassandraUsername = System.getenv("AZURE_COSMOS_USERNAME");
   String cassandraHost = System.getenv("AZURE_COSMOS_CONTACTPOINT");
   String cassandraKeyspace = System.getenv("AZURE_COSMOS_KEYSPACE");
   String listKeyUrl = System.getenv("AZURE_COSMOS_LISTKEYURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // 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 cassandraPassword = responseBody.get("primaryMasterKey");
   
   // Connect to Azure Cosmos DB for Cassandra
   final SSLContext sc = SSLContext.getInstance("TLSv1.2");
   CqlSession session = CqlSession.builder().withSslContext(sc)
       .addContactPoint(new InetSocketAddress(cassandraHost, cassandraPort)).withLocalDatacenter('datacenter1')
       .withAuthCredentials(cassandraUsername, cassandraPassword).build();
   

SpringBoot

Le type d’authentification n’est pas pris en charge pour Spring Boot.

Python

1. Installer des dépendances

   pip install Cassandra-driver 
   pip install pyopenssl
   pip install azure-identity
   

2. Permet azure-identity de s’authentifier auprès de l’identité managée ou du principal du service et d’envoyer une demande pour AZURE_COSMOS_LISTKEYURL obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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 cassandra.cluster import Cluster
   from ssl import PROTOCOL_TLSv1_2, SSLContext, CERT_NONE
   from cassandra.auth import PlainTextAuthProvider
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   contactPoint = os.getenv('AZURE_COSMOS_CONTACTPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   keyspace = os.getenv('AZURE_COSMOS_KEYSPACE')
   listKeyUrl = os.getenv('AZURE_COSMOS_LISTKEYURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # 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 Cassandra.
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contanctPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

Go

1. Installez des dépendances.

   go get github.com/gocql/gocql
   go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"
   

2. Dans le code, obtenez un jeton d’accès via azidentity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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/gocql/gocql"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func GetSession() *gocql.Session {
       cosmosCassandraContactPoint = os.Getenv("AAZURE_COSMOS_CONTACTPOINT")
       cosmosCassandraPort = os.Getenv("AZURE_COSMOS_PORT")
       cosmosCassandraUser = os.Getenv("AZURE_COSMOS_USERNAME")
       cosmosCassandraKeyspace = os.Getenv("AZURE_COSMOS_KEYSPACE")
       listKeyUrl = os.Getenv("AZURE_COSMOS_LISTKEYURL")
       scope = os.Getenv("AZUE_COSMOS_SCOPE")
   
       // Uncomment the following lines according to the authentication type.
       // 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 password.
       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)
       cosmosCassandraPassword, err := result["primaryMasterKey"]
   
       // Connect to Azure Cosmos DB for Cassandra
       clusterConfig := gocql.NewCluster(cosmosCassandraContactPoint)
       port, err := strconv.Atoi(cosmosCassandraPort)
       clusterConfig.Port = port
        clusterConfig.ProtoVersion = 4
       clusterConfig.Authenticator = gocql.PasswordAuthenticator{Username: cosmosCassandraUser, Password: cosmosCassandraPassword}
       clusterConfig.SslOpts = &gocql.SslOptions{Config: &tls.Config{MinVersion: tls.VersionTLS12}}
   
       session, err := clusterConfig.CreateSession()
       return session
   }
   
   func main() {
       session := utils.GetSession(cosmosCassandraContactPoint, cosmosCassandraPort, cosmosCassandraUser, cosmosCassandraPassword)
       defer session.Close()
       ...
   }
   

NodeJS

1. Installer des dépendances

   npm install cassandra-driver
   npm install --save @azure/identity
   

2. Dans le code, obtenez le jeton d’accès via @azure/identity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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";
   const cassandra = require("cassandra-driver");
   const axios = require('axios');
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let contactPoint = process.env.AZURE_COSMOS_CONTACTPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let keyspace = process.env.AZURE_COSMOS_KEYSPACE;
   let listKeyUrl = process.env.AZURE_COSMOS_LISTKEYURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // 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'];
   
   let authProvider = new cassandra.auth.PlainTextAuthProvider(
       username,
       password
   );
   
   let client = new cassandra.Client({
       contactPoints: [`${contactPoint}:${port}`],
       authProvider: authProvider,
       localDataCenter: 'datacenter1',
       sslOptions: {
           secureProtocol: "TLSv1_2_method"
       },
   });
   
   client.connect();
   

Autres

Pour d’autres langages, vous pouvez utiliser le point de contact Cassandra et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à la ressource Azure Cosmos DB pour Cassandra. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Cassandra à Service Connecter or.

Chaîne de connexion

Type de client SpringBoot

Nom de variable d’environnement par défaut	Description	Exemple de valeur
spring.data.cassandra.contact-points	Point de contact Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
spring.data.cassandra.port	Port de connexion Cassandra	10350
spring.data.cassandra.keyspace-name	Espace de clés Cassandra	<keyspace>
spring.data.cassandra.username	Nom d’utilisateur Cassandra	<username>
spring.data.cassandra.password	Mot de passe Cassandra	<password>
spring.data.cassandra.local-datacenter	Région Azure	<Azure-region>
spring.data.cassandra.ssl	État SSL	true

Autres types de clients

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_CONTACTPOINT	Point de contact Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Port de connexion Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espace de clés Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nom d’utilisateur Cassandra	<username>
AZURE_COSMOS_PASSWORD	Mot de passe Cassandra	<password>

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB pour Cassandra à l’aide d’un chaîne de connexion.

.NET

1. Installer des dépendances

   dotnet add package CassandraCSharpDriver --version 3.19.3
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra.

   using System;
   using System.Security.Authentication;
   using System.Net.Security;
   using System.Security.Authentication;
   using System.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using Cassandra;
   
   public class Program
   {
   	public static async Task Main()
   	{
           var cassandraContactPoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_CONTACTPOINT");
           var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
           var password = Environment.GetEnvironmentVariable("AZURE_COSMOS_PASSWORD");
           var cassandraPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
           var cassandraKeyspace = Environment.GetEnvironmentVariable("AZURE_COSMOS_KEYSPACE");
   
           var options = new Cassandra.SSLOptions(SslProtocols.Tls12, true, ValidateServerCertificate);
           options.SetHostNameResolver((ipAddress) => cassandraContactPoint);
           Cluster cluster = Cluster
               .Builder()
               .WithCredentials(userName, password)
               .WithPort(cassandraPort)
               .AddContactPoint(cassandraContactPoint).WithSSL(options).Build();
           ISession session = await cluster.ConnectAsync();
       }
   
       public static bool ValidateServerCertificate
   	(
           object sender,
           X509Certificate certificate,
           X509Chain chain,
           SslPolicyErrors sslPolicyErrors
       )
       {
           if (sslPolicyErrors == SslPolicyErrors.None)
               return true;
   
           Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
           // Do not allow this client to communicate with unauthenticated servers.
           return false;
       }
   }
   
   

Pour plus d’informations, consultez Créer une application Apache Cassandra avec le Kit de développement logiciel (SDK) .NET et Azure Cosmos DB.

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-core</artifactId>
       <version>4.5.1</version>
   </dependency>  
   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-query-builder</artifactId>
       <version>4.0.0</version>
   </dependency>       
   <dependency>
       <groupId>com.datastax.cassandra</groupId>
       <artifactId>cassandra-driver-extras</artifactId>
       <version>3.1.4</version>
   </dependency>
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra.

   import com.datastax.oss.driver.api.core.CqlSession;
   import javax.net.ssl.*;
   import java.net.InetSocketAddress;
   
   int cassandraPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String cassandraUsername = System.getenv("AZURE_COSMOS_USERNAME");
   String cassandraHost = System.getenv("AZURE_COSMOS_CONTACTPOINT");
   String cassandraPassword = System.getenv("AZURE_COSMOS_PASSWORD");
   String cassandraKeyspace = System.getenv("AZURE_COSMOS_KEYSPACE");
   
   final SSLContext sc = SSLContext.getInstance("TLSv1.2");
   
   CqlSession session = CqlSession.builder().withSslContext(sc)
       .addContactPoint(new InetSocketAddress(cassandraHost, cassandraPort)).withLocalDatacenter('datacenter1')
       .withAuthCredentials(cassandraUsername, cassandraPassword).build();
   

Pour plus d’informations, consultez Créer une application Java pour gérer les données Azure Cosmos DB pour Apache Cassandra.

SpringBoot

Configurez votre application Spring App en fonction de l’utilisation de Spring Data avec Azure Cosmos DB pour Apache Cassandra. Les propriétés de configuration de connexion sont ajoutées à Spring Apps by Service Connecter or.

Python

1. Installer des dépendances

   pip install Cassandra-driver 
   pip install pyopenssl
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra.

   from cassandra.cluster import Cluster
   from ssl import PROTOCOL_TLSv1_2, SSLContext, CERT_NONE
   from cassandra.auth import PlainTextAuthProvider
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   password = os.getenv('AZURE_COSMOS_PASSWORD')
   contactPoint = os.getenv('AZURE_COSMOS_CONTACTPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   keyspace = os.getenv('AZURE_COSMOS_KEYSPACE')
   
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contanctPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

Pour plus d’informations, consultez Créer une application Cassandra avec le Kit de développement logiciel (SDK) Python et Azure Cosmos DB

Go

1. Installez des dépendances.

   go get github.com/gocql/gocql
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra.

   import (
       "fmt"
       "os"
       "context"
       "log"
   
       "github.com/gocql/gocql"
   )
   
   func GetSession() *gocql.Session {
       cosmosCassandraContactPoint = os.Getenv("AZURE_COSMOS_CONTACTPOINT")
       cosmosCassandraPort = os.Getenv("AZURE_COSMOS_PORT")
       cosmosCassandraUser = os.Getenv("AZURE_COSMOS_USERNAME")
       cosmosCassandraPassword = os.Getenv("AZURE_COSMOS_PASSWORD")
       cosmosCassandraKeyspace = os.Getenv("AZURE_COSMOS_KEYSPACE")
   
       clusterConfig := gocql.NewCluster(cosmosCassandraContactPoint)
       port, err := strconv.Atoi(cosmosCassandraPort)
       if err != nil {
    	    // error handling
        }
   
       clusterConfig.Port = port
        clusterConfig.ProtoVersion = 4
       clusterConfig.Authenticator = gocql.PasswordAuthenticator{Username: cosmosCassandraUser, Password: cosmosCassandraPassword}
       clusterConfig.SslOpts = &gocql.SslOptions{Config: &tls.Config{MinVersion: tls.VersionTLS12}}
   
       session, err := clusterConfig.CreateSession()
       if err != nil {
    	    // error handling
        }
       return session
   }
   
   func main() {
       session := utils.GetSession(cosmosCassandraContactPoint, cosmosCassandraPort, cosmosCassandraUser, cosmosCassandraPassword)
       defer session.Close()
       ...
   }
   

Pour plus d’informations, consultez Générer une application Go avec le client gocql pour gérer les données Azure Cosmos DB pour Apache Cassandra.

NodeJS

1. Installer les dépendances

   npm install cassandra-driver
   

2. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra.

   const cassandra = require("cassandra-driver");
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let password = process.env.AZURE_COSMOS_PASSWORD;
   let contactPoint = process.env.AZURE_COSMOS_CONTACTPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let keyspace = process.env.AZURE_COSMOS_KEYSPACE;
   
   let authProvider = new cassandra.auth.PlainTextAuthProvider(
      username,
      password
   );
   
   let client = new cassandra.Client({
        contactPoints: [`${contactPoint}:${port}`],
        authProvider: authProvider,
        localDataCenter: 'datacenter1',
        sslOptions: {
            secureProtocol: "TLSv1_2_method"
        },
    });
   
    client.connect();
   

Pour plus d’informations, consultez Créer une application Cassandra avec Node.js SDK et Azure Cosmos DB

Autres

Pour d’autres langages, vous pouvez utiliser le point de contact Cassandra et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à la ressource Azure Cosmos DB pour Cassandra. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Cassandra à Service Connecter or.

Principal du service

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_COSMOS_LISTKEYURL	URL permettant d’accéder à la chaîne de connexion	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	Étendue de votre identité managée	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Votre point de terminaison de ressource	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_CONTACTPOINT	Point de contact Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Port de connexion Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espace de clés Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nom d’utilisateur Cassandra	<username>
AZURE_COSMOS_CLIENTID	Votre ID client	<client-ID>
AZURE_COSMOS_CLIENTSECRET	Votre clé secrète client	<client-secret>
AZURE_COSMOS_TENANTID	Votre ID d’abonné	<tenant-ID>

Exemple de code

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cosmos DB pour Cassandra à l’aide d’un principal de service.

.NET

1. Installer des dépendances

   dotnet add package CassandraCSharpDriver --version 3.19.3
   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 cliente Azure.Identity. Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL obtenez le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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.Security.Cryptography.X509Certificates;
   using System.Threading.Tasks;
   using Cassandra;
   using Azure.Identity;
   
   public class Program
   {
   	public static async Task Main()
   	{
           var cassandraContactPoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_CONTACTPOINT");
           var userName = Environment.GetEnvironmentVariable("AZURE_COSMOS_USERNAME");
           var cassandraPort = Int32.Parse(Environment.GetEnvironmentVariable("AZURE_COSMOS_PORT"));
           var cassandraKeyspace = Environment.GetEnvironmentVariable("AZURE_COSMOS_KEYSPACE");
           var listKeyUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTKEYURL");
           var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");
   
           // Uncomment the following lines according to the authentication type.
           // 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 Cassandra
           var options = new Cassandra.SSLOptions(SslProtocols.Tls12, true, ValidateServerCertificate);
           options.SetHostNameResolver((ipAddress) => cassandraContactPoint);
           Cluster cluster = Cluster
               .Builder()
               .WithCredentials(userName, password)
               .WithPort(cassandraPort)
               .AddContactPoint(cassandraContactPoint).WithSSL(options).Build();
           ISession session = await cluster.ConnectAsync();
       }
   
       public static bool ValidateServerCertificate
   	(
           object sender,
           X509Certificate certificate,
           X509Chain chain,
           SslPolicyErrors sslPolicyErrors
       )
       {
           if (sslPolicyErrors == SslPolicyErrors.None)
               return true;
   
           Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
           // Do not allow this client to communicate with unauthenticated servers.
           return false;
       }
   }
   
   

Java

1. Ajoutez les dépendances suivantes dans votre fichier pom.xml :

   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-core</artifactId>
       <version>4.5.1</version>
   </dependency>  
   <dependency>
       <groupId>com.datastax.oss</groupId>
       <artifactId>java-driver-query-builder</artifactId>
       <version>4.0.0</version>
   </dependency>       
   <dependency>
       <groupId>com.datastax.cassandra</groupId>
       <artifactId>cassandra-driver-extras</artifactId>
       <version>3.1.4</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 azure-identityde . Utilisez le jeton d’accès et AZURE_COSMOS_LISTKEYURL obtenez le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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 com.datastax.oss.driver.api.core.CqlSession;
   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 cassandraPort = Integer.parseInt(System.getenv("AZURE_COSMOS_PORT"));
   String cassandraUsername = System.getenv("AZURE_COSMOS_USERNAME");
   String cassandraHost = System.getenv("AZURE_COSMOS_CONTACTPOINT");
   String cassandraKeyspace = System.getenv("AZURE_COSMOS_KEYSPACE");
   String listKeyUrl = System.getenv("AZURE_COSMOS_LISTKEYURL");
   String scope = System.getenv("AZURE_COSMOS_SCOPE");
   
   // Uncomment the following lines according to the authentication type.
   // 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 cassandraPassword = responseBody.get("primaryMasterKey");
   
   // Connect to Azure Cosmos DB for Cassandra
   final SSLContext sc = SSLContext.getInstance("TLSv1.2");
   CqlSession session = CqlSession.builder().withSslContext(sc)
       .addContactPoint(new InetSocketAddress(cassandraHost, cassandraPort)).withLocalDatacenter('datacenter1')
       .withAuthCredentials(cassandraUsername, cassandraPassword).build();
   

SpringBoot

Le type d’authentification n’est pas pris en charge pour Spring Boot.

Python

1. Installer des dépendances

   pip install Cassandra-driver 
   pip install pyopenssl
   pip install azure-identity
   

2. Permet azure-identity de s’authentifier auprès de l’identité managée ou du principal du service et d’envoyer une demande pour AZURE_COSMOS_LISTKEYURL obtenir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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 cassandra.cluster import Cluster
   from ssl import PROTOCOL_TLSv1_2, SSLContext, CERT_NONE
   from cassandra.auth import PlainTextAuthProvider
   import requests
   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   
   username = os.getenv('AZURE_COSMOS_USERNAME')
   contactPoint = os.getenv('AZURE_COSMOS_CONTACTPOINT')
   port = os.getenv('AZURE_COSMOS_PORT')
   keyspace = os.getenv('AZURE_COSMOS_KEYSPACE')
   listKeyUrl = os.getenv('AZURE_COSMOS_LISTKEYURL')
   scope = os.getenv('AZURE_COSMOS_SCOPE')
   
   # Uncomment the following lines according to the authentication type.
   # 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 Cassandra.
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contanctPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

Go

1. Installez des dépendances.

   go get github.com/gocql/gocql
   go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"
   

2. Dans le code, obtenez un jeton d’accès via azidentity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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/gocql/gocql"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func GetSession() *gocql.Session {
       cosmosCassandraContactPoint = os.Getenv("AAZURE_COSMOS_CONTACTPOINT")
       cosmosCassandraPort = os.Getenv("AZURE_COSMOS_PORT")
       cosmosCassandraUser = os.Getenv("AZURE_COSMOS_USERNAME")
       cosmosCassandraKeyspace = os.Getenv("AZURE_COSMOS_KEYSPACE")
       listKeyUrl = os.Getenv("AZURE_COSMOS_LISTKEYURL")
       scope = os.Getenv("AZUE_COSMOS_SCOPE")
   
       // Uncomment the following lines according to the authentication type.
       // 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 password.
       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)
       cosmosCassandraPassword, err := result["primaryMasterKey"]
   
       // Connect to Azure Cosmos DB for Cassandra
       clusterConfig := gocql.NewCluster(cosmosCassandraContactPoint)
       port, err := strconv.Atoi(cosmosCassandraPort)
       clusterConfig.Port = port
        clusterConfig.ProtoVersion = 4
       clusterConfig.Authenticator = gocql.PasswordAuthenticator{Username: cosmosCassandraUser, Password: cosmosCassandraPassword}
       clusterConfig.SslOpts = &gocql.SslOptions{Config: &tls.Config{MinVersion: tls.VersionTLS12}}
   
       session, err := clusterConfig.CreateSession()
       return session
   }
   
   func main() {
       session := utils.GetSession(cosmosCassandraContactPoint, cosmosCassandraPort, cosmosCassandraUser, cosmosCassandraPassword)
       defer session.Close()
       ...
   }
   

NodeJS

1. Installer des dépendances

   npm install cassandra-driver
   npm install --save @azure/identity
   

2. Dans le code, obtenez le jeton d’accès via @azure/identity, puis utilisez-le pour acquérir le mot de passe. Obtenez les informations de connexion à partir des variables d’environnement ajoutées par Service Connecter or et connectez-vous à Azure Cosmos DB pour Cassandra. 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";
   const cassandra = require("cassandra-driver");
   const axios = require('axios');
   
   let username = process.env.AZURE_COSMOS_USERNAME;
   let contactPoint = process.env.AZURE_COSMOS_CONTACTPOINT;
   let port = process.env.AZURE_COSMOS_PORT;
   let keyspace = process.env.AZURE_COSMOS_KEYSPACE;
   let listKeyUrl = process.env.AZURE_COSMOS_LISTKEYURL;
   let scope = process.env.AZURE_COSMOS_SCOPE;
   
   // Uncomment the following lines according to the authentication type.  
   // 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'];
   
   let authProvider = new cassandra.auth.PlainTextAuthProvider(
       username,
       password
   );
   
   let client = new cassandra.Client({
       contactPoints: [`${contactPoint}:${port}`],
       authProvider: authProvider,
       localDataCenter: 'datacenter1',
       sslOptions: {
           secureProtocol: "TLSv1_2_method"
       },
   });
   
   client.connect();
   

Autres

Pour d’autres langages, vous pouvez utiliser le point de contact Cassandra et d’autres propriétés que Service Connecter or définit sur les variables d’environnement pour vous connecter à la ressource Azure Cosmos DB pour Cassandra. Pour plus d’informations sur la variable d’environnement, consultez Intégrer Azure Cosmos DB pour Cassandra à Service Connecter or.

Étapes suivantes

Suivez les tutoriels ci-dessous pour en savoir plus sur Service Connector.

En savoir plus sur les concepts Service Connector