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à. # Come scegliere lo strumento giusto per il caricamento in blocco o la migrazione di dati su Amazon Keyspaces In questa sezione puoi esaminare i diversi strumenti che puoi utilizzare per caricare in blocco o migrare dati su Amazon Keyspaces e scoprire come selezionare lo strumento corretto in base alle tue esigenze. Inoltre, questa sezione fornisce una panoramica e casi d'uso per step-by-step i tutorial disponibili che dimostrano come importare dati in Amazon Keyspaces. Per esaminare le strategie disponibili per migrare i carichi di lavoro da Apache Cassandra ad Amazon Keyspaces, consulta. [Crea un piano di migrazione per la migrazione da Apache Cassandra ad Amazon Keyspaces](migrating-cassandra.md) + **Strumenti di migrazione** + Con il [calcolatore dei prezzi per Amazon Keyspaces (per Apache Cassandra](https://aws-samples.github.io/sample-pricing-calculator-for-keyspaces/#cassandra)) disponibile su Github, puoi stimare i costi mensili per Amazon Keyspaces in base al tuo carico di lavoro Apache Cassandra esistente. Inserisci i parametri dello stato dello strumento Cassandra e della configurazione serverless prevista per Amazon Keyspaces per confrontare i costi diretti tra le due soluzioni. Tieni presente che questo calcolatore si concentra solo sui costi operativi di Amazon Keyspaces rispetto alla distribuzione Cassandra esistente. Non include fattori del costo totale di proprietà (TCO) come la manutenzione dell'infrastruttura, le spese generali operative o i costi di supporto per Cassandra. + **Proxy ZDM Dual Write per Amazon Keyspaces Migration — ZDM Dual Write Proxy disponibile su [Github](https://github.com/aws-samples/amazon-keyspaces-examples/blob/main/migration/online/zdm-proxy/README.md) supporta la migrazione** senza downtime da Apache Cassandra ad Amazon Keyspaces. + **CQLReplicator**— CQLReplicator è un'utilità open source disponibile su [Github](https://github.com/aws-samples/cql-replicator) che consente di migrare i dati da Apache Cassandra ad Amazon Keyspaces quasi in tempo reale. Per ulteriori informazioni, consulta [Migra i dati utilizzando CQLReplicator](migration-hybrid-cql-rep.md). + Per ulteriori informazioni su come utilizzare Amazon Managed Streaming for Apache Kafka per [implementare un](migrating-online.md) processo di migrazione online con doppia scrittura[, consulta la Guida per la migrazione continua dei dati da](https://aws.amazon.com/solutions/guidance/continuous-data-migration-from-apache-cassandra-to-amazon-keyspaces/) Apache Cassandra ad Amazon Keyspaces. + Per migrazioni di grandi dimensioni, prendi in considerazione l'utilizzo di uno strumento di estrazione, trasformazione e caricamento (ETL). È possibile utilizzarlo AWS Glue per eseguire migrazioni di trasformazione dei dati in modo rapido ed efficace. Per ulteriori informazioni, consulta [Processo di migrazione offline: da Apache Cassandra ad Amazon Keyspaces](migrating-offline.md). + Per informazioni su come utilizzare il connettore Apache Cassandra Spark per scrivere dati su Amazon Keyspaces, consulta. [Tutorial: Integrazione con Apache Spark per importare o esportare dati](spark-integrating.md) + Inizia rapidamente a caricare dati in Amazon Keyspaces utilizzando il `COPY FROM` comando cqlsh. cqlsh è incluso in Apache Cassandra ed è ideale per caricare piccoli set di dati o dati di test. step-by-stepPer istruzioni, consulta. [Tutorial: Caricamento di dati in Amazon Keyspaces utilizzando cqlsh](bulk-upload.md) + Puoi anche utilizzare DataStax Bulk Loader per Apache Cassandra per caricare dati in Amazon Keyspaces utilizzando il comando. `dsbulk` DSBulk[offre funzionalità di importazione più solide rispetto a cqlsh ed è disponibile nel repository. GitHub ](https://github.com/datastax/dsbulk) Per step-by-step istruzioni, vedere. [Tutorial: caricamento di dati in Amazon Keyspaces utilizzando DSBulk](dsbulk-upload.md) Considerazioni generali per il caricamento di dati su Amazon Keyspaces + **Suddividi il caricamento dei dati in componenti più piccoli.** Considerate le seguenti unità di migrazione e il loro potenziale impatto in termini di dimensioni dei dati grezzi. Il caricamento di piccole quantità di dati in una o più fasi può contribuire a semplificare la migrazione. + **Per cluster**: migra tutti i dati di Cassandra contemporaneamente. Questo approccio può essere utile per i cluster più piccoli. + **Per spazio di chiavi o tabella**: suddividi la migrazione in gruppi di spazi chiave o tabelle. Questo approccio può aiutarti a migrare i dati in fasi in base ai requisiti per ogni carico di lavoro. + **In base ai dati**: valuta la possibilità di migrare i dati per un gruppo specifico di utenti o prodotti, per ridurre ulteriormente le dimensioni dei dati. + **Dai la priorità ai dati da caricare per primi in base alla semplicità.** Valuta se disponi di dati che potrebbero essere migrati per primi più facilmente, ad esempio dati che non cambiano in orari specifici, dati provenienti da processi in batch notturni, dati non utilizzati durante le ore offline o dati provenienti da app interne. **Topics** + [Tutorial: Caricamento di dati in Amazon Keyspaces utilizzando cqlsh](bulk-upload.md) + [Tutorial: caricamento di dati in Amazon Keyspaces utilizzando DSBulk](dsbulk-upload.md) # 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. # 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).