Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Uso de un controlador de cliente de Cassandra para acceder a Amazon Keyspaces mediante programación
Puede utilizar muchos controladores de Cassandra de terceros y de código abierto para conectarse a Amazon Keyspaces. Amazon Keyspaces es compatible con controladores de Cassandra que admiten Apache Cassandra versión 3.11.2. Estos son los controladores y las versiones más recientes que hemos probado y que recomendamos usar con Amazon Keyspaces:
+ `Java v3.3`
+ `Java v4.17`
+ `Python Cassandra-driver 3.29.1`
+ `Node.js cassandra driver -v 4.7.2`
+ `GO using GOCQL v1.6`
+ `.NET CassandraCSharpDriver -v 3.20.1`
Para obtener más información sobre los controladores de Cassandra, consulte [Controladores de cliente de Apache Cassandra](http://cassandra.apache.org/doc/latest/getting_started/drivers.html).
**nota**
Para ayudarle a empezar, puede ver y descargar ejemplos de end-to-end código que establecen conexiones con Amazon Keyspaces con controladores populares. Consulte los [ejemplos de Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-examples) en. GitHub
Los tutoriales de este capítulo incluyen una sencilla consulta CQL para confirmar que la conexión con Amazon Keyspaces se ha establecido correctamente. Para obtener información sobre cómo trabajar con espacios de claves y tablas después de conectarse a un punto de conexión de Amazon Keyspaces, consulte [Referencia del lenguaje CQL para Amazon Keyspaces (para Apache Cassandra)](cql.md). Para ver un step-by-step tutorial que muestra cómo conectarse a Amazon Keyspaces desde un punto de enlace de Amazon VPC, consulte. [Tutorial: Conéctese a Amazon Keyspaces mediante un punto de enlace de VPC de interfaz](vpc-endpoints-tutorial.md)
**Topics**
+ [
# Uso de un controlador de cliente Java de Cassandra para acceder mediante programación a Amazon Keyspaces
](using_java_driver.md)
+ [
# Uso de un controlador de cliente Python para Cassandra para acceder mediante programación a Amazon Keyspaces
](using_python_driver.md)
+ [
# Uso de un controlador de cliente Node.js para Cassandra para acceder mediante programación a Amazon Keyspaces
](using_nodejs_driver.md)
+ [
# Uso de un controlador de cliente .NET Core para Cassandra para acceder a Amazon Keyspaces mediante programación
](using_dotnetcore_driver.md)
+ [
# Uso de un controlador de cliente Go para Cassandra para acceder a Amazon Keyspaces mediante programación
](using_go_driver.md)
+ [
# Uso de un controlador de cliente Perl para Cassandra para acceder a Amazon Keyspaces mediante programación
](using_perl_driver.md)
# Uso de un controlador de cliente Java de Cassandra para acceder mediante programación a Amazon Keyspaces
En esta sección le mostramos cómo conectarse a Amazon Keyspaces mediante un controlador de cliente Java.
**nota**
Actualmente, Java 17 y el controlador DataStax Java 4.17 solo son compatibles con la versión beta. Para obtener más información, consulte [https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/](https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/).
Para proporcionar a los usuarios y a las aplicaciones credenciales de acceso programático a los recursos de Amazon Keyspaces, puede realizar cualquiera de las siguientes acciones:
+ Crear credenciales específicas del servicio que se vinculen a un usuario de AWS Identity and Access Management (IAM) específico.
+ Para mejorar la seguridad, se recomienda crear claves de acceso de IAM para las identidades de IAM que se utilizan en todos los servicios. AWS El complemento de autenticación SigV4 de Amazon Keyspaces para controladores de cliente de Cassandra habilita la autenticación de llamadas a Amazon Keyspaces utilizando claves de acceso de IAM en vez de nombre de usuario y contraseña. Para obtener más información, consulte [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
**nota**
Para ver un ejemplo de cómo utilizar Amazon Keyspaces con Spring Boot, consulte [https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/spring](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/spring).
**Topics**
+ [
## Antes de empezar
](#using_java_driver.BeforeYouBegin)
+ [
## Step-by-step tutorial para conectarse a Amazon Keyspaces mediante el controlador DataStax Java para Apache Cassandra con credenciales específicas del servicio
](#java_tutorial)
+ [
## Step-by-step tutorial para conectarse a Amazon Keyspaces mediante el controlador DataStax Java 4.x para Apache Cassandra y el complemento de autenticación SigV4
](#java_tutorial.SigV4)
+ [
## Conéctese a Amazon Keyspaces mediante el controlador DataStax Java 3.x para Apache Cassandra y el complemento de autenticación SigV4
](#java3x_tutorial.SigV4)
## Antes de empezar
Para conectarse a Amazon Keyspaces, debe completar las siguientes tareas antes de poder comenzar.
1. Amazon Keyspaces requiere el uso de Seguridad de la capa de transporte (TLS) para ayudar a proteger las conexiones con los clientes.
1. Descargue los siguientes certificados digitales y guarde los archivos de forma local o en su directorio principal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional, para compatibilidad con versiones anteriores)
Para descargar los certificados, puede usar los siguientes comandos.
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**nota**
Anteriormente, Amazon Keyspaces utilizaba certificados TLS anclados a la CA de clase 2 de Starfield. AWS está migrando todo Regiones de AWS a certificados emitidos bajo Amazon Trust Services (Amazon Root CAs 1—4). Durante esta transición, configure los clientes para que confíen tanto en la raíz CAs 1—4 de Amazon como en la raíz de Starfield para garantizar la compatibilidad en todas las regiones.
1. Convierta los certificados digitales en archivos TrustStore y agréguelos al almacén de claves.
```
openssl x509 -outform der -in AmazonRootCA1.pem -out temp_file.der
keytool -import -alias amazon-root-ca-1 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA2.pem -out temp_file.der
keytool -import -alias amazon-root-ca-2 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA3.pem -out temp_file.der
keytool -import -alias amazon-root-ca-3 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA4.pem -out temp_file.der
keytool -import -alias amazon-root-ca-4 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in sf-class2-root.crt -out temp_file.der
keytool -import -alias cassandra -keystore cassandra_truststore.jks -file temp_file.der
```
En el último paso, debe crear una contraseña para el almacén de claves y confiar en cada certificado. El comando interactivo tiene el siguiente aspecto.
```
Enter keystore password:
Re-enter new password:
Owner: CN=Amazon Root CA 1, O=Amazon, C=US
Issuer: CN=Amazon Root CA 1, O=Amazon, C=US
Serial number: 66c9fcf99bf8c0a39e2f0788a43e696365bca
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sun Jan 17 00:00:00 UTC 2038
Certificate fingerprints:
SHA1: 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16
SHA256: 8E:CD:E6:88:4F:3D:87:B1:12:5B:A3:1A:C3:FC:B1:3D:70:16:DE:7F:57:CC:90:4F:E1:CB:97:C6:AE:98:19:6E
Signature algorithm name: SHA256withRSA
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: 84 18 CC 85 34 EC BC 0C 94 94 2E 08 59 9C C7 B2 ....4.......Y...
0010: 10 4E 0A 08 .N..
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 2, O=Amazon, C=US
Issuer: CN=Amazon Root CA 2, O=Amazon, C=US
Serial number: 66c9fd29635869f0a0fe58678f85b26bb8a37
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A
SHA256: 1B:A5:B2:AA:8C:65:40:1A:82:96:01:18:F8:0B:EC:4F:62:30:4D:83:CE:C4:71:3A:19:C3:9C:01:1E:A4:6D:B4
Signature algorithm name: SHA384withRSA
Subject Public Key Algorithm: 4096-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: B0 0C F0 4C 30 F4 05 58 02 48 FD 33 E5 52 AF 4B ...L0..X.H.3.R.K
0010: 84 E3 66 52 ..fR
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 3, O=Amazon, C=US
Issuer: CN=Amazon Root CA 3, O=Amazon, C=US
Serial number: 66c9fd5749736663f3b0b9ad9e89e7603f24a
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E
SHA256: 18:CE:6C:FE:7B:F1:4E:60:B2:E3:47:B8:DF:E8:68:CB:31:D0:2E:BB:3A:DA:27:15:69:F5:03:43:B4:6D:B3:A4
Signature algorithm name: SHA256withECDSA
Subject Public Key Algorithm: 256-bit EC (secp256r1) key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: AB B6 DB D7 06 9E 37 AC 30 86 07 91 70 C7 9C C4 ......7.0...p...
0010: 19 B1 78 C0 ..x.
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 4, O=Amazon, C=US
Issuer: CN=Amazon Root CA 4, O=Amazon, C=US
Serial number: 66c9fd7c1bb104c2943e5717b7b2cc81ac10e
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE
SHA256: E3:5D:28:41:9E:D0:20:25:CF:A6:90:38:CD:62:39:62:45:8D:A5:C6:95:FB:DE:A3:C2:2B:0B:FB:25:89:70:92
Signature algorithm name: SHA384withECDSA
Subject Public Key Algorithm: 384-bit EC (secp384r1) key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: D3 EC C7 3A 65 6E CC E1 DA 76 9A 56 FB 9C F3 86 ...:en...v.V....
0010: 6D 57 E5 81 mW..
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US
Issuer: OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US
Serial number: 0
Valid from: Tue Jun 29 17:39:16 UTC 2004 until: Thu Jun 29 17:39:16 UTC 2034
Certificate fingerprints:
SHA1: AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A
SHA256: 14:65:FA:20:53:97:B8:76:FA:A6:F0:A9:95:8E:55:90:E4:0F:CC:7F:AA:4F:B7:C2:C8:67:75:21:FB:5F:B6:58
Signature algorithm name: SHA1withRSA (weak)
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.35 Criticality=false
AuthorityKeyIdentifier [
KeyIdentifier [
0000: BF 5F B7 D1 CE DD 1F 86 F4 5B 55 AC DC D7 10 C2 ._.......[U.....
0010: 0E A9 88 E7 ....
]
[OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US]
SerialNumber: [ 00]
]
#2: ObjectId: 2.5.29.19 Criticality=false
BasicConstraints:[
CA:true
PathLen:2147483647
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: BF 5F B7 D1 CE DD 1F 86 F4 5B 55 AC DC D7 10 C2 ._.......[U.....
0010: 0E A9 88 E7 ....
]
]
Warning:
The input uses the SHA1withRSA signature algorithm which is considered a security risk. This algorithm will be disabled in a future update.
Trust this certificate? [no]: yes
Certificate was added to keystore
```
1. Adjunte el archivo trustStore en los argumentos de la JVM:
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## Step-by-step tutorial para conectarse a Amazon Keyspaces mediante el controlador DataStax Java para Apache Cassandra con credenciales específicas del servicio
En el siguiente step-by-step tutorial, se explica cómo conectarse a Amazon Keyspaces mediante un controlador Java para Cassandra con credenciales específicas del servicio. En concreto, utilizará la versión 4.0 del controlador de DataStax Java para Apache Cassandra.
**Topics**
+ [
### Paso 1: requisitos previos
](#java_tutorial.prereq)
+ [
### Paso 2: configurar el controlador
](#java_tutorial.driverconfiguration)
+ [
### Paso 3: ejecutar el ejemplo de aplicación
](#java_tutorial.application)
### Paso 1: requisitos previos
Para seguir este tutorial, debe generar credenciales específicas del servicio y añadir el controlador DataStax Java para Apache Cassandra a su proyecto de Java.
+ Genere credenciales específicas del servicio para su usuario de IAM de Amazon Keyspaces; para ello, siga los pasos que se indican en [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md). Si prefiere utilizar claves de acceso de IAM para la autenticación, consulte [Step-by-step tutorial para conectarse a Amazon Keyspaces mediante el controlador DataStax Java 4.x para Apache Cassandra y el complemento de autenticación SigV4](#java_tutorial.SigV4).
+ Añada el controlador de DataStax Java para Apache Cassandra a su proyecto de Java. Asegúrese de estar utilizando una versión de controlador compatible con Apache Cassandra 3.11.2. Para obtener más información, consulte la documentación del [controlador DataStax Java para Apache Cassandra](https://github.com/datastax/java-driver).
### Paso 2: configurar el controlador
Puede especificar los ajustes del controlador DataStax Java Cassandra creando un archivo de configuración para su aplicación. Este archivo de configuración anula los ajustes predeterminados e indica al controlador que se conecte al punto de conexión del servicio de Amazon Keyspaces a través del puerto 9142. Para obtener una lista de los puntos de conexión de servicio disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
Cree un archivo de configuración y guárdelo en la carpeta de recursos de la aplicación; por ejemplo, `src/main/resources/application.conf`. Abra `application.conf` y añada los siguientes ajustes de configuración.
1. **Proveedor de autenticación**: cree el proveedor de autenticación con la `PlainTextAuthProvider` clase. *ServiceUserName*y *ServicePassword* deben coincidir con el nombre de usuario y la contraseña que obtuvo al generar las credenciales específicas del servicio siguiendo los pasos que se indican en. [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md)
**nota**
Puede usar credenciales de corta duración mediante el complemento de autenticación del controlador DataStax Java para Apache Cassandra en lugar de codificar las credenciales en el archivo de configuración del controlador. Para obtener más información, siga las instrucciones de [Step-by-step tutorial para conectarse a Amazon Keyspaces mediante el controlador DataStax Java 4.x para Apache Cassandra y el complemento de autenticación SigV4](#java_tutorial.SigV4).
1. **Centro de datos local**: establezca el valor de `local-datacenter` a la región a la que se conecte. Por ejemplo, si la aplicación se conecta a `cassandra.us-east-2.amazonaws.com`, entonces establezca el centro de datos local en `us-east-2`. Para conocer todas las Regiones de AWS disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md). Establezca `slow-replica-avoidance = false` para equilibrar la carga con menos nodos.
1. **SSL/TLS**: para inicializar la configuración de SSLEngine fábrica, añada una sección en el archivo de configuración con una sola línea que especifique la clase con la que se especifica. `class = DefaultSslEngineFactory` Proporcione la ruta al archivo trustStore y la contraseña que creó anteriormente. Amazon Keyspaces no admite `hostname-validation` de pares, por lo que debe establecer esta opción en false.
```
datastax-java-driver {
basic.contact-points = [ "cassandra.us-east-2.amazonaws.com:9142"]
advanced.auth-provider{
class = PlainTextAuthProvider
username = "ServiceUserName"
password = "ServicePassword"
}
basic.load-balancing-policy {
local-datacenter = "us-east-2"
slow-replica-avoidance = false
}
advanced.ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./src/main/resources/cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
}
```
**nota**
En vez de añadir la ruta al trustStore en el archivo de configuración, también puede añadir la ruta al trustStore directamente en el código de la aplicación o a sus argumentos de la JVM.
### Paso 3: ejecutar el ejemplo de aplicación
Este ejemplo de código muestra una sencilla aplicación de línea de comandos que crea un grupo de conexión a Amazon Keyspaces utilizando el archivo de configuración se ha creado anteriormente. Confirma que se ha establecido la conexión ejecutando una consulta sencilla.
```
package ;
// add the following imports to your project
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
public class App
{
public static void main( String[] args )
{
//Use DriverConfigLoader to load your configuration file
DriverConfigLoader loader = DriverConfigLoader.fromClasspath("application.conf");
try (CqlSession session = CqlSession.builder()
.withConfigLoader(loader)
.build()) {
ResultSet rs = session.execute("select * from system_schema.keyspaces");
Row row = rs.one();
System.out.println(row.getString("keyspace_name"));
}
}
}
```
**nota**
Utilice un bloque `try` para establecer la conexión a fin de garantizar que siempre esté cerrada. Si no utilizas un bloque `try`, recuerde cerrar su conexión para evitar fugas de recursos.
## Step-by-step tutorial para conectarse a Amazon Keyspaces mediante el controlador DataStax Java 4.x para Apache Cassandra y el complemento de autenticación SigV4
En la siguiente sección se describe cómo utilizar el complemento de autenticación SigV4 para el controlador DataStax Java 4.x de código abierto para Apache Cassandra a fin de acceder a Amazon Keyspaces (para Apache Cassandra). [El complemento está disponible en el repositorio. GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin)
El complemento de autenticación SigV4 le permite utilizar credenciales de IAM para usuarios o roles al conectarse a Amazon Keyspaces. En vez de requerir un nombre de usuario y una contraseña, este complemento firma las solicitudes de la API utilizando claves de acceso. Para obtener más información, consulte [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
### Paso 1: requisitos previos
Para seguir este tutorial, necesita completar las siguientes tareas.
+ Si aún no lo ha hecho, cree credenciales para su usuario o rol de IAM; para ello, siga los pasos que se indican en [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md). En este tutorial se asume que las claves de acceso se almacenan como variables de entorno. Para obtener más información, consulte [Almacenamiento de claves de acceso para el acceso programático](aws.credentials.manage.md).
+ Añada el controlador DataStax Java para Apache Cassandra a su proyecto Java. Asegúrese de estar utilizando una versión de controlador compatible con Apache Cassandra 3.11.2. Para obtener más información, consulte la documentación del [controlador DataStax Java para Apache Cassandra](https://github.com/datastax/java-driver).
+ Añada el complemento de autenticación a su aplicación. El complemento de autenticación es compatible con la versión 4.x del controlador DataStax Java para Apache Cassandra. Si utiliza Apache Maven, o un sistema de compilación que pueda utilizar dependencias de Maven, añada las siguientes dependencias a su archivo `pom.xml`.
**importante**
[Sustituya la versión del complemento por la versión más reciente, tal y como se muestra en GitHub el repositorio.](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin#add-the-authentication-plugin-to-the-application)
```
software.aws.mcs
aws-sigv4-auth-cassandra-java-driver-plugin
4.0.9
```
### Paso 2: configurar el controlador
Puede especificar los ajustes del controlador DataStax Java Cassandra creando un archivo de configuración para su aplicación. Este archivo de configuración anula los ajustes predeterminados e indica al controlador que se conecte al punto de conexión del servicio de Amazon Keyspaces a través del puerto 9142. Para obtener una lista de los puntos de conexión de servicio disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
Cree un archivo de configuración y guárdelo en la carpeta de recursos de la aplicación; por ejemplo, `src/main/resources/application.conf`. Abra `application.conf` y añada los siguientes ajustes de configuración.
1. **Proveedor de autenticación**: establezca la `advanced.auth-provider.class` a una nueva instancia de `software.aws.mcs.auth.SigV4AuthProvider`. El SigV4 AuthProvider es el controlador de autenticación que proporciona el complemento para realizar la autenticación SigV4.
1. **Centro de datos local**: establezca el valor de `local-datacenter` a la región a la que se conecte. Por ejemplo, si la aplicación se conecta a `cassandra.us-east-2.amazonaws.com`, entonces establezca el centro de datos local en `us-east-2`. Para ver todos los disponibles Regiones de AWS, consulte. [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md) Configure `slow-replica-avoidance = false` para equilibrar la carga con respecto a todos los nodos disponibles.
1. **Idempotencia**: establezca el valor predeterminado de la aplicación `idempotence` para configurar el controlador para que siempre vuelva `true` a intentar las solicitudes fallidas. read/write/prepare/execute Esta es una práctica recomendada para las aplicaciones distribuidas que ayuda a administrar los errores transitorios reintentando las solicitudes fallidas.
1. **SSL/TLS**: para inicializar la configuración de SSLEngine fábrica, añada una sección en el archivo de configuración con una sola línea que especifique la clase con la que se especifica. `class = DefaultSslEngineFactory` Proporcione la ruta al archivo trustStore y la contraseña que creó anteriormente. Amazon Keyspaces no admite `hostname-validation` de pares, por lo que debe establecer esta opción en false.
1. **Conexiones**: cree al menos 3 conexiones locales por punto de conexión configurándolo en `local.size = 3`. Esta es una práctica recomendada que ayuda a su aplicación a administrar las sobrecargas y las ráfagas de tráfico. Para obtener más información sobre cómo calcular el número de conexiones locales por punto de conexión que necesita su aplicación en función de los patrones de tráfico esperados, consulte [Configuración de conexiones en Amazon Keyspaces](connections.md#connections.howtoconfigure).
1. **Política de reintentos**: implementa la política de reintentos de Amazon Keyspaces `AmazonKeyspacesExponentialRetryPolicy` en lugar de la política `DefaultRetryPolicy` que viene con el controlador de Cassandra. Esto le permite configurar el número de reintentos para la política `AmazonKeyspacesExponentialRetryPolicy` que mejor se adapte a sus necesidades. De forma predeterminada, el número de reintentos para la `AmazonKeyspacesExponentialRetryPolicy` está establecido en 3. Para obtener más información, consulte [Configuración de la política de reintentos para las conexiones en Amazon Keyspaces](connections.md#connections.retry-policies).
1. **Instrucciones preparadas**: configure `prepare-on-all-nodes` como false para optimizar el uso de la red.
```
datastax-java-driver {
basic {
contact-points = [ "cassandra.us-east-2.amazonaws.com:9142"]
request {
timeout = 2 seconds
consistency = LOCAL_QUORUM
page-size = 1024
default-idempotence = true
}
load-balancing-policy {
local-datacenter = "us-east-2"
class = DefaultLoadBalancingPolicy
slow-replica-avoidance = false
}
}
advanced {
auth-provider {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-2
}
ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./src/main/resources/cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
connection {
connect-timeout = 5 seconds
max-requests-per-connection = 512
pool {
local.size = 3
}
}
retry-policy {
class = com.aws.ssa.keyspaces.retry.AmazonKeyspacesExponentialRetryPolicy
max-attempts = 3
min-wait = 10 mills
max-wait = 100 mills
}
prepared-statements {
prepare-on-all-nodes = false
}
}
}
```
**nota**
En vez de añadir la ruta al trustStore en el archivo de configuración, también puede añadir la ruta al trustStore directamente en el código de la aplicación o a sus argumentos de la JVM.
### Paso 3: Ejecute la aplicación
Este ejemplo de código muestra una sencilla aplicación de línea de comandos que crea un grupo de conexión a Amazon Keyspaces utilizando el archivo de configuración se ha creado anteriormente. Confirma que se ha establecido la conexión ejecutando una consulta sencilla.
```
package ;
// add the following imports to your project
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
public class App
{
public static void main( String[] args )
{
//Use DriverConfigLoader to load your configuration file
DriverConfigLoader loader = DriverConfigLoader.fromClasspath("application.conf");
try (CqlSession session = CqlSession.builder()
.withConfigLoader(loader)
.build()) {
ResultSet rs = session.execute("select * from system_schema.keyspaces");
Row row = rs.one();
System.out.println(row.getString("keyspace_name"));
}
}
}
```
**nota**
Utilice un bloque `try` para establecer la conexión a fin de garantizar que siempre esté cerrada. Si no utilizas un bloque `try`, recuerde cerrar su conexión para evitar fugas de recursos.
## Conéctese a Amazon Keyspaces mediante el controlador DataStax Java 3.x para Apache Cassandra y el complemento de autenticación SigV4
En la siguiente sección, se describe cómo utilizar el complemento de autenticación SigV4 para el controlador DataStax Java 3.x de código abierto para que Apache Cassandra acceda a Amazon Keyspaces. [El complemento está disponible en el repositorio. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)
El complemento de autenticación SigV4 le permite utilizar credenciales de IAM para usuarios o roles al conectarse a Amazon Keyspaces. En vez de requerir un nombre de usuario y una contraseña, este complemento firma las solicitudes de la API utilizando claves de acceso. Para obtener más información, consulte [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
### Paso 1: requisitos previos
Para ejecutar este código de ejemplo, primero debe completar las siguientes tareas.
+ Cree credenciales para su usuario o rol de IAM; para ello, siga los pasos indicados en [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md). En este tutorial se asume que las claves de acceso se almacenan como variables de entorno. Para obtener más información, consulte [Almacenamiento de claves de acceso para el acceso programático](aws.credentials.manage.md).
+ Siga los pasos que se indican [Antes de empezar](#using_java_driver.BeforeYouBegin) para descargar los certificados digitales, convertirlos en archivos TrustStore y adjuntar el almacén de claves de los argumentos de la JVM a su aplicación.
+ Añada el controlador DataStax Java para Apache Cassandra a su proyecto Java. Asegúrese de estar utilizando una versión de controlador compatible con Apache Cassandra 3.11.2. Para obtener más información, consulte la documentación del [controlador DataStax Java para Apache Cassandra](https://github.com/datastax/java-driver).
+ Añada el complemento de autenticación a su aplicación. El complemento de autenticación es compatible con la versión 3.x del controlador DataStax Java para Apache Cassandra. Si utiliza Apache Maven, o un sistema de compilación que pueda utilizar dependencias de Maven, añada las siguientes dependencias a su archivo `pom.xml`. [Sustituya la versión del complemento por la versión más reciente, tal y como se muestra en GitHub el repositorio.](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)
```
software.aws.mcs
aws-sigv4-auth-cassandra-java-driver-plugin_3
3.0.3
```
### Paso 2: ejecute la aplicación
Este ejemplo de código muestra una sencilla aplicación de línea de comandos que crea un grupo de conexiones a Amazon Keyspaces. Confirma que se ha establecido la conexión ejecutando una consulta sencilla.
```
package ;
// add the following imports to your project
import software.aws.mcs.auth.SigV4AuthProvider;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
import com.datastax.driver.core.Session;
public class App
{
public static void main( String[] args )
{
String endPoint = "cassandra.us-east-2.amazonaws.com";
int portNumber = 9142;
Session session = Cluster.builder()
.addContactPoint(endPoint)
.withPort(portNumber)
.withAuthProvider(new SigV4AuthProvider("us-east-2"))
.withSSL()
.build()
.connect();
ResultSet rs = session.execute("select * from system_schema.keyspaces");
Row row = rs.one();
System.out.println(row.getString("keyspace_name"));
}
}
```
Notas de uso:
Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
Consulte el siguiente repositorio para obtener políticas, ejemplos y prácticas recomendadas útiles al utilizar el controlador Java con Amazon Keyspaces: [https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers).
# Uso de un controlador de cliente Python para Cassandra para acceder mediante programación a Amazon Keyspaces
En esta sección, le mostramos cómo conectarse a Amazon Keyspaces utilizando un controlador de cliente Python. Para proporcionar a los usuarios y a las aplicaciones credenciales de acceso programático a los recursos de Amazon Keyspaces, puede realizar cualquiera de las siguientes acciones:
+ Crear credenciales específicas del servicio que se vinculen a un usuario de AWS Identity and Access Management (IAM) específico.
+ Para mejorar la seguridad, recomendamos crear claves de acceso de IAM para los usuarios o roles de IAM que se utilicen en todos los AWS servicios. El complemento de autenticación SigV4 de Amazon Keyspaces para controladores de cliente de Cassandra habilita la autenticación de llamadas a Amazon Keyspaces utilizando claves de acceso de IAM en vez de nombre de usuario y contraseña. Para obtener más información, consulte [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Antes de empezar
](#using_python_driver.BeforeYouBegin)
+ [
## Conexión a Amazon Keyspaces mediante el controlador Python para Apache Cassandra y credenciales específicas del servicio
](#python_ssc)
+ [
## Conéctese a Amazon Keyspaces mediante el controlador de DataStax Python para Apache Cassandra y el complemento de autenticación SigV4
](#python_SigV4)
## Antes de empezar
Debe completar la siguiente tarea antes de comenzar.
Amazon Keyspaces requiere el uso de Seguridad de la capa de transporte (TLS) para ayudar a proteger las conexiones con los clientes. Para conectarse a Amazon Keyspaces mediante TLS, debe descargar los certificados digitales de Amazon y configurar el controlador de Python para que utilice TLS.
Descargue los siguientes certificados digitales y guarde los archivos de forma local o en su directorio principal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional, para compatibilidad con versiones anteriores)
Para descargar los certificados, puede usar los siguientes comandos.
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**nota**
Anteriormente, Amazon Keyspaces utilizaba certificados TLS anclados a la CA de clase 2 de Starfield. AWS está migrando todo Regiones de AWS a certificados emitidos bajo Amazon Trust Services (Amazon Root CAs 1—4). Durante esta transición, configure los clientes para que confíen tanto en la raíz CAs 1—4 de Amazon como en la raíz de Starfield para garantizar la compatibilidad en todas las regiones.
Combine todos los certificados descargados en un único `pem` archivo con el nombre de nuestros *keyspaces-bundle.pem* ejemplos. Puede hacerlo ejecutando el siguiente comando : Tome nota de la ruta al archivo, la necesitará más adelante.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Conexión a Amazon Keyspaces mediante el controlador Python para Apache Cassandra y credenciales específicas del servicio
En el siguiente ejemplo de código se muestra cómo conectarse a Amazon Keyspaces con un controlador de cliente Python y credenciales específicas del servicio.
```
from cassandra.cluster import Cluster
from ssl import SSLContext, PROTOCOL_TLSv1_2 , CERT_REQUIRED
from cassandra.auth import PlainTextAuthProvider
ssl_context = SSLContext(PROTOCOL_TLSv1_2 )
ssl_context.load_verify_locations('path_to_file/keyspaces-bundle.pem')
ssl_context.verify_mode = CERT_REQUIRED
auth_provider = PlainTextAuthProvider(username='ServiceUserName', password='ServicePassword')
cluster = Cluster(['cassandra.us-east-2.amazonaws.com'], ssl_context=ssl_context, auth_provider=auth_provider, port=9142)
session = cluster.connect()
r = session.execute('select * from system_schema.keyspaces')
print(r.current_rows)
```
Notas de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Sustitúyala por la ruta al archivo de certificado combinado guardado en el primer paso.
1. Asegúrese de que el nombre de usuario *ServiceUserName* y la contraseña que obtuvo al generar las credenciales específicas del servicio *ServicePassword* coinciden. Para ello, siga los pasos que se indican a continuación. [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
## Conéctese a Amazon Keyspaces mediante el controlador de DataStax Python para Apache Cassandra y el complemento de autenticación SigV4
En la siguiente sección, se muestra cómo utilizar el complemento de autenticación SigV4 para que el controlador DataStax Python de código abierto para Apache Cassandra acceda a Amazon Keyspaces (para Apache Cassandra).
Si aún no lo ha hecho, empiece creando las credenciales del rol de IAM; para ello, siga los pasos que se indican en [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md). En este tutorial se utilizan credenciales temporales que requieren un rol de IAM. Para obtener más información sobre credenciales temporales, consulte [Creación de credenciales temporales para conectarse a Amazon Keyspaces mediante un rol de IAM y el complemento SigV4](temporary.credentials.IAM.md).
A continuación, añada el complemento de autenticación SigV4 de Python a su entorno desde el [GitHub repositorio](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin).
```
pip install cassandra-sigv4
```
El siguiente ejemplo de código muestra cómo conectarse a Amazon Keyspaces mediante el controlador DataStax Python de código abierto para Cassandra y el complemento de autenticación SigV4. El plugin depende del AWS SDK para Python (Boto3). Utiliza `boto3.session` para obtener credenciales temporales.
```
from cassandra.cluster import Cluster
from ssl import SSLContext, PROTOCOL_TLSv1_2 , CERT_REQUIRED
from cassandra.auth import PlainTextAuthProvider
import boto3
from cassandra_sigv4.auth import SigV4AuthProvider
ssl_context = SSLContext(PROTOCOL_TLSv1_2)
ssl_context.load_verify_locations('path_to_file/keyspaces-bundle.pem')
ssl_context.verify_mode = CERT_REQUIRED
# use this if you want to use Boto to set the session parameters.
boto_session = boto3.Session(aws_access_key_id="AKIAIOSFODNN7EXAMPLE",
aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
aws_session_token="AQoDYXdzEJr...",
region_name="us-east-2")
auth_provider = SigV4AuthProvider(boto_session)
# Use this instead of the above line if you want to use the Default Credentials and not bother with a session.
# auth_provider = SigV4AuthProvider()
cluster = Cluster(['cassandra.us-east-2.amazonaws.com'], ssl_context=ssl_context, auth_provider=auth_provider,
port=9142)
session = cluster.connect()
r = session.execute('select * from system_schema.keyspaces')
print(r.current_rows)
```
Notas de uso:
1. Sustituya `"path_to_file/keyspaces-bundle.pem"` por la ruta al certificado guardado en el primer paso.
1. Asegúrate de que *aws\$1access\$1key\$1id**aws\$1secret\$1access\$1key*, y el *aws\$1session\$1token* coincidan con `Access Key``Secret Access Key`, y `Session Token` que obtuviste usando. `boto3.session` Para obtener más información, consulte la sección sobre [credenciales](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) en la *AWS SDK para Python (Boto3)*.
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
# Uso de un controlador de cliente Node.js para Cassandra para acceder mediante programación a Amazon Keyspaces
En esta sección le mostramos cómo conectarse a Amazon Keyspaces mediante un controlador de cliente Node.js. Para proporcionar a los usuarios y a las aplicaciones credenciales de acceso programático a los recursos de Amazon Keyspaces, puede realizar cualquiera de las siguientes acciones:
+ Crear credenciales específicas del servicio que se vinculen a un usuario de AWS Identity and Access Management (IAM) específico.
+ Para mejorar la seguridad, se recomienda crear claves de acceso de IAM para los usuarios o roles de IAM que se utilicen en todos los AWS servicios. El complemento de autenticación SigV4 de Amazon Keyspaces para controladores de cliente de Cassandra habilita la autenticación de llamadas a Amazon Keyspaces utilizando claves de acceso de IAM en vez de nombre de usuario y contraseña. Para obtener más información, consulte [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Antes de empezar
](#using_nodejs_driver.BeforeYouBegin)
+ [
## Conéctese a Amazon Keyspaces mediante el DataStax controlador Node.js para Apache Cassandra y credenciales específicas del servicio
](#nodejs_ssc)
+ [
## Conéctese a Amazon Keyspaces mediante el controlador DataStax Node.js para Apache Cassandra y el complemento de autenticación SigV4
](#nodejs_SigV4)
## Antes de empezar
Debe completar la siguiente tarea antes de comenzar.
Amazon Keyspaces requiere el uso de Seguridad de la capa de transporte (TLS) para ayudar a proteger las conexiones con los clientes. Para conectarse a Amazon Keyspaces mediante TLS, necesita descargar un certificado digital de Amazon y configurar el controlador Python para utilizar TLS.
Descargue los siguientes certificados digitales y guarde los archivos de forma local o en su directorio principal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional, para compatibilidad con versiones anteriores)
Para descargar los certificados, puede usar los siguientes comandos.
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**nota**
Anteriormente, Amazon Keyspaces utilizaba certificados TLS anclados a la CA de clase 2 de Starfield. AWS está migrando todo Regiones de AWS a certificados emitidos bajo Amazon Trust Services (Amazon Root CAs 1—4). Durante esta transición, configure los clientes para que confíen tanto en la raíz CAs 1—4 de Amazon como en la raíz de Starfield para garantizar la compatibilidad en todas las regiones.
Combine todos los certificados descargados en un único `pem` archivo con el nombre de nuestros *keyspaces-bundle.pem* ejemplos. Puede hacerlo ejecutando el siguiente comando : Tome nota de la ruta al archivo, la necesitará más adelante.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Conéctese a Amazon Keyspaces mediante el DataStax controlador Node.js para Apache Cassandra y credenciales específicas del servicio
Configure su controlador para que utilice el archivo de certificado combinado `keyspaces-bundle.pem` para TLS y autentique con credenciales específicas del servicio. Por ejemplo:
```
const cassandra = require('cassandra-driver');
const fs = require('fs');
const auth = new cassandra.auth.PlainTextAuthProvider('ServiceUserName', 'ServicePassword');
const sslOptions1 = {
ca: [
fs.readFileSync('path_to_file/keyspaces-bundle.pem', 'utf-8')],
host: 'cassandra.us-west-2.amazonaws.com',
rejectUnauthorized: true
};
const client = new cassandra.Client({
contactPoints: ['cassandra.us-west-2.amazonaws.com'],
localDataCenter: 'us-west-2',
authProvider: auth,
sslOptions: sslOptions1,
protocolOptions: { port: 9142 }
});
const query = 'SELECT * FROM system_schema.keyspaces';
client.execute(query)
.then( result => console.log('Row from Keyspaces %s', result.rows[0]))
.catch( e=> console.log(`${e}`));
```
Notas de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Sustitúyalo por la ruta al archivo de certificado combinado guardado en el primer paso.
1. Asegúrese de que el nombre de usuario *ServiceUserName* y la contraseña que obtuvo al generar las credenciales específicas del servicio *ServicePassword* coinciden. Para ello, siga los pasos que se indican a continuación. [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
## Conéctese a Amazon Keyspaces mediante el controlador DataStax Node.js para Apache Cassandra y el complemento de autenticación SigV4
En la siguiente sección, se muestra cómo utilizar el complemento de autenticación SigV4 para que el controlador DataStax Node.js de código abierto de Apache Cassandra acceda a Amazon Keyspaces (para Apache Cassandra).
Si aún no lo ha hecho, cree credenciales para su usuario o rol de IAM; para ello, siga los pasos que se indican en [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
[Agregue el complemento de autenticación SigV4 de Node.js a su aplicación desde el repositorio. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin) El complemento es compatible con la versión 4.x del controlador DataStax Node.js para Cassandra y depende del AWS SDK para Node.js. Utiliza `AWSCredentialsProvider` para obtener credenciales.
```
$ npm install aws-sigv4-auth-cassandra-plugin --save
```
En este ejemplo de código se muestra cómo configurar una instancia específica de una región de `SigV4AuthProvider` como proveedor de autenticación.
```
const cassandra = require('cassandra-driver');
const fs = require('fs');
const sigV4 = require('aws-sigv4-auth-cassandra-plugin');
const auth = new sigV4.SigV4AuthProvider({
region: 'us-west-2',
accessKeyId:'AKIAIOSFODNN7EXAMPLE',
secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'});
const sslOptions1 = {
ca: [
fs.readFileSync('path_to_file/keyspaces-bundle.pem', 'utf-8')],
host: 'cassandra.us-west-2.amazonaws.com',
rejectUnauthorized: true
};
const client = new cassandra.Client({
contactPoints: ['cassandra.us-west-2.amazonaws.com'],
localDataCenter: 'us-west-2',
authProvider: auth,
sslOptions: sslOptions1,
protocolOptions: { port: 9142 }
});
const query = 'SELECT * FROM system_schema.keyspaces';
client.execute(query).then(
result => console.log('Row from Keyspaces %s', result.rows[0]))
.catch( e=> console.log(`${e}`));
```
Notas de uso:
1. Sustituya `"path_to_file/keyspaces-bundle.pem"` por la ruta al certificado guardado en el primer paso.
1. Asegúrese de que la clave de acceso *accessKeyId* y la clave de acceso secreta *secretAccessKey* coincidan con la clave de acceso secreta que utilizó. `AWSCredentialsProvider` Para obtener más información, consulte [Configuración de credenciales en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html) en el *AWS SDK para JavaScript Node.js*.
1. Para almacenar las claves de acceso fuera del código, consulte las prácticas recomendadas en [Almacenamiento de claves de acceso para el acceso programático](aws.credentials.manage.md).
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
# Uso de un controlador de cliente .NET Core para Cassandra para acceder a Amazon Keyspaces mediante programación
En esta sección le mostramos cómo conectarse a Amazon Keyspaces mediante un controlador de cliente .NET Core. Los pasos de configuración varían en función de su entorno y del sistema operativo, por lo que es posible que tenga que modificarlos en consecuencia. Amazon Keyspaces requiere el uso de Seguridad de la capa de transporte (TLS) para ayudar a proteger las conexiones con los clientes. Para conectarse a Amazon Keyspaces mediante TLS, configure el controlador para que utilice el almacén de confianza del sistema, que incluye Amazon Root 1-4. CAs
1. Instale el CSharp controlador Cassandra a través de nuget, utilizando la consola nuget.
```
PM> Install-Package CassandraCSharpDriver
```
1. En el siguiente ejemplo se utiliza un proyecto de consola .NET Core C\$1 para conectarse a Amazon Keyspaces y ejecutar una consulta.
```
using Cassandra;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Security;
using System.Runtime.ConstrainedExecution;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
namespace CSharpKeyspacesExample
{
class Program
{
public Program(){}
static void Main(string[] args)
{
var userName = "ServiceUserName";
var pwd = "ServicePassword";
certCollection.Add(amazoncert);
var awsEndpoint = "cassandra.us-east-2.amazonaws.com" ;
var cluster = Cluster.Builder()
.AddContactPoints(awsEndpoint)
.WithPort(9142)
.WithAuthProvider(new PlainTextAuthProvider(userName, pwd))
.WithSSL(new SSLOptions().SetCertificateCollection(certCollection))
.Build();
var session = cluster.Connect();
var rs = session.Execute("SELECT * FROM system_schema.tables;");
foreach (var row in rs)
{
var name = row.GetValue("keyspace_name");
Console.WriteLine(name);
}
}
}
}
```
Notas de uso:
1. Asegúrese de utilizar el almacén de confianza del sistema predeterminado, que incluye Amazon Root CAs 1-4.
1. Asegúrese de que el nombre de usuario *ServiceUserName* y la contraseña que obtuvo al generar las credenciales específicas del servicio *ServicePassword* coinciden. Para ello, siga los pasos que se indican a continuación. [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
# Uso de un controlador de cliente Go para Cassandra para acceder a Amazon Keyspaces mediante programación
En esta sección le mostramos cómo conectarse a Amazon Keyspaces mediante un controlador de cliente Go para Cassandra. Para proporcionar a los usuarios y a las aplicaciones credenciales de acceso programático a los recursos de Amazon Keyspaces, puede realizar cualquiera de las siguientes acciones:
+ Crear credenciales específicas del servicio que se vinculen a un usuario de AWS Identity and Access Management (IAM) específico.
+ Para mejorar la seguridad, recomendamos crear claves de acceso de IAM para los directores de IAM que se utilicen en todos los servicios. AWS El complemento de autenticación SigV4 de Amazon Keyspaces para controladores de cliente de Cassandra habilita la autenticación de llamadas a Amazon Keyspaces utilizando claves de acceso de IAM en vez de nombre de usuario y contraseña. Para obtener más información, consulte [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Antes de empezar
](#using_go_driver.BeforeYouBegin)
+ [
## Conexión a Amazon Keyspaces mediante el controlador Gocql para Apache Cassandra y credenciales específicas del servicio
](#go_ssc)
+ [
## Conexión a Amazon Keyspaces mediante el controlador Go para Apache Cassandra y el complemento de autenticación SigV4
](#go_SigV4)
## Antes de empezar
Debe completar la siguiente tarea antes de comenzar.
Amazon Keyspaces requiere el uso de Seguridad de la capa de transporte (TLS) para ayudar a proteger las conexiones con los clientes. Para conectarse a Amazon Keyspaces mediante TLS, necesita descargar un certificado digital de Amazon y configurar el controlador Go para utilizar TLS.
Descargue los siguientes certificados digitales y guarde los archivos de forma local o en su directorio principal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional, para compatibilidad con versiones anteriores)
Para descargar los certificados, puede usar los siguientes comandos.
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**nota**
Anteriormente, Amazon Keyspaces utilizaba certificados TLS anclados a la CA de clase 2 de Starfield. AWS está migrando todo Regiones de AWS a certificados emitidos bajo Amazon Trust Services (Amazon Root CAs 1—4). Durante esta transición, configure los clientes para que confíen tanto en la raíz CAs 1—4 de Amazon como en la raíz de Starfield para garantizar la compatibilidad en todas las regiones.
Combine todos los certificados descargados en un único `pem` archivo con el nombre de nuestros *keyspaces-bundle.pem* ejemplos. Puede hacerlo ejecutando el siguiente comando : Tome nota de la ruta al archivo, la necesitará más adelante.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Conexión a Amazon Keyspaces mediante el controlador Gocql para Apache Cassandra y credenciales específicas del servicio
1. Cree un directorio para la aplicación.
```
mkdir ./gocqlexample
```
1. Vaya al nuevo directorio.
```
cd gocqlexample
```
1. Cree un archivo para su aplicación.
```
touch cqlapp.go
```
1. Descargue el controlador Go.
```
go get github.com/gocql/gocql
```
1. Añada el siguiente código de ejemplo al nuevo archivo.
```
package main
import (
"fmt"
"github.com/gocql/gocql"
"log"
)
func main() {
// add the Amazon Keyspaces service endpoint
cluster := gocql.NewCluster("cassandra.us-east-2.amazonaws.com")
cluster.Port=9142
// add your service specific credentials
cluster.Authenticator = gocql.PasswordAuthenticator{
Username: "ServiceUserName",
Password: "ServicePassword"}
// provide the path to the keyspaces-bundle.pem
cluster.SslOpts = &gocql.SslOptions{
CaPath: "path_to_file/keyspaces-bundle.pem",
EnableHostVerification: false,
}
// Override default Consistency to LocalQuorum
cluster.Consistency = gocql.LocalQuorum
cluster.DisableInitialHostLookup = false
session, err := cluster.CreateSession()
if err != nil {
fmt.Println("err>", err)
}
defer session.Close()
// run a sample query from the system keyspace
var text string
iter := session.Query("SELECT keyspace_name FROM system_schema.tables;").Iter()
for iter.Scan(&text) {
fmt.Println("keyspace_name:", text)
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
session.Close()
}
```
Notas de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Sustitúyala por la ruta al archivo de certificado combinado guardado en el primer paso.
1. Asegúrese de que el nombre de usuario *ServiceUserName* y la contraseña que obtuvo al generar las credenciales específicas del servicio *ServicePassword* coinciden. Para ello, siga los pasos que se indican a continuación. [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
1. Compile el programa.
```
go build cqlapp.go
```
1. Ejecute el programa.
```
./cqlapp
```
## Conexión a Amazon Keyspaces mediante el controlador Go para Apache Cassandra y el complemento de autenticación SigV4
El siguiente ejemplo de código muestra cómo utilizar el complemento de autenticación SigV4 para el controlador Go de código abierto para acceder a Amazon Keyspaces (para Apache Cassandra).
Si aún no lo ha hecho, cree credenciales para la entidad principal de IAM; para ello, siga los pasos que se indican en [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md). Si una aplicación se ejecuta en una instancia de Lambda o Amazon EC2, la aplicación utilizará automáticamente las credenciales de la instancia. Para ejecutar este tutorial de forma local, puede almacenar las credenciales como variables de entorno locales.
[Añada el complemento de autenticación Go SigV4 a su aplicación desde el repositorio. GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin) El complemento es compatible con la versión 1.2.x del controlador Go de código abierto para Cassandra y depende del SDK de Go AWS .
```
$ go mod init
$ go get github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin
```
En este ejemplo de código, el punto de conexión de Amazon Keyspaces está representado por la clase `Cluster`. Utiliza el `AwsAuthenticator` de la propiedad de autenticador del clúster para obtener las credenciales.
```
package main
import (
"fmt"
"github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin/sigv4"
"github.com/gocql/gocql"
"log"
)
func main() {
// configuring the cluster options
cluster := gocql.NewCluster("cassandra.us-west-2.amazonaws.com")
cluster.Port=9142
// the authenticator uses the default credential chain to find AWS credentials
cluster.Authenticator = sigv4.NewAwsAuthenticator()
cluster.SslOpts = &gocql.SslOptions{
CaPath: "path_to_file/keyspaces-bundle.pem",
EnableHostVerification: false,
}
cluster.Consistency = gocql.LocalQuorum
cluster.DisableInitialHostLookup = false
session, err := cluster.CreateSession()
if err != nil {
fmt.Println("err>", err)
return
}
defer session.Close()
// doing the query
var text string
iter := session.Query("SELECT keyspace_name FROM system_schema.tables;").Iter()
for iter.Scan(&text) {
fmt.Println("keyspace_name:", text)
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
}
```
Notas de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Sustitúyalo por la ruta al archivo de certificado guardado en el primer paso.
1. Para que este ejemplo se ejecute localmente, debe definir las siguientes variables como variables de entorno:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`
1. Para almacenar las claves de acceso fuera del código, consulte las prácticas recomendadas en [Almacenamiento de claves de acceso para el acceso programático](aws.credentials.manage.md).
1. Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
# Uso de un controlador de cliente Perl para Cassandra para acceder a Amazon Keyspaces mediante programación
En esta sección le mostramos cómo conectarse a Amazon Keyspaces mediante un controlador de cliente Perl. En este ejemplo de código, utilizamos Perl 5. Amazon Keyspaces requiere el uso de Seguridad de la capa de transporte (TLS) para ayudar a proteger las conexiones con los clientes.
**importante**
Los certificados de Amazon Keyspaces están pasando a la jerarquía de Amazon Trust Services (ATS). Asegúrese de que su entorno confíe en Amazon Root CAs 1—4 para evitar errores de conexión durante esta rotación. El controlador Perl no valida el certificado SSL de Amazon del servidor, lo que significa que no puede confirmar que se esté conectando a Amazon Keyspaces. El segundo paso, configurar el controlador para que utilice TLS al conectarse a Amazon Keyspaces, sigue siendo necesario y garantiza que los datos transferidos entre el cliente y el servidor estén cifrados.
1. Descargue el controlador DBI de Cassandra desde [https://metacpan.org/pod/DBD::Cassandra](https://metacpan.org/pod/DBD::Cassandra) e instale el controlador en su entorno Perl. Los pasos exactos dependen del entorno. El siguiente es un ejemplo común.
```
cpanm DBD::Cassandra
```
1. Cree un archivo para su aplicación.
```
touch cqlapp.pl
```
1. Añada el siguiente código de ejemplo al archivo cqlapp.
```
use DBI;
my $user = "ServiceUserName";
my $password = "ServicePassword";
my $db = DBI->connect("dbi:Cassandra:host=cassandra.us-east-2.amazonaws.com;port=9142;tls=1;",
$user, $password);
my $rows = $db->selectall_arrayref("select * from system_schema.keyspaces");
print "Found the following Keyspaces...\n";
for my $row (@$rows) {
print join(" ",@$row['keyspace_name']),"\n";
}
$db->disconnect;
```
**importante**
Asegúrese de que *ServicePassword* coincidan con el nombre de usuario y la contraseña que obtuvo al generar las credenciales específicas del servicio siguiendo los pasos que se indican a continuación. *ServiceUserName* [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md)
**nota**
Para obtener una lista de los puntos de conexión disponibles, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md).
1. Ejecute la aplicación .
```
perl cqlapp.pl
```