Direkt zum Inhalt

Die 20 wichtigsten Spark-Interview-Fragen

Die wichtigsten Spark-Interviewfragen mit Beispielantworten für Arbeitssuchende, Datenexperten und Personalverantwortliche.
Aktualisierte 15. Jan. 2025

Apache Spark ist eine einheitliche Analyse-Engine für Data Engineering, Data Science und maschinelles Lernen in großem Maßstab. Es kann mit Python, SQL, R, Java oder Scala verwendet werden. Spark wurde 2009 an der University of California, Berkeley, gegründet und 2013 an die Apache Software Foundation übergeben. Es ist jetzt "die am weitesten verbreitete Engine für skalierbares Computing" mit Tausenden von Stellenangeboten, die diese Technologie nutzen. Da diese Fähigkeit in der Welt der Datentechnik sehr geschätzt wird, findest du hier Interviewfragen, die dir bei deiner Jobsuche oder bei der Suche nach Talenten mit Spark-Erfahrung helfen. Die Antworten zum Kodieren werden in Python gegeben.

Grundlegende Spark-Interview-Fragen

Diese Fragen behandeln einige der Grundlagen von Spark und sind für diejenigen geeignet, die nur grundlegende Erfahrungen mit Spark haben. Wenn du eine Auffrischung brauchst, kannst du unsere Einführung in Spark SQL in Python Kurs ist der ideale Einstieg für dich.

1. Was ist Apache Spark und warum wird es in der Datenverarbeitung eingesetzt?

Mit dieser Frage wird das allgemeine Verständnis des Kandidaten für Apache Spark und seine Rolle im Big-Data-Ökosystem bewertet.

Antwort:

Apache Spark ist ein Open-Source-System für verteiltes Rechnen, das eine Schnittstelle für die Programmierung ganzer Cluster mit impliziter Datenparallelität und Fehlertoleranz bietet. Es wird für die Verarbeitung großer Datenmengen verwendet, da es schneller und einfacher zu bedienen ist als das traditionelle MapReduce.

Hauptmerkmale:

  • In-Memory Computing: Speichert Daten im Speicher für eine schnellere Verarbeitung.
  • Skalierbarkeit: Kann mit einem Cluster von Maschinen Petabytes an Daten verarbeiten.
  • Benutzerfreundlichkeit: Bietet APIs in Java, Scala, Python und R.
  • Unified Analytics Engine: Unterstützt SQL, Streaming-Daten, maschinelles Lernen und Graphverarbeitung.

2. Erkläre das Konzept der Resilient Distributed Datasets (RDDs)

Diese Fragen prüfen dich auf die grundlegenden Konzepte von Apache Spark. Vergewissere dich, dass du eine der entscheidenden Komponenten verstehst, die Spark so leistungsstark machen.

Resilient Distributed Datasets (RDDs) sind die grundlegenden Bausteine von Apache Spark. Sie stellen eine unveränderliche, verteilte Sammlung von Objekten dar, auf die in einem Cluster parallel zugegriffen werden kann. Hier findest du eine Erklärung der wichtigsten Merkmale und Konzepte von RDDs:

  1. Unveränderlich: RDDs sind unveränderlich, d.h. einmal erstellt, kann ihr Inhalt nicht mehr verändert werden. Du kannst RDDs nur transformieren, indem du Transformationen anwendest, um neue RDDs zu erstellen. Diese Unveränderlichkeit vereinfacht die Fehlertoleranz und ermöglicht das lazy evaluation model von Spark.
  2. Verteilt: RDDs werden auf mehrere Knoten in einem Cluster verteilt, sodass Spark parallele Operationen auf ihnen durchführen kann. Jedes RDD ist in mehrere Partitionen unterteilt und diese Partitionen können unabhängig voneinander auf verschiedenen Knoten bearbeitet werden.
  3. Resilient: Das "Resilient" in RDD steht für Fehlertoleranz. Spark sorgt für Ausfallsicherheit, indem es den Lernpfad jedes RDD verfolgt. Wenn eine Partition eines RDD aufgrund eines Knotenausfalls verloren geht, kann Spark diese Partition mithilfe der Lineage-Informationen und der auf die ursprünglichen Daten angewandten Transformationen neu berechnen.
  4. Dataset: RDDs sind eine verteilte Darstellung von Daten, d.h. sie können jede Art von Daten enthalten, einschließlich strukturierter oder unstrukturierter Daten. Spark bietet APIs in verschiedenen Sprachen (wie Scala, Java, Python und R), um mit RDDs zu arbeiten, was es vielseitig für verschiedene Anwendungsfälle und Datentypen macht.
  5. Faule Auswertung: RDDs unterstützen "lazy evaluation", d.h. Transformationen auf RDDs werden nicht sofort ausgeführt. Stattdessen baut Spark einen gerichteten azyklischen Graphen (DAG) aus Transformationen auf, die die Berechnung definieren, aber die Ausführung verzögert, bis eine Aktion ausgelöst wird. Diese Optimierung ermöglicht es Spark, den Ausführungsplan zu optimieren und die Leistung zu verbessern.

