Supposons que vous ayez une situation où un ensemble de données est très petit et un autre ensemble de données est assez grand, et que vous souhaitiez effectuer l’opération de jointure entre ces deux. Dans ce cas, nous devrions opter pour la jointure de diffusion afin que le petit ensemble de données puisse s’intégrer dans votre variable de diffusion. La syntaxe pour utiliser la variable de diffusion est df1.rejoindre (diffusion (df2)). Ici, nous avons une deuxième trame de données qui est très petite et nous conservons cette trame de données en tant que variable de diffusion.
Code:
val broadcastVar= sc.diffusion (Tableau(1, 2, 3))
broadcastVar.valeur
res0: Array= Array(1, 2, 3)
val accum = sc.Longaccumulateur (« Mon accumulateur »)
sc.paralléliser (Tableau(1, 2, 3, 4)).foreach(x=> accum.ajouter (x))
accum.valeur
res2: Long = 10
Cache et Persist
- Spark fournit ses propres mécanismes de mise en cache tels que persist() et cache().
- cache() et persist() stockeront l’ensemble de données en mémoire.
- Lorsque vous avez un petit jeu de données qui doit être utilisé plusieurs fois dans votre programme, nous mettons en cache cet ensemble de données.
- Cache() – Toujours en mémoire
- Persist() – Mémoire et disques
Spark fournit son propre mécanisme de mise en cache comme Persist et la mise en cache. Les mécanismes de persistance et de cache stockeront l’ensemble de données dans la mémoire chaque fois qu’il y a besoin, lorsque vous avez un petit ensemble de données et que cet ensemble de données est utilisé plusieurs fois dans votre programme. Si nous appliquons RDD.Cache() il stockera toujours les données en mémoire, et si nous appliquons RDD.Persist() alors une partie des données peut être stockée dans la mémoire, d’autres peuvent être stockées sur le disque.
5. Opération ByKey
- Les mélangements sont des opérations lourdes qui consomment beaucoup de mémoire.
- Lors du codage dans Spark, l’utilisateur doit toujours essayer d’éviter l’opération de lecture aléatoire.
- Un brassage élevé peut donner lieu à une erreur hors mémoire ; Pour éviter une telle erreur, l’utilisateur peut augmenter le niveau de parallélisme.
- Utilisez reduceByKey au lieu de groupByKey.
- Partitionnez correctement les données.
Comme nous le savons lors de notre transformation de Spark, nous avons de nombreuses opérations ByKey. Les opérations ByKey génèrent beaucoup de aléatoire. Les brassages sont une opération lourde car ils consomment beaucoup de mémoire. Lors du codage dans Spark, un utilisateur doit toujours essayer d’éviter toute opération de lecture aléatoire car l’opération de lecture aléatoire dégradera les performances. S’il y a un brassage élevé, un utilisateur peut extraire l’erreur de la mémoire. Dans ce cas, pour éviter cette erreur, un utilisateur doit augmenter le niveau de parallélisme. Au lieu de groupBy, un utilisateur doit opter pour reduceByKey car groupByKey crée beaucoup de brassages qui entravent les performances, tandis que reduceByKey ne mélange pas autant les données. Par conséquent, reduceByKey est plus rapide que groupByKey. Chaque fois qu’une opération ByKey est utilisée, l’utilisateur doit partitionner correctement les données.
6. Sélection du format de fichier
- Spark prend en charge de nombreux formats, tels que CSV, JSON, XML, PARQUET, ORC, AVRO, etc.
- Les travaux Spark peuvent être optimisés en choisissant le fichier parquet avec une compression rapide qui donne les meilleures performances et la meilleure analyse.
- Le fichier Parquet est natif de Spark qui contient les métadonnées avec son pied de page.
Spark est livré avec de nombreux formats de fichiers tels que CSV, JSON, XML, PARQUET, ORC, AVRO et plus encore. Un travail Spark peut être optimisé en choisissant le fichier parquet avec une compression rapide. Le fichier Parquet est natif de Spark, qui contient les métadonnées avec son pied de page, car nous savons que le fichier parquet est natif de spark, qui est au format binaire et avec les données, il porte également le pied de page, il porte également les métadonnées et son pied de page, donc chaque fois que vous créez un fichier parquet, vous verrez.fichier de métadonnées sur le même répertoire avec le fichier de données.
Code:
val peopleDF=spark.lire.json(« exemples/src/main/ressources/personnes.json »)
peopleDF.écrire.parquet (« les gens.parquet »)
val parquetFileDF=spark.lire.parquet (« les gens.parquet »)
val usersDF=spark.lire.format (« avro »).load(« exemples/src/main/ressources/utilisateurs.avro »)
usersDF.sélectionnez (« nom », « favorite_color »).écrire.format (« avro »).enregistrer (« namesAndFavColors.avro »)
Réglage de la collecte des ordures
- La collecte des ordures JVM peut être un problème lorsque vous avez une grande collection d’objets inutilisés.
- La première étape du réglage GC consiste à collecter des statistiques en choisissant –verbeux lors de la soumission des travaux spark.
- Dans une situation idéale, nous essayons de conserver les frais généraux GC < 10% de la mémoire de tas.
Comme nous le savons sous notre travail Spark s’exécute sur la plate-forme JVM, le garbage collection JVM peut donc poser problème lorsque vous avez une grande collection d’objets inutilisés. la première étape du réglage du garbage collection consiste à collecter la statique en choisissant l’option dans votre Spark submit verbose. Généralement, dans une situation idéale, nous devrions conserver notre mémoire de collecte des ordures à moins de 10% de la mémoire de tas.
8. Niveau de parallélisme
- Le parallélisme joue un rôle très important lors du réglage des tâches spark.
- Chaque tâche partition~ nécessite un seul cœur pour le traitement.
- Il existe deux façons de maintenir le parallélisme :
- Répartition: Donne un nombre égal de partitions avec un brassage élevé
- Coalesce: Réduit généralement le nombre de partitions avec moins de brassage.
Dans n’importe quel environnement distribué, le parallélisme joue un rôle très important lors du réglage de votre tâche Spark. Chaque fois qu’un travail Spark est soumis, il crée le bureau qui contiendra des étapes, et les tâches dépendent de la partition, de sorte que chaque partition ou tâche nécessite un seul cœur du système pour le traitement. Il existe deux façons de maintenir le parallélisme : la répartition et la fusion. Chaque fois que vous appliquez la méthode de répartition, elle vous donne un nombre égal de partitions, mais elle mélangera beaucoup, il n’est donc pas conseillé d’opter pour une répartition lorsque vous souhaitez fouetter toutes les données. La fusion réduira généralement le nombre de partitions et créera moins de brassage de données.
Ces facteurs d’optimisation des étincelles, s’ils sont correctement utilisés, peuvent –
