Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriel : Intégrer à Apache Spark pour importer ou exporter des données
Apache Spark est un moteur open source pour l'analyse de données à grande échelle. Apache Spark vous permet d'analyser plus efficacement les données stockées dans Amazon Keyspaces. Vous pouvez également utiliser Amazon Keyspaces pour fournir aux applications un accès en single-digit-millisecond lecture cohérent aux données analytiques de Spark. Le connecteur open source Spark Cassandra simplifie la lecture et l'écriture de données entre Amazon Keyspaces et Spark.
La prise en charge par Amazon Keyspaces du connecteur Spark Cassandra rationalise l'exécution des charges de travail Cassandra dans les pipelines d'analyse basés sur Spark en utilisant un service de base de données entièrement géré et sans serveur. Avec Amazon Keyspaces, vous n'avez pas à craindre que Spark soit en concurrence pour les mêmes ressources d'infrastructure sous-jacentes que vos tables. Les tables Amazon Keyspaces augmentent ou diminuent automatiquement en fonction du trafic de votre application.
Le didacticiel suivant explique les étapes et les meilleures pratiques requises pour lire et écrire des données sur Amazon Keyspaces à l'aide du connecteur Spark Cassandra. Ce didacticiel explique comment migrer des données vers Amazon Keyspaces en chargeant des données depuis un fichier avec le connecteur Spark Cassandra et en les écrivant dans une table Amazon Keyspaces. Le didacticiel explique ensuite comment relire les données d'Amazon Keyspaces à l'aide du connecteur Spark Cassandra. Vous devez procéder ainsi pour exécuter des charges de travail Cassandra dans des pipelines d'analyse basés sur Spark.
**Topics**
+ [Conditions préalables pour établir des connexions à Amazon Keyspaces avec le connecteur Spark Cassandra](spark-tutorial-prerequisites.md)
+ [Étape 1 : configurer Amazon Keyspaces pour l'intégration au connecteur Apache Cassandra Spark](spark-tutorial-step1.md)
+ [Étape 2 : Configuration du connecteur Apache Cassandra Spark](spark-tutorial-step2.md)
+ [Étape 3 : Création du fichier de configuration de l'application](spark-tutorial-step3.md)
+ [Étape 4 : préparer les données source et la table cible dans Amazon Keyspaces](spark-tutorial-step4.md)
+ [Étape 5 : Écrire et lire les données Amazon Keyspaces à l'aide du connecteur Apache Cassandra Spark](spark-tutorial-step5.md)
+ [Résolution des erreurs courantes lors de l'utilisation du connecteur Spark Cassandra avec Amazon Keyspaces](spark-tutorial-step6.md)
# Conditions préalables pour établir des connexions à Amazon Keyspaces avec le connecteur Spark Cassandra
Avant de vous connecter à Amazon Keyspaces avec le connecteur Spark Cassandra, vous devez vous assurer que vous avez installé les éléments suivants. La compatibilité d'Amazon Keyspaces avec le connecteur Spark Cassandra a été testée avec les versions recommandées suivantes :
+ Version 8 de Java
+ Scala 2.12
+ Spark 3.4
+ Cassandra Connector 2.5 et supérieur
+ pilote Cassandra 4.12
1. Pour installer Scala, suivez les instructions sur[https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html).
1. Pour installer Spark 3.4.1, suivez cet exemple.
```
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
```
```
# Étape 1 : configurer Amazon Keyspaces pour l'intégration au connecteur Apache Cassandra Spark
Au cours de cette étape, vous confirmez que le partitionneur de votre compte est compatible avec le connecteur Apache Spark et vous configurez les autorisations IAM requises. Les meilleures pratiques suivantes vous aident à fournir une read/write capacité suffisante pour la table.
1. Vérifiez que le `Murmur3Partitioner` partitionneur est le partitionneur par défaut pour votre compte. Ce partitionneur est compatible avec le connecteur Spark Cassandra. Pour plus d'informations sur les partitionneurs et sur la façon de les modifier, consultez. [Utilisation des partitionneurs dans Amazon Keyspaces](working-with-partitioners.md)
1. Configurez vos autorisations IAM pour Amazon Keyspaces, à l'aide des points de terminaison VPC de l'interface, avec Apache Spark.
+ Attribuez l' read/write accès à la table utilisateur et l'accès en lecture aux tables système, comme indiqué dans l'exemple de politique IAM ci-dessous.
+ [Les clients accédant à Amazon Keyspaces avec Spark via des points de terminaison VPC d'interface VPC doivent remplir le tableau system.peers.](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. Tenez compte des meilleures pratiques suivantes pour configurer une capacité de débit de lecture/écriture suffisante pour que votre table Amazon Keyspaces prenne en charge le trafic provenant du connecteur Spark Cassandra.
+ Commencez à utiliser la capacité à la demande pour vous aider à tester le scénario.
+ Pour optimiser le coût du débit des tables pour les environnements de production, utilisez un limiteur de débit pour le trafic provenant du connecteur et configurez votre table pour utiliser la capacité allouée avec un dimensionnement automatique. Pour de plus amples informations, veuillez consulter [Gérez automatiquement la capacité de débit grâce au dimensionnement automatique d'Amazon Keyspaces](autoscaling.md).
+ Vous pouvez utiliser un limiteur de débit fixe fourni avec le pilote Cassandra. Certains [limiteurs de débit sont adaptés à Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers) dans [AWS le](https://github.com/aws-samples) référentiel d'exemples.
+ Pour plus d'informations sur la gestion des capacités, consultez[Configurer les modes de read/write capacité dans Amazon Keyspaces](ReadWriteCapacityMode.md).
# Étape 2 : Configuration du connecteur Apache Cassandra Spark
Apache Spark est une plateforme informatique polyvalente que vous pouvez configurer de différentes manières. Pour configurer Spark et le connecteur Spark Cassandra en vue de leur intégration à Amazon Keyspaces, nous vous recommandons de commencer par les paramètres de configuration minimaux décrits dans la section suivante, puis de les augmenter ultérieurement en fonction de votre charge de travail.
+ **Créez des partitions Spark de taille inférieure à 8 MBs.**
Dans Spark, *les partitions* représentent un bloc atomique de données qui peut être exécuté en parallèle. Lorsque vous écrivez des données sur Amazon Keyspaces à l'aide du connecteur Spark Cassandra, plus la partition Spark est petite, plus le nombre d'enregistrements que la tâche va écrire est faible. Si une tâche Spark rencontre plusieurs erreurs, elle échoue une fois que le nombre de tentatives indiqué est épuisé. Pour éviter de rejouer des tâches volumineuses et de retraiter un grand nombre de données, limitez la taille de la partition Spark.
+ **Utilisez un faible nombre d'écritures simultanées par exécuteur avec un grand nombre de tentatives.**
Amazon Keyspaces renvoie les erreurs de capacité insuffisante aux pilotes Cassandra en cas d'expiration des délais de fonctionnement. Vous ne pouvez pas résoudre les délais d'attente causés par une capacité insuffisante en modifiant la durée d'expiration configurée, car le connecteur Spark Cassandra tente de réessayer les demandes de manière transparente à l'aide du. `MultipleRetryPolicy` Pour éviter que les nouvelles tentatives ne surchargent le pool de connexions du pilote, utilisez un faible nombre d'écritures simultanées par exécuteur avec un grand nombre de tentatives. L'extrait de code suivant en est un exemple.
```
spark.cassandra.query.retry.count = 500
spark.cassandra.output.concurrent.writes = 3
```
+ **Décomposez le débit total et répartissez-le sur plusieurs sessions Cassandra.**
+ Le connecteur Cassandra Spark crée une session pour chaque exécuteur Spark. Considérez cette session comme l'unité d'échelle permettant de déterminer le débit requis et le nombre de connexions requises.
+ Lorsque vous définissez le nombre de cœurs par exécuteur et le nombre de cœurs par tâche, commencez par un niveau bas et augmentez selon les besoins.
+ Définissez les échecs des tâches Spark pour autoriser le traitement en cas d'erreurs transitoires. Une fois que vous vous êtes familiarisé avec les caractéristiques et les exigences de trafic de votre application, nous vous recommandons `spark.task.maxFailures` de définir une valeur bornée.
+ Par exemple, la configuration suivante peut gérer deux tâches simultanées par exécuteur et par session :
```
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
```
+ **Désactivez le traitement par lots.**
+ Nous vous recommandons de désactiver le traitement par lots pour améliorer les modèles d'accès aléatoire. L'extrait de code suivant en est un exemple.
```
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)
```
+ **Réglez `SPARK_LOCAL_DIRS` sur un disque local rapide avec suffisamment d'espace.**
+ Par défaut, Spark enregistre les fichiers de sortie de carte et les ensembles de données distribués résilients (RDDs) `/tmp ` dans un dossier. En fonction de la configuration de votre hôte Spark, cela peut entraîner des erreurs de style qui ne *laissent aucun espace sur l'appareil*.
+ Pour définir la variable d'`SPARK_LOCAL_DIRS`environnement sur un répertoire appelé`/example/spark-dir`, vous pouvez utiliser la commande suivante.
```
export SPARK_LOCAL_DIRS=/example/spark-dir
```
# Étape 3 : Création du fichier de configuration de l'application
Pour utiliser le connecteur open source Spark Cassandra avec Amazon Keyspaces, vous devez fournir un fichier de configuration d'application contenant les paramètres requis pour vous connecter au pilote Java. DataStax Vous pouvez utiliser des informations d'identification spécifiques au service ou le plug-in SigV4 pour vous connecter.
Si ce n'est pas déjà fait, vous devez convertir le certificat numérique utilisé pour créer la connexion TLS en un fichier TrustStore. Vous pouvez suivre les étapes détaillées décrites dans le didacticiel [Avant de commencer](using_java_driver.md#using_java_driver.BeforeYouBegin) de connexion au pilote Java. Prenez note du chemin et du mot de passe du fichier TrustStore, car vous avez besoin de ces informations lorsque vous créez le fichier de configuration de l'application.
## Connect grâce à l'authentification SigV4
Cette section présente un exemple de `application.conf` fichier que vous pouvez utiliser lors de la connexion à l'aide des AWS informations d'identification et du plug-in SigV4. Si ce n'est pas déjà fait, vous devez générer vos clés d'accès IAM (un identifiant de clé d'accès et une clé d'accès secrète) et les enregistrer dans votre fichier de AWS configuration ou en tant que variables d'environnement. Pour obtenir des instructions complètes, consultez [Informations d'identification requises par AWS CLI le AWS SDK ou le plugin Amazon Keyspaces SigV4 pour les pilotes clients Cassandra](SigV4_credentials.md).
Dans l'exemple suivant, remplacez le chemin d'accès à votre fichier TrustStore et remplacez le mot de passe.
```
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
}
```
Mettez à jour et enregistrez ce fichier de configuration sous`/home/user1/application.conf`. Les exemples suivants utilisent ce chemin.
## Connectez-vous à l'aide d'informations d'identification spécifiques au service
Cette section présente un exemple de `application.conf` fichier que vous pouvez utiliser lorsque vous vous connectez avec des informations d'identification spécifiques au service. Si ce n'est pas déjà fait, vous devez générer des informations d'identification spécifiques au service pour Amazon Keyspaces. Pour obtenir des instructions complètes, consultez [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md).
Dans l'exemple suivant, remplacez `username` et par vos `password` propres informations d'identification. Remplacez également le chemin du fichier vers votre fichier TrustStore et remplacez le mot de passe.
```
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
}
}
}
}
```
Mettez à jour et enregistrez ce fichier de configuration `/home/user1/application.conf` afin de l'utiliser avec l'exemple de code.
## Connect avec un tarif fixe
Pour imposer un taux fixe par exécuteur Spark, vous pouvez définir un limiteur de requêtes. Ce limiteur de demandes limite le taux de demandes par seconde. Le connecteur Spark Cassandra déploie une session Cassandra par exécuteur. L'utilisation de la formule suivante peut vous aider à obtenir un débit constant par rapport à une table.
```
max-request-per-second * numberOfExecutors = total throughput against a table
```
Vous pouvez ajouter cet exemple au fichier de configuration de l'application que vous avez créé précédemment.
```
datastax-java-driver {
advanced.throttler {
class = RateLimitingRequestThrottler
max-requests-per-second = 3000
max-queue-size = 30000
drain-interval = 1 millisecond
}
}
```
# Étape 4 : préparer les données source et la table cible dans Amazon Keyspaces
Au cours de cette étape, vous allez créer un fichier source contenant des exemples de données et une table Amazon Keyspaces.
1. Créez le fichier source. Vous pouvez choisir l’une des options suivantes :
+ Pour ce didacticiel, vous utilisez un fichier de valeurs séparées par des virgules (CSV) dont le `keyspaces_sample_table.csv` nom est le fichier source pour la migration des données. Le fichier d'exemple fourni contient quelques lignes de données pour une table portant le nom`book_awards`.
1. Téléchargez l'exemple de fichier CSV (`keyspaces_sample_table.csv`) contenu dans le fichier d'archive [samplemigration.zip](samples/samplemigration.zip) suivant. Décompressez l'archive et notez le chemin vers`keyspaces_sample_table.csv`.
+ Si vous souhaitez utiliser votre propre fichier CSV pour écrire des données sur Amazon Keyspaces, assurez-vous que les données sont aléatoires. Les données lues directement depuis une base de données ou exportées vers des fichiers plats sont généralement classées par partition et clé primaire. L'importation de données commandées dans Amazon Keyspaces peut entraîner leur écriture sur de plus petits segments des partitions Amazon Keyspaces, ce qui entraîne une répartition inégale du trafic. Cela peut entraîner un ralentissement des performances et des taux d'erreur plus élevés.
En revanche, la randomisation des données permet de tirer parti des fonctionnalités d'équilibrage de charge intégrées d'Amazon Keyspaces en répartissant le trafic entre les partitions de manière plus uniforme. Il existe différents outils que vous pouvez utiliser pour randomiser les données. Pour un exemple utilisant l'outil open source [Shuf](https://en.wikipedia.org/wiki/Shuf), consultez le didacticiel [Étape 2 : Préparez les données à télécharger à l'aide de DSBulk](dsbulk-upload-prepare-data.md) de migration de données. L'exemple suivant montre comment mélanger des données sous forme de fichier. `DataFrame`
```
import org.apache.spark.sql.functions.randval
shuffledDF = dataframe.orderBy(rand())
```
1. Créez le keyspace et le tableau cibles dans Amazon Keyspaces.
1. Connectez-vous à Amazon Keyspaces à l'aide du. `cqlsh-expansion` Pour les instructions d'`cqlsh-expansion`installation, voir[Utilisation du `cqlsh-expansion` pour se connecter à Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh).
Dans l'exemple suivant, remplacez le point de terminaison du service par votre propre valeur.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Créez un nouvel espace de touches avec le `catalog` nom indiqué dans l'exemple suivant.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Une fois que le nouveau keyspace est devenu disponible, utilisez le code suivant pour créer la table `book_awards` cible. Pour en savoir plus sur la création de ressources asynchrones et sur la façon de vérifier si une ressource est disponible, consultez. [Vérifiez le statut de création des espaces de touches dans 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)
);
```
# Étape 5 : Écrire et lire les données Amazon Keyspaces à l'aide du connecteur Apache Cassandra Spark
Au cours de cette étape, vous commencez par charger les données du fichier d'exemple dans un fichier `DataFrame` avec le connecteur Spark Cassandra. Ensuite, vous écrivez les données du `DataFrame` dans votre table Amazon Keyspaces. Vous pouvez également utiliser cette partie indépendamment, par exemple pour migrer des données vers une table Amazon Keyspaces. Enfin, vous pouvez lire les données de votre table dans un à `DataFrame` l'aide du connecteur Spark Cassandra. Vous pouvez également utiliser cette partie indépendamment, par exemple pour lire les données d'une table Amazon Keyspaces afin d'effectuer des analyses de données avec Apache Spark.
1. Démarrez le Spark Shell comme indiqué dans l'exemple suivant. Notez que cet exemple utilise l'authentification 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. Importez le connecteur Spark Cassandra avec le code suivant.
```
import org.apache.spark.sql.cassandra._
```
1. Pour lire les données du fichier CSV et les stocker dans un fichier`DataFrame`, vous pouvez utiliser l'exemple de code suivant.
```
var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv")
```
Vous pouvez afficher le résultat à l'aide de la commande suivante.
```
scala> df.show();
```
La sortie doit ressembler à ceci.
```
+----------------+----+-----------+----+------------------+--------------------+-------------+
| 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|
+----------------+----+-----------+----+------------------+--------------------+-------------+
```
Vous pouvez confirmer le schéma des données dans le, `DataFrame` comme indiqué dans l'exemple suivant.
```
scala> df.printSchema
```
La sortie doit ressembler à ceci.
```
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. Utilisez la commande suivante pour écrire les données dans `DataFrame` le tableau Amazon Keyspaces.
```
df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save()
```
1. Pour confirmer que les données ont été enregistrées, vous pouvez les relire dans une trame de données, comme indiqué dans l'exemple suivant.
```
var newDf = spark.read.cassandraFormat("book_awards", "catalog").load()
```
Vous pouvez ensuite afficher les données qui sont désormais contenues dans le dataframe.
```
scala> newDf.show()
```
Le résultat de cette commande devrait ressembler à ceci.
```
+--------------------+------------------+----------------+-----------+-------------+----+----+
| 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|
+--------------------+------------------+----------------+-----------+-------------+----+----+
```
# Résolution des erreurs courantes lors de l'utilisation du connecteur Spark Cassandra avec Amazon Keyspaces
Si vous utilisez Amazon Virtual Private Cloud et que vous vous connectez à Amazon Keyspaces, les erreurs les plus courantes rencontrées lors de l'utilisation du connecteur Spark sont dues aux problèmes de configuration suivants.
+ L'utilisateur ou le rôle IAM utilisé dans le VPC ne dispose pas des autorisations requises pour accéder `system.peers` à la table dans Amazon Keyspaces. Pour de plus amples informations, veuillez consulter [Remplissage des entrées de `system.peers` table avec les informations de point de terminaison VPC de l'interface](vpc-endpoints.md#system_peers).
+ L'utilisateur ou le rôle IAM ne dispose pas des read/write autorisations requises pour accéder à la table des utilisateurs et ne dispose pas de l'accès en lecture aux tables système dans Amazon Keyspaces. Pour de plus amples informations, veuillez consulter [Étape 1 : configurer Amazon Keyspaces pour l'intégration au connecteur Apache Cassandra Spark](spark-tutorial-step1.md).
+ La configuration du pilote Java ne désactive pas la vérification du nom d'hôte lors de la création de la connexion SSL/TLS. Pour obtenir des exemples, consultez [Étape 2 : Configuration du pilote](using_java_driver.md#java_tutorial.driverconfiguration).
Pour connaître les étapes détaillées de résolution des problèmes de connexion, voir[La connexion de mon point de terminaison VPC ne fonctionne pas correctement](troubleshooting.connecting.md#troubleshooting.connection.vpce).
En outre, vous pouvez utiliser CloudWatch les métriques Amazon pour résoudre les problèmes liés à la configuration de votre connecteur Spark Cassandra dans Amazon Keyspaces. Pour en savoir plus sur l'utilisation d'Amazon Keyspaces avec CloudWatch, consultez. [Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md)
La section suivante décrit les métriques les plus utiles à observer lorsque vous utilisez le connecteur Spark Cassandra.
**PerConnectionRequestRateExceeded**
Amazon Keyspaces a un quota de 3 000 demandes par seconde et par connexion. Chaque exécuteur Spark établit une connexion avec Amazon Keyspaces. L'exécution de plusieurs tentatives peut épuiser votre quota de débit de demandes par connexion. Si vous dépassez ce quota, Amazon Keyspaces émet une `PerConnectionRequestRateExceeded` métrique. CloudWatch
Si vous PerConnectionRequestRateExceeded constatez la présence d'événements ainsi que d'autres erreurs système ou utilisateur, il est probable que Spark exécute plusieurs tentatives au-delà du nombre de demandes alloué par connexion.
Si vous voyez `PerConnectionRequestRateExceeded` des événements sans autre erreur, vous devrez peut-être augmenter le nombre de connexions dans les paramètres de votre pilote pour augmenter le débit, ou vous devrez peut-être augmenter le nombre d'exécuteurs dans votre tâche Spark.
**StoragePartitionThroughputCapacityExceeded**
Amazon Keyspaces a un quota de 1 000 WCUs ou WRUs par seconde/3 000 ou par seconde, RRUs par RCUs partition. Si vous observez `StoragePartitionThroughputCapacityExceeded` CloudWatch des événements, cela peut indiquer que les données ne sont pas randomisées lors du chargement. Pour obtenir des exemples de brassage de données, consultez. [Étape 4 : préparer les données source et la table cible dans Amazon Keyspaces](spark-tutorial-step4.md)
## Erreurs et avertissements courants
Si vous utilisez Amazon Virtual Private Cloud et que vous vous connectez à Amazon Keyspaces, le pilote Cassandra peut émettre un message d'avertissement concernant le nœud de contrôle lui-même dans le tableau. `system.peers` Pour de plus amples informations, veuillez consulter [Erreurs et avertissements courants](vpc-endpoints.md#vpc_troubleshooting). Vous pouvez ignorer cet avertissement en toute sécurité.