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: Integrazione con Apache Spark per importare o esportare dati Apache Spark è un motore open source per l'analisi dei dati su larga scala. Apache Spark ti consente di eseguire analisi sui dati archiviati in Amazon Keyspaces in modo più efficiente. Puoi anche utilizzare Amazon Keyspaces per fornire alle applicazioni un accesso coerente e in single-digit-millisecond lettura ai dati di analisi di Spark. L'open source Spark Cassandra Connector semplifica la lettura e la scrittura di dati tra Amazon Keyspaces e Spark. Il supporto di Amazon Keyspaces per Spark Cassandra Connector semplifica l'esecuzione dei carichi di lavoro Cassandra nelle pipeline di analisi basate su Spark utilizzando un servizio di database completamente gestito e senza server. Con Amazon Keyspaces, non devi preoccuparti che Spark possa competere per le stesse risorse infrastrutturali sottostanti delle tue tabelle. Le tabelle di Amazon Keyspaces si ridimensionano automaticamente verso l'alto e verso il basso in base al traffico dell'applicazione. Il seguente tutorial illustra i passaggi e le best practice necessari per leggere e scrivere dati su Amazon Keyspaces utilizzando il connettore Spark Cassandra. Il tutorial mostra come migrare i dati su Amazon Keyspaces caricando dati da un file con Spark Cassandra Connector e scrivendoli in una tabella Amazon Keyspaces. Quindi, il tutorial mostra come leggere i dati da Amazon Keyspaces utilizzando il connettore Spark Cassandra. Lo faresti per eseguire i carichi di lavoro di Cassandra in pipeline di analisi basate su Spark. **Topics** + [Prerequisiti per stabilire connessioni ad Amazon Keyspaces con Spark Cassandra Connector](spark-tutorial-prerequisites.md) + [Passaggio 1: configura Amazon Keyspaces per l'integrazione con il connettore Apache Cassandra Spark](spark-tutorial-step1.md) + [Fase 2: Configurazione del connettore Apache Cassandra Spark](spark-tutorial-step2.md) + [Fase 3: Creare il file di configurazione dell'applicazione](spark-tutorial-step3.md) + [Fase 4: Preparare i dati di origine e la tabella di destinazione in Amazon Keyspaces](spark-tutorial-step4.md) + [Passaggio 5: scrivere e leggere i dati di Amazon Keyspaces utilizzando il connettore Apache Cassandra Spark](spark-tutorial-step5.md) + [Risoluzione degli errori più comuni durante l'utilizzo del connettore Spark Cassandra con Amazon Keyspaces](spark-tutorial-step6.md) # Prerequisiti per stabilire connessioni ad Amazon Keyspaces con Spark Cassandra Connector Prima di connetterti ad Amazon Keyspaces con Spark Cassandra Connector, devi assicurarti di aver installato quanto segue. La compatibilità di Amazon Keyspaces con il connettore Spark Cassandra è stata testata con le seguenti versioni consigliate: + Java versione 8 + Scala 2.12 + Spark 3.4 + Cassandra Connector 2.5 e versioni successive + Driver Cassandra 4.12 1. Per installare Scala, segui le istruzioni su. [https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html) 1. Per installare Spark 3.4.1, segui questo esempio. ``` curl -o spark-3.4.1-bin-hadoop3.tgz -k https://dlcdn.apache.org/spark/spark-3.4.1/spark-3.4.1-bin-hadoop3.tgz # now to untar tar -zxvf spark-3.4.1-bin-hadoop3.tgz # set this variable. export SPARK_HOME=$PWD/spark-3.4.1-bin-hadoop3 ``` ``` # Passaggio 1: configura Amazon Keyspaces per l'integrazione con il connettore Apache Cassandra Spark In questo passaggio, confermi che il partizionatore del tuo account è compatibile con Apache Spark Connector e configuri le autorizzazioni IAM richieste. Le seguenti best practice consentono di fornire una capacità sufficiente read/write per la tabella. 1. Verifica che il `Murmur3Partitioner` partizionatore sia il partizionatore predefinito per il tuo account. Questo partizionatore è compatibile con lo Spark Cassandra Connector. Per ulteriori informazioni sui partizionatori e su come modificarli, consulta. [Utilizzo dei partizionatori in Amazon Keyspaces](working-with-partitioners.md) 1. Configura le autorizzazioni IAM per Amazon Keyspaces, utilizzando gli endpoint VPC dell'interfaccia, con Apache Spark. + Assegna read/write l'accesso alla tabella utenti e l'accesso in lettura alle tabelle di sistema, come mostrato nell'esempio di policy IAM riportato di seguito. + [È necessario compilare la tabella system.peers con gli endpoint VPC di interfaccia disponibili per i client che accedono ad Amazon Keyspaces con Spark tramite endpoint VPC.](https://docs.aws.amazon.com/keyspaces/latest/devguide/vpc-endpoints.html) ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "cassandra:Select", "cassandra:Modify" ], "Resource":[ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable", "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*" ] }, { "Sid":"ListVPCEndpoints", "Effect":"Allow", "Action":[ "ec2:DescribeNetworkInterfaces", "ec2:DescribeVpcEndpoints" ], "Resource":"*" } ] } ``` 1. Prendi in considerazione le seguenti best practice per configurare una capacità di throughput di lettura/scrittura sufficiente per la tabella Amazon Keyspaces per supportare il traffico proveniente dallo Spark Cassandra Connector. + Inizia a utilizzare la capacità on-demand per testare lo scenario. + Per ottimizzare il costo del throughput delle tabelle per gli ambienti di produzione, utilizza un limitatore di velocità per il traffico proveniente dal connettore e configura la tabella in modo che utilizzi la capacità assegnata con scalabilità automatica. Per ulteriori informazioni, consulta [Gestisci automaticamente la capacità di throughput con la scalabilità automatica di Amazon Keyspaces](autoscaling.md). + È possibile utilizzare un limitatore di velocità fisso fornito con il driver Cassandra. [Nel repository degli [esempi sono disponibili alcuni limitatori di velocità personalizzati per Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers).AWS](https://github.com/aws-samples) + Per ulteriori informazioni sulla gestione della capacità, consulta. [Configura le modalità di read/write capacità in Amazon Keyspaces](ReadWriteCapacityMode.md) # Fase 2: Configurazione del connettore Apache Cassandra Spark Apache Spark è una piattaforma di calcolo generica che puoi configurare in diversi modi. Per configurare Spark e Spark Cassandra Connector per l'integrazione con Amazon Keyspaces, ti consigliamo di iniziare con le impostazioni di configurazione minime descritte nella sezione seguente, per poi aumentarle in un secondo momento in base al tuo carico di lavoro. + **Crea partizioni Spark di dimensioni inferiori a 8. MBs** In Spark, *le partizioni* rappresentano un blocco atomico di dati che può essere eseguito in parallelo. Quando scrivi dati su Amazon Keyspaces con Spark Cassandra Connector, più piccola è la partizione Spark, minore è la quantità di record che l'attività scriverà. Se un'attività Spark rileva più errori, fallisce una volta esaurito il numero di tentativi designato. Per evitare di ripetere operazioni di grandi dimensioni e rielaborare una grande quantità di dati, mantieni piccole le dimensioni della partizione Spark. + **Utilizza un numero ridotto di scritture simultanee per esecutore con un numero elevato di tentativi.** Amazon Keyspaces restituisce errori di capacità insufficiente ai driver Cassandra come timeout operativi. Non puoi risolvere i timeout causati da una capacità insufficiente modificando la durata del timeout configurata, perché Spark Cassandra Connector tenta di riprovare le richieste in modo trasparente utilizzando il. `MultipleRetryPolicy` Per garantire che i nuovi tentativi non sovraccarichino il pool di connessioni del driver, utilizza un numero ridotto di scritture simultanee per esecutore con un numero elevato di tentativi. Il seguente frammento di codice ne è un esempio. ``` spark.cassandra.query.retry.count = 500 spark.cassandra.output.concurrent.writes = 3 ``` + **Suddividi il throughput totale e distribuiscilo su più sessioni di Cassandra.** + Il Cassandra Spark Connector crea una sessione per ogni esecutore Spark. Pensate a questa sessione come all'unità di scala per determinare il throughput richiesto e il numero di connessioni richieste. + Quando definite il numero di core per executor e il numero di core per task, iniziate con un valore basso e aumentatelo in base alle esigenze. + Imposta gli errori delle attività Spark per consentire l'elaborazione in caso di errori temporanei. Dopo aver acquisito familiarità con le caratteristiche e i requisiti di traffico dell'applicazione, ti consigliamo di `spark.task.maxFailures` impostare un valore limitato. + Ad esempio, la seguente configurazione può gestire due attività simultanee per esecutore, per sessione: ``` spark.executor.instances = configurable -> number of executors for the session. spark.executor.cores = 2 -> Number of cores per executor. spark.task.cpus = 1 -> Number of cores per task. spark.task.maxFailures = -1 ``` + **Disattiva il raggruppamento in batch.** + Ti consigliamo di disattivare il batch per migliorare i modelli di accesso casuale. Il seguente frammento di codice ne è un esempio. ``` spark.cassandra.output.batch.size.rows = 1 (Default = None) spark.cassandra.output.batch.grouping.key = none (Default = Partition) spark.cassandra.output.batch.grouping.buffer.size = 100 (Default = 1000) ``` + **`SPARK_LOCAL_DIRS`Impostato su un disco locale veloce con spazio sufficiente.** + Per impostazione predefinita, Spark salva i file di output delle mappe e i set di dati distribuiti resilienti (RDDs) in una cartella. `/tmp ` A seconda della configurazione dell'host Spark, ciò può comportare la perdita di *spazio sugli errori di stile del dispositivo*. + Per impostare la variabile di `SPARK_LOCAL_DIRS` ambiente su una directory chiamata`/example/spark-dir`, puoi usare il seguente comando. ``` export SPARK_LOCAL_DIRS=/example/spark-dir ``` # Fase 3: Creare il file di configurazione dell'applicazione Per utilizzare il connettore open source Spark Cassandra con Amazon Keyspaces, devi fornire un file di configurazione dell'applicazione che contenga le impostazioni necessarie per la connessione con il driver Java. DataStax Puoi utilizzare credenziali specifiche del servizio o il plug-in SigV4 per connetterti. Se non l'hai già fatto, devi convertire il certificato digitale utilizzato per creare la connessione TLS in un file TrustStore. Puoi seguire i passaggi dettagliati riportati nel tutorial sulla [Prima di iniziare](using_java_driver.md#using_java_driver.BeforeYouBegin) connessione dei driver Java. Prendi nota del percorso e della password del file TrustStore perché hai bisogno di queste informazioni quando crei il file di configurazione dell'applicazione. ## Connect con l'autenticazione SigV4 Questa sezione mostra un `application.conf` file di esempio che puoi usare quando ti connetti con AWS le credenziali e il plugin SigV4. Se non l'avete già fatto, dovete generare le vostre chiavi di accesso IAM (un ID della chiave di accesso e una chiave di accesso segreta) e salvarle nel file di AWS configurazione o come variabili di ambiente. Per istruzioni dettagliate, vedi [Credenziali richieste dal AWS CLI, dall' AWS SDK o dal plug-in Amazon Keyspaces SigV4 per i driver client Cassandra](SigV4_credentials.md). Nell'esempio seguente, sostituisci il percorso del file TrustStore e sostituisci la password. ``` datastax-java-driver { basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"] basic.load-balancing-policy { class = DefaultLoadBalancingPolicy local-datacenter = us-east-1 slow-replica-avoidance = false } basic.request { consistency = LOCAL_QUORUM } advanced { auth-provider = { class = software.aws.mcs.auth.SigV4AuthProvider aws-region = us-east-1 } ssl-engine-factory { class = DefaultSslEngineFactory truststore-path = "path_to_file/cassandra_truststore.jks" truststore-password = "password" hostname-validation=false } } advanced.connection.pool.local.size = 3 } ``` Aggiorna e salva questo file di configurazione come`/home/user1/application.conf`. I seguenti esempi utilizzano questo percorso. ## Connect con credenziali specifiche del servizio Questa sezione mostra un `application.conf` file di esempio che puoi utilizzare per connetterti con credenziali specifiche del servizio. Se non l'hai già fatto, devi generare credenziali specifiche per il servizio per Amazon Keyspaces. Per istruzioni dettagliate, vedi [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md). Nell'esempio seguente, sostituisci `username` e `password` con le tue credenziali. Inoltre, sostituisci il percorso del file TrustStore e sostituisci la password. ``` datastax-java-driver { basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"] basic.load-balancing-policy { class = DefaultLoadBalancingPolicy local-datacenter = us-east-1 } basic.request { consistency = LOCAL_QUORUM } advanced { auth-provider = { class = PlainTextAuthProvider username = "username" password = "password" aws-region = "us-east-1" } ssl-engine-factory { class = DefaultSslEngineFactory truststore-path = "path_to_file/cassandra_truststore.jks" truststore-password = "password" hostname-validation=false } metadata = { schema { token-map.enabled = true } } } } ``` Aggiorna e salva questo file di configurazione `/home/user1/application.conf` da utilizzare con l'esempio di codice. ## Connect con una tariffa fissa Per imporre una tariffa fissa per ogni esecutore Spark, puoi definire un Request throttler. Questo acceleratore di richieste limita la frequenza delle richieste al secondo. Lo Spark Cassandra Connector implementa una sessione Cassandra per executor. L'utilizzo della formula seguente può aiutarti a ottenere un throughput costante rispetto a una tabella. ``` max-request-per-second * numberOfExecutors = total throughput against a table ``` È possibile aggiungere questo esempio al file di configurazione dell'applicazione creato in precedenza. ``` datastax-java-driver { advanced.throttler { class = RateLimitingRequestThrottler max-requests-per-second = 3000 max-queue-size = 30000 drain-interval = 1 millisecond } } ``` # Fase 4: Preparare i dati di origine e la tabella di destinazione in Amazon Keyspaces In questo passaggio, crei un file sorgente con dati di esempio e una tabella Amazon Keyspaces. 1. Crea il file sorgente. Puoi scegliere una delle seguenti opzioni: + Per questo tutorial, si utilizza 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 lo stesso nome. `book_awards` 1. 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` + Se desideri scrivere dati in Amazon Keyspaces utilizzando il tuo file CSV, assicurati che i dati siano randomizzati. I dati letti direttamente da un database o esportati in file flat vengono in genere ordinati in base alla partizione e alla chiave primaria. L'importazione di dati ordinati in Amazon Keyspaces può causare la scrittura in segmenti più piccoli di partizioni Amazon Keyspaces, con conseguente distribuzione del traffico non uniforme. Ciò può comportare un rallentamento delle prestazioni e tassi di errore più elevati. Al contrario, la randomizzazione dei dati aiuta a sfruttare le funzionalità di bilanciamento del carico integrate di Amazon Keyspaces distribuendo il traffico tra le partizioni in modo più uniforme. Esistono vari strumenti che puoi utilizzare per la randomizzazione dei dati. Per un esempio che utilizza lo strumento open source [Shuf](https://en.wikipedia.org/wiki/Shuf), consulta [Passaggio 2: prepara i dati da caricare utilizzando DSBulk](dsbulk-upload-prepare-data.md) il tutorial sulla migrazione dei dati. Di seguito è riportato un esempio che mostra come mescolare i dati in un file. `DataFrame` ``` import org.apache.spark.sql.functions.randval shuffledDF = dataframe.orderBy(rand()) ``` 1. Crea lo spazio chiave e la tabella di destinazione in Amazon Keyspaces. 1. Connect ad Amazon Keyspaces utilizzando. `cqlsh-expansion` Per le istruzioni `cqlsh-expansion` di installazione, consulta[Utilizzo di `cqlsh-expansion` per connettersi ad Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Sostituisci l'endpoint del servizio nell'esempio seguente con il tuo valore. ``` cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl ``` 1. Create un nuovo keyspace con il nome `catalog` mostrato nell'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) ); ``` # Passaggio 5: scrivere e leggere i dati di Amazon Keyspaces utilizzando il connettore Apache Cassandra Spark In questo passaggio, inizierai caricando i dati dal file di esempio in un file `DataFrame` con lo Spark Cassandra Connector. Successivamente, scrivi i dati da `DataFrame` nella tabella Amazon Keyspaces. Puoi anche utilizzare questa parte in modo indipendente, ad esempio per migrare i dati in una tabella Amazon Keyspaces. Infine, leggi i dati dalla tua tabella in una `DataFrame` utilizzando lo Spark Cassandra Connector. Puoi anche utilizzare questa parte in modo indipendente, ad esempio per leggere i dati da una tabella Amazon Keyspaces per eseguire analisi dei dati con Apache Spark. 1. Avvia Spark Shell come mostrato nell'esempio seguente. Nota che questo esempio utilizza l'autenticazione SigV4. ``` ./spark-shell --files application.conf --conf spark.cassandra.connection.config.profile.path=application.conf --packages software.aws.mcs:aws-sigv4-auth-cassandra-java-driver-plugin:4.0.5,com.datastax.spark:spark-cassandra-connector_2.12:3.1.0 --conf spark.sql.extensions=com.datastax.spark.connector.CassandraSparkExtensions ``` 1. Importa lo Spark Cassandra Connector con il seguente codice. ``` import org.apache.spark.sql.cassandra._ ``` 1. Per leggere i dati dal file CSV e archiviarli in un file`DataFrame`, puoi utilizzare il seguente esempio di codice. ``` var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv") ``` È possibile visualizzare il risultato con il seguente comando. ``` scala> df.show(); ``` L'output dovrebbe essere simile a questo. ``` +----------------+----+-----------+----+------------------+--------------------+-------------+ | award|year| category|rank| author| book_title| publisher| +----------------+----+-----------+----+------------------+--------------------+-------------+ |Kwesi Manu Prize|2020| Fiction| 1| Akua Mansa| Where did you go?|SomePublisher| |Kwesi Manu Prize|2020| Fiction| 2| John Stiles| Yesterday|Example Books| |Kwesi Manu Prize|2020| Fiction| 3| Nikki Wolf|Moving to the Cha...| AnyPublisher| | Wolf|2020|Non-Fiction| 1| Wang Xiulan| History of Ideas|Example Books| | Wolf|2020|Non-Fiction| 2|Ana Carolina Silva| Science Today|SomePublisher| | Wolf|2020|Non-Fiction| 3| Shirley Rodriguez|The Future of Sea...| AnyPublisher| | Richard Roe|2020| Fiction| 1| Alejandro Rosalez| Long Summer|SomePublisher| | Richard Roe|2020| Fiction| 2| Arnav Desai| The Key|Example Books| | Richard Roe|2020| Fiction| 3| Mateo Jackson| Inside the Whale| AnyPublisher| +----------------+----+-----------+----+------------------+--------------------+-------------+ ``` È possibile confermare lo schema dei dati nel `DataFrame` modo illustrato nell'esempio seguente. ``` scala> df.printSchema ``` L'output dovrebbe essere simile a questo. ``` root |-- award: string (nullable = true) |-- year: integer (nullable = true) |-- category: string (nullable = true) |-- rank: integer (nullable = true) |-- author: string (nullable = true) |-- book_title: string (nullable = true) |-- publisher: string (nullable = true) ``` 1. Usa il comando seguente per scrivere i dati nella `DataFrame` tabella Amazon Keyspaces. ``` df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save() ``` 1. Per confermare che i dati sono stati salvati, puoi rileggerli in un dataframe, come mostrato nell'esempio seguente. ``` var newDf = spark.read.cassandraFormat("book_awards", "catalog").load() ``` Quindi puoi mostrare i dati che ora sono contenuti nel dataframe. ``` scala> newDf.show() ``` L'output di quel comando dovrebbe assomigliare a questo. ``` +--------------------+------------------+----------------+-----------+-------------+----+----+ | book_title| author| award| category| publisher|rank|year| +--------------------+------------------+----------------+-----------+-------------+----+----+ | Long Summer| Alejandro Rosalez| Richard Roe| Fiction|SomePublisher| 1|2020| | History of Ideas| Wang Xiulan| Wolf|Non-Fiction|Example Books| 1|2020| | Where did you go?| Akua Mansa|Kwesi Manu Prize| Fiction|SomePublisher| 1|2020| | Inside the Whale| Mateo Jackson| Richard Roe| Fiction| AnyPublisher| 3|2020| | Yesterday| John Stiles|Kwesi Manu Prize| Fiction|Example Books| 2|2020| |Moving to the Cha...| Nikki Wolf|Kwesi Manu Prize| Fiction| AnyPublisher| 3|2020| |The Future of Sea...| Shirley Rodriguez| Wolf|Non-Fiction| AnyPublisher| 3|2020| | Science Today|Ana Carolina Silva| Wolf|Non-Fiction|SomePublisher| 2|2020| | The Key| Arnav Desai| Richard Roe| Fiction|Example Books| 2|2020| +--------------------+------------------+----------------+-----------+-------------+----+----+ ``` # Risoluzione degli errori più comuni durante l'utilizzo del connettore Spark Cassandra con Amazon Keyspaces Se utilizzi Amazon Virtual Private Cloud e ti connetti ad Amazon Keyspaces, gli errori più comuni riscontrati durante l'utilizzo del connettore Spark sono causati dai seguenti problemi di configurazione. + L'utente o il ruolo IAM utilizzato nel VPC non dispone delle autorizzazioni necessarie per accedere alla tabella `system.peers` in Amazon Keyspaces. Per ulteriori informazioni, consulta [Inserimento delle voci della `system.peers` tabella con informazioni sugli endpoint VPC dell'interfaccia](vpc-endpoints.md#system_peers). + L'utente o il ruolo IAM non dispone delle read/write autorizzazioni richieste per la tabella degli utenti e l'accesso in lettura alle tabelle di sistema in Amazon Keyspaces. Per ulteriori informazioni, consulta [Passaggio 1: configura Amazon Keyspaces per l'integrazione con il connettore Apache Cassandra Spark](spark-tutorial-step1.md). + La configurazione del driver Java non disabilita la verifica del nome host durante la creazione della connessione SSL/TLS. Per alcuni esempi, consulta [Fase 2: Configurare il driver](using_java_driver.md#java_tutorial.driverconfiguration). Per una procedura dettagliata per la risoluzione dei problemi di connessione, consulta. [La mia connessione endpoint VPC non funziona correttamente](troubleshooting.connecting.md#troubleshooting.connection.vpce) Inoltre, puoi utilizzare i CloudWatch parametri di Amazon per aiutarti a risolvere i problemi relativi alla configurazione del connettore Spark Cassandra in Amazon Keyspaces. Per ulteriori informazioni sull'utilizzo di Amazon Keyspaces con CloudWatch, consulta. [Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md) La sezione seguente descrive le metriche più utili da osservare quando utilizzi lo Spark Cassandra Connector. **PerConnectionRequestRateExceeded** Amazon Keyspaces ha una quota di 3.000 richieste al secondo, per connessione. Ogni esecutore Spark stabilisce una connessione con Amazon Keyspaces. L'esecuzione di più tentativi può esaurire la quota di richieste per connessione. Se superi questa quota, Amazon Keyspaces emette un `PerConnectionRequestRateExceeded` parametro in. CloudWatch Se vedi PerConnectionRequestRateExceeded eventi presenti insieme ad altri errori di sistema o utente, è probabile che Spark stia eseguendo più tentativi oltre il numero di richieste assegnato per connessione. Se vedi `PerConnectionRequestRateExceeded` eventi senza altri errori, potrebbe essere necessario aumentare il numero di connessioni nelle impostazioni del driver per consentire una maggiore velocità di trasmissione, oppure potresti dover aumentare il numero di executor nel tuo job Spark. **StoragePartitionThroughputCapacityExceeded** Amazon Keyspaces ha una quota di 1.000 WCUs o WRUs al secondo/3.000 RCUs o RRUs al secondo, per partizione. Se visualizzi `StoragePartitionThroughputCapacityExceeded` CloudWatch eventi, ciò potrebbe indicare che i dati non sono randomizzati durante il caricamento. Per esempi su come mescolare i dati, vedi. [Fase 4: Preparare i dati di origine e la tabella di destinazione in Amazon Keyspaces](spark-tutorial-step4.md) ## Errori e avvertenze comuni Se utilizzi Amazon Virtual Private Cloud e ti connetti ad Amazon Keyspaces, il driver Cassandra potrebbe emettere un messaggio di avviso relativo al nodo di controllo stesso nella tabella. `system.peers` Per ulteriori informazioni, consulta [Errori e avvertenze comuni](vpc-endpoints.md#vpc_troubleshooting). Puoi tranquillamente ignorare questo avviso.