Les 20 meilleures questions d'entretien avec Spark

Apache Spark est un moteur d'analyse unifié pour l'ingénierie des données, la science des données et l'apprentissage automatique à l'échelle. Il peut être utilisé avec Python, SQL, R, Java ou Scala. Spark a été initialement lancé à l'Université de Californie, Berkeley, en 2009 et a ensuite été donné à la Apache Software Foundation en 2013. Il est aujourd'hui "le moteur le plus largement utilisé pour l'informatique évolutive" avec des milliers d'offres d'emploi qui utilisent cette technologie. Comme il s'agit d'une compétence très appréciée dans le monde de l'ingénierie des données, voici des questions d'entretien pour vous aider dans votre recherche d'emploi ou dans votre recherche de talents ayant de l'expérience avec Spark. Les réponses au codage seront fournies en Python.

Questions d'entretien de base sur Spark

Ces questions couvrent certains des principes fondamentaux de Spark et conviennent à ceux qui n'ont qu'une expérience basique de son utilisation. Si vous avez besoin d'une remise à niveau, notre Introduction à Spark SQL en Python est l'endroit idéal pour commencer.

1. Qu'est-ce qu'Apache Spark, et pourquoi est-il utilisé dans le traitement des données ?

Cette question évalue la compréhension générale du candidat sur Apache Spark et son rôle dans l'écosystème du big data.

Réponse :

Apache Spark est un système informatique distribué open-source qui fournit une interface pour programmer des clusters entiers avec un parallélisme de données implicite et une tolérance aux pannes. Il est utilisé pour le traitement de données à grande échelle en raison de sa vitesse et de sa facilité d'utilisation par rapport au MapReduce traditionnel.

Caractéristiques principales :

• Informatique en mémoire: Stocke les données en mémoire pour un traitement plus rapide.
• Évolutivité: Peut traiter des pétaoctets de données en utilisant une grappe de machines.
• Facilité d'utilisation: Fournit des API en Java, Scala, Python et R.
• Unified Analytics Engine: Prise en charge de SQL, des données en continu, de l'apprentissage automatique et du traitement des graphes.

2. Expliquer le concept d'ensembles de données distribuées résilientes (RDD)

Ces questions vous testent sur les concepts fondamentaux d'Apache Spark. Assurez-vous de comprendre l'un des éléments essentiels qui rendent Spark si puissant.

Les ensembles de données distribuées résilientes (RDD) constituent les éléments fondamentaux d'Apache Spark. Ils représentent une collection immuable et distribuée d'objets qui peuvent être exploités en parallèle dans une grappe. Voici une explication des principales caractéristiques et des concepts associés aux RDD :

1. Immuable: Les RDD sont immuables, ce qui signifie qu'une fois créés, leur contenu ne peut être modifié. Vous ne pouvez transformer les RDD qu'en appliquant des transformations pour créer de nouveaux RDD. Cette immutabilité simplifie la tolérance aux pannes et permet le modèle d'évaluation paresseux de Spark.
2. Distribué: Les RDD sont distribués sur plusieurs nœuds d'un cluster, ce qui permet à Spark d'effectuer des opérations parallèles sur eux. Chaque RDD est divisé en plusieurs partitions, et ces partitions peuvent être traitées indépendamment sur différents nœuds.
3. Résiliente: Le terme "Resilient" (résilient) dans RDD signifie tolérance aux pannes. Spark assure la résilience en gardant la trace du lignage de chaque RDD. Si une partition d'un RDD est perdue en raison de la défaillance d'un nœud, Spark peut recalculer cette partition à l'aide des informations de lignage et des transformations appliquées aux données d'origine.
4. Ensemble de données: Les RDD sont une représentation distribuée des données, ce qui signifie qu'ils peuvent contenir n'importe quel type de données, y compris des données structurées ou non structurées. Spark fournit des API dans plusieurs langages (comme Scala, Java, Python et R) pour travailler avec les RDD, ce qui le rend polyvalent pour divers cas d'utilisation et types de données.
5. Évaluation paresseuse: Les RDD permettent une évaluation paresseuse, ce qui signifie que les transformations sur les RDD ne sont pas exécutées immédiatement. Au lieu de cela, Spark construit un graphe acyclique dirigé (DAG) de transformations qui définit le calcul, mais retarde l'exécution jusqu'à ce qu'une action soit déclenchée. Cette optimisation permet à Spark d'optimiser le plan d'exécution et d'améliorer les performances.

