Integración de Azure Cosmos DB for Cassandra con Service Connector

En esta página se muestran los métodos de autenticación y los clientes admitidos y se muestra el código de ejemplo que puede usar para conectar Azure Cosmos DB for Apache Cassandra a otros servicios en la nube mediante Service Connector. Es posible que todavía pueda conectarse a Azure Cosmos DB for Cassandra en otros lenguajes de programación sin usar Service Connector. Esta página también muestra los nombres y valores predeterminados de las variables de entorno o la configuración de Spring Boot que se obtiene al crear la conexión de servicio.

Servicios de proceso admitidos

Service Connector puede utilizarse para conectar los siguientes servicios informáticos a Azure Cosmos DB for Apache Cassandra:

• Azure App Service
• Azure Container Apps
• Funciones de Azure
• Azure Kubernetes Service (AKS)
• Azure Spring Apps

Tipos de autenticación y tipos de cliente admitidos

En la tabla siguiente se muestran las combinaciones de tipos de cliente y métodos de autenticación que se admiten para conectar el servicio de proceso a Azure Cosmos DB for Apache Cassandra mediante Service Connector. Un valor "Sí" indica que se admite la combinación, mientras que "No" indica que no se admite.

Tipo de cliente	Identidad administrada asignada por el sistema	Identidad administrada asignada por el usuario	Secreto/cadena de conexión	Entidad de servicio
.NET	Sí	Sí	Sí	Sí
Go	Sí	Sí	Sí	Sí
Java	Sí	Sí	Sí	Sí
Java: Spring Boot	No	No	Sí	No
Node.js	Sí	Sí	Sí	Sí
Python	Sí	Sí	Sí	Sí
None	Sí	Sí	Sí	Sí

Esta tabla indica que se admiten todas las combinaciones de tipos de cliente y métodos de autenticación de la tabla, excepto para el tipo de cliente Java - Spring Boot, que solo admite el método de cadena de conexión o secreto. Todos los demás tipos de cliente pueden utilizar cualquiera de los métodos de autenticación para conectarse a Azure Cosmos DB for Apache Cassandra mediante Service Connector.

Nombres de variables de entorno predeterminados o propiedades de aplicación y código de ejemplo

Consulte los detalles de conexión y el código de ejemplo en las tablas siguientes, según el tipo de autenticación y el tipo de cliente de su conexión, para conectar servicios informáticos a Azure Cosmos DB for Apache Cassandra. Para más información sobre las convenciones de nomenclatura, consulte el artículo sobre los elementos internos del conector de servicio.

Identidad administrada asignada por el sistema

Nombre de la variable de entorno predeterminado	Descripción	Valor de ejemplo
AZURE_COSMOS_LISTKEYURL	Dirección URL para obtener la cadena de conexión	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	Ámbito de la identidad administrada	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Punto de conexión del recurso	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_CONTACTPOINT	Punto de contacto de Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Puerto de conexión de Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espacio de claves de Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nombre de usuario de Cassandra	<username>

Código de ejemplo

Consulte los pasos y el código siguientes para conectarse a Azure Cosmos DB for Cassandra utilizando una identidad administrada asignada por el sistema.

.NET

1. Instalación de dependencias

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

2. Puede obtener un token de acceso para la identidad administrada o la entidad de servicio utilizando una biblioteca de cliente como Azure.Identity. Use el token de acceso y AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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;
       }
   }
   
   

Java

1. Agregue las siguientes dependencias al archivo 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. Obtenga un token de acceso para la identidad administrada o la entidad de servicio mediante azure-identity. Use el token de acceso y AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
   

SpringBoot

El tipo de autenticación no se admite para Spring Boot.

Python

1. Instalación de dependencias

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

2. Use azure-identity para autenticarse con la identidad administrada o la entidad de servicio y envíe una solicitud a AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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()
   

Go

1. Instale las dependencias.

   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. En el código, obtenga un token de acceso a través de azidentity y úselo para adquirir la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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()
       ...
   }
   

NodeJS

1. Instalar dependencias

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

2. En el código, obtenga un token de acceso a través de @azure/identity y úselo para adquirir la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
   

Otros