3. Was ist YARN?

YARN ist ein verteilter Container-Manager, der Ressourcen in Hadoop verwaltet. Spark kann YARN nutzen, wenn es auf Hadoop-Clustern läuft, um die Ressourcen effektiver und effizienter zu verwalten. Eine der wichtigsten Komponenten von YARN ist die Fähigkeit, Ressourcen effizient im Cluster zu verteilen, Jobs effizient zu planen und bei Knotenausfällen fehlertolerant zu sein. Sie ist eine der vielen Komponenten, die Spark zu einem leistungsstarken Werkzeug machen.

4. Was ist der Unterschied zwischen map- und flatMap-Transformationen in Spark RDDs?

Mit dieser Frage kannst du feststellen, ob du die verschiedenen Arten von Transformationen in Spark RDDs (Resilient Distributed Datasets) verstehst.

Antwort:

  • .map(): Wandelt jedes Element des RDDs in genau ein neues Element um. Das Ergebnis ist ein RDD mit der gleichen Anzahl von Elementen wie das Eingabe-RDD.
  • .flatMap(): Wandelt jedes Element des RDD in null oder mehr neue Elemente um. Das Ergebnis ist ein RDD mit einer potenziell anderen Anzahl von Elementen als das Eingabe-RDD.
# Example of map
rdd = spark.sparkContext.parallelize([1, 2, 3])
mapped_rdd = rdd.map(lambda x: x * 2)
print(mapped_rdd.collect())  # Output: [2, 4, 6]
# Example of flatMap
flat_mapped_rdd = rdd.flatMap(lambda x: [x, x * 2])
print(flat_mapped_rdd.collect())  # Output: [1, 2, 2, 4, 3, 6]

Dieser Code veranschaulicht den Unterschied zwischen map und flatMap, indem er ein RDD mit ganzen Zahlen transformiert.

5. Wie kannst du Spark SQL verwenden, um Daten aus einem DataFrame abzufragen?

Mit dieser Frage wird geprüft, ob der/die Kandidat/in Spark SQL zur Abfrage von Daten verwenden kann, was für die Datenanalyse unerlässlich ist.

Antwort:

# Register the DataFrame as a SQL temporary view
df.createOrReplaceTempView("table")
# Execute SQL query
result = spark.sql("SELECT column1, SUM(column2) FROM table GROUP BY column1")
# Show the results
result.show()

Dieses Snippet zeigt, wie du eine temporäre Ansicht aus einem DataFrame erstellst und mit Spark SQL eine Group-by-Abfrage durchführst.

Spark-Interviewfragen für Fortgeschrittene

Für diejenigen, die die Grundlagen beherrschen und sie in ihrer beruflichen Rolle anwenden, sind diese Fragen vielleicht häufiger: 

6. Erkläre das Konzept der lazy evaluation in Spark und warum es wichtig ist

Diese Frage prüft das Verständnis des Kandidaten für eines der Kernprinzipien von Spark, das für die Optimierung der Leistung entscheidend ist.