3. Qu'est-ce que YARN ?

YARN est un gestionnaire de conteneurs distribués qui gère les ressources dans Hadoop. Spark peut utiliser YARN lorsqu'il s'exécute sur des clusters Hadoop pour une gestion des ressources plus efficace et plus efficiente. L'un des éléments essentiels de YARN est sa capacité à allouer efficacement les ressources dans le cluster, à planifier efficacement les tâches et à tolérer les pannes en cas de défaillance d'un nœud. C'est l'un des nombreux éléments qui font de Spark un outil puissant.

4. Quelle est la différence entre les transformations map et flatMap dans les RDD de Spark ?

Cette question permet de déterminer si vous comprenez les différents types de transformations dans les RDD (Resilient Distributed Datasets) de Spark.

Réponse:

• .map(): Transforme chaque élément du RDD en exactement un nouvel élément. Le résultat est un RDD avec le même nombre d'éléments que le RDD d'entrée.
• .flatMap(): Transforme chaque élément du RDD en zéro ou plusieurs nouveaux éléments. Le résultat est un RDD dont le nombre d'éléments peut être différent de celui du RDD d'entrée.

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

Ce code illustre la différence entre map et flatMap en transformant un RDD d'entiers.

5. Comment utiliser Spark SQL pour interroger des données à partir d'un DataFrame ?

Cette question vérifie la capacité du candidat à utiliser Spark SQL pour interroger des données, ce qui est essentiel pour les tâches d'analyse de données.

Réponse:

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

Cet extrait démontre la création d'une vue temporaire à partir d'un DataFrame et l'utilisation de Spark SQL pour effectuer une requête group-by.

Questions d'entretien intermédiaires sur Spark

Pour ceux qui ont maîtrisé les bases et les ont appliquées dans leur rôle professionnel, ces questions peuvent être plus courantes : 

6. Expliquez le concept d'évaluation paresseuse dans Spark et pourquoi il est important.

Cette question évalue la compréhension par le candidat de l'un des principes fondamentaux de Spark, qui est crucial pour l'optimisation des performances.

Réponse:

L'évaluation paresseuse signifie que Spark n'exécute pas immédiatement les transformations au fur et à mesure qu'elles sont appelées. Au lieu de cela, il élabore un plan d'exécution logique. Les transformations ne sont exécutées que lorsqu'une action (comme collecter ou compter) est appelée, ce qui déclenche le calcul proprement dit.

L'évaluation paresseuse est importante pour deux raisons :

1. Il permet à Spark d'optimiser l'ensemble du flux de traitement des données avant de l'exécuter, en combinant les opérations pour minimiser le brassage des données.
2. Il réduit le nombre de passages dans les données, ce qui améliore les performances.

7. Comment persister les données dans Spark, et quels sont les différents niveaux de stockage disponibles ?

Cette question vérifie les connaissances du candidat sur la persistance des données dans Spark, ce qui est important pour l'optimisation des performances et les algorithmes itératifs.

Réponse:

Les données peuvent être persistées dans Spark en utilisant les méthodes .persist() ou .cache(). .cache() est une abréviation de .persist() avec le niveau de stockage par défaut.

Niveaux de stockage :

