De 20 beste Spark-sollicitatievragen

Apache Spark is een uniforme analytics-engine voor grootschalige data engineering, data science en machine learning. Je kunt het gebruiken met Python, SQL, R, Java of Scala. Spark werd oorspronkelijk gestart aan de University of California, Berkeley, in 2009 en is in 2013 geschonken aan de Apache Software Foundation. Het is nu “de meest gebruikte engine voor schaalbare computing,” met duizenden vacatures waarin de technologie wordt gebruikt. Omdat het zo’n waardevolle skill is in de data-engineeringwereld, vind je hier sollicitatievragen die je helpen bij je zoektocht naar een baan of naar talent met Spark-ervaring. De code-antwoorden worden in Python gegeven.

Basisvragen over Spark

Deze vragen behandelen enkele fundamenten van Spark en zijn geschikt voor wie er slechts basiservaring mee heeft. Als je een opfrisser nodig hebt, is onze cursus Inleiding tot Spark SQL in Python de ideale plek om te beginnen. 

1. Wat is Apache Spark en waarom wordt het gebruikt bij dataverwerking?

Deze vraag toetst de algemene kennis van de kandidaat over Apache Spark en de rol ervan in het big-data-ecosysteem.

Antwoord:

Apache Spark is een open-source, gedistribueerd computingsysteem dat een interface biedt om complete clusters te programmeren met impliciete dataparalleliteit en fouttolerantie. Het wordt gebruikt voor grootschalige dataverwerking vanwege de snelheid en het gebruiksgemak vergeleken met traditioneel MapReduce.

Belangrijkste kenmerken:

• In-memory computing: Slaat data in het geheugen op voor snellere verwerking.
• Schaalbaarheid: Kan petabytes aan data verwerken met een cluster van machines.
• Gebruiksgemak: Biedt API’s in Java, Scala, Python en R.
• Uniforme analytics-engine: Ondersteunt SQL, streaming data, machine learning en graafverwerking.

2. Leg het concept van Resilient Distributed Datasets (RDD’s) uit

Deze vraag test je op de fundamentele concepten van Apache Spark. Zorg dat je een van de cruciale componenten begrijpt die Spark zo krachtig maken.

Resilient Distributed Datasets (RDD’s) zijn de fundamentele bouwstenen van Apache Spark. Ze vertegenwoordigen een onveranderlijke, gedistribueerde verzameling objecten waarop parallelle bewerkingen kunnen worden uitgevoerd in een cluster. Hier volgt een uitleg van de belangrijkste kenmerken en concepten van RDD’s:

1. Immutable: RDD’s zijn onveranderlijk; eenmaal gemaakt kun je de inhoud niet wijzigen. Je kunt RDD’s alleen transformeren door transformaties toe te passen om nieuwe RDD’s te creëren. Deze onveranderlijkheid vereenvoudigt fouttolerantie en maakt Spark’s luie evaluatiemodel mogelijk.
2. Gedistribueerd: RDD’s zijn verdeeld over meerdere nodes in een cluster, zodat Spark er parallelle operaties op kan uitvoeren. Elke RDD is opgedeeld in meerdere partitions, die onafhankelijk op verschillende nodes verwerkt kunnen worden.
3. Resilient: De “Resilient” in RDD staat voor fouttolerantie. Spark waarborgt veerkracht door de afstamming (lineage) van elke RDD bij te houden. Als een partition van een RDD verloren gaat door een node-fout, kan Spark die partition herberekenen met de lineage-informatie en de toegepaste transformaties op de oorspronkelijke data.
4. Dataset: RDD’s zijn een gedistribueerde representatie van data, wat betekent dat ze elk type data kunnen bevatten, inclusief gestructureerde en ongestructureerde data. Spark biedt API’s in meerdere talen (zoals Scala, Java, Python en R) om met RDD’s te werken, wat het veelzijdig maakt voor uiteenlopende use-cases en datatypen.
5. Luie evaluatie (Lazy Evaluation): RDD’s ondersteunen luie evaluatie: transformaties worden niet meteen uitgevoerd. In plaats daarvan bouwt Spark een gerichte acyclische graaf (DAG) van transformaties die de berekening definiëren, maar stelt de uitvoering uit tot een actie wordt getriggerd. Hierdoor kan Spark het uitvoeringsplan optimaliseren en de prestaties verbeteren.

3. Wat is YARN?

