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 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.