Le 20 migliori domande di colloquio su Spark

Apache Spark è un motore di analytics unificato per data engineering, data science e machine learning su larga scala. Può essere usato con Python, SQL, R, Java o Scala. Spark è stato avviato originariamente all'Università della California, Berkeley, nel 2009 e successivamente donato all'Apache Software Foundation nel 2013. Oggi è “il motore più utilizzato per il calcolo scalabile,” con migliaia di offerte di lavoro che richiedono questa tecnologia. Essendo una competenza molto richiesta nel mondo del data engineering, ecco alcune domande di colloquio per aiutarti sia nella ricerca di lavoro sia nella selezione di talenti con esperienza in Spark. Le risposte in codice saranno fornite in Python.

Domande di base su Spark

Queste domande coprono alcuni fondamentali di Spark e sono adatte a chi ha solo un'esperienza di base. Se ti serve un ripasso, il nostro corso Introduction to Spark SQL in Python è il punto di partenza ideale. 

1. Che cos'è Apache Spark e perché viene utilizzato nell'elaborazione dei dati?

Questa domanda valuta la comprensione generale del candidato di Apache Spark e del suo ruolo nell'ecosistema big data.

Risposta:

Apache Spark è un sistema di calcolo distribuito open source che fornisce un'interfaccia per programmare interi cluster con parallelismo dei dati implicito e tolleranza ai guasti. È utilizzato per l'elaborazione di dati su larga scala grazie alla sua velocità e facilità d'uso rispetto al tradizionale MapReduce.

Caratteristiche principali:

• Calcolo in memoria: Memorizza i dati in memoria per un'elaborazione più rapida.
• Scalabilità: Può gestire petabyte di dati utilizzando un cluster di macchine.
• Facilità d'uso: Fornisce API in Java, Scala, Python e R.
• Motore di analytics unificato: Supporta SQL, dati in streaming, machine learning ed elaborazione di grafi.

2. Spiega il concetto di Resilient Distributed Datasets (RDD)

Questa domanda verifica i concetti fondamentali di Apache Spark. Assicurati di comprendere uno dei componenti critici che rendono Spark così potente.

I Resilient Distributed Datasets (RDD) sono i mattoni fondamentali di Apache Spark. Rappresentano una raccolta distribuita e immutabile di oggetti su cui è possibile operare in parallelo attraverso un cluster. Ecco una spiegazione delle caratteristiche e dei concetti chiave associati agli RDD:

1. Immutabili: Gli RDD sono immutabili, cioè una volta creati il loro contenuto non può essere modificato. Puoi solo trasformarli applicando trasformazioni per creare nuovi RDD. Questa immutabilità semplifica la tolleranza ai guasti e abilita il modello di valutazione pigra (lazy evaluation) di Spark.
2. Distribuiti: Gli RDD sono distribuiti su più nodi in un cluster, consentendo a Spark di eseguire operazioni in parallelo. Ogni RDD è suddiviso in più partizioni che possono essere elaborate in modo indipendente su nodi diversi.
3. Resilienti: La "resilienza" negli RDD indica la tolleranza ai guasti. Spark garantisce la resilienza tenendo traccia della lineage di ogni RDD. Se una partizione di un RDD viene persa a causa del guasto di un nodo, Spark può ricalcolarla usando le informazioni di lineage e le trasformazioni applicate ai dati originali.
4. Dataset: Gli RDD sono una rappresentazione distribuita dei dati, il che significa che possono contenere qualsiasi tipo di dato, inclusi dati strutturati o non strutturati. Spark fornisce API in più linguaggi (come Scala, Java, Python e R) per lavorare con gli RDD, rendendoli versatili per vari casi d'uso e tipi di dati.
5. Valutazione pigra (Lazy Evaluation): Gli RDD supportano la valutazione pigra, cioè le trasformazioni non vengono eseguite immediatamente. Spark costruisce invece un DAG (grafo aciclico diretto) di trasformazioni che definisce la computazione, ma ne rimanda l'esecuzione finché non viene attivata un'azione. Questa ottimizzazione consente a Spark di ottimizzare il piano di esecuzione e migliorare le prestazioni.