YARN is een gedistribueerde container-manager die resources in Hadoop beheert. Spark kan YARN gebruiken wanneer het draait op Hadoop-clusters voor effectiever en efficiënter resourcemanagement. Een van de cruciale componenten van YARN is het efficiënt toewijzen van resources in het cluster, het efficiënt plannen van jobs en fouttolerantie bij node-uitval. Het is een van de vele componenten die Spark tot een krachtig hulpmiddel maken.

4. Wat is het verschil tussen map- en flatMap-transformaties in Spark RDD’s?

Deze vraag laat zien of je verschillende soorten transformaties in Spark RDD’s (Resilient Distributed Datasets) begrijpt.

Antwoord:

• .map(): Zet elk element van de RDD om in precies één nieuw element. Het resultaat is een RDD met hetzelfde aantal elementen als de invoer-RDD.
• .flatMap(): Zet elk element van de RDD om in nul of meer nieuwe elementen. Het resultaat is een RDD met mogelijk een ander aantal elementen dan de invoer-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]

Deze code laat het verschil zien tussen map en flatMap door een RDD van gehele getallen te transformeren.

5. Hoe gebruik je Spark SQL om data uit een DataFrame te bevragen?

Deze vraag controleert of de kandidaat Spark SQL kan gebruiken voor query’s, wat essentieel is voor data-analyse.

Antwoord:

# 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()

Dit fragment laat zien hoe je een tijdelijke view van een DataFrame maakt en Spark SQL gebruikt om een group-by-query uit te voeren.

Gevorderde basis: Intermediate Spark-sollicitatievragen

Voor wie de basis beheerst en die in de praktijk heeft toegepast, komen deze vragen vaker voor: 

6. Leg het concept van luie evaluatie in Spark uit en waarom het belangrijk is

Deze vraag toetst het begrip van een van Sparks kernprincipes, cruciaal voor prestatie-optimalisatie.

Antwoord:

Luie evaluatie betekent dat Spark transformaties niet direct uitvoert wanneer ze worden aangeroepen. In plaats daarvan bouwt het een logisch uitvoeringsplan. De transformaties worden pas uitgevoerd wanneer een actie (zoals collect of count) wordt aangeroepen, die de daadwerkelijke berekening triggert.

Luie evaluatie is belangrijk om twee redenen:

1. Het stelt Spark in staat de volledige dataverwerkingsworkflow te optimaliseren vóór uitvoering, door bewerkingen te combineren om data shuffling te minimaliseren.
2. Het vermindert het aantal keren dat de data wordt doorlopen, wat de prestaties verbetert.

7. Hoe persisteer je data in Spark en welke opslagniveaus zijn er?

Deze vraag toetst kennis van datapersistentie in Spark, belangrijk voor performance tuning en iteratieve algoritmen.

Antwoord:

Data kan in Spark worden gepersisteerd met de methoden .persist() of .cache(). .cache() is een verkorte vorm van .persist() met het standaardopslagniveau.

Opslagniveaus:

• MEMORY_ONLY: Slaat RDD op als gedeserialiseerde Java-objecten in de JVM. Als de RDD niet in het geheugen past, worden sommige partitions niet gecachet.
• MEMORY_AND_DISK: Slaat RDD op als gedeserialiseerde Java-objecten in het geheugen. Als de RDD niet past, worden partitions op schijf opgeslagen.
• MEMORY_ONLY_SER: Slaat RDD op als geserialiseerde Java-objecten in de JVM. Dit vermindert het geheugengebruik, maar verhoogt de CPU-overhead voor (de)serialisatie.
• MEMORY_AND_DISK_SER: Vergelijkbaar met MEMORY_AND_DISK maar slaat geserialiseerde objecten op.
• DISK_ONLY: Slaat RDD-partitions alleen op schijf op.

rdd = spark.sparkContext.parallelize([1, 2, 3, 4, 5])
rdd.persist(storageLevel=StorageLevel.MEMORY_AND_DISK)

8. Hoe ga je om met scheve data (skew) in Spark?

Deze vraag beoordeelt het begrip van datascheefheid en hoe je die beheert, cruciaal voor efficiënte dataverwerking.

Antwoord:

Datascheefheid ontstaat wanneer sommige partitions aanzienlijk meer data bevatten dan andere, wat prestatieknelpunten veroorzaakt. Strategieën om hiermee om te gaan zijn onder meer:

• Salting: Een willekeurige sleutel toevoegen om data gelijkmatiger over partitions te verdelen.
• Repartitioneren: Het aantal partitions verhogen om de data gelijkmatiger te verdelen.
• Broadcast-variabelen: Een kleine dataset naar alle nodes broadcasten om het shufflen van grote datasets te vermijden.

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. Leg het verschil uit tussen smalle (narrow) en brede (wide) transformaties in Spark

Deze vraag test het begrip van Sparks uitvoeringsmodel en de impact van verschillende transformatietypen op prestaties.

Antwoord:

• Smalle transformaties: Bewerkingen waarbij elke input-partition bijdraagt aan precies één output-partition. Voorbeelden: .map(), .filter() en .union(). Ze zijn meestal sneller omdat er geen data-shuffle nodig is.
• Brede transformaties: Bewerkingen waarbij elke input-partition bijdraagt aan meerdere output-partitions. Voorbeelden: .groupByKey(), .reduceByKey() en .join(). Ze vereisen data-shuffling over het netwerk, wat tijdrovend kan zijn.

# Narrow transformation example
rdd1 = rdd.map(lambda x: x * 2)
# Wide transformation example
rdd2 = rdd.groupByKey()

10. Spark Streaming bij realtime dataverwerking

Spark blinkt uit in het streamen van realtime data uit bronnen zoals Apache Kafka of Amazon Kinesis omdat het schaalbaar en fouttolerant is. Dit gebeurt via de uitbreiding Spark Streaming. Het werkt met externe databronnen via input DStreams, die een continue datastroom vanuit deze bronnen vertegenwoordigen. 

Spark Streaming waarborgt fouttolerantie en dataconsistentie via technieken zoals checkpointing en write-ahead logs. Checkpointing slaat periodiek de status van de streamingapplicatie op duurzame opslag (bijv. HDFS) op om te herstellen na fouten, terwijl write-ahead logs fouttolerantie bieden voor data die uit externe bronnen wordt ontvangen.

Geavanceerde Spark-sollicitatievragen

Deze vragen zijn voor gebruikers met meer hands-on-ervaring met Spark, vooral met meer geavanceerde onderwerpen. Heb je een opfrisser nodig, bekijk dan onze Spark Machine Learning-tutorial. 

11. Bespreek hoe Spark kan worden ingezet voor machine learning

Deze vraag test het begrip van de omgeving van Spark en de MLlib-bibliotheek. 

Sparks MLlib-bibliotheek biedt een rijke set hulpmiddelen en algoritmen voor machinelearning-taken op schaal. Voor feature engineering en preprocessing van grootschalige datasets biedt MLlib diverse geavanceerde technieken en optimalisaties:

1. Featuretransformatie en -selectie: MLlib biedt uiteenlopende featuretransformaties, zoals schalen, normaliseren, binariseren en vectoriseren (bijv. one-hot encoding). Daarnaast zijn er methoden voor featureselectie, waaronder filteren op basis van correlatie, information gain of statistische tests, en geavanceerdere technieken zoals Principal Component Analysis (PCA) voor dimensiereductie.

2. Categorische features verwerken: MLlib bevat tools voor het efficiënt verwerken van categorische features, zoals StringIndexer om categorische variabelen naar numerieke representaties om te zetten en OneHotEncoder om ze naar binaire vectoren om te zetten. Deze transformaties zijn geoptimaliseerd voor parallelle uitvoering op gedistribueerde Spark-clusters.

3. Pipeline-API: Sparks Pipeline-API maakt het mogelijk om meerdere stappen van feature engineering en modellering aan elkaar te schakelen in één workflow. Dit vereenvoudigt het bouwen van complexe transformatiepijplijnen en waarborgt consistentie en reproduceerbaarheid over datasets en ML-taken heen.

4. Aangepaste transformers en estimators: MLlib laat je aangepaste featuretransformers en estimators definiëren met Sparks DataFrame-API. Zo kun je domeinspecifieke feature engineering of externe bibliotheken integreren in de Spark ML-pijplijn, wat de functionaliteit en flexibiliteit vergroot.

12. Leg uit hoe Spark integreert met externe opslagsystemen zoals Apache Hadoop HDFS en Apache Cassandra. Wat zijn de voordelen van deze integraties in een Spark-gebaseerde datapijplijn?

Dit test of gebruikers de onderliggende functionaliteit van Spark-gebaseerde systemen begrijpen en hoe Spark samenwerkt met HDFS en Apache Cassandra. Het is belangrijk om te begrijpen hoe je data via code ophaalt en hoe die data door het systeem beweegt.

