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 DSBulk Questo step-by-step tutorial ti guida nella migrazione dei dati da Apache Cassandra ad Amazon Keyspaces utilizzando DataStax Bulk Loader () disponibile su. DSBulk [GitHub](https://github.com/datastax/dsbulk.git) L'utilizzo DSBulk è utile per caricare 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, configura, scarica `cqlsh` DSBulk, installa e configura un file. `application.conf` 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 DSBulk le impostazioni**: crea un file di DSBulk configurazione con impostazioni come autenticazione, SSL/TLS, livello di coerenza e dimensione del pool di connessioni. 1. **Esegui il comando DSBulk load**: esegui il comando DSBulk load per caricare i dati dal file CSV nella tabella Amazon Keyspaces e monitorare l'avanzamento. **Topics** + [Prerequisiti: passaggi da completare prima di poter caricare i dati con DSBulk](dsbulk-upload-prequs.md) + [Passaggio 1: creare il file CSV di origine e una tabella di destinazione per il caricamento dei dati utilizzando DSBulk](dsbulk-upload-source.md) + [Passaggio 2: prepara i dati da caricare utilizzando DSBulk](dsbulk-upload-prepare-data.md) + [Fase 3: Impostare la capacità di throughput per la tabella di destinazione](dsbulk-upload-capacity.md) + [Passaggio 4: Configurare `DSBulk` le impostazioni per caricare i dati dal file CSV alla tabella di destinazione](dsbulk-upload-config.md) + [Passaggio 5: Esegui il DSBulk `load` comando per caricare i dati dal file CSV nella tabella di destinazione](dsbulk-upload-run.md) # Prerequisiti: passaggi da completare prima di poter caricare i dati con DSBulk È necessario completare le seguenti attività prima di iniziare questo tutorial. 1. Se non l'hai ancora fatto, crea un AWS account seguendo i passaggi riportati in[Configurazione AWS Identity and Access Management](accessing.md#SettingUp.IAM). 1. Crea le credenziali seguendo i passaggi riportati in[Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md). 1. Crea un file di trust store JKS. 1. Scarica i seguenti certificati digitali e salva i file localmente o nella tua home directory. 1. AmazonRootCA1 1. AmazonRootCA2 1. AmazonRootCA3 1. AmazonRootCA4 1. Starfield Class 2 Root (opzionale, per compatibilità con le versioni precedenti) Per scaricare i certificati, puoi usare i seguenti comandi. ``` 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** Amazon Keyspaces utilizzava in precedenza certificati TLS ancorati alla CA Starfield Class 2. AWS sta migrando tutto Regioni AWS verso certificati emessi nell'ambito di Amazon Trust Services (Amazon Root CAs 1—4). Durante questa transizione, configura i client in modo che si fidino sia di Amazon Root CAs 1-4 che di Starfield root per garantire la compatibilità in tutte le regioni. 1. Converti i certificati digitali in file TrustStore e aggiungili al 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 ``` Nell'ultimo passaggio, è necessario creare una password per il keystore e considerare attendibile ogni certificato. Il comando interattivo ha questo aspetto. ``` 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. 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) 1. Scarica e installa. DSBulk **Nota** La versione mostrata in questo tutorial potrebbe non essere l'ultima disponibile. Prima di eseguire il download DSBulk, controlla la [pagina di download di DataStax Bulk Loader](https://downloads.datastax.com/#bulk-loader) per la versione più recente e aggiorna di conseguenza il numero di versione nei seguenti comandi. 1. Per effettuare il download DSBulk, è possibile utilizzare il codice seguente. ``` curl -OL https://downloads.datastax.com/dsbulk/dsbulk-1.8.0.tar.gz ``` 1. Quindi decomprimi il file tar e aggiungilo DSBulk al tuo `PATH` come mostrato nell'esempio seguente. ``` tar -zxvf dsbulk-1.8.0.tar.gz # add the DSBulk directory to the path export PATH=$PATH:./dsbulk-1.8.0/bin ``` 1. Crea un `application.conf` file per memorizzare le impostazioni da utilizzare. DSBulk È possibile salvare il seguente esempio come`./dsbulk_keyspaces.conf`. Sostituiscilo `localhost` con il punto di contatto del cluster Cassandra locale se non ti trovi sul nodo locale, ad esempio il nome DNS o l'indirizzo IP. Prendi nota del nome e del percorso del file, poiché dovrai specificarlo più avanti nel `dsbulk load` comando. ``` datastax-java-driver { basic.contact-points = [ "localhost"] advanced.auth-provider { class = software.aws.mcs.auth.SigV4AuthProvider aws-region = us-east-1 } } ``` 1. Per abilitare il supporto SigV4, scaricate il `jar` file ombreggiato da [GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/)e inseritelo nella DSBulk `lib` cartella come mostrato nell'esempio seguente. ``` 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 ``` # Passaggio 1: creare il file CSV di origine e una tabella di destinazione per il caricamento dei dati utilizzando DSBulk 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 `dsbulk unload` quanto illustrato nell'esempio seguente. ``` dsbulk unload -k mykeyspace -t mytable -f ./my_application.conf > keyspaces_sample_table.csv ``` 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. Dopo che il nuovo keyspace ha lo stato di disponibile, utilizzate il codice seguente per creare la tabella di destinazione. `book_awards` Per ulteriori informazioni sulla creazione asincrona di risorse e su come verificare se una risorsa è disponibile, consulta. [Verifica lo stato di creazione del keyspace in 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 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 mostrato 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 da caricare utilizzando DSBulk 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 `dsbulk` parametri appropriati e le impostazioni della tabella richieste. **Randomizza i dati** Il `dsbulk` comando legge e scrive i dati nello stesso ordine in cui appaiono nel file CSV. Se si utilizza il `dsbulk` 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} ``` Assicurati che la dimensione massima delle righe non superi 1 MB. In caso affermativo, devi suddividere la riga o comprimere i dati per portare la dimensione della riga al di sotto di 1 MB. Nel passaggio successivo di questo tutorial, utilizzerai la dimensione media delle righe per fornire la capacità di scrittura per la tabella. # Fase 3: Impostare la capacità di throughput per la tabella di destinazione Questo tutorial mostra come eseguire la regolazione per DSBulk 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 assegnare fino a 40.000 unità WCUs a una tabella e 80.000 unità WCUs in 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 `ALTER TABLE` comando. Di seguito è riportata la sintassi per modificare le impostazioni della capacità assegnata a una tabella con il comando. `ALTER TABLE` ``` ALTER TABLE catalog.book_awards WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ; ``` Per il riferimento completo alla lingua, vedere e. [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter) # Passaggio 4: Configurare `DSBulk` le impostazioni per caricare i dati dal file CSV alla tabella di destinazione Questa sezione descrive i passaggi necessari DSBulk per configurare il caricamento dei dati su Amazon Keyspaces. La configurazione DSBulk viene effettuata utilizzando un file di configurazione. Il file di configurazione viene specificato direttamente dalla riga di comando. 1. Crea un file di DSBulk configurazione per la migrazione ad Amazon Keyspaces, in questo esempio utilizziamo il nome del file. `dsbulk_keyspaces.conf` Specificate le seguenti impostazioni nel file DSBulk di configurazione. 1. *`PlainTextAuthProvider`*— Crea il provider di autenticazione con la `PlainTextAuthProvider` classe. `ServiceUserName`e `ServicePassword` deve corrispondere al nome utente e alla password ottenuti al momento della generazione delle credenziali specifiche del servizio seguendo la procedura riportata in. [Crea credenziali per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.md) 1. *`local-datacenter`*— Imposta il valore `local-datacenter` per il quale Regione AWS ti stai connettendo. Ad esempio, se l'applicazione si connette a`cassandra.us-east-1.amazonaws.com`, imposta il data center locale su`us-east-1`. Per tutte le opzioni disponibili Regioni AWS, vedi[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md). Per evitare repliche, imposta su`slow-replica-avoidance`. `false` 1. *`SSLEngineFactory`*— Per configurare SSL/TLS, inizializza `SSLEngineFactory` aggiungendo una sezione nel file di configurazione con una sola riga che specifica la classe con. `class = DefaultSslEngineFactory` Fornisci il percorso `cassandra_truststore.jks` e la password che hai creato in precedenza. 1. *`consistency`*— Imposta il livello di coerenza su`LOCAL QUORUM`. Altri livelli di coerenza di scrittura non sono supportati, per ulteriori informazioni, vedere[Livelli di coerenza di lettura e scrittura supportati da Apache Cassandra e costi associati](consistency.md). 1. Il numero di connessioni per pool è configurabile nel driver Java. Per questo esempio, imposta su `advanced.connection.pool.local.size` 3. Di seguito è riportato il file di configurazione di esempio 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. Esaminate i parametri del DSBulk `load` comando. 1. *`executor.maxPerSecond`*— Il numero massimo di righe che il comando load tenta di elaborare contemporaneamente al secondo. Se non è impostata, questa impostazione viene disabilitata con -1. Imposta in `executor.maxPerSecond` base al numero di WCUs elementi che hai assegnato alla tabella di destinazione. Il valore `executor.maxPerSecond` del `load` comando non è un limite, ma una media obiettivo. 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 `executor.maxPerSecond` il 90% della capacità di scrittura della tabella. ``` executor.maxPerSecond = WCUs * .90 ``` In questo tutorial, abbiamo impostato su `executor.maxPerSecond` 5. **Nota** Se stai usando DSBulk 1.6.0 o versioni successive, puoi usare `dsbulk.engine.maxConcurrentQueries` invece. 1. Configura questi parametri aggiuntivi per il DSBulk `load` comando. + *`batch-mode`*— Questo parametro indica al sistema di raggruppare le operazioni per chiave di partizione. Si consiglia di disabilitare la modalità batch, poiché può causare scenari e cause `WriteThrottleEvents` con tasti di scelta rapida. + *`driver.advanced.retry-policy-max-retries`*— Ciò determina quante volte riprovare un'interrogazione non riuscita. Se non è impostata, l'impostazione predefinita è 10. È possibile modificare questo valore in base alle esigenze. + *`driver.basic.request.timeout`*— Il tempo in minuti in cui il sistema attende la restituzione di una query. Se non è impostata, l'impostazione predefinita è «5 minuti». È possibile modificare questo valore in base alle esigenze. # Passaggio 5: Esegui il DSBulk `load` comando per caricare i dati dal file CSV nella tabella di destinazione Nella fase finale di questo tutorial, carichi i dati in Amazon Keyspaces. Per eseguire il DSBulk `load` comando, completa i seguenti passaggi. 1. Esegui il codice seguente per caricare i dati dal tuo file csv nella tabella Amazon Keyspaces. Assicurati di aggiornare il percorso del file di configurazione dell'applicazione che hai creato in precedenza. ``` 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. L'output include la posizione di un file di registro che riporta i dettagli delle operazioni riuscite e non riuscite. Il file è memorizzato nella seguente directory. ``` Operation directory: /home/user_name/logs/UNLOAD_20210308-202317-801911 ``` 1. Le voci del file di registro includeranno le metriche, come nell'esempio seguente. Assicurati che il numero di righe sia coerente con il numero di righe del tuo file csv. ``` total | failed | rows/s | p50ms | p99ms | p999ms 200 | 0 | 200 | 21.63 | 21.89 | 21.89 ``` **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. Per ulteriori informazioni, consulta [Configura le modalità di read/write capacità in Amazon Keyspaces](ReadWriteCapacityMode.md).