3. Che cos'è YARN?

YARN è un gestore di container distribuito che gestisce le risorse in Hadoop. Spark può utilizzare YARN quando viene eseguito su cluster Hadoop per una gestione delle risorse più efficace ed efficiente. Uno dei componenti critici di YARN è la capacità di allocare le risorse in modo efficiente nel cluster, pianificare i job in modo efficiente ed essere tollerante ai guasti in caso di malfunzionamenti dei nodi. È uno dei tanti componenti che rendono Spark uno strumento potente.

4. Qual è la differenza tra le trasformazioni map e flatMap negli RDD di Spark?

Questa domanda aiuta a capire se conosci i diversi tipi di trasformazioni nei RDD (Resilient Distributed Datasets) di Spark.

Risposta:

• .map(): Trasforma ciascun elemento dell'RDD in esattamente un nuovo elemento. Il risultato è un RDD con lo stesso numero di elementi dell'RDD di input.
• .flatMap(): Trasforma ciascun elemento dell'RDD in zero o più nuovi elementi. Il risultato è un RDD con un numero di elementi potenzialmente diverso rispetto all'RDD di input.

# 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]

Questo codice illustra la differenza tra map e flatMap trasformando un RDD di interi.

5. Come usi Spark SQL per interrogare i dati da un DataFrame?

Questa domanda verifica la capacità del candidato di usare Spark SQL per interrogare i dati, fondamentale per i compiti di analisi.

Risposta:

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

Questo snippet mostra come creare una vista temporanea da un DataFrame e usare Spark SQL per eseguire una query con group by.

Domande intermedie su Spark

Per chi ha padroneggiato le basi e le ha applicate nel proprio ruolo professionale, queste domande possono essere più comuni: 

6. Spiega il concetto di valutazione pigra (lazy evaluation) in Spark e perché è importante

Questa domanda valuta la comprensione di uno dei principi cardine di Spark, cruciale per ottimizzare le prestazioni.

Risposta:

La valutazione pigra significa che Spark non esegue immediatamente le trasformazioni quando vengono chiamate. Al contrario, costruisce un piano di esecuzione logico. Le trasformazioni vengono eseguite solo quando viene chiamata un'azione (come collect o count), che attiva la computazione effettiva.

La valutazione pigra è importante per due ragioni:

1. Consente a Spark di ottimizzare l'intero flusso di elaborazione dei dati prima di eseguirlo, combinando operazioni per minimizzare lo shuffling dei dati.
2. Riduce il numero di passaggi sui dati, migliorando le prestazioni.

7. Come persisti i dati in Spark e quali sono i diversi livelli di storage disponibili?

Questa domanda verifica la conoscenza della persistenza dei dati in Spark, importante per l'ottimizzazione delle prestazioni e gli algoritmi iterativi.

Risposta:

I dati possono essere persistiti in Spark usando i metodi .persist() o .cache(). .cache() è una scorciatoia di .persist() con il livello di storage predefinito.

Livelli di storage:

• MEMORY_ONLY: Memorizza l'RDD come oggetti Java deserializzati nella JVM. Se l'RDD non entra in memoria, alcune partizioni non verranno messe in cache.
• MEMORY_AND_DISK: Memorizza l'RDD come oggetti Java deserializzati in memoria. Se l'RDD non entra in memoria, le partizioni vengono archiviate su disco.
• MEMORY_ONLY_SER: Memorizza l'RDD come oggetti Java serializzati nella JVM. Questo riduce l'uso di memoria ma aumenta l'overhead CPU per serializzazione/deserializzazione.
• MEMORY_AND_DISK_SER: Simile a MEMORY_AND_DISK ma archivia oggetti serializzati.
• DISK_ONLY: Archivia le partizioni dell'RDD solo su disco.

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

8. Come gestisci i dati sbilanciati (skewed) in Spark?

Questa domanda valuta la comprensione dello skew dei dati e di come gestirlo, fondamentale per garantire un'elaborazione efficiente.

Risposta:

Lo skew dei dati si verifica quando alcune partizioni hanno molti più dati di altre, causando colli di bottiglia prestazionali. Strategie per gestire dati sbilanciati includono:

