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: Carregando dados no Amazon Keyspaces usando DSBulk
Este step-by-step tutorial orienta você na migração de dados do Apache Cassandra para o Amazon Keyspaces usando o Bulk Loader () DataStax disponível em. DSBulk [GitHub](https://github.com/datastax/dsbulk.git) DSBulk O uso é útil para fazer upload de conjuntos de dados para o 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). Neste tutorial, você concluirá as seguintes etapas.
Pré-requisitos — Configure uma AWS conta com credenciais, crie um arquivo de armazenamento confiável JKS para o certificado, configure, baixe `cqlsh` DSBulk, instale e configure um arquivo. `application.conf`
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. ** DSBulk Definir configurações** — Crie um arquivo de DSBulk configuração com configurações como autenticação, SSL/TLS, nível de consistência e tamanho do pool de conexão.
1. **Execute o comando DSBulk load** — Execute o comando DSBulk load para carregar os dados do arquivo CSV para a tabela do Amazon Keyspaces e monitorar o progresso.
**Topics**
+ [Pré-requisitos: etapas que você precisa concluir antes de fazer o upload de dados com DSBulk](dsbulk-upload-prequs.md)
+ [Etapa 1: Crie o arquivo CSV de origem e uma tabela de destino para o upload de dados usando DSBulk](dsbulk-upload-source.md)
+ [Etapa 2: Prepare os dados para upload usando DSBulk](dsbulk-upload-prepare-data.md)
+ [Etapa 3: definir a capacidade de throughput da tabela de destino](dsbulk-upload-capacity.md)
+ [Etapa 4: definir as configurações de `DSBulk` para carregar dados do arquivo CSV para a tabela de destino](dsbulk-upload-config.md)
+ [Etapa 5: Executar o comando DSBulk `load` para carregar dados do arquivo CSV para a tabela de destino](dsbulk-upload-run.md)
# Pré-requisitos: etapas que você precisa concluir antes de fazer o upload de dados com DSBulk
É necessário concluir as tarefas a seguir antes de iniciar este tutorial.
1. Se você ainda não fez isso, inscreva-se em uma AWS conta seguindo as etapas em[Conf AWS Identity and Access Management iguração](accessing.md#SettingUp.IAM).
1. Crie credenciais seguindo as etapas em [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
1. Crie um arquivo JKS de armazenamento confiável.
1. Faça o download dos seguintes certificados digitais e salve os arquivos localmente ou em seu diretório pessoal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional — para compatibilidade com versões anteriores)
Para baixar os certificados, você pode usar os seguintes 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**
O Amazon Keyspaces usava anteriormente certificados TLS ancorados na CA Starfield Class 2. AWS está migrando tudo Regiões da AWS para certificados emitidos pelo Amazon Trust Services (Amazon Root CAs 1—4). Durante essa transição, configure os clientes para que confiem tanto na Amazon Root CAs 1—4 quanto na raiz Starfield para garantir a compatibilidade em todas as regiões.
1. Converta os certificados digitais em arquivos TrustStore e adicione-os ao keystore.
```
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
```
Na última etapa, você precisa criar uma senha para o armazenamento de chaves e confiar em cada certificado. O comando interativo tem a aparência a seguir.
```
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 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).
1. Baixe e instale DSBulk.
**nota**
A versão mostrada neste tutorial pode não ser a versão mais recente disponível. Antes de fazer o download DSBulk, verifique a [página de download do DataStax Bulk Loader](https://downloads.datastax.com/#bulk-loader) para obter a versão mais recente e atualize adequadamente o número da versão nos comandos a seguir.
1. Para fazer o download DSBulk, você pode usar o código a seguir.
```
curl -OL https://downloads.datastax.com/dsbulk/dsbulk-1.8.0.tar.gz
```
1. Em seguida, descompacte o arquivo tar e adicione-o DSBulk ao seu`PATH`, conforme mostrado no exemplo a seguir.
```
tar -zxvf dsbulk-1.8.0.tar.gz
# add the DSBulk directory to the path
export PATH=$PATH:./dsbulk-1.8.0/bin
```
1. Crie um `application.conf` arquivo para armazenar as configurações a serem usadas DSBulk. Você pode salvar o exemplo a seguir como `./dsbulk_keyspaces.conf`. Substitua `localhost` pelo ponto de contato do seu cluster Cassandra local se você não estiver no nó local, por exemplo, o nome DNS ou o endereço IP. Anote o nome e o caminho do arquivo, pois você precisará especificar isso posteriormente no 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 ativar o suporte ao SigV4, baixe o `jar` arquivo sombreado [GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/)e coloque-o na DSBulk `lib` pasta, conforme mostrado no exemplo a seguir.
```
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
```
# Etapa 1: Crie o arquivo CSV de origem e uma tabela de destino para o upload de dados usando DSBulk
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 Apache Cassandra, você pode preencher o arquivo CSV de origem usando `dsbulk unload`, conforme mostrado no exemplo a seguir.
```
dsbulk unload -k mykeyspace -t mytable -f ./my_application.conf > keyspaces_sample_table.csv
```
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. Depois que o novo keyspace tiver o status de disponível, use o código a seguir para criar a tabela `book_awards` de destino. Para saber mais sobre a criação assíncrona de recursos e como verificar se um recurso está disponível, consulte [Verifique o status de criação do keyspace no 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)
);
```
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 declaração `CREATE TABLE` a partir da tabela de origem, conforme mostrado na declaraçã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: Prepare os dados para upload usando DSBulk
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 `dsbulk` apropriados e as configurações de tabela necessárias.
**Randomizar os dados**
O comando `dsbulk` lê e grava dados na mesma ordem em que aparecem no arquivo CSV. Se você usar o comando `dsbulk` 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}
```
Certifique-se de que o tamanho máximo da linha não exceda 1 MB. Se isso acontecer, você precisará dividir a linha ou compactar os dados para reduzir o tamanho da linha para menos de 1 MB. Na próxima etapa deste tutorial, você usa o tamanho médio da linha para provisionar a capacidade de gravação da tabela.
# Etapa 3: definir a capacidade de throughput da tabela de destino
Este tutorial mostra como ajustar o carregamento DSBulk de dados dentro de 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 `ALTER TABLE`. A seguir está a sintaxe para alterar as configurações de capacidade provisionada de uma tabela com o 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 obter a referência completa do idioma, consulte [CRIAR TABELA](cql.ddl.table.md#cql.ddl.table.create) e [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Etapa 4: definir as configurações de `DSBulk` para carregar dados do arquivo CSV para a tabela de destino
Esta seção descreve as etapas necessárias para configurar o upload de dados DSBulk para o Amazon Keyspaces. Você configura DSBulk usando um arquivo de configuração. Você especifica o arquivo de configuração diretamente da linha de comando.
1. Crie um arquivo de DSBulk configuração para a migração para o Amazon Keyspaces. Neste exemplo, usamos o nome do arquivo. `dsbulk_keyspaces.conf` Especifique as seguintes configurações no arquivo DSBulk de configuração.
1. *`PlainTextAuthProvider`*: crie o provedor de autenticação com a classe `PlainTextAuthProvider`. `ServiceUserName` e `ServicePassword` devem corresponder ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas em [Crie credenciais para acesso programático ao Amazon Keyspaces](programmatic.credentials.md).
1. *`local-datacenter`*— Defina o valor do `local-datacenter` ao Região da AWS qual você está se conectando. Por exemplo, se o aplicativo estiver se conectando a `cassandra.us-east-1.amazonaws.com`, defina o datacenter local como `us-east-1`. Para todos os disponíveis Regiões da AWS, consulte[Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md). Para evitar réplicas, defina `slow-replica-avoidance` como `false`.
1. *`SSLEngineFactory`*: para configurar o SSL/TLS, inicialize o `SSLEngineFactory` adicionando uma seção no arquivo de configuração com uma única linha que especifica a classe com `class = DefaultSslEngineFactory`. Forneça o caminho para `cassandra_truststore.jks` e a senha que você criou anteriormente.
1. *`consistency`*: defina o nível de consistência como `LOCAL QUORUM`. Outros níveis de consistência de gravação não são compatíveis; para obter mais informações, consulte [Níveis de consistência de leitura e gravação do Apache Cassandra suportados e custos associados](consistency.md).
1. O número de conexões por grupo é configurável no driver Java. Para este exemplo, defina `advanced.connection.pool.local.size` como 3.
Veja a seguir o arquivo de configuração de exemplo 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 os parâmetros do DSBulk `load` comando.
1. *`executor.maxPerSecond`*: o número máximo de linhas que o comando load tenta processar simultaneamente por segundo. Se não for definida, essa configuração é desativada com -1.
Defina `executor.maxPerSecond` com base no número do WCUs que você provisionou para a tabela de destino de destino. O `executor.maxPerSecond` do comando `load` 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 `executor.maxPerSecond` como 90% da capacidade de gravação da tabela.
```
executor.maxPerSecond = WCUs * .90
```
Neste tutorial, definimos `executor.maxPerSecond` como 5.
**nota**
Se você estiver usando DSBulk 1.6.0 ou superior, poderá usar `dsbulk.engine.maxConcurrentQueries` em vez disso.
1. Configure esses parâmetros adicionais para o DSBulk `load` comando.
+ *`batch-mode`*: esse parâmetro instrui o sistema a agrupar as operações por chave de partição. Recomendamos desativar o modo em lote, pois isso pode resultar em cenários e causas de teclas de atalho `WriteThrottleEvents`.
+ *`driver.advanced.retry-policy-max-retries`*: isso determina quantas vezes tentar novamente uma consulta com falha. Se não estiver definido, o padrão é 10. Você pode ajustar esse valor conforme necessário.
+ *`driver.basic.request.timeout`* – O tempo em minutos em que o sistema espera o retorno de uma consulta. Se não estiver definido, o padrão é "5 minutos". Você pode ajustar esse valor conforme necessário.
# Etapa 5: Executar o comando DSBulk `load` para carregar dados do arquivo CSV para a tabela de destino
Na etapa final deste tutorial, você carrega os dados no Amazon Keyspaces.
Conclua as etapas a seguir para executar o comando DSBulk `load`.
1. Execute o código a seguir para fazer o upload dos dados do seu arquivo csv para a tabela do Amazon Keyspaces. Certifique-se de atualizar o caminho para o arquivo de configuração do aplicativo que você criou 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. A saída inclui a localização de um arquivo de log que detalha as operações bem-sucedidas e malsucedidas. O arquivo é armazenado no diretório a seguir.
```
Operation directory: /home/user_name/logs/UNLOAD_20210308-202317-801911
```
1. As entradas do arquivo de log incluirão métricas, como no exemplo a seguir. Verifique se o número de linhas é consistente com o número de linhas em seu arquivo csv.
```
total | failed | rows/s | p50ms | p99ms | p999ms
200 | 0 | 200 | 21.63 | 21.89 | 21.89
```
**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. Para obter mais informações, consulte [Configurar modos de read/write capacidade no Amazon Keyspaces](ReadWriteCapacityMode.md).