Para otros lenguajes, puede usar el punto de contacto de Cassandra y otras propiedades que Service Connector establece en las variables de entorno para conectarse al recurso de Azure Cosmos DB for Cassandra. Para más información sobre las variables de entorno, consulte Integración de Azure Cosmos DB for Cassandra con Service Connector.

Identidad administrada asignada por el usuario

Nombre de la variable de entorno predeterminado	Descripción	Valor de ejemplo
AZURE_COSMOS_LISTKEYURL	Dirección URL para obtener la cadena de conexión	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	Ámbito de la identidad administrada	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Punto de conexión del recurso	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_CONTACTPOINT	Punto de contacto de Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Puerto de conexión de Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espacio de claves de Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nombre de usuario de Cassandra	<username>
AZURE_COSMOS_CLIENTID	Id. de cliente	<client-ID>

Código de ejemplo

Consulte los pasos y el código siguientes para conectarse a Azure Cosmos DB for Cassandra utilizando una identidad administrada asignada por el usuario.

.NET

1. Instalación de dependencias

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

2. Puede obtener un token de acceso para la identidad administrada o la entidad de servicio utilizando una biblioteca de cliente como Azure.Identity. Use el token de acceso y AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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;
       }
   }
   
   

Java

1. Agregue las siguientes dependencias al archivo 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. Obtenga un token de acceso para la identidad administrada o la entidad de servicio mediante azure-identity. Use el token de acceso y AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
   

SpringBoot

El tipo de autenticación no se admite para Spring Boot.

Python

1. Instalación de dependencias

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

2. Use azure-identity para autenticarse con la identidad administrada o la entidad de servicio y envíe una solicitud a AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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()
   

Go

1. Instale las dependencias.

   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. En el código, obtenga un token de acceso a través de azidentity y úselo para adquirir la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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()
       ...
   }
   

NodeJS

1. Instalar dependencias

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

2. En el código, obtenga un token de acceso a través de @azure/identity y úselo para adquirir la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
   

Otros

Para otros lenguajes, puede usar el punto de contacto de Cassandra y otras propiedades que Service Connector establece en las variables de entorno para conectarse al recurso de Azure Cosmos DB for Cassandra. Para más información sobre las variables de entorno, consulte Integración de Azure Cosmos DB for Cassandra con Service Connector.

Cadena de conexión

Advertencia

Microsoft recomienda usar el flujo de autenticación más seguro disponible. El flujo de autenticación que se describe en este procedimiento requiere un alto grado de confianza en la aplicación y conlleva riesgos que no están presentes en otros flujos. Solo debe usar este flujo cuando otros flujos más seguros, como las identidades administradas, no sean viables.

Tipo de cliente de SpringBoot

Nombre de la variable de entorno predeterminado	Descripción	Valor de ejemplo
spring.data.cassandra.contact-points	Punto de contacto de Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
spring.data.cassandra.port	Puerto de conexión de Cassandra	10350
spring.data.cassandra.keyspace-name	Espacio de claves de Cassandra	<keyspace>
spring.data.cassandra.username	Nombre de usuario de Cassandra	<username>
spring.data.cassandra.password	Contraseña de Cassandra	<password>
spring.data.cassandra.local-datacenter	Región de Azure	<Azure-region>
spring.data.cassandra.ssl	Estado SSL	true

Otros tipos de clientes

Nombre de la variable de entorno predeterminado	Descripción	Valor de ejemplo
AZURE_COSMOS_CONTACTPOINT	Punto de contacto de Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Puerto de conexión de Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espacio de claves de Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nombre de usuario de Cassandra	<username>
AZURE_COSMOS_PASSWORD	Contraseña de Cassandra	<password>

Código de ejemplo

Consulte los pasos y el código siguientes para conectarse a Azure Cosmos DB for Cassandra utilizando una cadena de conexión.

.NET

1. Instalación de dependencias

   dotnet add package CassandraCSharpDriver --version 3.19.3
   

2. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a 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 obtener más información, consulte Creación de una aplicación de Apache Cassandra con el SDK de .NET y Azure Cosmos DB.

Java

1. Agregue las siguientes dependencias al archivo 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. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a 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 más información, consulte Creación de una aplicación de Java para administrar datos de Azure Cosmos DB for Apache Cassandra.

SpringBoot