Antwort:

Lazy Evaluation bedeutet, dass Spark Transformationen nicht sofort ausführt, wenn sie aufgerufen werden. Stattdessen wird ein logischer Ausführungsplan erstellt. Die Transformationen werden nur ausgeführt, wenn eine Aktion (wie collect oder count) aufgerufen wird, die die eigentliche Berechnung auslöst.

Eine faule Bewertung ist aus zwei Gründen wichtig:

  1. So kann Spark den gesamten Datenverarbeitungsprozess optimieren, bevor er ausgeführt wird, und die Operationen so kombinieren, dass die Daten so wenig wie möglich umgeschichtet werden.
  2. Dadurch wird die Anzahl der Durchläufe durch die Daten reduziert und die Leistung verbessert.

7. Wie werden Daten in Spark aufbewahrt und welche verschiedenen Speicherebenen gibt es?

Diese Frage prüft das Wissen der Bewerber/innen über die Datenpersistenz in Spark, die für die Leistungsoptimierung und iterative Algorithmen wichtig ist.

Antwort:

Daten können in Spark mit den Methoden .persist() oder .cache() persistiert werden. .cache() ist eine Abkürzung für .persist() mit der Standard-Speicherebene.

Lagerungsebenen:

  • MEMORY_ONLY: Speichert RDD als deserialisierte Java-Objekte in der JVM. Wenn das RDD nicht in den Speicher passt, werden einige Partitionen nicht zwischengespeichert.
  • MEMORY_AND_DISK: Speichert RDD als deserialisierte Java-Objekte im Speicher. Wenn das RDD nicht in den Speicher passt, werden die Partitionen auf der Festplatte gespeichert.
  • MEMORY_ONLY_SER: Speichert RDD als serialisierte Java-Objekte in der JVM. Das reduziert den Speicherverbrauch, erhöht aber den CPU-Overhead für die Serialisierung/Deserialisierung.
  • MEMORY_AND_DISK_SER: Ähnlich wie MEMORY_AND_DISK, speichert aber serialisierte Objekte.
  • DISK_ONLY: Speichert RDD-Partitionen nur auf der Festplatte.
rdd = spark.sparkContext.parallelize([1, 2, 3, 4, 5])
rdd.persist(storageLevel=StorageLevel.MEMORY_AND_DISK)

8. Wie gehst du mit schiefen Daten in Spark um?

Diese Frage bewertet das Verständnis des Kandidaten für Datenschieflage und wie man damit umgeht, was für eine effiziente Datenverarbeitung entscheidend ist.

Antwort:

Datenschieflage tritt auf, wenn einige Partitionen deutlich mehr Daten haben als andere, was zu Leistungsengpässen führt. Zu den Strategien zum Umgang mit schiefen Daten gehören:

  • Salzen: Hinzufügen eines Zufallsschlüssels zu den Daten, um sie gleichmäßiger auf die Partitionen zu verteilen.
  • Repartitionierung: Erhöhen der Anzahl der Partitionen, um die Daten gleichmäßiger zu verteilen.
  • Broadcast-Variablen: Verteilen eines kleinen Datensatzes an alle Knotenpunkte, um das Mischen großer Datensätze zu vermeiden.
from pyspark.sql.functions import monotonically_increasing_id, col
# Example of salting
df = df.withColumn("salt", monotonically_increasing_id() % 10)
df = df.withColumn("new_key", col("original_key") + col("salt"))

9. Erkläre den Unterschied zwischen engen und weiten Transformationen in Spark

Diese Frage prüft das Verständnis des Kandidaten für das Ausführungsmodell von Spark und die Auswirkungen der verschiedenen Arten von Transformationen auf die Leistung.

