As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutorial: Como carregar dados no Amazon Keyspaces usando cqlsh
Este tutorial orienta você no processe de migração de dados do Apache Cassandra para o Amazon Keyspaces usando o comando `cqlsh COPY FROM`. O comando `cqlsh COPY FROM` é útil para carregar pequenos conjuntos de dados de forma rápida e fácil no Amazon Keyspaces para fins acadêmicos ou de teste. Para obter mais informações sobre como migrar workloads de produção, consulte [Processo de migração off-line: Apache Cassandra para Amazon Keyspaces](migrating-offline.md). Você concluirá as seguintes etapas neste tutorial:
Pré-requisitos — Configure uma AWS conta com credenciais, crie um arquivo JKS trust store para o certificado e configure para se conectar `cqlsh` ao Amazon Keyspaces.
1. **Crie CSV de origem e tabela de destino**: prepare um arquivo CSV como dados de origem e crie o keyspace e a tabela de destino no Amazon Keyspaces.
1. **Prepare os dados**: randomize os dados no arquivo CSV e analise-os para determinar os tamanhos médio e máximo das linhas.
1. **Defina a capacidade de taxa de transferência** — calcule as unidades de capacidade de gravação necessárias (WCUs) com base no tamanho dos dados e no tempo de carregamento desejado, e configure a capacidade provisionada da tabela.
1. **Configurar parâmetros cqlsh**: determine os valores ideais para parâmetros de`cqlsh COPY FROM` como `INGESTRATE`, `NUMPROCESSES`, `MAXBATCHSIZE` e `CHUNKSIZE` distribua a workload uniformemente.
1. **Execute o comando `cqlsh COPY FROM`**: execute o comando `cqlsh COPY FROM` para carregar os dados do arquivo CSV para a tabela do Amazon Keyspaces e monitorar o progresso.
Solução de problemas: resolva problemas comuns, como solicitações inválidas, erros do analisador, erros de capacidade e erros de cqlsh durante o processo de upload de dados.
**Topics**
+ [Pré-requisitos: etapas a serem concluídas antes de fazer o upload de dados usando `cqlsh COPY FROM`](bulk-upload-prequs.md)
+ [Etapa 1: criar o arquivo CSV de origem e uma tabela de destino para o carregamento de dados](bulk-upload-source.md)
+ [Etapa 2: Preparar os dados de origem para um carregamento de dados bem-sucedido](bulk-upload-prepare-data.md)
+ [Etapa 3: definir a capacidade de throughput da tabela](bulk-upload-capacity.md)
+ [Etapa 4: Definir configurações de `cqlsh COPY FROM`](bulk-upload-config.md)
+ [Etapa 5: Executar o comando `cqlsh COPY FROM` para carregar dados do arquivo CSV para a tabela de destino](bulk-upload-run.md)
+ [Solução de problemas](bulk-upload-troubleshooting.md)
# Pré-requisitos: etapas a serem concluídas antes de fazer o upload de dados usando `cqlsh COPY FROM`
É necessário concluir as tarefas a seguir antes de iniciar este tutorial.
1. Se você ainda não fez isso, inscreva-se em um Conta da AWS seguindo as etapas em[Conf AWS Identity and Access Management iguração](accessing.md#SettingUp.IAM).
1. Crie credenciais específicas do serviço seguindo as etapas em [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md).
1. Configure a conexão shell do Cassandra Query Language (cqlsh) e confirme se você pode se conectar ao Amazon Keyspaces seguindo as etapas em [Usar `cqlsh` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md).
# Etapa 1: criar o arquivo CSV de origem e uma tabela de destino para o carregamento de dados
Neste tutorial, usamos um arquivo de valores separados por vírgula (CSV) com o nome `keyspaces_sample_table.csv` como arquivo de origem para a migração de dados. O arquivo de amostra fornecido contém algumas linhas de dados de uma tabela com o nome `book_awards`.
1. Criar o arquivo de origem. Você pode escolher uma das seguintes opções:
+ Baixe o arquivo CSV de amostra (`keyspaces_sample_table.csv`) contido no seguinte arquivo [samplemigration.zip](samples/samplemigration.zip). Descompacte o arquivo e anote o caminho até `keyspaces_sample_table.csv`.
+ Para preencher um arquivo CSV com seus próprios dados armazenados em um banco de dados do Apache Cassandra, você pode preencher o arquivo CSV de origem usando a instrução `cqlsh` `COPY TO`, conforme mostrado no exemplo a seguir.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "COPY mykeyspace.mytable TO 'keyspaces_sample_table.csv' WITH HEADER=true";
```
Certifique-se de que o arquivo CSV criado atenda aos seguintes requisitos:
+ A primeira linha contém os nomes das colunas.
+ Os nomes das colunas no arquivo CSV de origem correspondem aos nomes das colunas na tabela de destino.
+ Os dados são delimitados por uma vírgula.
+ Todos os valores de dados são tipos de dados válidos do Amazon Keyspaces. Consulte [Tipos de dados](cql.elements.md#cql.data-types).
1. Criar o espaço de chaves e a tabela de destino no Amazon Keyspaces.
1. Conecte-se ao Amazon Keyspaces usando `cqlsh` e substituindo o endpoint do serviço, o nome de usuário e a senha no exemplo a seguir por seus próprios valores.
```
cqlsh cassandra.us-east-1.amazonaws.com 9142 -u "111122223333" -p "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" --ssl
```
1. Crie um novo espaço de chave com o nome `catalog` mostrado no exemplo a seguir.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Quando o novo espaço de chave estiver disponível, use o código a seguir para criar a tabela `book_awards` de destino.
```
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 o Apache Cassandra for sua fonte de dados original, uma maneira simples de criar a tabela de destino do Amazon Keyspaces com cabeçalhos correspondentes é gerar a instrução `CREATE TABLE` a partir da tabela de origem, conforme mostrado na instrução a seguir.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "DESCRIBE TABLE mykeyspace.mytable;"
```
Em seguida, crie a tabela de destino no Amazon Keyspaces com os nomes das colunas e os tipos de dados correspondentes à descrição da tabela de origem do Cassandra.
# Etapa 2: Preparar os dados de origem para um carregamento de dados bem-sucedido
Preparar os dados de origem para uma transferência eficiente é um processo de duas etapas. Primeiro, você randomiza os dados. Na segunda etapa, você analisa os dados para determinar os valores de parâmetros `cqlsh` apropriados e as configurações de tabela necessárias para garantir que o carregamento de dados teve sucesso.
**Randomizar os dados**
O comando `cqlsh COPY FROM` lê e grava dados na mesma ordem em que aparecem no arquivo CSV. Se você usar o comando `cqlsh COPY TO` para criar o arquivo de origem, os dados serão gravados em ordem de classificação por chave no CSV. Internamente, o Amazon Keyspaces particiona os dados usando chaves de partição. Embora o Amazon Keyspaces tenha uma lógica integrada para ajudar a balancear a carga de solicitações para a mesma chave de partição, carregar os dados é mais rápido e eficiente se você randomizar o pedido. Isso ocorre porque você pode aproveitar o balanceamento de carga incorporado que ocorre quando o Amazon Keyspaces está gravando em partições diferentes.
Para distribuir uniformemente as gravações pelas partições, você deve randomizar os dados no arquivo de origem. Você pode escrever um aplicativo para fazer isso ou usar uma ferramenta de código aberto, como o [Shuf](https://en.wikipedia.org/wiki/Shuf). O Shuf está disponível gratuitamente em distribuições do Linux, no macOS (instalando coreutils no [homebrew](https://brew.sh)) e no Windows (usando o Subssistema Windows para Linux (WSL)). É necessária uma etapa extra para evitar que a linha do cabeçalho com os nomes das colunas sejam embaralhados nessa etapa.
Para randomizar o arquivo de origem enquanto preserva o cabeçalho, insira o código a seguir.
```
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
```
O Shuf reescreve os dados em um novo arquivo CSV chamado `keyspace.table.csv`. Agora você pode excluir o arquivo `keyspaces_sample_table.csv` — ele não é mais necessário.
**Analisar os dados**
Determine o tamanho médio e máximo da linha analisando os dados.
Você pode fazer isso pelas seguintes razões:
+ O tamanho médio da linha ajuda a estimar a quantidade total de dados a serem transferidos.
+ Você precisa do tamanho médio da linha para provisionar a capacidade de gravação necessária para o upload dos dados.
+ Você pode garantir que cada linha tenha menos de 1 MB, que é o tamanho máximo da linha no Amazon Keyspaces.
**nota**
Essa cota se refere ao tamanho da linha, não ao tamanho da partição. Diferentemente das partições do Apache Cassandra, as partições do Amazon Keyspaces podem ser virtualmente desvinculadas em tamanho. As chaves de partição e as colunas de clustering exigem armazenamento adicional para metadados, que você deve adicionar ao tamanho bruto das linhas. Para obter mais informações, consulte [Estimar o tamanho da linha no Amazon Keyspaces](calculating-row-size.md).
O código a seguir usa [AWK](https://en.wikipedia.org/wiki/AWK) para analisar um arquivo CSV e imprimir o tamanho médio e máximo da linha.
```
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
```
A execução desse código resulta na saída a seguir.
```
using 10,000 samples:
{lines: 10000, avg: 123 bytes, max: 225 bytes}
```
Você usa o tamanho médio da linha na próxima etapa deste tutorial para provisionar a capacidade de gravação da tabela.
# Etapa 3: definir a capacidade de throughput da tabela
Este tutorial mostra como ajustar o cqlsh para carregar dados em um intervalo de tempo definido. Como você sabe com antecedência quantas leituras e gravações você executa, use o modo de capacidade provisionada. Depois de concluir a transferência de dados, você deve definir o modo de capacidade da tabela de acordo com os padrões de tráfego do seu aplicativo. Para saber mais sobre gerenciamento de capacidade, consulte [Como gerenciar os recursos de tecnologia sem servidor no Amazon Keyspaces (para Apache Cassandra)](serverless_resource_management.md).
Com o modo de capacidade provisionada, você especifica com antecedência quanta capacidade de leitura e gravação deseja provisionar para sua tabela. A capacidade de gravação é cobrada por hora e medida em unidades de capacidade de gravação ()WCUs. Cada WCU tem capacidade de gravação suficiente para suportar a gravação de 1 KB de dados por segundo. Quando você carrega os dados, a taxa de gravação deve estar abaixo do máximo WCUs (parâmetro:`write_capacity_units`) definido na tabela de destino.
Por padrão, você pode provisionar até 40.000 WCUs em uma tabela e 80.000 WCUs em todas as tabelas da sua conta. Se precisar aumentar a capacidade, solicite um aumento de cota no console [Service Quotas](https://console.aws.amazon.com/servicequotas/home#!/services/cassandra/quotas). Para obter mais informações sobre cotas, consulte [Cotas para Amazon Keyspaces (para Apache Cassandra)](quotas.md).
**Calcule o número médio WCUs necessário para uma inserção**
A inserção de 1 KB de dados por segundo exige 1 WCU. Se o arquivo CSV tiver 360.000 linhas e você quiser carregar todos os dados em 1 hora, deverá gravar 100 linhas por segundo (360.000 linhas / 60 minutos / 60 segundos = 100 linhas por segundo). Se cada linha tiver até 1 KB de dados, para inserir 100 linhas por segundo, você deverá WCUs provisionar 100 para sua tabela. Se cada linha tiver 1,5 KB de dados, você precisará de duas WCUs para inserir uma linha por segundo. Portanto, para inserir 100 linhas por segundo, você deve provisionar 200 WCUs.
Para determinar quantas linhas WCUs você precisa inserir por segundo, divida o tamanho médio da linha em bytes por 1024 e arredonde para o número inteiro mais próximo.
Por exemplo, se o tamanho médio da linha for 3000 bytes, você precisará de três WCUs para inserir uma linha por segundo.
```
ROUNDUP(3000 / 1024) = ROUNDUP(2.93) = 3 WCUs
```
**Calcule o tempo e a capacidade de carregamento de dados**
Agora que você sabe o tamanho médio e o número de linhas em seu arquivo CSV, você pode calcular quantas WCUs são necessárias para carregar os dados em um determinado período de tempo e o tempo aproximado necessário para carregar todos os dados em seu arquivo CSV usando diferentes configurações de WCU.
Por exemplo, se cada linha em seu arquivo tiver 1 KB e você tiver 1.000.000 de linhas em seu arquivo CSV, para carregar os dados em 1 hora, você precisará provisionar pelo menos 278 WCUs para sua tabela nessa hora.
```
1,000,000 rows * 1 KBs = 1,000,000 KBs
1,000,000 KBs / 3600 seconds =277.8 KBs / second = 278 WCUs
```
**Defina as configurações de capacidade provisionada**
Você pode definir as configurações de capacidade de gravação de uma tabela ao criar a tabela ou usando o comando CQL `ALTER TABLE`. A seguir está a sintaxe para alterar as configurações de capacidade provisionada de uma tabela com o comando CQL `ALTER TABLE`.
```
ALTER TABLE mykeyspace.mytable WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Para obter a referência completa da linguagem, consulte [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Etapa 4: Definir configurações de `cqlsh COPY FROM`
Esta seção descreve como determinar os valores dos parâmetros de `cqlsh COPY FROM`. O comando `cqlsh COPY FROM` lê o arquivo CSV que você preparou anteriormente e insere os dados no Amazon Keyspaces usando CQL. O comando divide as linhas e distribui as operações `INSERT` entre um conjunto de operadores. Cada operador estabelece uma conexão com o Amazon Keyspaces e envia solicitações `INSERT` por esse canal.
O comando `cqlsh COPY` não tem lógica interna para distribuir o trabalho uniformemente entre seus operadores. No entanto, você pode configurá-lo manualmente para garantir que o trabalho seja distribuído uniformemente. Comece revisando esses principais parâmetros do cqlsh:
+ **DELIMITADOR**: se você usou um delimitador diferente de uma vírgula, você pode definir esse parâmetro, cujo padrão é vírgula.
+ **INGESTRATE**: o número alvo de linhas que `cqlsh COPY FROM` tenta processar por segundo. Se não especificado, o padrão será 100.000.
+ **NUMPROCESSES**: o número de processos do operador secundário que o cqlsh cria para tarefas `COPY FROM`. O máximo para essa configuração é 16, o padrão é `num_cores - 1`, onde `num_cores` é o número de núcleos de processamento no host executando cqlsh.
+ **MAXBATCHSIZE**: o tamanho do lote determina o número máximo de linhas inseridas na tabela de destino em um único lote. Se não for definido, o cqlsh usa lotes de 20 linhas inseridas.
+ **CHUNKSIZE**: o tamanho da unidade de trabalho que passa para o operador secundário. Por padrão, ele é definido como 5.000.
+ **MAXATTEMPTS**: o número máximo de novas tentativas de um bloco de operadores com falha. Depois que a tentativa máxima é atingida, os registros com falha são gravados em um novo arquivo CSV que você pode executar novamente depois de investigar a falha.
Defina `INGESTRATE` com base no número do WCUs que você provisionou para a tabela de destino de destino. O `INGESTRATE` do comando `cqlsh COPY FROM` não é um limite, é uma média de destino. Isso significa que ele pode (e geralmente acontece) ultrapassar o número que você definiu. Para permitir picos e garantir que haja capacidade suficiente para lidar com as solicitações de carregamento de dados, defina `INGESTRATE` como 90% da capacidade de gravação da tabela.
```
INGESTRATE = WCUs * .90
```
Em seguida, defina o parâmetro `NUMPROCESSES` como igual a um a menos que o número de núcleos em seu sistema. Para descobrir qual é o número de núcleos do seu sistema, você pode executar o código a seguir.
```
python -c "import multiprocessing; print(multiprocessing.cpu_count())"
```
Neste tutorial, use o valor a seguir.
```
NUMPROCESSES = 4
```
Cada processo cria um operador e cada operador estabelece uma conexão com o Amazon Keyspaces. O Amazon Keyspaces pode suportar até 3.000 solicitações de CQL por segundo em cada conexão. Isso significa que você precisa garantir que cada operador esteja processando menos de 3.000 solicitações por segundo.
Assim como `INGESTRATE`, os operadores geralmente ultrapassam o número definido e não são limitados pelos segundos do relógio. Portanto, para contabilizar as intermitências, defina seus parâmetros de cqlsh para que cada operador processe 2.500 solicitações por segundo. Para calcular a quantidade de trabalho distribuída a um operador, use a seguinte diretriz.
+ Divida `INGESTRATE` por `NUMPROCESSES`.
+ Se `INGESTRATE` / `NUMPROCESSES` > 2.500, diminua `INGESTRATE` para tornar essa fórmula verdadeira.
```
INGESTRATE / NUMPROCESSES <= 2,500
```
Antes de definir as configurações para otimizar o upload de nossos dados de amostra, vamos analisar as configurações padrão `cqlsh` e ver como o uso delas afeta o processo de carregamento de dados. Como `cqlsh COPY FROM` usa o `CHUNKSIZE` para criar blocos do trabalho (instruções `INSERT`) para distribuir aos operadores, o trabalho não é automaticamente distribuído uniformemente. Alguns operadores podem ficar ociosos, dependendo da configuração de `INGESTRATE`.
Para distribuir o trabalho uniformemente entre os operadores e manter cada operador na taxa ideal de 2.500 solicitações por segundo, você deve definir `CHUNKSIZE`, `MAXBATCHSIZE` e `INGESTRATE` alterando os parâmetros de entrada. Para otimizar a utilização do tráfego de rede durante o carregamento de dados, escolha um valor para `MAXBATCHSIZE` próximo ao valor máximo de 30. Ao mudar `CHUNKSIZE` para 100 e `MAXBATCHSIZE` para 25, as 10.000 linhas são distribuídas uniformemente entre os quatro operadores (10.000/2.500 = 4).
O exemplo de código a seguir ilustra isso.
```
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
```
Para resumir, use as seguintes fórmulas ao definir os parâmetros de `cqlsh COPY FROM`:
+ **INGESTRATE** = write\$1capacity\$1units \$1 .90
+ **NUMPROCESSES** = num\$1cores -1 (padrão)
+ **INGESTRATE/NUMPROCESSES** = 2.500 (Essa deve ser uma afirmação verdadeira.)
+ **MAXBATCHSIZE** = 30 (O padrão é 20. O Amazon Keyspaces aceita lotes de até 30.)
+ **CHUNKSIZE** = (INGESTRATE / NUMPROCESSES) / MAXBATCHSIZE
Agora que você calculou `NUMPROCESSES`, `INGESTRATE` e `CHUNKSIZE`, você está pronto para carregar seus dados.
# Etapa 5: Executar o comando `cqlsh COPY FROM` para carregar dados do arquivo CSV para a tabela de destino
Conclua as etapas a seguir para executar o comando `cqlsh COPY FROM`.
1. Conecte-se ao Amazon Keyspaces usando cqlsh.
1. Escolha seu espaço de chave com o código a seguir.
```
USE catalog;
```
1. Defina a consistência de gravação como `LOCAL_QUORUM`. Para garantir a durabilidade dos dados, o Amazon Keyspaces não permite outras configurações de consistência de gravação. Consulte o código a seguir.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Prepare sua sintaxe `cqlsh COPY FROM` usando o exemplo de código a seguir.
```
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. Execute a instrução preparada na etapa anterior. O cqlsh reproduz todas as configurações que você definiu.
1. Verifique se as configurações correspondem à entrada. Veja o exemplo a seguir.
```
Reading options from the command line: {'chunksize': '120', 'header': 'true', 'ingestrate': '36000', 'numprocesses': '15', 'maxbatchsize': '20'}
Using 15 child processes
```
1. Verifique o número de linhas transferidas e a taxa média atual, conforme mostrado no exemplo a seguir.
```
Processed: 57834 rows; Rate: 6561 rows/s; Avg. rate: 31751 rows/s
```
1. Quando o cqlsh terminar de carregar os dados, revise o resumo das estatísticas de carregamento de dados (o número de arquivos lidos, o runtime e as linhas ignoradas), conforme mostrado no exemplo a seguir.
```
15556824 rows imported from 1 files in 8 minutes and 8.321 seconds (0 skipped).
```
Nesta etapa final do tutorial, você fez o upload dos dados para o Amazon Keyspaces.
**Importante**
Agora que você transferiu seus dados, ajuste as configurações do modo de capacidade da tabela de destino para corresponder aos padrões de tráfego regulares do seu aplicativo. Você incorre em cobranças de acordo com a taxa horária de sua capacidade provisionada até alterá-la.
# Solução de problemas
Depois que o upload dos dados for concluído, verifique se as linhas foram ignoradas. Para fazer isso, navegue até o diretório de origem do arquivo CSV de origem e pesquise um arquivo com o nome a seguir.
```
import_yourcsvfilename.err.timestamp.csv
```
O cqlsh grava todas as linhas de dados ignoradas em um arquivo com esse nome. Se o arquivo existir em seu diretório de origem e tiver dados nele, essas linhas não foram carregadas no Amazon Keyspaces. Para repetir essas linhas, primeiro verifique se há erros encontrados durante o upload e ajuste os dados adequadamente. Para repetir essas linhas, você pode executar o processo novamente.
**Erros comuns**
Os motivos mais comuns pelos quais as linhas não são carregadas são erros de capacidade e erros de análise.
**Erros de solicitação inválidos ao fazer o upload de dados para o Amazon Keyspaces**
No exemplo a seguir, a tabela de origem contém uma coluna de contador, que resulta em chamadas em lote registradas do comando cqlsh `COPY`. As chamadas em lote registradas não são compatíveis com o 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
```
Para resolver esse erro, use DSBulk para migrar os dados. Para obter mais informações, consulte [Tutorial: Carregando dados no Amazon Keyspaces usando DSBulk](dsbulk-upload.md).
**Erros do analisador ao fazer o upload de dados para o Amazon Keyspaces**
O exemplo a seguir mostra uma linha ignorada devido a `ParseError`.
```
Failed to import 1 rows: ParseError - Invalid ... –
```
Para resolver esse erro, você precisa garantir que os dados a serem importados correspondam ao esquema da tabela no Amazon Keyspaces. Verifique se há erros de análise no arquivo de importação. Você pode tentar usar uma única linha de dados usando uma instrução `INSERT` para isolar o erro.
**Erros de capacidade ao fazer o upload de dados para o 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
```
O Amazon Keyspaces usa as exceções `ReadTimeout` e `WriteTimeout` para indicar quando uma solicitação de gravação falha devido à capacidade de throughput insuficiente. Para ajudar a diagnosticar exceções de capacidade insuficiente, o Amazon Keyspaces publica `WriteThrottleEvents` uma métrica na Amazon. `ReadThrottledEvents` CloudWatch Para obter mais informações, consulte [Monitorando o Amazon Keyspaces com a Amazon CloudWatch](monitoring-cloudwatch.md).
**Erros de cqlsh ao fazer upload de dados para o Amazon Keyspaces**
Para ajudar a solucionar erros de cqlsh, execute novamente o comando com falha com o sinalizador `--debug`.
Ao usar uma versão incompatível do cqlsh, você vê o seguinte erro.
```
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 se a versão correta do cqlsh foi instalada executando o comando a seguir.
```
cqlsh --version
```
Você deve ver algo parecido com a saída a seguir.
```
cqlsh 5.0.1
```
Se estiver usando o Windows, substitua todas as instâncias de `cqlsh` por `cqlsh.bat`. Por exemplo, para verificar a versão do cqlsh no Windows, execute o comando a seguir.
```
cqlsh.bat --version
```
A conexão com o Amazon Keyspaces falha depois que o cliente cqlsh recebe três erros consecutivos de qualquer tipo do servidor. O cliente cqlsh falha com a seguinte mensagem.
```
Failed to import 1 rows: NoHostAvailable - , will retry later, attempt 3 of 100
```
Para resolver esse erro, você precisa garantir que os dados a serem importados correspondam ao esquema da tabela no Amazon Keyspaces. Verifique se há erros de análise no arquivo de importação. Você pode tentar usar uma única linha de dados usando uma instrução INSERT para isolar o erro.
O cliente tenta automaticamente restabelecer a conexão.