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.
# Tutorial: Carga de datos en Amazon Keyspaces mediante DSBulk
Este step-by-step tutorial le guía a través de la migración de datos de Apache Cassandra a Amazon Keyspaces mediante DataStax Bulk Loader () DSBulk disponible en. [GitHub](https://github.com/datastax/dsbulk.git) Su uso DSBulk es útil para cargar conjuntos de datos a Amazon Keyspaces con fines académicos o de prueba. Para obtener más información acerca de cómo migrar cargas de trabajo de producción, consulte [Proceso de migración sin conexión: de Apache Cassandra a Amazon Keyspaces](migrating-offline.md). En este tutorial, completará los siguientes pasos:
Requisitos previos: configurar una AWS cuenta con credenciales, crear un archivo de almacenamiento de confianza de JKS para el certificado, configurar`cqlsh`, descargar e instalar DSBulk y configurar un archivo. `application.conf`
1. **Creación del CSV de origen y la tabla de destino**: prepare un archivo CSV como datos de origen y cree el espacio de claves y la tabla de destino en Amazon Keyspaces.
1. **Preparación de los datos**: asigne al azar los datos del archivo CSV y analícelos para determinar el tamaño medio y máximo de las filas.
1. **Defina la capacidad de rendimiento**: calcule las unidades de capacidad de escritura necesarias (WCUs) en función del tamaño de los datos y el tiempo de carga deseado, y configure la capacidad aprovisionada de la tabla.
1. **Configure los DSBulk ajustes**: cree un archivo de DSBulk configuración con parámetros como la autenticación, el SSL/TLS, el nivel de coherencia y el tamaño del grupo de conexiones.
1. **Ejecute el comando DSBulk load**: ejecute el comando DSBulk load para cargar los datos del archivo CSV a la tabla Amazon Keyspaces y monitorizar el progreso.
**Topics**
+ [Requisitos previos: los pasos que debes completar antes de poder cargar datos con DSBulk](dsbulk-upload-prequs.md)
+ [Paso 1: Cree el archivo CSV de origen y una tabla de destino para la carga de datos mediante DSBulk](dsbulk-upload-source.md)
+ [Paso 2: Prepare los datos para cargarlos mediante DSBulk](dsbulk-upload-prepare-data.md)
+ [Paso 3: establecimiento de la capacidad de rendimiento de la tabla de destino](dsbulk-upload-capacity.md)
+ [Paso 4: configuración de los ajustes de `DSBulk` para cargar los datos del archivo CSV a la tabla de destino](dsbulk-upload-config.md)
+ [Paso 5: ejecución del comando DSBulk `load` para cargar los datos del archivo CSV a la tabla de destino](dsbulk-upload-run.md)
# Requisitos previos: los pasos que debes completar antes de poder cargar datos con DSBulk
Para poder comenzar el tutorial, antes debe completar las siguientes tareas.
1. Si aún no lo ha hecho, registre una AWS cuenta siguiendo los pasos que se indican en[Con AWS Identity and Access Management figuración](accessing.md#SettingUp.IAM).
1. Cree las credenciales; para ello, siga los pasos indicados en [Creación y configuración de AWS credenciales para Amazon Keyspaces](access.credentials.md).
1. Cree un archivo de almacén de confianza de JKS.
1. Descargue los siguientes certificados digitales y guarde los archivos localmente o en su directorio personal.
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. Configure la conexión del intérprete de comandos de Cassandra Query Language (cqlsh) y confirme que puede conectarse a Amazon Keyspaces siguiendo los pasos indicados en [Uso de `cqlsh` para conectarse a Amazon Keyspaces](programmatic.cqlsh.md).
1. Descarga e instala DSBulk.
**nota**
Es posible que la versión que se muestra en este tutorial no sea la última disponible. Antes de realizar la descarga DSBulk, consulte la [página de descarga de DataStax Bulk Loader](https://downloads.datastax.com/#bulk-loader) para ver la versión más reciente y actualice el número de versión en los siguientes comandos según corresponda.
1. Para descargar DSBulk, puede usar el siguiente código.
```
curl -OL https://downloads.datastax.com/dsbulk/dsbulk-1.8.0.tar.gz
```
1. A continuación, descomprima el archivo tar y DSBulk agréguelo al suyo `PATH` como se muestra en el siguiente ejemplo.
```
tar -zxvf dsbulk-1.8.0.tar.gz
# add the DSBulk directory to the path
export PATH=$PATH:./dsbulk-1.8.0/bin
```
1. Cree un `application.conf` archivo para almacenar la configuración que utilizará. DSBulk Puede guardar el siguiente ejemplo como `./dsbulk_keyspaces.conf`. Sustituya `localhost` por el punto de contacto de su clúster local de Cassandra si no se encuentra en el nodo local, por ejemplo, el nombre DNS o la dirección IP. Tome nota del nombre del archivo y de la ruta, dado que deberá especificarlos más adelante en el comando `dsbulk load`.
```
datastax-java-driver {
basic.contact-points = [ "localhost"]
advanced.auth-provider {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-1
}
}
```
1. Para habilitar la compatibilidad con SiGv4, descargue el `jar` archivo sombreado [GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/)y colóquelo en la DSBulk `lib` carpeta, como se muestra en el siguiente ejemplo.
```
curl -O -L https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/download/4.0.6-shaded-v2/aws-sigv4-auth-cassandra-java-driver-plugin-4.0.6-shaded.jar
```
# Paso 1: Cree el archivo CSV de origen y una tabla de destino para la carga de datos mediante DSBulk
En este tutorial, utilizamos un archivo de valores separados por comas (CSV) llamado `keyspaces_sample_table.csv` como archivo de origen para la migración de datos. El archivo de ejemplo proporcionado contiene algunas filas de datos de una tabla llamada `book_awards`.
1. Cree el archivo de origen. Puede elegir una de las siguientes opciones:
+ Descargue el archivo CSV de ejemplo (`keyspaces_sample_table.csv`), contenido en el siguiente archivo comprimido: [samplemigration.zip](samples/samplemigration.zip). Descomprima el archivo y tome nota de la ruta a `keyspaces_sample_table.csv`.
+ Para rellenar un archivo CSV de origen con sus propios datos almacenados en una base de datos de Apache Cassandra, utilice `dsbulk unload`, como se muestra en el siguiente ejemplo.
```
dsbulk unload -k mykeyspace -t mytable -f ./my_application.conf > keyspaces_sample_table.csv
```
Asegúrese de que el archivo CSV que cree satisfaga los siguientes requisitos:
+ La primera fila contiene los nombres de las columnas.
+ Los nombres de las columnas del archivo CSV de origen coinciden con los nombres de las columnas de la tabla de destino.
+ Los datos están delimitados con una coma.
+ Todos los valores de los datos son tipos de datos válidos de Amazon Keyspaces. Consulte [Tipos de datos](cql.elements.md#cql.data-types).
1. Cree el espacio de claves y la tabla de destino en Amazon Keyspaces.
1. Conéctese a Amazon Keyspaces con `cqlsh` y sustituya el punto de conexión del servicio, el nombre de usuario y la contraseña del siguiente ejemplo por sus propios valores.
```
cqlsh cassandra.us-east-1.amazonaws.com 9142 -u "111122223333" -p "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" --ssl
```
1. Cree un nuevo espacio de claves con el nombre `catalog` como se muestra en el siguiente ejemplo.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Una vez que el nuevo espacio de claves tenga el estado de disponible, utilice el siguiente código para crear la tabla de destino `book_awards`. Para obtener más información sobre la creación asíncrona de recursos y cómo comprobar si un recurso está disponible, consulte [Comprobación del estado de creación de los espacios de claves en Amazon Keyspaces](keyspaces-create.md).
```
CREATE TABLE catalog.book_awards (
year int,
award text,
rank int,
category text,
book_title text,
author text,
publisher text,
PRIMARY KEY ((year, award), category, rank)
);
```
Si Apache Cassandra es su origen de datos, una forma sencilla de crear la tabla de destino de Amazon Keyspaces con encabezados que coincidan es generar la instrucción `CREATE TABLE` a partir de la tabla de origen, como se muestra en la siguiente instrucción.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "DESCRIBE TABLE mykeyspace.mytable;"
```
A continuación, cree la tabla de destino en Amazon Keyspaces con los nombres de las columnas y los tipos de datos que coincidan con la descripción de la tabla de origen de Cassandra.
# Paso 2: Prepare los datos para cargarlos mediante DSBulk
La preparación de los datos de origen para una transferencia eficaz es un proceso de dos pasos. En primer lugar, usted aleatoriza los datos. En segundo lugar, usted analiza los datos para determinar los valores apropiados de los parámetros de `dsbulk` y los ajustes necesarios de la tabla.
**Aleatorización de los datos**
El comando `dsbulk` lee y escribe los datos en el mismo orden en que aparecen en el archivo CSV. Si utiliza el comando `dsbulk` para crear el archivo de origen, los datos se escriben en el orden en que aparecen ordenados por claves en el CSV. Internamente, Amazon Keyspaces divide los datos utilizando claves de partición. Si bien Amazon Keyspaces tiene una lógica integrada para ayudar a equilibrar la carga de las solicitudes de la misma clave de partición, la carga de datos es más rápida y eficiente si aleatoriza el orden. Esto se debe a que puede aprovechar el equilibrio de carga integrado que se produce cuando Amazon Keyspaces escribe en diferentes particiones.
Para repartir las escrituras entre las particiones de manera uniforme, debe aleatorizar los datos en el archivo de origen. Puede escribir una aplicación para hacerlo o utilizar una herramienta de código abierto, como [Shuf](https://en.wikipedia.org/wiki/Shuf). Shuf está disponible de forma gratuita en distribuciones Linux, en macOS (instalando coreutils en [homebrew](https://brew.sh)) y en Windows (utilizando Windows Subsystem for Linux [WSL]). Se requiere un paso adicional para evitar que la fila del encabezado con los nombres de las columnas se baraje en este paso.
Para aleatorizar el archivo de origen conservando el encabezado, introduzca el siguiente código.
```
tail -n +2 keyspaces_sample_table.csv | shuf -o keyspace.table.csv && (head -1 keyspaces_sample_table.csv && cat keyspace.table.csv ) > keyspace.table.csv1 && mv keyspace.table.csv1 keyspace.table.csv
```
Shuf reescribe los datos en un nuevo archivo CSV llamado `keyspace.table.csv`. Ahora puede eliminar el archivo `keyspaces_sample_table.csv`, dado que ya no lo necesita.
**Análisis de los datos**
Determine el tamaño medio y máximo de las filas analizando los datos.
Debe hacerlo por las siguientes razones:
+ El tamaño medio de fila ayuda a estimar la cantidad total de datos que se van a transferir.
+ Necesita el tamaño medio de fila para aprovisionar la capacidad de escritura necesaria para la carga de datos.
+ Puede asegurarse de que cada fila tenga un tamaño inferior a 1 MB, que es el tamaño máximo de fila en Amazon Keyspaces.
**nota**
Esta cuota se refiere al tamaño de fila, no al de la partición. A diferencia de las particiones de Apache Cassandra, las particiones de Amazon Keyspaces pueden tener un tamaño prácticamente ilimitado. Las claves de partición y las columnas de agrupación requieren almacenamiento adicional para los metadatos, que debe añadir al tamaño bruto de las filas. Para obtener más información, consulte [Estimación del tamaño de las filas en Amazon Keyspaces](calculating-row-size.md).
El siguiente código utiliza [AWK](https://en.wikipedia.org/wiki/AWK) para analizar un archivo CSV e imprimir el tamaño medio y máximo de las filas.
```
awk -F, 'BEGIN {samp=10000;max=-1;}{if(NR>1){len=length($0);t+=len;avg=t/NR;max=(len>max ? len : max)}}NR==samp{exit}END{printf("{lines: %d, average: %d bytes, max: %d bytes}\n",NR,avg,max);}' keyspace.table.csv
```
La ejecución de este código da como resultado la siguiente salida.
```
using 10,000 samples:
{lines: 10000, avg: 123 bytes, max: 225 bytes}
```
Asegúrese de que el tamaño máximo de su fila no supere 1 MB. De ser así, debe dividir la fila o comprimir los datos para que el tamaño de la fila sea inferior a 1 MB. En el siguiente paso de este tutorial, usted utiliza el tamaño medio de fila para aprovisionar la capacidad de escritura de la tabla.
# Paso 3: establecimiento de la capacidad de rendimiento de la tabla de destino
Este tutorial le muestra cómo ajustar la carga DSBulk de datos dentro de un rango de tiempo establecido. Dado que sabe de antemano cuántas lecturas y escrituras realiza, utilice el modo de capacidad aprovisionada. Una vez finalizada la transferencia de datos, debe ajustar el modo de capacidad de la tabla para que se adapte a los patrones de tráfico de su aplicación. Para obtener más información sobre administración de capacidad, consulte [Administración de recursos sin servidor en Amazon Keyspaces (para Apache Cassandra)](serverless_resource_management.md).
Con el modo de capacidad aprovisionada, usted especifica con antelación cuánta capacidad de lectura y escritura desea aprovisionar a su tabla. La capacidad de escritura se factura por hora y se mide en unidades de capacidad de escritura ()WCUs. Cada WCU es capacidad de escritura suficiente para admitir la escritura de 1 KB de datos por segundo. Al cargar los datos, la velocidad de escritura debe estar por debajo del máximo WCUs (parámetro:`write_capacity_units`) establecido en la tabla de destino.
De forma predeterminada, puedes aprovisionar WCUs hasta 40 000 en una tabla y 80 000 WCUs en todas las tablas de tu cuenta. Si necesita capacidad adicional, puede solicitar un aumento de cuota en la consola de [Service Quotas](https://console.aws.amazon.com/servicequotas/home#!/services/cassandra/quotas). Para obtener más información sobre las cuotas, consulte [Cuotas para Amazon Keyspaces (para Apache Cassandra)](quotas.md).
**Calcula la cantidad media WCUs necesaria para un encarte**
Insertar 1 KB de datos por segundo requiere 1 WCU. Si su archivo CSV tiene 360 000 filas y quiere cargar todos los datos en 1 hora, debe escribir 100 filas por segundo (360 000 filas / 60 minutos / 60 segundos = 100 filas por segundo). Si cada fila tiene hasta 1 KB de datos, para insertar 100 filas por segundo, debe aprovisionar 100 WCUs a la tabla. Si cada fila tiene 1,5 KB de datos, necesitará dos WCUs para insertar una fila por segundo. Por lo tanto, para insertar 100 filas por segundo, debe aprovisionar 200 WCUs.
Para determinar cuántas filas WCUs necesita insertar una fila por segundo, divida el tamaño medio de las filas en bytes entre 1024 y redondee al número entero más cercano.
Por ejemplo, si el tamaño medio de una fila es de 3000 bytes, necesitará tres WCUs para insertar una fila por segundo.
```
ROUNDUP(3000 / 1024) = ROUNDUP(2.93) = 3 WCUs
```
**Cálculo de capacidad y tiempo de carga de datos**
Ahora que conoce el tamaño y el número promedio de filas del archivo CSV, puede calcular cuántas WCUs necesita para cargar los datos en un período de tiempo determinado y el tiempo aproximado que se tarda en cargar todos los datos del archivo CSV con diferentes configuraciones de WCU.
Por ejemplo, si cada fila del archivo ocupa 1 KB y tiene 1 000 000 de filas en el archivo CSV, para cargar los datos en 1 hora, debe aprovisionar al menos 278 WCUs a la tabla para esa hora.
```
1,000,000 rows * 1 KBs = 1,000,000 KBs
1,000,000 KBs / 3600 seconds =277.8 KBs / second = 278 WCUs
```
**Configuración de los ajustes de capacidad aprovisionada**
Puede configurar los ajustes de capacidad de escritura de una tabla al crearla o mediante el comando `ALTER TABLE`. A continuación se muestra la sintaxis para modificar los ajustes de capacidad aprovisionada de una tabla con el comando `ALTER TABLE`.
```
ALTER TABLE catalog.book_awards WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Para ver la referencia completa del lenguaje, consulte [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) y [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Paso 4: configuración de los ajustes de `DSBulk` para cargar los datos del archivo CSV a la tabla de destino
En esta sección se describen los pasos necesarios DSBulk para configurar la carga de datos en Amazon Keyspaces. La configuración se DSBulk realiza mediante un archivo de configuración. Puede especificar el archivo de configuración directamente desde la línea de comandos.
1. Cree un archivo de DSBulk configuración para la migración a Amazon Keyspaces; en este ejemplo, utilizamos el nombre del archivo. `dsbulk_keyspaces.conf` Especifique los siguientes ajustes en el archivo de DSBulk configuración.
1. *`PlainTextAuthProvider`*: cree el proveedor de autenticación con la clase `PlainTextAuthProvider`. `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 en [Creación de credenciales para el acceso programático a Amazon Keyspaces](programmatic.credentials.md).
1. *`local-datacenter`*— Defina el valor `local-datacenter` al valor al Región de AWS que se está conectando. Por ejemplo, si la aplicación se conecta a `cassandra.us-east-1.amazonaws.com`, entonces establezca el centro de datos local en `us-east-1`. Para ver todas las opciones disponibles Regiones de AWS, consulte[Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md). Para evitar réplicas, establezca `slow-replica-avoidance` en `false`.
1. *`SSLEngineFactory`*: para configurar SSL/TLS, inicialice la `SSLEngineFactory` añadiendo una sección en el archivo de configuración con una sola línea que especifique la clase con `class = DefaultSslEngineFactory`. Proporcione la ruta a `cassandra_truststore.jks` y la contraseña que creó anteriormente.
1. *`consistency`*: establezca el nivel de coherencia en `LOCAL QUORUM`. No se admiten otros niveles de coherencia de escritura. Para obtener más información consulte [Niveles de coherencia de lectura y escritura de Apache Cassandra admitidos y costos asociados](consistency.md).
1. El número de conexiones por grupo es configurable en el controlador Java. Para este ejemplo, establezca `advanced.connection.pool.local.size` en 3.
A continuación se muestra el archivo de configuración de ejemplo completo.
```
datastax-java-driver {
basic.contact-points = [ "cassandra.us-east-1.amazonaws.com:9142"]
advanced.auth-provider {
class = PlainTextAuthProvider
username = "ServiceUserName"
password = "ServicePassword"
}
basic.load-balancing-policy {
local-datacenter = "us-east-1"
slow-replica-avoidance = false
}
basic.request {
consistency = LOCAL_QUORUM
default-idempotence = true
}
advanced.ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
advanced.connection.pool.local.size = 3
}
```
1. Revise los parámetros del DSBulk `load` comando.
1. *`executor.maxPerSecond`*: el número máximo de filas que el comando de carga intenta procesar concurrentemente por segundo. Si no se establece, este parámetro se deshabilita con -1.
`executor.maxPerSecond`Configúrelo en función del número de los WCUs que haya aprovisionado en la tabla de destino de destino. El valor `executor.maxPerSecond` del comando `load` no es un límite, es una media objetivo. Esto significa que puede (y a menudo lo hace) dispararse por encima del número que usted fije. Para tener en cuenta los picos y asegurarse de que exista capacidad suficiente para gestionar las solicitudes de carga de datos, establezca `executor.maxPerSecond` en el 90 % de la capacidad de escritura de la tabla.
```
executor.maxPerSecond = WCUs * .90
```
En este tutorial, establecemos `executor.maxPerSecond` en 5.
**nota**
Si utiliza la DSBulk versión 1.6.0 o una versión superior, puede `dsbulk.engine.maxConcurrentQueries` utilizarla en su lugar.
1. Configure estos parámetros adicionales para el DSBulk `load` comando.
+ *`batch-mode`*: este parámetro indica al sistema que agrupe las operaciones por clave de partición. Recomendamos deshabilitar el modo por lotes, ya que puede provocar situaciones de sobrecarga de claves y provocar `WriteThrottleEvents`.
+ *`driver.advanced.retry-policy-max-retries`*: determina cuántas veces se debe reintentar una consulta fallida. Si no se establece, el valor predeterminado es 10. Puede ajustar este valor según sea necesario.
+ *`driver.basic.request.timeout`*: el tiempo en minutos que el sistema espera el regreso de una consulta. Si no se establece, el valor predeterminado es “5 minutos”. Puede ajustar este valor según sea necesario.
# Paso 5: ejecución del comando DSBulk `load` para cargar los datos del archivo CSV a la tabla de destino
En el último paso de este tutorial, cargará los datos en Amazon Keyspaces.
Para ejecutar el comando DSBulk `load`, complete los siguientes pasos.
1. Ejecute el siguiente código para cargar los datos de su archivo csv en su tabla de Amazon Keyspaces. Asegúrese de actualizar la ruta al archivo de configuración de la aplicación que creó anteriormente.
```
dsbulk load -f ./dsbulk_keyspaces.conf --connector.csv.url keyspace.table.csv -header true --batch.mode DISABLED --executor.maxPerSecond 5 --driver.basic.request.timeout "5 minutes" --driver.advanced.retry-policy.max-retries 10 -k catalog -t book_awards
```
1. La salida incluye la ubicación de un archivo de registro que detalla las operaciones exitosas y fallidas. El archivo se almacena en el siguiente directorio.
```
Operation directory: /home/user_name/logs/UNLOAD_20210308-202317-801911
```
1. Las entradas del archivo de registro incluirán métricas, como se muestra en el siguiente ejemplo. Compruebe que el número de filas sea coherente con el número de filas de su archivo csv.
```
total | failed | rows/s | p50ms | p99ms | p999ms
200 | 0 | 200 | 21.63 | 21.89 | 21.89
```
**importante**
Ahora que ha transferido los datos, ajuste la configuración de modo de capacidad de su tabla de destino para que coincida con los patrones de tráfico habituales de su aplicación. Incurrirá en cargos según la tarifa horaria de su capacidad aprovisionada hasta que la modifique. Para obtener más información, consulte [Configurar los modos de read/write capacidad en Amazon Keyspaces](ReadWriteCapacityMode.md).