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. # Selección de la herramienta adecuada para cargar o migrar datos por lotes a Amazon Keyspaces En esta sección, revisará las diferentes herramientas que puede utilizar para cargar o migrar datos por lotes a Amazon Keyspaces y aprenderá a seleccionar la herramienta correcta en función de sus necesidades. Además, en esta sección se proporciona información general y casos de uso de los step-by-step tutoriales disponibles que muestran cómo importar datos a Amazon Keyspaces. Para revisar las estrategias disponibles para migrar cargas de trabajo de Apache Cassandra a Amazon Keyspaces, consulte [Creación de un plan de migración para migrar de Apache Cassandra a Amazon Keyspaces](migrating-cassandra.md). + **Herramientas de migración** + Con la [calculadora de precios de Amazon Keyspaces (para Apache Cassandra)](https://aws-samples.github.io/sample-pricing-calculator-for-keyspaces/#cassandra) disponible en Github, puede estimar los costes mensuales de Amazon Keyspaces en función de su carga de trabajo actual de Apache Cassandra. Introduzca las métricas del resultado de estado de Cassandra nodetool y de la configuración sin servidor prevista para Amazon Keyspaces a fin de comparar los costes directos entre las dos soluciones. Tenga en cuenta que esta calculadora se centra únicamente en los costes operativos de Amazon Keyspaces en comparación con su implementación actual de Cassandra. No incluye los factores del costo total de propiedad (TCO), como el mantenimiento de la infraestructura, los gastos operativos o los costos de soporte de Cassandra. + Proxy de **escritura doble de ZDM para la migración de Amazon Keyspaces: el proxy** de escritura doble de ZDM, disponible [en](https://github.com/aws-samples/amazon-keyspaces-examples/blob/main/migration/online/zdm-proxy/README.md) Github, permite la migración sin tiempo de inactividad de Apache Cassandra a Amazon Keyspaces. + **CQLReplicator**— CQLReplicator es una utilidad de código abierto disponible en [Github](https://github.com/aws-samples/cql-replicator) que le ayuda a migrar datos de Apache Cassandra a Amazon Keyspaces casi en tiempo real. Para obtener más información, consulte [Migre los datos mediante CQLReplicator](migration-hybrid-cql-rep.md). + Para obtener más información sobre cómo usar Amazon Managed Streaming para Apache Kafka para implementar un proceso de [migración en línea](migrating-online.md) con escrituras duales, consulte [Guidance for continuous data migration from Apache Cassandra to Amazon Keyspaces](https://aws.amazon.com/solutions/guidance/continuous-data-migration-from-apache-cassandra-to-amazon-keyspaces/). + Para migraciones grandes, considere la posibilidad de utilizar una herramienta de extracción, transformación y carga (ETL). Puede utilizar AWS Glue para realizar migraciones de transformación de datos de forma rápida y eficaz. Para obtener más información, consulte [Proceso de migración sin conexión: de Apache Cassandra a Amazon Keyspaces](migrating-offline.md). + Para obtener información sobre cómo utilizar el conector Apache Cassandra Spark para escribir datos en Amazon Keyspaces, consulte [Tutorial: Intégrelo con Apache Spark para importar o exportar datos](spark-integrating.md). + Comience sin demora a cargar datos en Amazon Keyspaces con el comando `COPY FROM` de cqlsh. cqlsh se incluye con Apache Cassandra y es el más adecuado para cargar pequeños conjuntos de datos o datos de prueba. Para obtener step-by-step instrucciones, consulte. [Tutorial: Carga de datos en Amazon Keyspaces utilizando cqlsh](bulk-upload.md) + También puede usar DataStax Bulk Loader for Apache Cassandra para cargar datos en Amazon Keyspaces mediante `dsbulk` el comando. DSBulk[proporciona capacidades de importación más sólidas que cqlsh y está disponible en el repositorio. GitHub ](https://github.com/datastax/dsbulk) Para obtener step-by-step instrucciones, consulte. [Tutorial: Carga de datos en Amazon Keyspaces mediante DSBulk](dsbulk-upload.md) Consideraciones generales para la carga de datos a Amazon Keyspaces + **Divida la carga de datos en componentes más pequeños.** Considere las siguientes unidades de migración y su huella potencial en términos de tamaño de datos en bruto. Cargar cantidades más pequeñas de datos en una o varias fases puede ayudar a simplificar su migración. + **Por clúster**: migre todos sus datos de Cassandra a la vez. Este enfoque podría ser adecuado para clústeres pequeños. + **Por espacio de claves o tabla**: divida su migración en grupos de espacios de claves o tablas. Este enfoque puede ayudarle a migrar los datos por fases en función de sus necesidades para cada carga de trabajo. + **Por datos**: considere la posibilidad de migrar los datos de un grupo específico de usuarios o productos, para reducir aún más el tamaño de los datos. + **Priorice qué datos cargar primero en función de la simplicidad.** Considere si tiene datos que podrían migrarse primero con más facilidad; por ejemplo, datos que no cambien durante horas específicas, datos de trabajos por lotes nocturnos, datos que no se utilicen durante horas sin conexión o datos de aplicaciones internas. **Topics** + [Tutorial: Carga de datos en Amazon Keyspaces utilizando cqlsh](bulk-upload.md) + [Tutorial: Carga de datos en Amazon Keyspaces mediante DSBulk](dsbulk-upload.md) # Tutorial: Carga de datos en Amazon Keyspaces utilizando cqlsh En este tutorial le guiaremos en el proceso de migración de datos de Apache Cassandra a Amazon Keyspaces utilizando el comando `cqlsh COPY FROM`. El comando `cqlsh COPY FROM` resulta útil para cargar rápida y fácilmente pequeños 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: configure una AWS cuenta con credenciales, cree un archivo de almacén de confianza JKS para el certificado y configúrelo para conectarse `cqlsh` a Amazon Keyspaces. 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. **Configuración de los parámetros cqlsh**: determine los valores óptimos para los parámetros `cqlsh COPY FROM` como `INGESTRATE`, `NUMPROCESSES`, `MAXBATCHSIZE` y `CHUNKSIZE` para distribuir la carga de trabajo de manera uniforme. 1. **Ejecución del comando `cqlsh COPY FROM`**: ejecute el comando `cqlsh COPY FROM` para cargar los datos del archivo CSV a la tabla de Amazon Keyspaces y supervise el progreso. Solución de problemas: resuelva problemas comunes, como solicitudes no válidas, errores del analizador, errores de capacidad y errores de cqlsh durante el proceso de carga de datos. **Topics** + [Requisitos previos: pasos que debe completar antes de poder cargar datos mediante `cqlsh COPY FROM`](bulk-upload-prequs.md) + [Paso 1: creación del archivo CSV de origen y de una tabla de destino para la carga de datos](bulk-upload-source.md) + [Paso 2: preparación de los datos de origen para una carga de datos correcta](bulk-upload-prepare-data.md) + [Paso 3: Establecer la capacidad de rendimiento de la tabla](bulk-upload-capacity.md) + [Paso 4: Configurar los ajustes de `cqlsh COPY FROM`](bulk-upload-config.md) + [Paso 5: ejecución del comando `cqlsh COPY FROM` para cargar los datos del archivo CSV a la tabla de destino](bulk-upload-run.md) + [Resolución de problemas](bulk-upload-troubleshooting.md) # Requisitos previos: pasos que debe completar antes de poder cargar datos mediante `cqlsh COPY FROM` Para poder comenzar el tutorial, antes debe completar las siguientes tareas. 1. Si aún no lo ha hecho, inscríbase en una Cuenta de AWS siguiendo los pasos que se indican en. [Con AWS Identity and Access Management figuración](accessing.md#SettingUp.IAM) 1. Cree las credenciales específicas del servicio; para ello, siga los pasos indicados en [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md). 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). # Paso 1: creación del archivo CSV de origen y de una tabla de destino para la carga de datos 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 la instrucción `cqlsh` `COPY TO`, como se muestra en el siguiente ejemplo. ``` cqlsh localhost 9042 -u "username" -p "password" --execute "COPY mykeyspace.mytable TO 'keyspaces_sample_table.csv' WITH HEADER=true"; ``` 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, utilice el siguiente código para crear la tabla de destino `book_awards`. ``` 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: preparación de los datos de origen para una carga de datos correcta La preparación de los datos de origen para una transferencia eficaz es un proceso de dos pasos. En primer lugar, asigna al azar los datos. En segundo lugar, analiza los datos para determinar los valores apropiados del parámetro `cqlsh` y los ajustes necesarios de la tabla para garantizar que la carga de datos se realice correctamente. **Asignación al azar de los datos** El comando `cqlsh COPY FROM` lee y escribe los datos en el mismo orden en que aparecen en el archivo CSV. Si utiliza el comando `cqlsh COPY TO` 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} ``` El tamaño medio de fila se utiliza en el siguiente paso de este tutorial para aprovisionar la capacidad de escritura de la tabla. # Paso 3: Establecer la capacidad de rendimiento de la tabla En este tutorial se muestra cómo ajustar cqlsh para que cargue los datos dentro de un intervalo 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 asignar 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 CQL `ALTER TABLE`. A continuación se muestra la sintaxis para modificar los ajustes de capacidad aprovisionada de una tabla con la instrucción CQL `ALTER TABLE`. ``` ALTER TABLE mykeyspace.mytable WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ; ``` Para ver la referencia completa del lenguaje, consulte [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter). # Paso 4: Configurar los ajustes de `cqlsh COPY FROM` En esta sección se describe cómo determinar los valores de los parámetros para `cqlsh COPY FROM`. El comando `cqlsh COPY FROM` lee el archivo CSV que preparó anteriormente e inserta los datos en Amazon Keyspaces mediante CQL. El comando divide las filas y distribuye las operaciones `INSERT` entre un conjunto de trabajadores. Cada trabajador establece una conexión con Amazon Keyspaces y envía solicitudes `INSERT` por este canal. El comando `cqlsh COPY` no dispone de lógica interna para distribuir el trabajo de manera uniforme entre sus trabajadores. Sin embargo, puede configurarlo manualmente para asegurarse de que el trabajo se distribuya uniformemente. Para comenzar, revise estos parámetros clave de cqlsh: + **DELIMITER**: si ha utilizado un delimitador distinto de la coma, puede configurar este parámetro, que por defecto es la coma. + **INGESTRATE**: el número objetivo de filas que `cqlsh COPY FROM` intenta procesar por segundo. Si no se establece, su valor predeterminado es 100 000. + **NUMPROCESSES**: el número de procesos de trabajadores subordinados que cqlsh crea para las tareas `COPY FROM`. El valor máximo para este ajuste es 16, el valor predeterminado es `num_cores - 1`, donde `num_cores` es el número de núcleos de procesamiento en el host que ejecuta cqlsh. + **MAXBATCHSIZE**: el tamaño del lote determina el número máximo de filas insertadas en la tabla de destino en un único lote. Si no se establece, cqlsh utiliza lotes de 20 filas insertadas. + **CHUNKSIZE**: el tamaño de la unidad de trabajo que pasa al trabajador subordinado. De forma predeterminada, se establece en 5000. + **MAXATTEMPTS** el número máximo de veces que se debe reintentar un bloque de trabajador fallido. Una vez alcanzado el máximo de intentos, los registros fallidos se escriben en un nuevo archivo CSV que puede volver a ejecutar más tarde tras investigar el fallo. `INGESTRATE`Establézcalo en función de la cantidad WCUs que hayas aprovisionado en la tabla de destino de destino. El valor `INGESTRATE` del comando `cqlsh COPY FROM` 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 `INGESTRATE` en el 90 % de la capacidad de escritura de la tabla. ``` INGESTRATE = WCUs * .90 ``` A continuación, fije el parámetro `NUMPROCESSES` en uno menos que el número de núcleos de su sistema. Para averiguar el número de núcleos de su sistema, puede ejecutar el siguiente código. ``` python -c "import multiprocessing; print(multiprocessing.cpu_count())" ``` En este tutorial, utilizamos el siguiente valor. ``` NUMPROCESSES = 4 ``` Cada proceso crea un trabajador, y cada trabajador establece una conexión con Amazon Keyspaces. Amazon Keyspaces puede admitir hasta 3000 solicitudes CQL por segundo en cada conexión. Esto significa que debe asegurarse de que cada trabajador procese menos de 3000 solicitudes por segundo. Al igual que con `INGESTRATE`, los trabajadores suelen dispararse por encima del número que usted establezca y no están limitados por segundos de reloj. Por tanto, para tener en cuenta los picos, establezca sus parámetros de cqlsh para que cada trabajador procese 2500 solicitudes por segundo. Para calcular la cantidad de trabajo distribuida a un trabajador, utilice la siguiente pauta. + Divida `INGESTRATE` por `NUMPROCESSES`. + Si `INGESTRATE` / `NUMPROCESSES` > 2500, disminuya el valor `INGESTRATE` para que esta fórmula se cumpla. ``` INGESTRATE / NUMPROCESSES <= 2,500 ``` Antes de configurar los ajustes para optimizar la carga de nuestros datos de ejemplo, revisemos los ajustes predeterminados de `cqlsh` y veamos cómo afecta su uso al proceso de carga de datos. Dado que `cqlsh COPY FROM` utiliza el valor `CHUNKSIZE` a fin de crear bloques de trabajo (instrucciones `INSERT`) para distribuir a los trabajadores, el trabajo no se distribuye automáticamente de manera uniforme. Algunos trabajadores podrían permanecer inactivos, en función del ajuste de `INGESTRATE`. Para distribuir el trabajo de manera uniforme entre los trabajadores y mantener a cada trabajador en la tasa óptima de 2500 solicitudes por segundo, debe establecer `CHUNKSIZE`, `MAXBATCHSIZE` y `INGESTRATE` cambiando los parámetros de entrada. Para optimizar la utilización del tráfico de red durante la carga de datos, elija un valor para `MAXBATCHSIZE` que se acerque al valor máximo de 30. Al cambiar `CHUNKSIZE` a 100 y `MAXBATCHSIZE` a 25, las 10 000 filas se reparten uniformemente entre los cuatro trabajadores (10 000 / 2500 = 4). El siguiente ejemplo de código lo ilustra. ``` INGESTRATE = 10,000 NUMPROCESSES = 4 CHUNKSIZE = 100 MAXBATCHSIZE. = 25 Work Distribution: Connection 1 / Worker 1 : 2,500 Requests per second Connection 2 / Worker 2 : 2,500 Requests per second Connection 3 / Worker 3 : 2,500 Requests per second Connection 4 / Worker 4 : 2,500 Requests per second ``` En resumen, utilice las siguientes fórmulas al establecer los parámetros de `cqlsh COPY FROM`: + **INGESTRATE** = write\$1capacity\$1units \$1 .90 + **NUMPROCESSES** = num\$1cores -1 (predeterminado) + **INGESTRATE / NUMPROCESSES** = 2500 (Esta debe ser una instrucción true) + **MAXBATCHSIZE** = 30 (De forma predeterminada, 20. Amazon Keyspaces acepta lotes de hasta 30) + **CHUNKSIZE** = (INGESTRATE / NUMPROCESSES) / MAXBATCHSIZE Ahora que ha calculado `NUMPROCESSES`, `INGESTRATE` y `CHUNKSIZE`, está listo para cargar sus datos. # Paso 5: ejecución del comando `cqlsh COPY FROM` para cargar los datos del archivo CSV a la tabla de destino Para ejecutar el comando `cqlsh COPY FROM`, complete los siguientes pasos. 1. Conéctese a Amazon Keyspaces con cqlsh. 1. Elija su espacio de claves con el siguiente código. ``` USE catalog; ``` 1. Establezca la coherencia de escritura en `LOCAL_QUORUM`. Para garantizar la durabilidad de los datos, Amazon Keyspaces no permite otras configuraciones de coherencia de escritura. Consulte el código siguiente. ``` CONSISTENCY LOCAL_QUORUM; ``` 1. Prepare su sintaxis de `cqlsh COPY FROM` utilizando el siguiente ejemplo de código. ``` COPY book_awards FROM './keyspace.table.csv' WITH HEADER=true AND INGESTRATE=calculated ingestrate AND NUMPROCESSES=calculated numprocess AND MAXBATCHSIZE=20 AND CHUNKSIZE=calculated chunksize; ``` 1. Ejecute la instrucción preparada en el paso anterior. cqlsh le devuelve un eco con todos los ajustes que haya configurado. 1. Asegúrese de que los ajustes coincidan con los que ha introducido. Consulte el siguiente ejemplo. ``` Reading options from the command line: {'chunksize': '120', 'header': 'true', 'ingestrate': '36000', 'numprocesses': '15', 'maxbatchsize': '20'} Using 15 child processes ``` 1. Revise el número de filas transferidas y la tasa media actual, como se muestra en el siguiente ejemplo. ``` Processed: 57834 rows; Rate: 6561 rows/s; Avg. rate: 31751 rows/s ``` 1. Cuando cqlsh haya terminado de cargar los datos, revise el resumen de las estadísticas de carga de datos (el número de archivos leídos, el tiempo de ejecución y las filas omitidas), como se muestra en el siguiente ejemplo. ``` 15556824 rows imported from 1 files in 8 minutes and 8.321 seconds (0 skipped). ``` En este último paso del tutorial, ha cargado los datos en Amazon Keyspaces. **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. # Resolución de problemas Una vez finalizada la carga de datos, compruebe si se han omitido filas. Para ello, navegue hasta el directorio de origen del archivo CSV de origen y busque un archivo con el siguiente nombre. ``` import_yourcsvfilename.err.timestamp.csv ``` cqlsh escribe las filas de datos omitidas en un archivo con ese nombre. Si el archivo existe en su directorio de origen y contiene datos, estas filas no se cargaron en Amazon Keyspaces. Para reintentar estas filas, compruebe primero si se ha producido algún error durante la carga y ajuste los datos en consecuencia. Para reintentar estas filas, puede volver a ejecutar el proceso. **Errores comunes** Los motivos más comunes por los que no se cargan las filas son errores de capacidad y errores de análisis sintáctico. **Errores de solicitud no válida al cargar datos en Amazon Keyspaces** En el siguiente ejemplo, la tabla de origen contiene una columna de contador, lo que da lugar a llamadas por lotes registradas con el comando `COPY` de cqlsh. Amazon Keyspaces no admite llamadas por lotes registradas. ``` Failed to import 10 rows: InvalidRequest - Error from server: code=2200 [Invalid query] message=“Only UNLOGGED Batches are supported at this time.“, will retry later, attempt 22 of 25 ``` Para resolver este error, usa DSBulk para migrar los datos. Para obtener más información, consulte [Tutorial: Carga de datos en Amazon Keyspaces mediante DSBulk](dsbulk-upload.md). **Errores del analizador de sintaxis al cargar datos en Amazon Keyspaces** El siguiente ejemplo muestra una fila omitida debido a un `ParseError`. ``` Failed to import 1 rows: ParseError - Invalid ... – ``` Para resolver este error, debe asegurarse de que los datos que se vayan a importar coincidan con el esquema de la tabla en Amazon Keyspaces. Revise el archivo de importación en busca de errores de análisis sintáctico. Puede intentar utilizar una única fila de datos mediante una instrucción `INSERT` para aislar el error. **Errores de capacidad al cargar datos en Amazon Keyspaces** ``` Failed to import 1 rows: WriteTimeout - Error from server: code=1100 [Coordinator node timed out waiting for replica nodes' responses] message="Operation timed out - received only 0 responses." info={'received_responses': 0, 'required_responses': 2, 'write_type': 'SIMPLE', 'consistency': 'LOCAL_QUORUM'}, will retry later, attempt 1 of 100 ``` Amazon Keyspaces utiliza las excepciones `ReadTimeout` y `WriteTimeout` para indicar cuándo falla una solicitud de escritura debido a una capacidad de rendimiento insuficiente. Para ayudar a diagnosticar las excepciones de capacidad insuficiente, Amazon Keyspaces publica `WriteThrottleEvents` y elabora `ReadThrottledEvents` métricas en Amazon. CloudWatch Para obtener más información, consulte [Supervisión de Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md). **Errores de cqlsh al cargar datos en Amazon Keyspaces** Como ayuda para solucionar los errores de cqlsh, vuelva a ejecutar el comando que falla con la bandera `--debug`. En caso de utilizar una versión incompatible de cqlsh, verá el siguiente error. ``` AttributeError: 'NoneType' object has no attribute 'is_up' Failed to import 3 rows: AttributeError - 'NoneType' object has no attribute 'is_up', given up after 1 attempts ``` Confirme que la versión de cqlsh instalada sea correcta; para ello, ejecute el siguiente comando. ``` cqlsh --version ``` Debería ver algo similar a lo siguiente como salida. ``` cqlsh 5.0.1 ``` Si utiliza Windows, sustituya todas las instancias de `cqlsh` con `cqlsh.bat`. Por ejemplo, para comprobar la versión de cqlsh en Windows, ejecute el siguiente comando. ``` cqlsh.bat --version ``` La conexión a Amazon Keyspaces falla una vez que el cliente cqlsh recibe tres errores consecutivos de cualquier tipo procedentes del servidor. El cliente cqlsh falla con el siguiente mensaje. ``` Failed to import 1 rows: NoHostAvailable - , will retry later, attempt 3 of 100 ``` Para resolver este error, debe asegurarse de que los datos que se vayan a importar coincidan con el esquema de la tabla en Amazon Keyspaces. Revise el archivo de importación en busca de errores de análisis sintáctico. Puede intentar utilizar una única fila de datos mediante una instrucción INSERT para aislar el error. El cliente intentará restablecer la conexión de forma automática. # 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).