Antwort:

  • Enge Transformationen: Operationen, bei denen jede Eingabepartition zu genau einer Ausgabepartition beiträgt. Beispiele sind .map(), .filter() und .union(). Sie sind in der Regel schneller, weil die Daten nicht umgeschichtet werden müssen.
  • Wide Transformations: Vorgänge, bei denen jede Eingabepartition zu mehreren Ausgabepartitionen beiträgt. Beispiele sind .groupByKey(), .reduceByKey() und .join(). Sie erfordern ein Umschichten der Daten im Netzwerk, was zeitaufwändig sein kann.
# Narrow transformation example
rdd1 = rdd.map(lambda x: x * 2)
# Wide transformation example
rdd2 = rdd.groupByKey()

10. Spark Streaming in der Echtzeit-Datenverarbeitung

Spark eignet sich hervorragend für das Streaming von Echtzeitdaten aus Quellen wie Apache Kafka oder Amazon Kinesis weil es skalierbar und fehlertolerant ist. Dies geschieht über die Erweiterung Spark Streaming. Es interagiert mit externen Datenquellen über Eingabe-DStreams, die einen kontinuierlichen Datenstrom aus diesen Quellen darstellen. 

Spark Streaming gewährleistet Fehlertoleranz und Datenkonsistenz durch Techniken wie Checkpointing und Write-Ahead-Logs. Checkpointing speichert den Zustand der Streaming-Anwendung regelmäßig in einem dauerhaften Speicher (z. B. HDFS), um Ausfälle zu beheben, während Write-Ahead-Logs Fehlertoleranz für Daten aus externen Quellen bieten.

Fortgeschrittene Spark-Interview-Fragen

Diese Fragen richten sich an Nutzer mit mehr praktischer Erfahrung mit Spark, insbesondere mit anspruchsvolleren Themen. Wenn du eine Auffrischung brauchst, sieh dir unsere Spark Machine Learning Tutorium.

11. Erörtere, wie Spark für maschinelles Lernen eingesetzt werden kann

Diese Frage testet das Verständnis der Befragten für die Spark-Umgebung und die MLib-Bibliothek. 

Die MLlib-Bibliothek von Spark bietet eine Vielzahl von Werkzeugen und Algorithmen für die Durchführung von Machine Learning-Aufgaben in großem Maßstab. Wenn es um Feature-Engineering und Vorverarbeitung für große Datensätze geht, bietet MLlib mehrere fortschrittliche Techniken und Optimierungen:

  1. Umwandlung und Auswahl von Merkmalen: MLlib bietet eine Reihe von Techniken zur Umwandlung von Merkmalen, wie z. B. Skalierung, Normalisierung, Binarisierung und Vektorisierung (z. B. One-Hot-Codierung). Darüber hinaus bietet es Methoden zur Merkmalsauswahl, einschließlich der Filterung auf der Grundlage von Korrelation, Informationsgewinn oder statistischen Tests, sowie fortgeschrittenere Techniken wie Principal Component Analysis (PCA) zur Dimensionalitätsreduktion.
  1. Umgang mit kategorischen Merkmalen: MLlib enthält Werkzeuge für den effizienten Umgang mit kategorialen Merkmalen, z. B. StringIndexer für die Umwandlung kategorialer Variablen in numerische Darstellungen und OneHotEncoder für die Umwandlung in binäre Vektoren. Diese Transformationen sind für die parallele Ausführung in verteilten Spark-Clustern optimiert.
  1. Pipeline API: Die Pipeline-API von Spark ermöglicht es den Nutzern, mehrere Phasen des Feature Engineering und der Modellierung in einem einzigen Workflow zu verknüpfen. Dies erleichtert die Erstellung komplexer Feature-Transformationspipelines und gewährleistet gleichzeitig Konsistenz und Reproduzierbarkeit über verschiedene Datensätze und Machine-Learning-Aufgaben hinweg.
  1. Kundenspezifische Transformatoren und Schätzer: MLlib ermöglicht es den Nutzern, mithilfe der DataFrame-API von Spark benutzerdefinierte Feature-Transformatoren und Schätzer zu definieren. Dies ermöglicht die Integration von domänenspezifischen Feature-Engineering-Techniken oder Bibliotheken von Drittanbietern in die Spark ML-Pipeline und erweitert deren Funktionalität und Flexibilität.

