Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Tutorial: Integrieren Sie Apache Spark, um Daten zu importieren oder zu exportieren Apache Spark ist eine Open-Source-Engine für umfangreiche Datenanalysen. Mit Apache Spark können Sie Analysen von Daten, die in Amazon Keyspaces gespeichert sind, effizienter durchführen. Sie können Amazon Keyspaces auch verwenden, um Anwendungen einen konsistenten single-digit-millisecond Lesezugriff auf Analysedaten von Spark zu ermöglichen. Der Open-Source-Spark Cassandra Connector vereinfacht das Lesen und Schreiben von Daten zwischen Amazon Keyspaces und Spark. Die Unterstützung von Amazon Keyspaces für den Spark Cassandra Connector optimiert die Ausführung von Cassandra-Workloads in Spark-basierten Analyse-Pipelines mithilfe eines vollständig verwalteten und serverlosen Datenbankdienstes. Mit Amazon Keyspaces müssen Sie sich keine Sorgen machen, dass Spark um dieselben zugrunde liegenden Infrastrukturressourcen wie Ihre Tabellen konkurriert. Amazon Keyspaces-Tabellen werden basierend auf Ihrem Anwendungsdatenverkehr automatisch nach oben und unten skaliert. Das folgende Tutorial führt Sie durch die Schritte und bewährten Methoden, die zum Lesen und Schreiben von Daten in Amazon Keyspaces mit dem Spark Cassandra Connector erforderlich sind. Das Tutorial zeigt, wie Daten zu Amazon Keyspaces migriert werden, indem Daten aus einer Datei mit dem Spark Cassandra Connector geladen und in eine Amazon Keyspaces-Tabelle geschrieben werden. Anschließend zeigt das Tutorial, wie Sie die Daten mit dem Spark Cassandra Connector aus Amazon Keyspaces zurücklesen. Sie würden dies tun, um Cassandra-Workloads in Spark-basierten Analyse-Pipelines auszuführen. **Topics** + [Voraussetzungen für den Aufbau von Verbindungen zu Amazon Keyspaces mit dem Spark Cassandra Connector](spark-tutorial-prerequisites.md) + [Schritt 1: Amazon Keyspaces für die Integration mit dem Apache Cassandra Spark Connector konfigurieren](spark-tutorial-step1.md) + [Schritt 2: Konfigurieren Sie den Apache Cassandra Spark Connector](spark-tutorial-step2.md) + [Schritt 3: Erstellen Sie die Anwendungskonfigurationsdatei](spark-tutorial-step3.md) + [Schritt 4: Bereiten Sie die Quelldaten und die Zieltabelle in Amazon Keyspaces vor](spark-tutorial-step4.md) + [Schritt 5: Amazon Keyspaces-Daten mit dem Apache Cassandra Spark Connector schreiben und lesen](spark-tutorial-step5.md) + [Behebung häufiger Fehler bei der Verwendung des Spark Cassandra Connectors mit Amazon Keyspaces](spark-tutorial-step6.md) # Voraussetzungen für den Aufbau von Verbindungen zu Amazon Keyspaces mit dem Spark Cassandra Connector Bevor Sie mit dem Spark Cassandra Connector eine Verbindung zu Amazon Keyspaces herstellen, müssen Sie sicherstellen, dass Sie Folgendes installiert haben. Die Kompatibilität von Amazon Keyspaces mit dem Spark Cassandra Connector wurde mit den folgenden empfohlenen Versionen getestet: + Java-Version 8 + Maßstab 2.12 + Spark 3.4 + Cassandra Connector 2.5 und höher + Cassandra-Treiber 4.12 1. Um Scala zu installieren, folgen Sie den Anweisungen unter. [https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html) 1. Folgen Sie diesem Beispiel, um Spark 3.4.1 zu installieren. ``` 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 ``` ``` # Schritt 1: Amazon Keyspaces für die Integration mit dem Apache Cassandra Spark Connector konfigurieren In diesem Schritt bestätigen Sie, dass der Partitionierer für Ihr Konto mit dem Apache Spark Connector kompatibel ist, und richten die erforderlichen IAM-Berechtigungen ein. Die folgenden bewährten Methoden helfen Ihnen dabei, ausreichend read/write Kapazität für die Tabelle bereitzustellen. 1. Vergewissern Sie sich, dass der `Murmur3Partitioner` Partitionierer der Standardpartitionierer für Ihr Konto ist. Dieser Partitionierer ist mit dem Spark Cassandra Connector kompatibel. Weitere Informationen zu Partitionierern und deren Änderung finden Sie unter. [Arbeiten mit Partitionierern in Amazon Keyspaces](working-with-partitioners.md) 1. Richten Sie Ihre IAM-Berechtigungen für Amazon Keyspaces mithilfe von Schnittstellen-VPC-Endpunkten mit Apache Spark ein. + Weisen Sie read/write Zugriff auf die Benutzertabelle und Lesezugriff auf die Systemtabellen zu, wie im unten aufgeführten Beispiel für eine IAM-Richtlinie dargestellt. + [Das Auffüllen der system.peers-Tabelle mit Ihren verfügbaren Schnittstellen-VPC-Endpunkten ist für Clients erforderlich, die mit Spark über VPC-Endpunkte auf Amazon Keyspaces zugreifen.](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. Beachten Sie die folgenden bewährten Methoden, um eine ausreichende Lese-/Schreibdurchsatzkapazität für Ihre Amazon Keyspaces-Tabelle zu konfigurieren, um den Datenverkehr vom Spark Cassandra Connector zu unterstützen. + Beginnen Sie mit der Nutzung von On-Demand-Kapazität, um das Szenario zu testen. + Um die Kosten des Tabellendurchsatzes für Produktionsumgebungen zu optimieren, verwenden Sie einen Ratenbegrenzer für den Datenverkehr vom Connector und konfigurieren Sie Ihre Tabelle so, dass die bereitgestellte Kapazität mit automatischer Skalierung genutzt wird. Weitere Informationen finden Sie unter [Automatische Verwaltung der Durchsatzkapazität mit Amazon Keyspaces Auto Scaling](autoscaling.md). + Sie können einen festen Ratenbegrenzer verwenden, der im Lieferumfang des Cassandra-Treibers enthalten ist. Im [AWS Samples-Repo](https://github.com/aws-samples) gibt es einige auf [Amazon Keyspaces zugeschnittene Ratenbegrenzer](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers). + Weitere Informationen zur Kapazitätsverwaltung finden Sie unter. [read/write Kapazitätsmodi in Amazon Keyspaces konfigurieren](ReadWriteCapacityMode.md) # Schritt 2: Konfigurieren Sie den Apache Cassandra Spark Connector Apache Spark ist eine Allzweck-Rechenplattform, die Sie auf verschiedene Arten konfigurieren können. Um Spark und den Spark Cassandra Connector für die Integration mit Amazon Keyspaces zu konfigurieren, empfehlen wir, mit den im folgenden Abschnitt beschriebenen Mindestkonfigurationseinstellungen zu beginnen und diese später entsprechend Ihrer Arbeitslast zu erhöhen. + **Erstellen Sie Spark-Partitionsgrößen, die kleiner als 8 sind. MBs** In Spark stellen *Partitionen* einen atomaren Datenblock dar, der parallel ausgeführt werden kann. Wenn Sie mit dem Spark Cassandra Connector Daten in Amazon Keyspaces schreiben, gilt: Je kleiner die Spark-Partition, desto geringer ist die Anzahl der Datensätze, die die Aufgabe schreiben wird. Wenn eine Spark-Aufgabe auf mehrere Fehler stößt, schlägt sie fehl, nachdem die festgelegte Anzahl von Wiederholungsversuchen ausgeschöpft ist. Um zu vermeiden, dass große Aufgaben wiederholt und viele Daten erneut verarbeitet werden, sollten Sie die Größe der Spark-Partition klein halten. + **Verwenden Sie eine geringe Anzahl gleichzeitiger Schreibvorgänge pro Executor mit einer großen Anzahl von Wiederholungsversuchen.** Amazon Keyspaces gibt Fehler mit unzureichender Kapazität als Betriebs-Timeouts an Cassandra-Treibern zurück. Sie können Timeouts, die durch unzureichende Kapazität verursacht wurden, nicht beheben, indem Sie die konfigurierte Timeout-Dauer ändern, da der Spark Cassandra Connector versucht, Anfragen transparent mit dem zu wiederholen. `MultipleRetryPolicy` Um sicherzustellen, dass Wiederholungsversuche den Verbindungspool des Treibers nicht überlasten, sollten Sie eine geringe Anzahl gleichzeitiger Schreibvorgänge pro Executor mit einer großen Anzahl von Wiederholungen verwenden. Der folgende Codeausschnitt ist ein Beispiel dafür. ``` spark.cassandra.query.retry.count = 500 spark.cassandra.output.concurrent.writes = 3 ``` + **Teilen Sie den Gesamtdurchsatz auf und verteilen Sie ihn auf mehrere Cassandra-Sitzungen.** + Der Cassandra Spark Connector erstellt eine Sitzung für jeden Spark-Executor. Stellen Sie sich diese Sitzung als Maßstabseinheit zur Bestimmung des erforderlichen Durchsatzes und der Anzahl der erforderlichen Verbindungen vor. + Wenn Sie die Anzahl der Kerne pro Executor und die Anzahl der Kerne pro Task definieren, beginnen Sie niedrig und erhöhen Sie sie nach Bedarf. + Stellen Sie Spark-Aufgabenfehler ein, um die Verarbeitung bei vorübergehenden Fehlern zu ermöglichen. Nachdem Sie sich mit den Verkehrseigenschaften und Anforderungen Ihrer Anwendung vertraut gemacht haben, empfehlen wir, einen begrenzten Wert festzulegen`spark.task.maxFailures`. + Die folgende Konfiguration kann beispielsweise zwei gleichzeitige Aufgaben pro Executor und Sitzung verarbeiten: ``` 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 ``` + **Schalten Sie die Batchverarbeitung aus.** + Wir empfehlen, die Batchverarbeitung zu deaktivieren, um die Direktzugriffsmuster zu verbessern. Der folgende Codeausschnitt ist ein Beispiel dafür. ``` 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) ``` + **Stellen `SPARK_LOCAL_DIRS` Sie eine schnelle, lokale Festplatte mit ausreichend Speicherplatz ein.** + Standardmäßig speichert Spark Kartenausgabedateien und robuste verteilte Datensätze (RDDs) in einem `/tmp ` Ordner. Abhängig von der Konfiguration Ihres Spark-Hosts kann dies dazu führen, dass *auf dem Gerät kein Platz mehr übrig* ist. + Um die `SPARK_LOCAL_DIRS` Umgebungsvariable auf ein Verzeichnis mit dem Namen festzulegen`/example/spark-dir`, können Sie den folgenden Befehl verwenden. ``` export SPARK_LOCAL_DIRS=/example/spark-dir ``` # Schritt 3: Erstellen Sie die Anwendungskonfigurationsdatei Um den Open-Source-Spark Cassandra Connector mit Amazon Keyspaces zu verwenden, müssen Sie eine Anwendungskonfigurationsdatei bereitstellen, die die Einstellungen enthält, die für die Verbindung mit dem DataStax Java-Treiber erforderlich sind. Sie können entweder dienstspezifische Anmeldeinformationen oder das SigV4-Plugin verwenden, um eine Verbindung herzustellen. Falls Sie dies noch nicht getan haben, müssen Sie das digitale Zertifikat, mit dem die TLS-Verbindung hergestellt wurde, in eine TrustStore-Datei konvertieren. Die detaillierten Schritte finden Sie im [Bevor Sie beginnen](using_java_driver.md#using_java_driver.BeforeYouBegin) Tutorial zur Java-Treiberverbindung. Notieren Sie sich den TrustStore-Dateipfad und das Passwort, da Sie diese Informationen benötigen, wenn Sie die Anwendungskonfigurationsdatei erstellen. ## Connect mit SigV4-Authentifizierung her Dieser Abschnitt zeigt Ihnen eine `application.conf` Beispieldatei, die Sie verwenden können, wenn Sie eine Verbindung mit AWS Anmeldeinformationen und dem SigV4-Plugin herstellen. Falls Sie dies noch nicht getan haben, müssen Sie Ihre IAM-Zugriffsschlüssel (eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel) generieren und sie in Ihrer AWS Konfigurationsdatei oder als Umgebungsvariablen speichern. Detaillierte Anweisungen finden Sie unter [Anmeldeinformationen AWS CLI, die für das AWS SDK oder das Amazon Keyspaces SigV4-Plugin für Cassandra-Client-Treiber erforderlich sind](SigV4_credentials.md). Ersetzen Sie im folgenden Beispiel den Dateipfad zu Ihrer TrustStore-Datei und ersetzen Sie das Passwort. ``` 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 } ``` Aktualisieren und speichern Sie diese Konfigurationsdatei unter. `/home/user1/application.conf` Die folgenden Beispiele verwenden diesen Pfad. ## Connect mit dienstspezifischen Anmeldeinformationen her Dieser Abschnitt zeigt Ihnen eine `application.conf` Beispieldatei, die Sie verwenden können, wenn Sie eine Verbindung mit dienstspezifischen Anmeldeinformationen herstellen. Falls Sie dies noch nicht getan haben, müssen Sie dienstspezifische Anmeldeinformationen für Amazon Keyspaces generieren. Detaillierte Anweisungen finden Sie unter [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md). Ersetzen Sie im folgenden Beispiel `username` und `password` durch Ihre eigenen Anmeldeinformationen. Ersetzen Sie außerdem den Dateipfad zu Ihrer TrustStore-Datei und das Passwort. ``` 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 } } } } ``` Aktualisieren und speichern Sie diese Konfigurationsdatei`/home/user1/application.conf`, um sie mit dem Codebeispiel zu verwenden. ## Connect dich mit einem festen Tarif Um eine feste Rate pro Spark-Executor zu erzwingen, können Sie einen Request-Throttler definieren. Dieser Anforderungs-Throttler begrenzt die Rate der Anfragen pro Sekunde. Der Spark Cassandra Connector stellt pro Executor eine Cassandra-Sitzung bereit. Mithilfe der folgenden Formel können Sie einen konsistenten Durchsatz für eine Tabelle erzielen. ``` max-request-per-second * numberOfExecutors = total throughput against a table ``` Sie können dieses Beispiel der Anwendungskonfigurationsdatei hinzufügen, die Sie zuvor erstellt haben. ``` datastax-java-driver { advanced.throttler { class = RateLimitingRequestThrottler max-requests-per-second = 3000 max-queue-size = 30000 drain-interval = 1 millisecond } } ``` # Schritt 4: Bereiten Sie die Quelldaten und die Zieltabelle in Amazon Keyspaces vor In diesem Schritt erstellen Sie eine Quelldatei mit Beispieldaten und einer Amazon Keyspaces-Tabelle. 1. Erstellen Sie die Quelldatei. Sie können eine der folgenden Optionen wählen: + Für dieses Tutorial verwenden Sie eine Datei mit kommagetrennten Werten (CSV) mit dem Namen `keyspaces_sample_table.csv` als Quelldatei für die Datenmigration. Die mitgelieferte Beispieldatei enthält einige Datenzeilen für eine Tabelle mit dem Namen. `book_awards` 1. Laden Sie die CSV-Beispieldatei (`keyspaces_sample_table.csv`) herunter, die in der folgenden Archivdatei [samplemigration.zip](samples/samplemigration.zip) enthalten ist. Entpacken Sie das Archiv und notieren Sie sich den Pfad zu`keyspaces_sample_table.csv`. + Wenn Sie Ihre eigene CSV-Datei verwenden möchten, um Daten in Amazon Keyspaces zu schreiben, stellen Sie sicher, dass die Daten randomisiert sind. Daten, die direkt aus einer Datenbank gelesen oder in Flatfiles exportiert werden, werden in der Regel nach Partition und Primärschlüssel sortiert. Der Import bestellter Daten in Amazon Keyspaces kann dazu führen, dass sie in kleinere Segmente von Amazon Keyspaces-Partitionen geschrieben werden, was zu einer ungleichmäßigen Verteilung des Datenverkehrs führt. Dies kann zu einer langsameren Leistung und höheren Fehlerraten führen. Im Gegensatz dazu trägt die Randomisierung von Daten dazu bei, die Vorteile der integrierten Lastenausgleichsfunktionen von Amazon Keyspaces zu nutzen, indem der Datenverkehr gleichmäßiger auf die Partitionen verteilt wird. Es gibt verschiedene Tools, die Sie für die Randomisierung von Daten verwenden können. Ein Beispiel, das das Open-Source-Tool [Shuf](https://en.wikipedia.org/wiki/Shuf) verwendet, finden Sie [Schritt 2: Bereiten Sie die Daten für den Upload vor mit DSBulk](dsbulk-upload-prepare-data.md) im Tutorial zur Datenmigration. Im Folgenden finden Sie ein Beispiel, das zeigt, wie Daten gemischt werden. `DataFrame` ``` import org.apache.spark.sql.functions.randval shuffledDF = dataframe.orderBy(rand()) ``` 1. Erstellen Sie den Zielschlüsselraum und die Zieltabelle in Amazon Keyspaces. 1. Stellen Sie mit dem eine Verbindung zu Amazon Keyspaces her. `cqlsh-expansion` `cqlsh-expansion`Installationsanweisungen finden Sie unter[Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh). Ersetzen Sie den Service-Endpunkt im folgenden Beispiel durch Ihren eigenen Wert. ``` cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl ``` 1. Erstellen Sie einen neuen Schlüsselraum mit dem Namen, `catalog` wie im folgenden Beispiel gezeigt. ``` CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'}; ``` 1. Wenn der neue Schlüsselraum den Status verfügbar hat, verwenden Sie den folgenden Code, um die Zieltabelle zu erstellen. `book_awards` Weitere Informationen zur asynchronen Ressourcenerstellung und zur Überprüfung, ob eine Ressource verfügbar ist, finden Sie unter. [Überprüfen Sie den Status der Schlüsselraumerstellung 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) ); ``` # Schritt 5: Amazon Keyspaces-Daten mit dem Apache Cassandra Spark Connector schreiben und lesen In diesem Schritt laden Sie zunächst die Daten aus der Beispieldatei `DataFrame` mit dem Spark Cassandra Connector in eine. Als Nächstes schreiben Sie die Daten aus der `DataFrame` in Ihre Amazon Keyspaces-Tabelle. Sie können diesen Teil auch unabhängig verwenden, um beispielsweise Daten in eine Amazon Keyspaces-Tabelle zu migrieren. Schließlich lesen Sie `DataFrame` mit dem Spark Cassandra Connector die Daten aus Ihrer Tabelle in eine. Sie können diesen Teil auch unabhängig verwenden, um beispielsweise Daten aus einer Amazon Keyspaces-Tabelle zu lesen, um Datenanalysen mit Apache Spark durchzuführen. 1. Starten Sie die Spark-Shell wie im folgenden Beispiel gezeigt. Beachten Sie, dass dieses Beispiel die SigV4-Authentifizierung verwendet. ``` ./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. Importieren Sie den Spark Cassandra Connector mit dem folgenden Code. ``` import org.apache.spark.sql.cassandra._ ``` 1. Um Daten aus der CSV-Datei zu lesen und in einer zu speichern`DataFrame`, können Sie das folgende Codebeispiel verwenden. ``` var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv") ``` Sie können das Ergebnis mit dem folgenden Befehl anzeigen. ``` scala> df.show(); ``` Die Ausgabe sollte in etwa so aussehen. ``` +----------------+----+-----------+----+------------------+--------------------+-------------+ | 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| +----------------+----+-----------+----+------------------+--------------------+-------------+ ``` Sie können das Schema der Daten in der überprüfen, `DataFrame` wie im folgenden Beispiel gezeigt. ``` scala> df.printSchema ``` Die Ausgabe sollte so aussehen. ``` 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. Verwenden Sie den folgenden Befehl, um die Daten in die Amazon Keyspaces-Tabelle `DataFrame` zu schreiben. ``` df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save() ``` 1. Um zu bestätigen, dass die Daten gespeichert wurden, können Sie sie in einen Datenrahmen zurücklesen, wie im folgenden Beispiel gezeigt. ``` var newDf = spark.read.cassandraFormat("book_awards", "catalog").load() ``` Anschließend können Sie die Daten anzeigen, die jetzt im Datenrahmen enthalten sind. ``` scala> newDf.show() ``` Die Ausgabe dieses Befehls sollte so aussehen. ``` +--------------------+------------------+----------------+-----------+-------------+----+----+ | 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| +--------------------+------------------+----------------+-----------+-------------+----+----+ ``` # Behebung häufiger Fehler bei der Verwendung des Spark Cassandra Connectors mit Amazon Keyspaces Wenn Sie Amazon Virtual Private Cloud verwenden und eine Verbindung zu Amazon Keyspaces herstellen, werden die häufigsten Fehler bei der Verwendung des Spark-Connectors durch die folgenden Konfigurationsprobleme verursacht. + Dem in der VPC verwendeten IAM-Benutzer oder der Rolle fehlen die erforderlichen Berechtigungen für den Zugriff auf die `system.peers` Tabelle in Amazon Keyspaces. Weitere Informationen finden Sie unter [Auffüllen von `system.peers` Tabelleneinträgen mit VPC-Endpunktinformationen der Schnittstelle](vpc-endpoints.md#system_peers). + Dem IAM-Benutzer oder der IAM-Rolle fehlen die erforderlichen read/write Berechtigungen für die Benutzertabelle und der Lesezugriff auf die Systemtabellen in Amazon Keyspaces. Weitere Informationen finden Sie unter [Schritt 1: Amazon Keyspaces für die Integration mit dem Apache Cassandra Spark Connector konfigurieren](spark-tutorial-step1.md). + Die Java-Treiberkonfiguration deaktiviert die Überprüfung des Hostnamens beim Erstellen der SSL/TLS-Verbindung nicht. Beispiele finden Sie unter [Schritt 2: Konfigurieren Sie den Treiber](using_java_driver.md#java_tutorial.driverconfiguration). Detaillierte Schritte zur Fehlerbehebung bei Verbindungen finden Sie unter. [Meine VPC-Endpunktverbindung funktioniert nicht richtig](troubleshooting.connecting.md#troubleshooting.connection.vpce) Darüber hinaus können Sie CloudWatch Amazon-Metriken verwenden, um Probleme mit Ihrer Spark Cassandra Connector-Konfiguration in Amazon Keyspaces zu beheben. Weitere Informationen zur Verwendung von Amazon Keyspaces mit finden Sie CloudWatch unter[Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md). Im folgenden Abschnitt werden die nützlichsten Messwerte beschrieben, die Sie bei der Verwendung des Spark Cassandra Connectors beobachten sollten. **PerConnectionRequestRateExceeded** Amazon Keyspaces hat ein Kontingent von 3.000 Anfragen pro Sekunde und Verbindung. Jeder Spark-Executor stellt eine Verbindung mit Amazon Keyspaces her. Wenn Sie mehrere Wiederholungen durchführen, kann Ihr Kontingent für die Anforderungsrate pro Verbindung ausgeschöpft sein. Wenn Sie dieses Kontingent überschreiten, gibt Amazon Keyspaces eine `PerConnectionRequestRateExceeded` Metrik in aus. CloudWatch Wenn Sie feststellen, dass PerConnectionRequestRateExceeded Ereignisse zusammen mit anderen System- oder Benutzerfehlern auftreten, führt Spark wahrscheinlich mehrere Wiederholungen durch, die über die zugewiesene Anzahl von Anfragen pro Verbindung hinausgehen. Wenn Sie `PerConnectionRequestRateExceeded` Ereignisse ohne andere Fehler sehen, müssen Sie möglicherweise die Anzahl der Verbindungen in Ihren Treibereinstellungen erhöhen, um einen höheren Durchsatz zu erzielen, oder Sie müssen möglicherweise die Anzahl der Executoren in Ihrem Spark-Job erhöhen. **StoragePartitionThroughputCapacityExceeded** Amazon Keyspaces hat ein Kontingent von 1.000 WCUs oder WRUs pro Sekunde/3.000 RCUs oder RRUs pro Sekunde pro Partition. Wenn Sie `StoragePartitionThroughputCapacityExceeded` CloudWatch Ereignisse sehen, könnte dies darauf hindeuten, dass Daten beim Laden nicht randomisiert werden. Beispiele für das Mischen von Daten finden Sie unter. [Schritt 4: Bereiten Sie die Quelldaten und die Zieltabelle in Amazon Keyspaces vor](spark-tutorial-step4.md) ## Häufige Fehler und Warnungen Wenn Sie Amazon Virtual Private Cloud verwenden und eine Verbindung zu Amazon Keyspaces herstellen, gibt der Cassandra-Treiber möglicherweise eine Warnmeldung über den Kontrollknoten selbst in der `system.peers` Tabelle aus. Weitere Informationen finden Sie unter [Häufige Fehler und Warnungen](vpc-endpoints.md#vpc_troubleshooting). Sie können diese Warnung getrost ignorieren.