• Salting: Aggiungere una chiave casuale ai dati per distribuirli più uniformemente tra le partizioni.
• Repartitioning: Aumentare il numero di partizioni per distribuire i dati in modo più uniforme.
• Variabili broadcast: Trasmettere un dataset piccolo a tutti i nodi per evitare lo shuffling di dataset grandi.

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. Spiega la differenza tra trasformazioni strette (narrow) e larghe (wide) in Spark

Questa domanda testa la comprensione del modello di esecuzione di Spark e l'impatto dei diversi tipi di trasformazioni sulle prestazioni.

Risposta:

• Trasformazioni strette (Narrow): Operazioni in cui ogni partizione di input contribuisce a una sola partizione di output. Esempi: .map(), .filter() e .union(). In genere sono più veloci perché non richiedono shuffling dei dati.
• Trasformazioni larghe (Wide): Operazioni in cui ogni partizione di input contribuisce a più partizioni di output. Esempi: .groupByKey(), .reduceByKey() e .join(). Richiedono lo shuffling dei dati in rete, che può richiedere tempo.

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

10. Spark Streaming nell'elaborazione dei dati in tempo reale

Spark eccelle nello streaming di dati in tempo reale da fonti come Apache Kafka o Amazon Kinesis perché è scalabile e tollerante ai guasti. Lo fa tramite l'estensione Spark Streaming. Interagisce con sorgenti dati esterne usando input DStreams, che rappresentano un flusso continuo di dati da queste fonti. 

Spark Streaming garantisce tolleranza ai guasti e consistenza dei dati tramite tecniche come checkpointing e write-ahead logs. Il checkpointing salva periodicamente lo stato dell'applicazione di streaming su storage durevole (ad es. HDFS) per riprendersi dai guasti, mentre i write-ahead log forniscono tolleranza ai guasti per i dati ricevuti da fonti esterne.

Domande avanzate su Spark

Queste domande sono per utenti con più esperienza pratica con Spark, in particolare su argomenti più sofisticati. Se ti serve un ripasso, dai un'occhiata al nostro tutorial Spark Machine Learning. 

11. Spiega come utilizzare Spark per il machine learning

Questa domanda verifica la comprensione dell'ambiente Spark e della libreria MLlib. 

La libreria MLlib di Spark fornisce un ricco set di strumenti e algoritmi per eseguire attività di machine learning su larga scala. Per il feature engineering e il preprocessing su dataset di grandi dimensioni, MLlib offre diverse tecniche avanzate e ottimizzazioni:

1. Trasformazione e selezione delle feature: MLlib offre un'ampia gamma di tecniche di trasformazione delle feature, come scaling, normalizzazione, binarizzazione e vettorizzazione (ad es. one-hot encoding). Inoltre, fornisce metodi per la selezione delle feature, inclusi filtri basati su correlazione, information gain o test statistici, oltre a tecniche più avanzate come Principal Component Analysis (PCA) per la riduzione della dimensionalità.

2. Gestione delle variabili categoriche: MLlib include strumenti per gestire in modo efficiente le variabili categoriche, come StringIndexer per convertire le variabili categoriche in rappresentazioni numeriche e OneHotEncoder per convertirle in vettori binari. Queste trasformazioni sono ottimizzate per l'esecuzione parallela sui cluster Spark distribuiti.

3. API Pipeline: La Pipeline API di Spark consente di concatenare più fasi di feature engineering e modellazione in un singolo workflow. Questo facilita la creazione di pipeline di trasformazione delle feature complesse garantendo coerenza e riproducibilità tra dataset e compiti di machine learning diversi.

4. Transformer ed estimator personalizzati: MLlib permette di definire transformer ed estimator personalizzati usando la DataFrame API di Spark. Ciò consente di integrare tecniche di feature engineering specifiche del dominio o librerie di terze parti nella pipeline ML di Spark, estendendone funzionalità e flessibilità.

12. Spiega come Spark si integra con sistemi di storage esterni come Apache Hadoop HDFS e Apache Cassandra. Quali sono i vantaggi di sfruttare queste integrazioni in una pipeline dati basata su Spark?

