Integrar o Azure Cosmos DB for Cassandra ao Conector de Serviço

1. Instalar dependências

   dotnet add package CassandraCSharpDriver --version 3.19.3
   dotnet add package Azure.Identity
   

2. Obtenha um token de acesso para a identidade gerenciada ou entidade de serviço usando a biblioteca de clientes Azure.Identity. Use o token de acesso e AZURE_COSMOS_LISTKEYURL para obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

1. Adicione as dependências a seguir no seu arquivo 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. Obtenha um token de acesso para a identidade gerenciada ou entidade de serviço usando azure-identity. Use o token de acesso e AZURE_COSMOS_LISTKEYURL para obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   import com.datastax.oss.driver.api.core.CqlSession;
   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 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 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 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();
   

O tipo de autenticação não é compatível com o Spring Boot.

1. Instalar dependências

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

2. Use azure-identity para autenticar com a identidade gerenciada ou a entidade de serviço e enviar solicitação para AZURE_COSMOS_LISTKEYURL e obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   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 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 Cassandra.
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contactPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

1. Instale as dependências.

   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. No código, obtenha um token de acesso via azidentity e use-o para adquirir a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   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("AZURE_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("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 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()
       ...
   }
   

1. Instalar dependências

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

2. No código, obtenha o token de acesso via @azure/identity e use-o para adquirir a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

Para outros idiomas, você pode usar o ponto de contato Cassandra e outras propriedades que Conector de Serviço define para as variáveis de ambiente para se conectar ao recurso Azure Cosmos DB for Cassandra. Para obter detalhes das variáveis de ambiente, confira o artigo Integrar o Azure Cosmos DB for Cassandra com o Service Connector.

1. Instalar dependências

   dotnet add package CassandraCSharpDriver --version 3.19.3
   dotnet add package Azure.Identity
   

2. Obtenha um token de acesso para a identidade gerenciada ou entidade de serviço usando a biblioteca de clientes Azure.Identity. Use o token de acesso e AZURE_COSMOS_LISTKEYURL para obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

1. Adicione as dependências a seguir no seu arquivo 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. Obtenha um token de acesso para a identidade gerenciada ou entidade de serviço usando azure-identity. Use o token de acesso e AZURE_COSMOS_LISTKEYURL para obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   import com.datastax.oss.driver.api.core.CqlSession;
   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 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 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 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();
   

O tipo de autenticação não é compatível com o Spring Boot.

1. Instalar dependências

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

2. Use azure-identity para autenticar com a identidade gerenciada ou a entidade de serviço e enviar solicitação para AZURE_COSMOS_LISTKEYURL e obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   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 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 Cassandra.
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contactPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

1. Instale as dependências.

   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. No código, obtenha um token de acesso via azidentity e use-o para adquirir a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   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("AZURE_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("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 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()
       ...
   }
   

1. Instalar dependências

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

2. No código, obtenha o token de acesso via @azure/identity e use-o para adquirir a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

Para outros idiomas, você pode usar o ponto de contato Cassandra e outras propriedades que Conector de Serviço define para as variáveis de ambiente para se conectar ao recurso Azure Cosmos DB for Cassandra. Para obter detalhes das variáveis de ambiente, confira o artigo Integrar o Azure Cosmos DB for Cassandra com o Service Connector.

1. Instalar dependências

   dotnet add package CassandraCSharpDriver --version 3.19.3
   

2. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for 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;
       }
   }
   
   

Para mais informações, confira o artigo Criar um aplicativo do Apache Cassandra com o SDK do .NET e o Azure Cosmos DB.

1. Adicione as dependências a seguir no seu arquivo 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. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for 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();
   

Para mais informações, confira o artigo Criar um aplicativo Java para gerenciar dados do Azure Cosmos DB for Apache Cassandra.

Configure seu Aplicativo Spring conforme mostrado no artigo Como usar o Spring Data com Azure Cosmos DB for Apache Cassandra. As propriedades de configuração de conexão são adicionadas aos Aplicativos Spring pelo Conector de Serviço.

1. Instalar dependências

   pip install Cassandra-driver 
   pip install pyopenssl
   

2. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for 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([contactPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

Para mais informações, confira o artigo Criar um aplicativo Cassandra com o SDK do Python e o Azure Cosmos DB

1. Instale as dependências.

   go get github.com/gocql/gocql
   

2. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for 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()
       ...
   }
   

Para mais informações, confira o artigo Criar um aplicativo Go com o cliente gocql para gerenciar dados do Azure Cosmos DB for Apache Cassandra.

1. Instalar dependências

   npm install cassandra-driver
   

2. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for 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();
   

Para mais informações, confira o artigo Criar um aplicativo Cassandra com o SDK do Node.js e o Azure Cosmos DB

Para outros idiomas, você pode usar o ponto de contato Cassandra e outras propriedades que Conector de Serviço define para as variáveis de ambiente para se conectar ao recurso Azure Cosmos DB for Cassandra. Para obter detalhes das variáveis de ambiente, confira o artigo Integrar o Azure Cosmos DB for Cassandra com o Service Connector.

1. Instalar dependências

   dotnet add package CassandraCSharpDriver --version 3.19.3
   dotnet add package Azure.Identity
   

2. Obtenha um token de acesso para a identidade gerenciada ou entidade de serviço usando a biblioteca de clientes Azure.Identity. Use o token de acesso e AZURE_COSMOS_LISTKEYURL para obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

1. Adicione as dependências a seguir no seu arquivo 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. Obtenha um token de acesso para a identidade gerenciada ou entidade de serviço usando azure-identity. Use o token de acesso e AZURE_COSMOS_LISTKEYURL para obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   import com.datastax.oss.driver.api.core.CqlSession;
   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 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 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 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();
   

O tipo de autenticação não é compatível com o Spring Boot.

1. Instalar dependências

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

2. Use azure-identity para autenticar com a identidade gerenciada ou a entidade de serviço e enviar solicitação para AZURE_COSMOS_LISTKEYURL e obter a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   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 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 Cassandra.
   ssl_context = SSLContext(PROTOCOL_TLSv1_2)
   ssl_context.verify_mode = CERT_NONE
   auth_provider = PlainTextAuthProvider(username, password)
   cluster = Cluster([contactPoint], port = port, auth_provider=auth_provider,ssl_context=ssl_context)
   session = cluster.connect()
   

1. Instale as dependências.

   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. No código, obtenha um token de acesso via azidentity e use-o para adquirir a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

   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("AZURE_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("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 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()
       ...
   }
   

1. Instalar dependências

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

2. No código, obtenha o token de acesso via @azure/identity e use-o para adquirir a senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Service Connector e conecte-se ao Azure Cosmos DB for Cassandra. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

Para outros idiomas, você pode usar o ponto de contato Cassandra e outras propriedades que Conector de Serviço define para as variáveis de ambiente para se conectar ao recurso Azure Cosmos DB for Cassandra. Para obter detalhes das variáveis de ambiente, confira o artigo Integrar o Azure Cosmos DB for Cassandra com o Service Connector.