Configure la aplicación de Spring de acuerdo con Uso de Spring Data con Azure Cosmos DB for Apache Cassandra. Las propiedades de conexión de configuración se agregan a las aplicaciones de Spring mediante Service Connector.

Python

1. Instalación de dependencias

   pip install Cassandra-driver 
   pip install pyopenssl
   

2. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a 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 más información, consulte Compilación de una aplicación de Cassandra con el SDK de Python y Azure Cosmos DB

Go

1. Instale las dependencias.

   go get github.com/gocql/gocql
   

2. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a 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 más información, consulte Creación de una aplicación de Go con el cliente gocql para administrar datos de Azure Cosmos DB for Apache Cassandra.

NodeJS

1. Instalación de dependencias

   npm install cassandra-driver
   

2. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a 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 más información, consulte Compilación de una aplicación de Cassandra con Node.js SDK y Azure Cosmos DB

Otros

Para otros lenguajes, puede usar el punto de contacto de Cassandra y otras propiedades que Service Connector establece en las variables de entorno para conectarse al recurso de Azure Cosmos DB for Cassandra. Para más información sobre las variables de entorno, consulte Integración de Azure Cosmos DB for Cassandra con Service Connector.

Entidad de servicio

Nombre de la variable de entorno predeterminado	Descripción	Valor de ejemplo
AZURE_COSMOS_LISTKEYURL	Dirección URL para obtener la cadena de conexión	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	Ámbito de la identidad administrada	https://management.azure.com/.default
AZURE_COSMOS_RESOURCEENDPOINT	Punto de conexión del recurso	https://<Azure-Cosmos-DB-account>.documents.azure.com:443/
AZURE_COSMOS_CONTACTPOINT	Punto de contacto de Azure Cosmos DB for Apache Cassandra	<Azure-Cosmos-DB-account>.cassandra.cosmos.azure.com
AZURE_COSMOS_PORT	Puerto de conexión de Cassandra	10350
AZURE_COSMOS_KEYSPACE	Espacio de claves de Cassandra	<keyspace>
AZURE_COSMOS_USERNAME	Nombre de usuario de Cassandra	<username>
AZURE_COSMOS_CLIENTID	Id. de cliente	<client-ID>
AZURE_COSMOS_CLIENTSECRET	Secreto de cliente	<client-secret>
AZURE_COSMOS_TENANTID	El identificador de inquilino	<tenant-ID>

Código de ejemplo

Consulte los pasos y el código siguientes para conectarse a Azure Cosmos DB for Cassandra utilizando una entidad de servicio.

.NET

1. Instalación de dependencias

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

2. Puede obtener un token de acceso para la identidad administrada o la entidad de servicio utilizando una biblioteca de cliente como Azure.Identity. Use el token de acceso y AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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;
       }
   }
   
   

Java

1. Agregue las siguientes dependencias al archivo 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. Obtenga un token de acceso para la identidad administrada o la entidad de servicio mediante azure-identity. Use el token de acceso y AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
   

SpringBoot

El tipo de autenticación no se admite para Spring Boot.

Python

1. Instalación de dependencias

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

2. Use azure-identity para autenticarse con la identidad administrada o la entidad de servicio y envíe una solicitud a AZURE_COSMOS_LISTKEYURL para obtener la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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()
   

Go

1. Instale las dependencias.

   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. En el código, obtenga un token de acceso a través de azidentity y úselo para adquirir la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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()
       ...
   }
   

NodeJS

1. Instalar dependencias

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

2. En el código, obtenga un token de acceso a través de @azure/identity y úselo para adquirir la contraseña. Obtenga la información de conexión de las variables de entorno agregadas por Service Connector y conéctese a Azure Cosmos DB for Cassandra. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
   

Otros

Para otros lenguajes, puede usar el punto de contacto de Cassandra y otras propiedades que Service Connector establece en las variables de entorno para conectarse al recurso de Azure Cosmos DB for Cassandra. Para más información sobre las variables de entorno, consulte Integración de Azure Cosmos DB for Cassandra con Service Connector.

Pasos siguientes

Para más información sobre Service Connector, siga los tutoriales que se enumeran a continuación.

Más información sobre los conceptos de Service Connector