Questo verifica se gli utenti comprendono il funzionamento alla base dei sistemi basati su Spark e come Spark lavori con HDFS e Apache Cassandra. È importante capire sia come recuperare i dati tramite codice sia come quei dati si muovono nel sistema.

1. Connessione a Hadoop HDFS: Spark si integra con sistemi di storage esterni come Apache Hadoop HDFS e Apache Cassandra tramite connettori o librerie specifiche per ciascun sistema. Ad esempio, l'integrazione con HDFS è nativa in Spark, consentendo di leggere e scrivere dati direttamente da/su HDFS usando le API Hadoop InputFormat e OutputFormat.
2. Connessione ad Apache Cassandra: I vantaggi di sfruttare queste integrazioni includono prestazioni migliorate grazie alla località dei dati (nel caso di HDFS), accesso e manipolazione dei dati semplificati e compatibilità con l'infrastruttura dati esistente. Inoltre, Spark può sfruttare la natura distribuita di questi sistemi di storage per l'elaborazione parallela, abilitando processi scalabili.

13. Spiega il concetto di variabili broadcast in Spark

Le variabili broadcast in Spark sono variabili di sola lettura che vengono messe in cache e rese disponibili a tutti i nodi worker in un'applicazione Spark distribuita. Si usano per distribuire in modo efficiente dataset o valori grandi e di sola lettura ai nodi worker, riducendo l'overhead di rete e migliorando le prestazioni dei task. 

Le variabili broadcast vengono serializzate e inviate a ciascun nodo worker una sola volta, dove vengono messe in cache in memoria e riutilizzate tra più task. Questo elimina la necessità di inviare la variabile con ogni task, riducendo il traffico dati, soprattutto per dataset di grandi dimensioni.

• Utilizzo: Le variabili broadcast sono comunemente usate in scenari in cui un dataset o un valore grande deve essere condiviso tra più task o fasi della computazione. Ad esempio, nelle join in cui un DataFrame o un RDD è significativamente più piccolo dell'altro, trasmettere (broadcast) il DataFrame/RDD più piccolo può ridurre notevolmente la quantità di dati scambiati in rete durante la join.
• Scenari vantaggiosi:
• Operazioni di join: Trasmettere dataset più piccoli per le join può migliorare molto le prestazioni riducendo il traffico di rete e accelerando l'esecuzione dei task.
• Tabelle di lookup: Trasmettere piccole tabelle di lookup o dizionari utilizzati per arricchimento o filtraggio può migliorare le prestazioni evitando trasferimenti ripetuti di dati.
• Machine learning: Trasmettere vettori di feature o parametri di modello ai nodi worker durante l'addestramento distribuito può accelerare il processo, specialmente quando i vettori o i parametri sono relativamente piccoli rispetto al dataset.
• Sfide:
• Overhead di memoria: Trasmettere variabili grandi può consumare molta memoria sui nodi worker, portando potenzialmente a errori di out-of-memory se non gestito con attenzione.
• Congestione di rete: Trasmettere variabili grandi può introdurre congestione di rete nella fase iniziale di broadcast, soprattutto in cluster grandi con banda limitata.
• Dati dinamici: Le variabili broadcast sono immutabili una volta trasmesse, quindi non sono adatte a scenari in cui i dati trasmessi debbano essere aggiornati dinamicamente durante l'esecuzione del job Spark.

14. Come ottimizzi un job Spark usando partitioning e coalescing? 

Questa domanda valuta la capacità di ottimizzare i job Spark, una competenza chiave per migliorare prestazioni ed efficienza. Tramite il tuning delle prestazioni di Spark, possiamo sfruttare il framework distribuito usando partitioning e coalescing, che gestiscono la distribuzione del carico nel cluster per eseguire le operazioni sui dati più rapidamente. 

Risposta:

• Partitioning: Controlla il numero di partizioni in un RDD o DataFrame. Usa .repartition() per aumentare o distribuire uniformemente le partizioni. È più costoso computazionalmente e andrebbe usato solo quando serve dividere i dati in modo uniforme per un'elaborazione bilanciata.
• Coalescing: Riduce il numero di partizioni senza eseguire uno shuffle completo, risultando più efficiente del repartition quando si riducono le partizioni. Si usa con .coalesce().

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