1. Hadoop HDFS-verbinding: Spark integreert met externe opslagsystemen zoals Apache Hadoop HDFS en Apache Cassandra via connectors of bibliotheken die specifiek voor elk systeem zijn ontworpen. Zo is HDFS-integratie native in Spark, waardoor Spark data rechtstreeks kan lezen en schrijven van/naar HDFS met Hadoop InputFormat- en OutputFormat-API’s.
2. Apache Cassandra-verbinding: De voordelen van deze integraties omvatten betere prestaties dankzij datalocaliteit (bij HDFS), eenvoudiger data-toegang en -manipulatie, en compatibiliteit met bestaande datainfrastructuur. Bovendien kan Spark profiteren van de gedistribueerde aard van deze opslagsystemen voor parallelle verwerking, wat schaalbare dataverwerking mogelijk maakt.

13. Leg het concept van broadcast-variabelen in Spark uit

Broadcast-variabelen in Spark zijn read-only variabelen die worden gecachet en beschikbaar worden gemaakt op alle workernodes in een gedistribueerde Spark-applicatie. Ze worden gebruikt om grote, read-only datasets of waarden efficiënt te distribueren naar workernodes, waardoor de netwerkoverhead afneemt en de taakprestaties verbeteren. 

Broadcast-variabelen worden geserialiseerd en slechts één keer naar elke workernode verzonden, waar ze in het geheugen worden gecachet en hergebruikt over meerdere taken. Dit voorkomt dat de variabele bij elke taak meegezonden moet worden, wat datatransfer-overhead vermindert, vooral bij grote datasets.

• Gebruik: Broadcast-variabelen worden vaak gebruikt wanneer een grote dataset of waarde moet worden gedeeld over meerdere taken of fasen van de berekening. Bijvoorbeeld bij joins waar één DataFrame of RDD aanzienlijk kleiner is dan de andere: door de kleinere te broadcasten, verminder je de hoeveelheid data die over het netwerk wordt geschuffeld tijdens de join.
• Situaties waarin het loont:
• Join-bewerkingen: Het broadcasten van kleinere datasets voor joins kan de prestaties sterk verbeteren door minder netwerkverkeer en snellere taakuitvoering.
• Opzoektabellen: Kleine opzoektabellen of dictionaires broadcasten die worden gebruikt voor verrijking of filtering kan prestaties verbeteren door herhaalde datatransfers te vermijden.
• Machine learning: Featurevectoren of modelparameters broadcasten naar workernodes tijdens gedistribueerde training kan het trainingsproces versnellen, vooral wanneer deze relatief klein zijn ten opzichte van de dataset.
• Uitdagingen:
• Geheugenkosten: Grote variabelen broadcasten kan veel geheugen verbruiken op workernodes, wat tot out-of-memory-fouten kan leiden als je niet oplet.
• Netwerkcongestie: Het initiële broadcasten van grote variabelen kan netwerkcongestie veroorzaken, vooral in grote clusters met beperkte bandbreedte.
• Dynamische data: Broadcast-variabelen zijn onveranderlijk nadat ze zijn verstuurd, dus ze zijn niet geschikt voor scenario’s waarin de gebroadcastte data tijdens de uitvoering moet worden bijgewerkt.

14. Hoe optimaliseer je een Spark-job met partitioning en coalescing? 

Deze vraag beoordeelt het vermogen van de kandidaat om Spark-jobs te optimaliseren, een kernvaardigheid om prestaties en efficiëntie te verbeteren. Via Spark performance tuning kunnen we Sparks gedistribueerde framework benutten met partitioning en coalescing, die de werkverdeling over het cluster sturen om bewerkingen sneller uit te voeren. 

Antwoord:

• Partitioning: Bepaalt het aantal partitions in een RDD of DataFrame. Gebruik .repartition() om het aantal te verhogen of gelijkmatiger te verdelen. Dit is rekenintensiever en moet je alleen gebruiken wanneer je de data gelijkmatig wilt verdelen voor gebalanceerde verwerking.
• Coalescing: Vermindert het aantal partitions zonder een volledige shuffle uit te voeren, wat efficiënter is dan repartition bij het verlagen van het aantal partitions. Dit doe je met .coalesce().

# Increasing partitions (full shuffle)
df_repartitioned = df.repartition(10)
# Reducing partitions (no full shuffle)
df_coalesced = df.coalesce(2)