• MEMORY_ONLY: Stocke les RDD sous forme d'objets Java désérialisés dans la JVM. Si le RDD ne tient pas dans la mémoire, certaines partitions ne seront pas mises en cache.
• MÉMOIRE_ET_DISQUE: Stocke les RDD sous forme d'objets Java désérialisés en mémoire. Si le RDD ne tient pas dans la mémoire, les partitions sont stockées sur le disque.
• MEMORY_ONLY_SER: Stocke les RDD sous forme d'objets Java sérialisés dans la JVM. Cela réduit l'utilisation de la mémoire mais augmente la charge de travail de l'unité centrale pour la sérialisation/désérialisation.
• MÉMOIRE_ET_DISQUE_SER: Similaire à MEMORY_AND_DISK mais stocke des objets sérialisés.
• DISK_ONLY: Stocke les partitions RDD uniquement sur le disque.

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

8. Comment gérer les données asymétriques dans Spark ?

Cette question évalue la compréhension par le candidat de l'asymétrie des données et de la manière de la gérer, ce qui est essentiel pour assurer un traitement efficace des données.

Réponse:

Il y a asymétrie des données lorsque certaines partitions contiennent beaucoup plus de données que d'autres, ce qui entraîne des goulets d'étranglement au niveau des performances. Les stratégies permettant de traiter les données asymétriques sont les suivantes :

• Salage: Ajout d'une clé aléatoire aux données pour les répartir plus uniformément entre les partitions.
• Repartitionnement: Augmenter le nombre de partitions pour mieux répartir les données.
• Variables de diffusion: Diffusion d'un petit ensemble de données à tous les nœuds pour éviter de mélanger des ensembles de données volumineux.

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. Expliquez la différence entre les transformations étroites et larges dans Spark.

Cette question permet de tester la compréhension du candidat sur le modèle d'exécution de Spark et l'impact des différents types de transformations sur les performances.

Réponse:

• Transformations étroites: Opérations dans lesquelles chaque partition d'entrée contribue à exactement une partition de sortie. Les exemples incluent .map(), .filter(), et .union(). Ils sont généralement plus rapides car ils ne nécessitent pas de brassage de données.
• Grandes transformations: Opérations où chaque partition d'entrée contribue à plusieurs partitions de sortie. Les exemples incluent .groupByKey(), .reduceByKey(), et .join(). Elles nécessitent le brassage des données sur le réseau, ce qui peut prendre beaucoup de temps.

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

10. Spark Streaming dans le traitement des données en temps réel

Spark excelle dans la diffusion en continu de données en temps réel à partir de sources telles que Apache Kafka ou Amazon Kinesis car il est évolutif et tolérant aux pannes. Il le fait par l'intermédiaire de l'extension Spark Streaming. Il interagit avec des sources de données externes à l'aide de flux de données d'entrée, qui représentent un flux continu de données provenant de ces sources. 

Spark Streaming assure la tolérance aux pannes et la cohérence des données grâce à des techniques telles que le point de contrôle et les journaux write-ahead. Le point de contrôle sauvegarde périodiquement l'état de l'application de diffusion en continu sur un support de stockage durable (par exemple, HDFS) afin de pallier les défaillances, tandis que les journaux en avance sur l'écriture offrent une tolérance aux pannes pour les données reçues de sources externes.

Questions d'entretien avancées sur Spark

Ces questions s'adressent aux utilisateurs ayant une expérience plus pratique de Spark, en particulier avec des sujets plus sophistiqués. Si vous avez besoin d'une remise à niveau, consultez notre rubrique Apprentissage automatique Spark sur Spark Machine Learning.

11. Discutez de la façon dont Spark peut être utilisé pour l'apprentissage automatique.

Cette question permet de tester la compréhension de l'environnement de Spark et de la bibliothèque MLib par la personne interrogée. 