12. Erkläre, wie Spark mit externen Speichersystemen wie Apache Hadoop HDFS und Apache Cassandra zusammenarbeitet. Welche Vorteile bietet die Nutzung dieser Integrationen in einer Spark-basierten Datenpipeline?

Dabei wird getestet, ob die Nutzer die grundlegenden Funktionen von Spark-basierten Systemen verstehen und wie Spark mit HDFS und Apache Cassandra zusammenarbeitet. Es ist wichtig zu verstehen, wie man Daten durch Kodierung abruft und wie sich diese Daten im System bewegen.

  1. Hadoop HDFS-Verbindung: Spark lässt sich mit externen Speichersystemen wie Apache Hadoop HDFS und Apache Cassandra über Konnektoren oder Bibliotheken integrieren, die speziell für jedes System entwickelt wurden. Zum Beispiel ist die HDFS-Integration nativ in Spark, so dass Spark mit den Hadoop InputFormat- und OutputFormat-APIs Daten direkt von/nach HDFS lesen und schreiben kann.
  2. Apache Cassandra Verbindung: Zu den Vorteilen dieser Integrationen gehören eine verbesserte Leistung aufgrund der Datenlokalität (im Falle von HDFS), ein vereinfachter Datenzugriff und eine vereinfachte Datenmanipulation sowie die Kompatibilität mit der bestehenden Dateninfrastruktur. Außerdem kann Spark die verteilte Natur dieser Speichersysteme für die parallele Verarbeitung nutzen und so eine skalierbare Datenverarbeitung ermöglichen.

13. Erkläre das Konzept der Broadcast-Variablen in Spark

Broadcast-Variablen in Spark sind schreibgeschützte Variablen, die zwischengespeichert werden und allen Worker-Knoten in einer verteilten Spark-Anwendung zur Verfügung stehen. Sie werden verwendet, um große, nur lesbare Datensätze oder Werte effizient auf die Arbeitsknoten zu verteilen und so den Netzwerk-Overhead zu reduzieren und die Aufgabenleistung zu verbessern. 

Broadcast-Variablen werden serialisiert und nur einmal an jeden Arbeiterknoten gesendet, wo sie im Speicher zwischengespeichert und über mehrere Aufgaben hinweg wiederverwendet werden. Damit entfällt die Notwendigkeit, die Variable mit jeder Aufgabe zu senden, was den Overhead bei der Datenübertragung verringert, insbesondere bei großen Datensätzen.

  • Nutzung: Broadcast-Variablen werden häufig in Szenarien verwendet, in denen ein großer Datensatz oder ein großer Wert über mehrere Aufgaben oder Berechnungsschritte verteilt werden muss. Wenn zum Beispiel ein DataFrame oder RDD deutlich kleiner ist als das andere, kann die Übertragung des kleineren DataFrame/RDD die Datenmenge, die während des Join-Vorgangs über das Netzwerk verschoben wird, erheblich reduzieren.
  • Nützliche Szenarien:
    • Join Operations: Das Verteilen kleinerer Datensätze für Join-Operationen kann die Leistung erheblich verbessern, indem der Netzwerkverkehr reduziert und die Ausführung von Aufgaben beschleunigt wird.
    • Nachschlagetabellen: Die Übertragung von kleinen Tabellen oder Wörterbüchern, die zur Anreicherung oder Filterung verwendet werden, kann die Leistung verbessern, da wiederholte Datenübertragungen vermieden werden.
    • Maschinelles Lernen: Die Weitergabe von Merkmalsvektoren oder Modellparametern an die Arbeitsknoten während des verteilten Trainings kann den Trainingsprozess beschleunigen, besonders wenn die Merkmalsvektoren oder Parameter im Vergleich zum Datensatz relativ klein sind.
  • Herausforderungen:
    • Speicher-Overhead: Die Übertragung großer Variablen kann viel Speicherplatz auf den Worker Nodes verbrauchen, was zu Out-of-Memory-Fehlern führen kann, wenn sie nicht sorgfältig verwaltet wird.
    • Netzwerküberlastung: Die Übertragung großer Variablen kann auch zu einer Überlastung des Netzwerks während der ersten Übertragungsphase führen, insbesondere in großen Clustern mit begrenzter Netzwerkbandbreite.
    • Dynamische Daten: Broadcast-Variablen sind unveränderlich, sobald sie übertragen wurden. Sie eignen sich daher nicht für Szenarien, in denen die übertragenen Daten während der Ausführung des Spark-Jobs dynamisch aktualisiert werden müssen.

