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

# Etapa 4: Definir configurações de `cqlsh COPY FROM`
<a name="bulk-upload-config"></a>

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.