Nota che una domanda di follow-up può riguardare quando queste operazioni sono più utili. Assicurati di menzionare che sono più efficaci su dataset grandi e che non conviene sprecare potenza di calcolo su dataset piccoli.

15. Spiega l'interoperabilità di Spark con i formati di serializzazione dei dati

I professionisti dei dati interagiranno con un'ampia varietà di formati di dati, ciascuno con diversi compromessi. Assicurati di saper spiegare come Spark interagisce generalmente con questi formati e di offrire considerazioni di alto livello su prestazioni e integrazione nell'ecosistema più ampio.

1. Supporto ai formati di serializzazione dei dati: Spark interoperabile con formati come Avro, Parquet o ORC tramite supporto nativo o librerie di terze parti. Questi formati offrono vantaggi come compressione efficiente, storage colonnare ed evoluzione dello schema, rendendoli adatti all'elaborazione e all'archiviazione dei dati nelle pipeline basate su Spark.
2. Ottimizzazione della lettura dei dati: Spark ottimizza le operazioni di lettura e scrittura con questi formati utilizzando reader e writer specializzati che sfruttano la loro struttura interna e le tecniche di compressione. Ad esempio, Parquet e ORC sfruttano lo storage colonnare per minimizzare l'I/O e migliorare le prestazioni delle query.
3. Trade-off dei formati dati: I compromessi includono efficienza di storage (ad es. rapporto di compressione), prestazioni (ad es. throughput di lettura/scrittura) e compatibilità con altri strumenti di elaborazione dati. La scelta del formato di serializzazione giusto dipende da fattori come caratteristiche dei dati, pattern di query e requisiti di integrazione nella pipeline.

Domande di codice su Spark

Queste domande di codice si concentrano sull'uso di PySpark per interagire con un ambiente Spark. 

16. Trova le N parole più frequenti in un grande file di testo

Questa domanda verifica la tua capacità di interagire con Spark e comprendere l'uso del mapping in Spark.

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. Trova la media dei valori in un dato RDD

Questa domanda è un ottimo modo per mostrare se qualcuno sa creare e manipolare un semplice RDD. Trovare la media dei valori è un compito molto comune per i professionisti dei dati ed è fondamentale capire come prendere i dati e lavorarci in un contesto Spark.

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. Esegui una left outer join tra due RDD

L'esecuzione di attività di manipolazione e trasformazione dei dati come le join è un componente chiave di SparkSQL. Questo consente di combinare i dati da fonti diverse per l'analisi. 

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. Leggi dati da Kafka, esegui trasformazioni e scrivi i risultati su HDFS

Questo verifica la tua capacità di acquisire dati da sorgenti esterne e la comprensione di come Spark possa connettersi a fonti esterne. Concentrati qui sui concetti generali, come la necessità di importare estensioni/utility per un particolare flusso di dati, invece di memorizzare il codice esatto. Nota che per lo SparkContext abbiamo scelto di avere un appname (KafkaWordCount) come parametro opzionale, ma è utile perché mantiene chiari i processi.

# 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. Come esegui trasformazioni e azioni di base su un DataFrame Spark?

Questa domanda valuta la comprensione delle operazioni sui DataFrame in Spark.

Le trasformazioni sono operazioni sui DataFrame che restituiscono un nuovo DataFrame, come select, filter e groupBy. Le azioni sono operazioni che attivano la computazione e restituiscono risultati, come show, count e collect.

Questo snippet mostra la selezione di colonne, il filtraggio di righe e un'aggregazione con group by.

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

Considerazioni finali

Padroneggiare queste domande di colloquio è un ottimo primo passo per diventare un professionista dei dati. Spark è un'infrastruttura comune utilizzata da molte organizzazioni per gestire le pipeline di big data. Comprendere i vantaggi e le sfide di Spark ti aiuterà a distinguerti come professionista competente. Questo è solo l'inizio! Fare esperienza pratica con Spark è il modo migliore per imparare. 

Puoi iniziare con i seguenti corsi e tutorial su PySpark su DataCamp:

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