14. Wie optimierst du einen Spark-Job mit Partitionierung und Koaleszenz? 

Mit dieser Frage wird die Fähigkeit des Bewerbers bewertet, Spark-Jobs zu optimieren, eine Schlüsselqualifikation zur Verbesserung von Leistung und Effizienz. Durch das Leistungstuning von Spark können wir das verteilte Framework von Spark nutzen, indem wir Partitionierung und Koaleszenz verwenden, die die Arbeitslast über den Cluster verteilen, um Datenoperationen schneller durchzuführen. 

Antwort:

  • Partitionierung: Steuert die Anzahl der Partitionen in einem RDD oder DataFrame. Verwende .repartition(), um die Trennwände zu vergrößern oder gleichmäßig zu verteilen. Dies ist rechenintensiver und sollte nur verwendet werden, wenn die Daten gleichmäßig aufgeteilt werden müssen, um eine ausgewogene Verarbeitung zu gewährleisten.
  • Coalescing: Verringert die Anzahl der Partitionen, ohne einen vollständigen Shuffle durchzuführen. Das ist effizienter als eine Neupartitionierung, wenn die Anzahl der Partitionen verringert werden soll. Dazu verwenden wir .coalesce().
# Increasing partitions (full shuffle)
df_repartitioned = df.repartition(10)
# Reducing partitions (no full shuffle)
df_coalesced = df.coalesce(2)

Beachte, dass in einer Folgefrage erwähnt werden kann, wann diese Vorgänge am sinnvollsten sind. Erwähne unbedingt, dass diese bei der Arbeit mit großen Datensätzen effektiver sind und die Rechenleistung nicht für kleinere Datensätze verschwendet werden sollte.

15. Erklärt die Interoperabilität von Spark mit Datenserialisierungsformaten

Datenfachleute arbeiten mit einer Vielzahl unterschiedlicher Datenformate. Jede dieser Möglichkeiten bringt unterschiedliche Nachteile mit sich. Stelle sicher, dass du erklären kannst, wie Spark generell mit diesen Formaten interagiert, und biete eine hohe Leistung sowie Überlegungen, die für das größere Ökosystem gemacht werden müssen.

  1. Unterstützung von Daten-Serialisierungsformaten: Spark arbeitet mit Daten-Serialisierungsformaten wie Avro, Parquet oder ORC durch integrierte Unterstützung oder Bibliotheken von Drittanbietern zusammen. Diese Formate bieten Vorteile wie effiziente Komprimierung, spaltenweise Speicherung und Schemaentwicklung und eignen sich daher für die Datenverarbeitung und -speicherung in Spark-basierten Pipelines.
  2. Optimierung des Datenlesens: Spark optimiert das Lesen und Schreiben von Daten in diesen Formaten, indem es spezielle Lese- und Schreibprogramme einsetzt, die ihre interne Struktur und Komprimierungstechniken ausnutzen. Parquet und ORC nutzen zum Beispiel die spaltenbasierte Speicherung, um den I/O-Overhead zu minimieren und die Abfrageleistung zu verbessern.
  3. Kompromisse beim Datenformat: Zu den Kompromissen gehören die Speichereffizienz (z. B. die Komprimierungsrate), die Leistung (z. B. der Lese-/Schreibdurchsatz) und die Kompatibilität mit anderen Datenverarbeitungsprogrammen. Die Wahl des richtigen Serialisierungsformats hängt von Faktoren wie den Dateneigenschaften, Abfragemustern und Integrationsanforderungen innerhalb der Datenpipeline ab.