La bibliothèque MLlib de Spark fournit un riche ensemble d'outils et d'algorithmes permettant d'effectuer des tâches d'apprentissage automatique à grande échelle. Lorsqu'il s'agit d'ingénierie des caractéristiques et de prétraitement pour des ensembles de données à grande échelle, MLlib offre plusieurs techniques et optimisations avancées :

1. Transformation et sélection des caractéristiques : MLlib fournit une gamme de techniques de transformation des caractéristiques, telles que la mise à l'échelle, la normalisation, la binarisation et la vectorisation (par exemple, l'encodage à un seul coup). En outre, il propose des méthodes de sélection des caractéristiques, notamment le filtrage basé sur la corrélation, le gain d'information ou les tests statistiques, ainsi que des techniques plus avancées telles que l'analyse en composantes principales. l'analyse en composantes principales (ACP) pour la réduction de la dimensionnalité.

2. Traitement des caractéristiques catégorielles : MLlib comprend des outils permettant de traiter efficacement les caractéristiques catégorielles, tels que StringIndexer pour convertir les variables catégorielles en représentations numériques et OneHotEncoder pour les convertir en vecteurs binaires. Ces transformations sont optimisées pour une exécution parallèle sur des clusters Spark distribués.

3. Pipeline API : L'API Pipeline de Spark permet aux utilisateurs d'enchaîner plusieurs étapes d'ingénierie et de modélisation des fonctionnalités en un seul flux de travail. Cela facilite la création de pipelines de transformation de caractéristiques complexes tout en garantissant la cohérence et la reproductibilité entre différents ensembles de données et tâches d'apprentissage automatique.

4. Transformateurs et estimateurs sur mesure : MLlib permet aux utilisateurs de définir des transformateurs de caractéristiques et des estimateurs personnalisés en utilisant l'API DataFrame de Spark. Cela permet d'intégrer des techniques d'ingénierie des fonctionnalités spécifiques à un domaine ou des bibliothèques tierces dans le pipeline Spark ML, en étendant ses fonctionnalités et sa flexibilité.

12. Expliquez comment Spark s'intègre aux systèmes de stockage externes comme Apache Hadoop HDFS et Apache Cassandra. Quels sont les avantages de tirer parti de ces intégrations dans un pipeline de données basé sur Spark ?

Cela permet de vérifier si les utilisateurs comprennent les fonctionnalités sous-jacentes des systèmes basés sur Spark et comment Spark fonctionne avec HDFS et Apache Cassandra. Il est important de comprendre à la fois comment extraire des données par le biais du codage et comment ces données se déplacent dans le système.

1. Connexion Hadoop HDFS : Spark s'intègre à des systèmes de stockage externes comme Apache Hadoop HDFS et Apache Cassandra par le biais de connecteurs ou de bibliothèques spécifiquement conçus pour chaque système. Par exemple, l'intégration HDFS est native dans Spark, permettant à Spark de lire et d'écrire des données directement depuis/vers HDFS en utilisant les API Hadoop InputFormat et OutputFormat.
2. Apache Cassandra Connexion : Les avantages de ces intégrations sont notamment l'amélioration des performances grâce à la localité des données (dans le cas de HDFS), la simplification de l'accès aux données et de leur manipulation, et la compatibilité avec l'infrastructure de données existante. En outre, Spark peut exploiter la nature distribuée de ces systèmes de stockage pour le traitement parallèle, ce qui permet un traitement évolutif des données.

13. Expliquer le concept de variables de diffusion dans Spark

Les variables de diffusion dans Spark sont des variables en lecture seule qui sont mises en cache et mises à la disposition de tous les nœuds de travail dans une application Spark distribuée. Ils sont utilisés pour distribuer efficacement de grands ensembles de données ou de valeurs en lecture seule aux nœuds de travail, réduisant ainsi la surcharge du réseau et améliorant la performance des tâches. 

