Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: Caricamento di dati in Amazon Keyspaces utilizzando cqlsh
Questo tutorial ti guida attraverso il processo di migrazione dei dati da Apache Cassandra ad Amazon Keyspaces utilizzando il comando. `cqlsh COPY FROM` Il `cqlsh COPY FROM` comando è utile per caricare rapidamente e facilmente piccoli set di dati su Amazon Keyspaces per scopi accademici o di test. Per ulteriori informazioni su come migrare i carichi di lavoro di produzione, consulta. [Processo di migrazione offline: da Apache Cassandra ad Amazon Keyspaces](migrating-offline.md) In questo tutorial, completerai i seguenti passaggi:
Prerequisiti: configura un AWS account con credenziali, crea un file di trust store JKS per il certificato e configura la connessione `cqlsh` ad Amazon Keyspaces.
1. **Crea CSV di origine e tabella di destinazione**: prepara un file CSV come dati di origine e crea lo spazio chiave e la tabella di destinazione in Amazon Keyspaces.
1. **Preparazione dei dati**: randomizza i dati nel file CSV e analizzali per determinare le dimensioni medie e massime delle righe.
1. **Imposta la capacità di trasmissione**: calcola le unità di capacità di scrittura richieste (WCUs) in base alla dimensione dei dati e al tempo di caricamento desiderato e configura la capacità assegnata alla tabella.
1. **Configura i parametri cqlsh**: determina i valori ottimali per `cqlsh COPY FROM` parametri come`INGESTRATE`, `NUMPROCESSES``MAXBATCHSIZE`, e distribuisci il carico di lavoro `CHUNKSIZE` in modo uniforme.
1. **Esegui il `cqlsh COPY FROM` comando**: esegui il `cqlsh COPY FROM` comando per caricare i dati dal file CSV nella tabella Amazon Keyspaces e monitorare l'avanzamento.
Risoluzione dei problemi: risolvi problemi comuni come richieste non valide, errori del parser, errori di capacità ed errori cqlsh durante il processo di caricamento dei dati.
**Topics**
+ [Prerequisiti: passaggi da completare prima di poter caricare i dati utilizzando `cqlsh COPY FROM`](bulk-upload-prequs.md)
+ [Passaggio 1: crea il file CSV di origine e una tabella di destinazione per il caricamento dei dati](bulk-upload-source.md)
+ [Passaggio 2: prepara i dati di origine per un corretto caricamento dei dati](bulk-upload-prepare-data.md)
+ [Fase 3: Impostare la capacità di throughput per la tabella](bulk-upload-capacity.md)
+ [Fase 4: Configurare `cqlsh COPY FROM` le impostazioni](bulk-upload-config.md)
+ [Passaggio 5: Esegui il `cqlsh COPY FROM` comando per caricare i dati dal file CSV nella tabella di destinazione](bulk-upload-run.md)
+ [Risoluzione dei problemi](bulk-upload-troubleshooting.md)
# Prerequisiti: passaggi da completare prima di poter caricare i dati utilizzando `cqlsh COPY FROM`
Devi completare le seguenti attività prima di iniziare questo tutorial.
1. Se non l'hai già fatto, iscriviti a un account Account AWS seguendo i passaggi riportati in[Configurazione AWS Identity and Access Management](accessing.md#SettingUp.IAM).
1. Crea credenziali specifiche per il servizio seguendo i passaggi riportati in. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Configura la connessione shell Cassandra Query Language (cqlsh) e conferma di poterti connettere ad Amazon Keyspaces seguendo i passaggi indicati. [Utilizzo `cqlsh` per connettersi ad Amazon Keyspaces](programmatic.cqlsh.md)
# Passaggio 1: crea il file CSV di origine e una tabella di destinazione per il caricamento dei dati
Per questo tutorial, utilizziamo un file con valori separati da virgole (CSV) con il nome `keyspaces_sample_table.csv` come file di origine per la migrazione dei dati. Il file di esempio fornito contiene alcune righe di dati per una tabella con il nome. `book_awards`
1. Crea il file sorgente. Puoi scegliere una delle seguenti opzioni:
+ Scaricate il file CSV di esempio (`keyspaces_sample_table.csv`) contenuto nel seguente file di archivio [samplemigration.zip](samples/samplemigration.zip). Decomprimi l'archivio e prendi nota del percorso verso. `keyspaces_sample_table.csv`
+ Per compilare un file CSV con i propri dati memorizzati in un database Apache Cassandra, è possibile compilare il file CSV di origine utilizzando l'`cqlsh``COPY TO`istruzione, come illustrato nell'esempio seguente.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "COPY mykeyspace.mytable TO 'keyspaces_sample_table.csv' WITH HEADER=true";
```
Assicurati che il file CSV che crei soddisfi i seguenti requisiti:
+ La prima riga contiene i nomi delle colonne.
+ I nomi delle colonne nel file CSV di origine corrispondono ai nomi delle colonne nella tabella di destinazione.
+ I dati sono delimitati da una virgola.
+ Tutti i valori dei dati sono tipi di dati Amazon Keyspaces validi. Per informazioni, consulta [Tipi di dati](cql.elements.md#cql.data-types).
1. Crea lo spazio chiave e la tabella di destinazione in Amazon Keyspaces.
1. Connettiti ad Amazon Keyspaces utilizzando `cqlsh` e sostituendo l'endpoint del servizio, il nome utente e la password nell'esempio seguente con i tuoi valori.
```
cqlsh cassandra.us-east-1.amazonaws.com 9142 -u "111122223333" -p "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" --ssl
```
1. Crea un nuovo keyspace con il nome mostrato nell'`catalog`esempio seguente.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Quando il nuovo keyspace è disponibile, utilizzate il codice seguente per creare la tabella di destinazione. `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)
);
```
Se Apache Cassandra è la tua fonte di dati originale, un modo semplice per creare la tabella di destinazione di Amazon Keyspaces con intestazioni corrispondenti consiste nel generare l'`CREATE TABLE`istruzione dalla tabella di origine, come illustrato nell'istruzione seguente.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "DESCRIBE TABLE mykeyspace.mytable;"
```
Quindi crea la tabella di destinazione in Amazon Keyspaces con i nomi delle colonne e i tipi di dati che corrispondono alla descrizione della tabella di origine di Cassandra.
# Passaggio 2: prepara i dati di origine per un corretto caricamento dei dati
La preparazione dei dati di origine per un trasferimento efficiente è un processo in due fasi. Innanzitutto, i dati vengono randomizzati. Nella seconda fase, si analizzano i dati per determinare i valori dei `cqlsh` parametri appropriati e le impostazioni della tabella richieste per garantire che il caricamento dei dati abbia esito positivo.
**Randomizza i dati**
Il `cqlsh COPY FROM` comando legge e scrive i dati nello stesso ordine in cui appaiono nel file CSV. Se si utilizza il `cqlsh COPY TO` comando per creare il file sorgente, i dati vengono scritti in ordine di chiave nel file CSV. Internamente, Amazon Keyspaces partiziona i dati utilizzando chiavi di partizione. Sebbene Amazon Keyspaces disponga di una logica integrata per aiutare a bilanciare il carico delle richieste per la stessa chiave di partizione, il caricamento dei dati è più rapido ed efficiente se si rende casuale l'ordine. Questo perché puoi sfruttare il bilanciamento del carico integrato che si verifica quando Amazon Keyspaces scrive su partizioni diverse.
Per distribuire le scritture tra le partizioni in modo uniforme, devi randomizzare i dati nel file sorgente. [È possibile scrivere un'applicazione per eseguire questa operazione o utilizzare uno strumento open source, come Shuf.](https://en.wikipedia.org/wiki/Shuf) Shuf è disponibile gratuitamente sulle distribuzioni Linux, su macOS (installando coreutils in [homebrew](https://brew.sh)) e su Windows (utilizzando Windows Subsystem for Linux (WSL)). È necessario un passaggio aggiuntivo per evitare che la riga di intestazione con i nomi delle colonne venga mescolata in questo passaggio.
Per rendere casuale il file sorgente preservando l'intestazione, inserisci il codice seguente.
```
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 riscrive i dati in un nuovo file CSV chiamato. `keyspace.table.csv` Ora puoi eliminare il `keyspaces_sample_table.csv` file, non è più necessario.
**Analizza i dati**
Determina la dimensione media e massima delle righe analizzando i dati.
Lo fai per i seguenti motivi:
+ La dimensione media delle righe aiuta a stimare la quantità totale di dati da trasferire.
+ È necessaria la dimensione media delle righe per fornire la capacità di scrittura necessaria per il caricamento dei dati.
+ Puoi assicurarti che ogni riga abbia una dimensione inferiore a 1 MB, che è la dimensione massima delle righe in Amazon Keyspaces.
**Nota**
Questa quota si riferisce alla dimensione della riga, non alla dimensione della partizione. A differenza delle partizioni Apache Cassandra, le partizioni Amazon Keyspaces possono avere dimensioni praticamente illimitate. Le chiavi di partizione e le colonne di clustering richiedono spazio di archiviazione aggiuntivo per i metadati, che è necessario aggiungere alla dimensione grezza delle righe. Per ulteriori informazioni, consulta [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md).
Il codice seguente utilizza [AWK](https://en.wikipedia.org/wiki/AWK) per analizzare un file CSV e stampare la dimensione media e massima delle righe.
```
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
```
L'esecuzione di questo codice produce il seguente risultato.
```
using 10,000 samples:
{lines: 10000, avg: 123 bytes, max: 225 bytes}
```
Utilizzerai la dimensione media delle righe nel passaggio successivo di questo tutorial per fornire la capacità di scrittura per la tabella.
# Fase 3: Impostare la capacità di throughput per la tabella
Questo tutorial mostra come ottimizzare cqlsh per caricare i dati entro un intervallo di tempo prestabilito. Poiché sapete quante letture e scritture eseguite in anticipo, utilizzate la modalità di capacità fornita. Al termine del trasferimento dei dati, è necessario impostare la modalità di capacità della tabella in modo che corrisponda ai modelli di traffico dell'applicazione. Per ulteriori informazioni sulla gestione della capacità, consulta[Gestione delle risorse serverless in Amazon Keyspaces (per Apache Cassandra)](serverless_resource_management.md).
Con la modalità di capacità fornita, è possibile specificare in anticipo la quantità di capacità di lettura e scrittura che si desidera fornire alla tabella. La capacità di scrittura viene fatturata ogni ora e misurata in unità di capacità di scrittura (). WCUs Ogni WCU ha una capacità di scrittura sufficiente per supportare la scrittura di 1 KB di dati al secondo. Quando si caricano i dati, la velocità di scrittura deve essere inferiore al valore massimo WCUs (parametro:`write_capacity_units`) impostato nella tabella di destinazione.
Per impostazione predefinita, puoi eseguire il provisioning fino a 40.000 WCUs per tabella e 80.000 per WCUs tutte le tabelle del tuo account. Se hai bisogno di capacità aggiuntiva, puoi richiedere un aumento della quota nella console [Service Quotas](https://console.aws.amazon.com/servicequotas/home#!/services/cassandra/quotas). Per ulteriori informazioni sulle quote, consulta [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md).
**Calcola il numero medio di componenti WCUs necessari per un inserto**
L'inserimento di 1 KB di dati al secondo richiede 1 WCU. Se il tuo file CSV ha 360.000 righe e desideri caricare tutti i dati in un'ora, devi scrivere 100 righe al secondo (360.000 righe/60 minuti/60 secondi = 100 righe al secondo). Se ogni riga contiene fino a 1 KB di dati, per inserire 100 righe al secondo, devi assegnarne 100 WCUs alla tabella. Se ogni riga contiene 1,5 KB di dati, ne occorrono due WCUs per inserire una riga al secondo. Pertanto, per inserire 100 righe al secondo, è necessario predisporre 200 WCUs.
Per determinare quante WCUs righe sono necessarie per inserire una riga al secondo, dividi la dimensione media delle righe in byte per 1024 e arrotonda al numero intero più vicino.
Ad esempio, se la dimensione media delle righe è 3000 byte, ne occorrono tre WCUs per inserire una riga al secondo.
```
ROUNDUP(3000 / 1024) = ROUNDUP(2.93) = 3 WCUs
```
**Calcola il tempo e la capacità di caricamento dei dati**
Ora che conosci la dimensione e il numero medi di righe del tuo file CSV, puoi calcolare quante sono WCUs necessarie per caricare i dati in un determinato periodo di tempo e il tempo approssimativo necessario per caricare tutti i dati nel file CSV utilizzando diverse impostazioni WCU.
Ad esempio, se ogni riga del file è di 1 KB e il file CSV contiene 1.000.000 di righe, per caricare i dati in un'ora, è necessario fornire almeno 278 righe WCUs alla tabella per quell'ora.
```
1,000,000 rows * 1 KBs = 1,000,000 KBs
1,000,000 KBs / 3600 seconds =277.8 KBs / second = 278 WCUs
```
**Configura le impostazioni della capacità assegnata**
È possibile impostare le impostazioni della capacità di scrittura di una tabella al momento della creazione della tabella o utilizzando il comando `ALTER TABLE` CQL. Di seguito è riportata la sintassi per modificare le impostazioni della capacità assegnata a una tabella con l'istruzione CQL. `ALTER TABLE`
```
ALTER TABLE mykeyspace.mytable WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Per il riferimento completo alla lingua, vedere. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
# Fase 4: Configurare `cqlsh COPY FROM` le impostazioni
Questa sezione descrive come determinare i valori dei parametri per`cqlsh COPY FROM`. Il `cqlsh COPY FROM` comando legge il file CSV preparato in precedenza e inserisce i dati in Amazon Keyspaces utilizzando CQL. Il comando divide le righe e distribuisce le operazioni tra un insieme di lavoratori. `INSERT` Ogni lavoratore stabilisce una connessione con Amazon Keyspaces e `INSERT` invia richieste attraverso questo canale.
Il `cqlsh COPY` comando non ha una logica interna per distribuire il lavoro in modo uniforme tra i suoi lavoratori. Tuttavia, puoi configurarlo manualmente per assicurarti che il lavoro sia distribuito in modo uniforme. Inizia esaminando questi parametri chiave di cqlsh:
+ **DELIMITATORE**: se hai utilizzato un delimitatore diverso da una virgola, puoi impostare questo parametro, che per impostazione predefinita è la virgola.
+ **INGESTRATE**: il numero target di righe che tenta di elaborare al secondo. `cqlsh COPY FROM` Se non è impostato, il valore predefinito è 100.000.
+ **NUMPROCESSES: il numero di processi** di lavoro minorile che cqlsh crea per le attività. `COPY FROM` Il massimo per questa impostazione è 16, l'impostazione predefinita è`num_cores - 1`, `num_cores` dov'è il numero di core di elaborazione sull'host che esegue cqlsh.
+ **MAXBATCHSIZE** — La dimensione del batch determina il numero massimo di righe inserite nella tabella di destinazione in un singolo batch. Se non è impostato, cqlsh utilizza batch di 20 righe inserite.
+ **CHUNKSIZE — La dimensione** dell'unità di lavoro che passa al lavoratore minorile. Per impostazione predefinita, è impostata su 5.000.
+ **MAXTENTEMENTS** — Il numero massimo di volte in cui riprovare un blocco di lavoro non riuscito. Una volta raggiunto il tentativo massimo, i record non riusciti vengono scritti in un nuovo file CSV che è possibile eseguire nuovamente in un secondo momento dopo aver esaminato l'errore.
`INGESTRATE`Impostato in base al numero di file WCUs che hai assegnato alla tabella di destinazione. Il `INGESTRATE` valore del `cqlsh COPY FROM` comando non è un limite, ma una media target. Ciò significa che può (e spesso succede) superare il numero impostato. Per consentire l'insorgenza di interruzioni e assicurarvi che sia disponibile una capacità sufficiente per gestire le richieste di caricamento dei dati, impostate `INGESTRATE` il 90% della capacità di scrittura della tabella.
```
INGESTRATE = WCUs * .90
```
Quindi, impostate il `NUMPROCESSES` parametro in modo che sia uguale a uno in meno rispetto al numero di core del sistema. Per scoprire qual è il numero di core del sistema, è possibile eseguire il codice seguente.
```
python -c "import multiprocessing; print(multiprocessing.cpu_count())"
```
Per questo tutorial, utilizziamo il seguente valore.
```
NUMPROCESSES = 4
```
Ogni processo crea un lavoratore e ogni lavoratore stabilisce una connessione ad Amazon Keyspaces. Amazon Keyspaces può supportare fino a 3.000 richieste CQL al secondo su ogni connessione. Ciò significa che devi assicurarti che ogni lavoratore elabori meno di 3.000 richieste al secondo.
Inoltre`INGESTRATE`, i lavoratori spesso superano il numero impostato e non sono limitati dai secondi. Pertanto, per tenere conto delle interruzioni, impostate i parametri cqlsh in modo che ciascun lavoratore elabori 2.500 richieste al secondo. Per calcolare la quantità di lavoro distribuita a un lavoratore, utilizzate le seguenti linee guida.
+ Dividi `INGESTRATE` per`NUMPROCESSES`.
+ Se`INGESTRATE`/`NUMPROCESSES`> 2.500, abbassa il valore `INGESTRATE` per rendere vera questa formula.
```
INGESTRATE / NUMPROCESSES <= 2,500
```
Prima di configurare le impostazioni per ottimizzare il caricamento dei nostri dati di esempio, esaminiamo le impostazioni `cqlsh` predefinite e vediamo come il loro utilizzo influisce sul processo di caricamento dei dati. Poiché `cqlsh COPY FROM` utilizza il `CHUNKSIZE` per creare blocchi di lavoro (`INSERT`rendiconti) da distribuire ai lavoratori, il lavoro non viene distribuito automaticamente in modo uniforme. Alcuni lavoratori potrebbero rimanere inattivi, a seconda dell'impostazione. `INGESTRATE`
Per distribuire il lavoro in modo uniforme tra i lavoratori e mantenere per ogni lavoratore la frequenza ottimale di 2.500 richieste al secondo, è necessario impostare `CHUNKSIZE` e modificare i `INGESTRATE` parametri di input. `MAXBATCHSIZE` Per ottimizzare l'utilizzo del traffico di rete durante il caricamento dei dati, scegliete un valore vicino al valore massimo di 30. `MAXBATCHSIZE` Passando `CHUNKSIZE` a 100 e `MAXBATCHSIZE` a 25, le 10.000 righe vengono distribuite uniformemente tra i quattro lavoratori (10.000/2500 = 4).
Il seguente esempio di codice lo illustra.
```
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
```
Per riassumere, utilizzate le seguenti formule per impostare i parametri: `cqlsh COPY FROM`
+ **INGESTRATE** = write\$1capacity\$1units \$1 .90
+ **NUMPROCESSES** = num\$1cores -1 (impostazione predefinita)
+ **INGESTRATE/NUMPROCESSES** = 2.500 (deve essere una dichiarazione vera).
+ **MAXBATCHSIZE** = 30 (il valore predefinito è 20. Amazon Keyspaces accetta batch fino a 30.)
+ **CHUNKSIZE** = (INGESTRATE/NUMPROCESSES)/MAXBATCHSIZE
Ora che hai calcolato e `CHUNKSIZE` sei pronto per `NUMPROCESSES` caricare `INGESTRATE` i tuoi dati.
# Passaggio 5: Esegui il `cqlsh COPY FROM` comando per caricare i dati dal file CSV nella tabella di destinazione
Per eseguire il `cqlsh COPY FROM` comando, completare i passaggi seguenti.
1. Connect ad Amazon Keyspaces utilizzando cqlsh.
1. Scegli il tuo keyspace con il codice seguente.
```
USE catalog;
```
1. Imposta la coerenza di scrittura su`LOCAL_QUORUM`. Per garantire la durabilità dei dati, Amazon Keyspaces non consente altre impostazioni di coerenza di scrittura. Vedi il codice seguente.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Preparate la `cqlsh COPY FROM` sintassi utilizzando il seguente esempio di codice.
```
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. Esegui l'istruzione preparata nel passaggio precedente. cqlsh riporta tutte le impostazioni che hai configurato.
1. Assicurati che le impostazioni corrispondano ai dati immessi. Guarda l'esempio seguente.
```
Reading options from the command line: {'chunksize': '120', 'header': 'true', 'ingestrate': '36000', 'numprocesses': '15', 'maxbatchsize': '20'}
Using 15 child processes
```
1. Controlla il numero di righe trasferite e il tasso medio corrente, come mostrato nell'esempio seguente.
```
Processed: 57834 rows; Rate: 6561 rows/s; Avg. rate: 31751 rows/s
```
1. Quando cqlsh ha finito di caricare i dati, esamina il riepilogo delle statistiche di caricamento dei dati (il numero di file letti, di runtime e le righe ignorate) come mostrato nell'esempio seguente.
```
15556824 rows imported from 1 files in 8 minutes and 8.321 seconds (0 skipped).
```
In questo passaggio finale del tutorial, hai caricato i dati su Amazon Keyspaces.
**Importante**
Ora che hai trasferito i dati, regola le impostazioni della modalità di capacità della tabella di destinazione in modo che corrispondano ai normali modelli di traffico dell'applicazione. Fino a quando non la modifichi, ti verranno addebitati i costi in base alla tariffa oraria per la capacità assegnata.
# Risoluzione dei problemi
Una volta completato il caricamento dei dati, controlla se le righe sono state saltate. Per farlo, accedi alla directory dei sorgenti del file CSV di origine e cerca un file con il nome seguente.
```
import_yourcsvfilename.err.timestamp.csv
```
cqlsh scrive tutte le righe di dati saltate in un file con quel nome. Se il file esiste nella tua directory di origine e contiene dati, queste righe non sono state caricate su Amazon Keyspaces. Per riprovare queste righe, verifica innanzitutto la presenza di eventuali errori riscontrati durante il caricamento e modifica i dati di conseguenza. Per riprovare queste righe, puoi eseguire nuovamente il processo.
**Errori comuni**
I motivi più comuni per cui le righe non vengono caricate sono gli errori di capacità e gli errori di analisi.
**Errori di richiesta non validi durante il caricamento di dati su Amazon Keyspaces**
Nell'esempio seguente, la tabella di origine contiene una colonna counter, che genera chiamate batch registrate dal comando cqlsh. `COPY` Le chiamate batch registrate non sono supportate da Amazon Keyspaces.
```
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
```
Per risolvere questo errore, usa DSBulk per migrare i dati. Per ulteriori informazioni, consulta [Tutorial: caricamento di dati in Amazon Keyspaces utilizzando DSBulk](dsbulk-upload.md).
**Errori del parser durante il caricamento di dati su Amazon Keyspaces**
L'esempio seguente mostra una riga saltata a causa di un. `ParseError`
```
Failed to import 1 rows: ParseError - Invalid ... –
```
Per risolvere questo errore, devi assicurarti che i dati da importare corrispondano allo schema della tabella in Amazon Keyspaces. Controlla il file di importazione per verificare eventuali errori di analisi. Puoi provare a utilizzare una singola riga di dati utilizzando un'`INSERT`istruzione per isolare l'errore.
**Errori di capacità durante il caricamento dei dati su 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 utilizza le `WriteTimeout` eccezioni `ReadTimeout` e per indicare quando una richiesta di scrittura non riesce a causa di una capacità di throughput insufficiente. Per aiutare a diagnosticare eccezioni di capacità insufficienti, Amazon Keyspaces pubblica parametri e `WriteThrottleEvents` parametri in Amazon. `ReadThrottledEvents` CloudWatch Per ulteriori informazioni, consulta [Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).
**errori cqlsh durante il caricamento di dati su Amazon Keyspaces**
Per facilitare la risoluzione degli errori cqlsh, esegui nuovamente il comando che ha avuto esito negativo con il flag. `--debug`
Quando si utilizza una versione incompatibile di cqlsh, viene visualizzato il seguente errore.
```
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
```
Verificare che sia installata la versione corretta di cqlsh eseguendo il comando seguente.
```
cqlsh --version
```
Dovreste vedere qualcosa di simile a quanto segue per l'output.
```
cqlsh 5.0.1
```
Se usi Windows, sostituisci tutte le istanze di `cqlsh` with`cqlsh.bat`. Ad esempio, per verificare la versione di cqlsh in Windows, esegui il comando seguente.
```
cqlsh.bat --version
```
La connessione ad Amazon Keyspaces fallisce dopo che il client cqlsh riceve tre errori consecutivi di qualsiasi tipo dal server. Il client cqlsh fallisce e viene visualizzato il seguente messaggio.
```
Failed to import 1 rows: NoHostAvailable - , will retry later, attempt 3 of 100
```
Per risolvere questo errore, devi assicurarti che i dati da importare corrispondano allo schema della tabella in Amazon Keyspaces. Controlla il file di importazione per verificare eventuali errori di analisi. Puoi provare a utilizzare una singola riga di dati utilizzando un'istruzione INSERT per isolare l'errore.
Il client tenta automaticamente di ristabilire la connessione.