Spark Coding Interview Fragen

Diese Programmierfragen konzentrieren sich auf die Verwendung von PySpark, um mit einer Spark-Umgebung zu interagieren. 

16. Finde die N häufigsten Wörter in einer großen Textdatei

Diese Frage prüft deine Fähigkeit, mit Spark zu interagieren und die Nutzung von Mapping in Spark selbst zu verstehen.

from pyspark import SparkContext
# create your spark context
sc = SparkContext("local", "WordCount")
# import a text file from a local path
lines = sc.textFile("path/to/your/text/file.txt")
# split and map the words
# then reduce by using the words as keys and add to the count
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
# order the words and take only the top N frequent words
top_n_words = word_counts.takeOrdered(N, key=lambda x: -x[1])
print(top_n_words)

17. Finde den Durchschnitt der Werte in einem bestimmten RDD

Diese Frage ist eine gute Möglichkeit zu zeigen, ob jemand weiß, wie man ein einfaches RDD erstellt und manipuliert. Den Durchschnitt von Werten zu finden, ist eine sehr häufige Aufgabe für Datenexperten und es ist wichtig, dass du verstehst, wie man Daten in einem Spark-Kontext formt.

from pyspark import SparkContext
# Create sparkContext and name it “Average”
sc = SparkContext("local", "Average")
# Generate Spark RDD
data = sc.parallelize([1, 2, 3, 4, 5])
# Sum the RDD, count the number of values in RDD
total_sum = data.sum()
count = data.count()
# divide sum by count to get average 
average = total_sum / count
print("Average:", average)
	

18. Einen Left Outer Join zwischen zwei RDDs durchführen

Die Durchführung von Datenmanipulations- und -transformationsaufgaben wie Joins ist eine Schlüsselkomponente von SparkSQL. So können die Daten aus verschiedenen Quellen für die Datenanalyse kombiniert werden. 

from pyspark import SparkContext
# Create SparkContext
sc = SparkContext("local", "LeftOuterJoin")
# Create two RDDs with tuples sharing keys
rdd1 = sc.parallelize([(1, 'a'), (2, 'b'), (3, 'c')])
rdd2 = sc.parallelize([(1, 'x'), (2, 'y')])
# Use the .leftOuterJoin() method to join the first rdd to the second rdd
joined_rdd = rdd1.leftOuterJoin(rdd2)
# Use the .collect() method to show the rdd
print(joined_rdd.collect())
	

19. Daten aus Kafka lesen, Transformationen durchführen und dann die Ergebnisse in HDFS schreiben

Hier wird deine Fähigkeit getestet, Daten aus externen Datenquellen einzubringen und zu verstehen, wie Spark mit externen Datenquellen verbunden werden kann. Konzentriere dich hier auf die allgemeinen Konzepte, wie z.B. die Notwendigkeit, Erweiterungen/Hilfsmittel für einen bestimmten Datenstrom zu importieren, anstatt die genaue Codierung auswendig zu lernen. Beachte, dass wir für den SparkContext einen App-Namen (KafkaWordCount) als optionalen Parameter gewählt haben, aber es ist gut, ihn zu haben, da er die Prozesse übersichtlich hält.

# Import the sparkcontext, additionally import streaming context and Kafka
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.streaming.kafka import KafkaUtils
# Create context 
sc = SparkContext("local", "KafkaWordCount")
# Use streaming context to bring in data at 10 second intervals
ssc = StreamingContext(sc, 10)  # 10-second batch interval
# Use Kafka param dictionary in order to connect to the stream using the streaming context, the topic of interest, and the parameters
kafka_params = {"metadata.broker.list": "broker1:9092,broker2:9092"}
kafka_stream = KafkaUtils.createDirectStream(ssc, ["topic"], kafka_params)
# save the results of this stream to lines
# perform MapReduce in order to generate dictionary and count by keys
lines = kafka_stream.map(lambda x: x[1])
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
# save to external file
word_counts.saveAsTextFiles("hdfs://path/to/save")
# start context until you terminate
ssc.start()
ssc.awaitTermination()
	