Let op: een vervolgvraag kan gaan over wanneer deze bewerkingen het meest nuttig zijn. Noem dan dat ze vooral effect hebben bij grote datasets en dat je rekenkracht niet moet verspillen aan kleine datasets.

15. Leg Sparks interoperabiliteit met dataserialisatieformaten uit

Dataprofessionals werken met een breed scala aan dataformaten. Elk heeft eigen trade-offs. Zorg dat je kunt uitleggen hoe Spark met deze formaten omgaat en geef overwegingen op hoog niveau voor prestaties en voor het bredere ecosysteem.

1. Ondersteuning voor dataserialisatieformaten: Spark werkt samen met serialisatieformaten zoals Avro, Parquet of ORC via ingebouwde ondersteuning of externe bibliotheken. Deze formaten bieden voordelen zoals efficiënte compressie, kolommageheugen en schema-evolutie, waardoor ze geschikt zijn voor verwerking en opslag in Spark-pijplijnen.
2. Optimalisatie van lezen/schrijven: Spark optimaliseert lees- en schrijfbewerkingen met deze formaten via gespecialiseerde readers en writers die hun interne structuur en compressietechnieken benutten. Zo gebruiken Parquet en ORC kolomopslag om I/O-overhead te minimaliseren en queryprestaties te verbeteren.
3. Trade-offs van dataformaten: Afwegingen omvatten opslag-efficiëntie (bijv. compressieratio), prestaties (bijv. lees-/schrijfsnelheid) en compatibiliteit met andere tools. De keuze voor het juiste formaat hangt af van factoren zoals datakenmerken, querypatronen en integratievereisten in de pijplijn.

Spark coding-sollicitatievragen

Deze codeervragen richten zich op het gebruik van PySpark om met een Spark-omgeving te werken. 

16. Vind de top N meest voorkomende woorden in een groot tekstbestand

Deze vraag controleert je vaardigheid om met Spark te werken en het gebruik van mapping in Spark te begrijpen.

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. Vind het gemiddelde van waarden in een gegeven RDD

Deze vraag is een goede manier om te laten zien of iemand weet hoe hij een eenvoudige RDD maakt en ermee werkt. Het gemiddelde van waarden zoeken is een veelvoorkomende taak voor dataprofessionals en het is belangrijk dat je begrijpt hoe je data binnen een Spark-context vormgeeft.

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. Voer een left outer join uit tussen twee RDD’s

Het uitvoeren van datamanipulatie- en transformatietaken zoals joins is een kernonderdeel van SparkSQL. Hiermee kan data uit verschillende bronnen worden gecombineerd voor analyse. 

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. Lees data uit Kafka, voer transformaties uit en schrijf de resultaten naar HDFS

Dit test je vermogen om data uit externe bronnen binnen te halen en je begrip van hoe Spark met externe bronnen verbindt. Richt je hier op de algemene concepten, zoals de noodzaak om extensies/utilities te importeren voor een bepaalde datastroom, in plaats van exacte code te memoriseren. Merk op dat we voor de SparkContext een appname (KafkaWordCount) als optionele parameter hebben gekozen; het is handig voor duidelijkheid in processen.

# 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. Hoe voer je basistransformaties en -acties uit op een Spark DataFrame?

Deze vraag beoordeelt het begrip van DataFrame-bewerkingen in Spark.

Transformaties zijn bewerkingen op DataFrames die een nieuw DataFrame teruggeven, zoals select, filter en groupBy. Acties zijn bewerkingen die de berekening triggeren en resultaten teruggeven, zoals show, count en collect.

Dit fragment laat zien hoe je kolommen selecteert, rijen filtert en een group-by-aggregatie uitvoert.

# 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()

Tot slot

Het beheersen van deze sollicitatievragen is een goede eerste stap richting een carrière als dataprofessional. Spark is een veelgebruikte infrastructuur bij organisaties om hun big-datapijplijnen te beheren. Inzicht in de voordelen en uitdagingen van Spark helpt je opvallen als een kundige dataprofessional. Dit is nog maar het begin! Praktische ervaring met Spark is de beste manier om te leren. 

Je kunt aan de slag met de volgende PySpark-cursussen en -tutorials op DataCamp:

• Introduction to PySpark
• Introduction to Spark SQL in Python
• Big Data with PySpark
• Apache Spark Tutorial: ML with PySpark