Les variables de diffusion sont sérialisées et envoyées à chaque nœud de travail une seule fois, où elles sont mises en cache dans la mémoire et réutilisées dans plusieurs tâches. Il n'est donc pas nécessaire d'envoyer la variable avec chaque tâche, ce qui réduit les frais de transfert de données, en particulier pour les grands ensembles de données.

• Utilisation: Les variables de diffusion sont couramment utilisées dans les scénarios où un grand ensemble de données ou de valeurs doit être partagé entre plusieurs tâches ou étapes de calcul. Par exemple, dans les opérations de jonction où un DataFrame ou un RDD est nettement plus petit que l'autre, la diffusion du DataFrame/RDD le plus petit peut réduire considérablement la quantité de données mélangées sur le réseau au cours de l'opération de jonction.
• Scénarios bénéfiques:
• Rejoignez les opérations: La diffusion d'ensembles de données plus petits pour les opérations de jointure peut améliorer considérablement les performances en réduisant le trafic réseau et en accélérant l'exécution des tâches.
• Tableaux de consultation: La diffusion de petits tableaux de consultation ou de dictionnaires utilisés pour des opérations d'enrichissement ou de filtrage peut améliorer les performances en évitant des transferts de données répétés.
• Machine Learning: La diffusion de vecteurs de caractéristiques ou de paramètres de modèle aux nœuds travailleurs pendant la formation distribuée peut accélérer le processus de formation, en particulier lorsque les vecteurs de caractéristiques ou les paramètres sont relativement petits par rapport à l'ensemble de données.
• Défis:
• Frais généraux de mémoire: La diffusion de grandes variables peut consommer beaucoup de mémoire sur les nœuds de travail, ce qui peut entraîner des erreurs de sortie de mémoire si elle n'est pas gérée avec soin.
• Congestion du réseau: La diffusion de grandes variables peut également entraîner une congestion du réseau lors de la phase initiale de diffusion, en particulier dans les grandes grappes dont la bande passante est limitée.
• Données dynamiques: Les variables de diffusion sont immuables une fois diffusées, elles ne conviennent donc pas aux scénarios dans lesquels les données diffusées doivent être mises à jour dynamiquement pendant l'exécution du job Spark.

14. Comment optimiser un job Spark en utilisant le partitionnement et le coalescing ? 

Cette question évalue la capacité du candidat à optimiser les tâches de Spark, une compétence clé pour améliorer la performance et l'efficacité. Grâce à l'optimisation des performances de Spark, nous pouvons tirer parti du cadre distribué de Spark en utilisant le partitionnement et le coalescing, qui gère la répartition de la charge de travail sur le cluster afin d'effectuer des opérations sur les données plus rapidement. 

Réponse:

• Partitionnement: Contrôle le nombre de partitions dans un RDD ou un DataFrame. Utilisez .repartition() pour augmenter ou répartir uniformément les partitions. Cette méthode est plus coûteuse en termes de calcul et ne doit être utilisée que lorsque les données doivent être divisées de manière égale pour un traitement équilibré.
• Coalescence: Réduit le nombre de partitions sans effectuer un brassage complet, ce qui est plus efficace que la répartition lors de la réduction du nombre de partitions. Pour ce faire, nous utilisons .coalesce().

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

Notez qu'une question complémentaire peut mentionner le moment où ces opérations sont les plus utiles. Veillez à mentionner que ces méthodes sont plus efficaces lorsque vous travaillez sur de grands ensembles de données, et que la puissance de calcul ne doit pas être gaspillée sur des ensembles de données plus petits.

15. Explique l'interopérabilité de Spark avec les formats de sérialisation des données

Les professionnels des données sont amenés à interagir avec une grande variété de formats de données. Chacun d'entre eux présente des compromis différents. Assurez-vous de pouvoir expliquer comment Spark interagit généralement avec ces formats et d'offrir des performances de haut niveau ainsi que des considérations à prendre en compte pour l'écosystème plus large.

1. Prise en charge du format de sérialisation des données : Spark interagit avec des formats de sérialisation de données comme Avro, Parquet ou ORC via une prise en charge intégrée ou des bibliothèques tierces. Ces formats offrent des avantages tels qu'une compression efficace, un stockage en colonnes et une évolution des schémas, ce qui les rend adaptés au traitement et au stockage des données dans les pipelines basés sur Spark.
2. Optimisation de la lecture des données : Spark optimise les opérations de lecture et d'écriture de données avec ces formats en utilisant des lecteurs et des écrivains spécialisés qui exploitent leur structure interne et leurs techniques de compression. Par exemple, Parquet et ORC s'appuient sur le stockage en colonnes pour minimiser les frais généraux d'E/S et améliorer les performances des requêtes.
3. Compromis en matière de format de données : Les compromis portent sur l'efficacité du stockage (par exemple, le taux de compression), les performances (par exemple, le débit de lecture/écriture) et la compatibilité avec d'autres outils de traitement des données. Le choix du bon format de sérialisation dépend de facteurs tels que les caractéristiques des données, les modèles de requête et les exigences d'intégration dans le pipeline de données.

Questions d'entretien sur le codage Spark

Ces questions de codage se concentreront sur l'utilisation de Spark afin d'interagir avec un environnement spark. 

16. Trouvez les N mots les plus fréquents dans un grand fichier texte

Cette question vérifie votre capacité à interagir avec Spark et à comprendre l'utilisation de la cartographie dans Spark lui-même.

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. Trouver la moyenne des valeurs dans un RDD donné

Cette question est un excellent moyen de vérifier si quelqu'un sait créer un simple RDD et le manipuler. Trouver la moyenne des valeurs est une tâche très courante confiée aux professionnels des données et il est essentiel que vous compreniez comment prendre les données et les mettre en forme dans un contexte 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. Effectuer une jointure externe gauche entre deux RDD

L'exécution de tâches de manipulation et de transformation des données, telles que les jointures, est un élément clé de SparkSQL. Cela permet de combiner les données de différentes sources pour l'analyse des données. 

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. Lire les données de Kafka, effectuer des transformations, puis écrire les résultats sur HDFS.

Cela permet de tester votre capacité à apporter des données à partir de sources de données externes et votre compréhension de la façon dont Spark peut se connecter à des sources de données externes. Concentrez-vous sur les concepts généraux, tels que la nécessité d'importer des extensions/utilités pour un flux de données particulier, plutôt que de mémoriser le codage exact. Notez que pour le SparkContext, nous avons choisi d'avoir un appname (KafkaWordCount) comme paramètre optionnel, mais c'est bien de l'avoir car cela permet de garder les processus clairs.

# 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. Comment effectuer des transformations et des actions de base sur un DataFrame Spark ?

Cette question permet d'évaluer la compréhension du candidat sur les opérations DataFrame dans Spark.

Les transformations sont des opérations sur les DataFrame qui renvoient un nouveau DataFrame, telles que select, filter et groupBy. Les actions sont des opérations qui déclenchent des calculs et renvoient des résultats, comme montrer, compter et collecter.

Cet extrait montre la sélection de colonnes, le filtrage de lignes et l'exécution d'une agrégation par groupe.

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

Réflexions finales

Maîtriser ces questions d'entretien est une première étape importante pour devenir un professionnel des données. Spark est une infrastructure courante utilisée par de nombreuses organisations pour gérer leurs pipelines de big data. Comprendre les avantages et les défis de Spark vous aidera à vous démarquer en tant que professionnel des données bien informé. Ce n'est que le début ! Obtenir une expérience pratique avec Spark est la meilleure façon d'apprendre. 

Vous pouvez commencer avec les cours et tutoriels PySpark suivants sur DataCamp :

• Introduction à PySpark
• Introduction à Spark SQL en Python
• Big Data avec PySpark
• Tutoriel Apache Spark : ML avec PySpark