20. Wie kannst du grundlegende Transformationen und Aktionen an einem Spark DataFrame durchführen?

Mit dieser Frage wird das Verständnis des Kandidaten für DataFrame-Operationen in Spark bewertet.

Transformationen sind Operationen an DataFrames, die einen neuen DataFrame zurückgeben, wie z.B. select, filter und groupBy. Aktionen sind Operationen, die Berechnungen auslösen und Ergebnisse zurückgeben, wie show, count und collect.

Dieses Snippet zeigt, wie man Spalten auswählt, Zeilen filtert und eine Gruppierung durchführt.

# Select specific columns
selected_df = df.select("column1", "column2")
# Filter rows based on a condition
filtered_df = df.filter(df["column1"] > 100)
# Group by a column and perform aggregation
grouped_df = df.groupBy("column2").agg({"column1": "sum"})
# Show the results
selected_df.show()
filtered_df.show()
grouped_df.show()

Schlussgedanken

Die Beherrschung dieser Interviewfragen ist ein großer erster Schritt auf dem Weg zum Datenprofi. Spark ist eine gängige Infrastruktur, die von vielen Unternehmen für ihre Big-Data-Pipelines genutzt wird. Wenn du die Vorteile und Herausforderungen von Spark verstehst, kannst du dich als kompetenter Datenexperte profilieren. Das ist erst der Anfang! Praktische Erfahrungen mit Spark sind der beste Weg, um zu lernen. 

Du kannst mit den folgenden PySpark-Kursen und -Tutorials auf DataCamp loslegen:

Spark Interview FAQs

Wie fange ich mit Spark an, wenn ich noch keine Erfahrung mit Big Data-Technologien habe?

Entdecke die DataCamp-Kurse wie zum Beispiel Einführung in PySpark, Einführung in Spark SQL in Pythonund Big Data mit PySpark um loszulegen.

Was sind die häufigsten Anwendungsfälle für Spark in der Praxis?

Spark wird für ETL-Pipelines, Datenexploration, Echtzeit-Analysen, maschinelles Lernen und Data Warehousing eingesetzt. Mit Kenntnissen in Spark kannst du in vielen Branchen eine Stelle bekommen.

Wie schneidet Spark im Vergleich zu anderen Big-Data-Verarbeitungssystemen wie Hadoop MapReduce ab?

Spark behält die Ergebnisse so weit wie möglich im Speicher, während MapReduce Zwischenergebnisse auf eine Festplatte schreibt. Spark kann jedoch die Hadoop-Infrastruktur wie YARN für das Ressourcenmanagement nutzen, sodass beide oft zusammenarbeiten.

Eignet sich Spark für kleine Datenverarbeitungsaufgaben oder nur für Big Data?

Ja. Spark ist so konzipiert, dass es je nach Datenverarbeitungsbedarf skaliert werden kann. Bestimmte Spark-Funktionen, die zur Leistungsoptimierung entwickelt wurden, können bei kleineren Datensätzen Rechenleistung verschwenden, sodass du deine Pipelines entsprechend anpassen musst.

Kann ich Spark auch mit anderen Sprachen als Python verwenden?

Ja. Spark kann in Scala, Java, R und SQL eingesetzt werden.


Tim Lu's photo
Author
Tim Lu
LinkedIn

Ich bin Datenwissenschaftler mit Erfahrung in räumlicher Analyse, maschinellem Lernen und Datenpipelines. Ich habe mit GCP, Hadoop, Hive, Snowflake, Airflow und anderen Data Science/Engineering-Prozessen gearbeitet.

Themen

Lerne Spark mit dem DataCamp

Zertifizierung verfügbar

Kurs

Einführung in Spark SQL in Python

4 hr
17.2K
Lerne, wie du mit SQL in Python Daten manipulieren und Feature Sets für maschinelles Lernen in Spark erstellen kannst.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow