Apache Spark - Apache Spark

Apache Spark

Auteur(s) original(aux)	Matei Zaharia
Développeur(s)	Apache Spark
Première version	26 mai 2014 ; Il y a 7 ans ( 2014-05-26 )
Version stable	3.1.1 / 2 mars 2021 ; il y a 7 mois ( 2021-03-02 )
Dépôt	Référentiel Spark
Écrit en	Scala
Système opérateur	Microsoft Windows , macOS , Linux
Disponible en	Scala , Java , SQL , Python , R , C# , F#
Taper	Analyse de données, algorithmes d' apprentissage automatique
Licence	Licence Apache 2.0
Site Internet	étincelle .apache .org

Apache Spark est un moteur d'analyse unifié open source pour le traitement de données à grande échelle. Spark fournit une interface pour programmer des clusters entiers avec un parallélisme de données implicite et une tolérance aux pannes . Initialement développé à l' Université de Californie, Berkeley de » AMPLab , la Spark codebase a ensuite été remis à la Fondation Apache Software , qui a maintenu depuis.

Aperçu

Apache Spark a sa base architecturale dans le jeu de données distribué résilient (RDD), un multi -ensemble en lecture seule d'éléments de données répartis sur un cluster de machines, qui est maintenu de manière tolérante aux pannes . L'API Dataframe a été publiée en tant qu'abstraction au-dessus du RDD, suivie de l'API Dataset. Dans Spark 1.x, le RDD était la principale interface de programmation d'application (API), mais à partir de Spark 2.x, l'utilisation de l'API Dataset est encouragée même si l'API RDD n'est pas obsolète . La technologie RDD sous-tend toujours l'API Dataset.

Spark et ses RDD ont été développés en 2012 en réponse aux limitations du paradigme de calcul en cluster MapReduce , qui impose une structure de flux de données linéaire particulière sur les programmes distribués : les programmes MapReduce lisent les données d'entrée à partir du disque, mappent une fonction à travers les données, réduisent les résultats du map, et stocker les résultats de la réduction sur le disque. Les RDD de Spark fonctionnent comme un ensemble de travail pour les programmes distribués qui offrent une forme (délibérément) restreinte de mémoire partagée distribuée .

Dans Apache Spark, le workflow est géré comme un graphe acyclique dirigé (DAG). Les nœuds représentent les RDD tandis que les arêtes représentent les opérations sur les RDD.

Spark facilite la mise en œuvre à la fois d' algorithmes itératifs , qui visitent leur ensemble de données plusieurs fois dans une boucle, et d'analyses de données interactives/exploratoires, c'est-à-dire l' interrogation répétée de données de style base de données. La latence de telles applications peut être réduite de plusieurs ordres de grandeur par rapport à l' implémentation Apache Hadoop MapReduce. Parmi la classe d'algorithmes itératifs figurent les algorithmes d'entraînement pour les systèmes d' apprentissage automatique, qui ont donné l'impulsion initiale au développement d'Apache Spark.

Apache Spark nécessite un gestionnaire de cluster et un système de stockage distribué . Pour la gestion des clusters, Spark prend en charge le standalone (cluster Spark natif, où vous pouvez lancer un cluster manuellement ou utiliser les scripts de lancement fournis par le package d'installation. Il est également possible d'exécuter ces démons sur une seule machine pour les tests), Hadoop YARN , Apache Mesos ou Kubernetes . Pour le stockage distribué, Spark peut s'interfacer avec une grande variété, y compris Alluxio , Hadoop Distributed File System (HDFS) , MapR File System (MapR-FS) , Cassandra , OpenStack Swift , Amazon S3 , Kudu , Lustre système de fichiers ou une solution personnalisée peut être mis en œuvre. Spark prend également en charge un mode local pseudo-distribué, généralement utilisé uniquement à des fins de développement ou de test, où le stockage distribué n'est pas requis et où le système de fichiers local peut être utilisé à la place ; dans un tel scénario, Spark est exécuté sur une seule machine avec un exécuteur par cœur de processeur .

Noyau d'étincelle

Spark Core est la base du projet global. Il fournit des fonctionnalités de répartition de tâches distribuées, de planification et d' E/S de base , exposées via une interface de programmation d'applications (pour Java , Python , Scala , .NET et R ) centrée sur l' abstraction RDD (l'API Java est disponible pour d'autres langages JVM, mais est également utilisable pour d'autres langages non-JVM pouvant se connecter à la JVM, tels que Julia ). Cette interface reflète un modèle de programmation fonctionnel / d'ordre supérieur : un programme « pilote » invoque des opérations parallèles telles que mapper, filtrer ou réduire sur un RDD en passant une fonction à Spark, qui planifie ensuite l'exécution de la fonction en parallèle sur le cluster. Ces opérations, ainsi que d'autres telles que les jointures , prennent des RDD en entrée et produisent de nouveaux RDD. Les RDD sont immuables et leurs opérations sont paresseuses ; la tolérance aux pannes est obtenue en gardant une trace de la "lignée" de chaque RDD (la séquence d'opérations qui l'a produit) afin qu'il puisse être reconstruit en cas de perte de données. Les RDD peuvent contenir tout type d'objets Python, .NET, Java ou Scala.

Outre le style de programmation fonctionnel orienté RDD, Spark fournit deux formes restreintes de variables partagées : les variables de diffusion font référence à des données en lecture seule qui doivent être disponibles sur tous les nœuds, tandis que les accumulateurs peuvent être utilisés pour programmer des réductions dans un style impératif .

Un exemple typique de programmation fonctionnelle centrée sur RDD est le programme Scala suivant qui calcule les fréquences de tous les mots apparaissant dans un ensemble de fichiers texte et imprime les plus courants. Chaque map , flatMap (une variante de map ) et reduceByKey prend une fonction anonyme qui exécute une opération simple sur un seul élément de données (ou une paire d'éléments) et applique son argument pour transformer un RDD en un nouveau RDD.

val conf = new SparkConf().setAppName("wiki_test") // create a spark config object
val sc = new SparkContext(conf) // Create a spark context
val data = sc.textFile("/path/to/somedir") // Read files from "somedir" into an RDD of (filename, content) pairs.
val tokens = data.flatMap(_.split(" ")) // Split each file into a list of tokens (words).
val wordFreq = tokens.map((_, 1)).reduceByKey(_ + _) // Add a count of one to each token, then sum the counts per word type.
wordFreq.sortBy(s => -s._2).map(x => (x._2, x._1)).top(10) // Get the top 10 words. Swap word and count to sort by count.

Spark SQL

Spark SQL est un composant au-dessus de Spark Core qui a introduit une abstraction de données appelée DataFrames, qui prend en charge les données structurées et semi-structurées . Spark SQL fournit un langage spécifique au domaine (DSL) pour manipuler les DataFrames en Scala , Java , Python ou .NET . Il prend également en charge le langage SQL, avec des interfaces de ligne de commande et un serveur ODBC / JDBC . Bien que les DataFrames ne disposent pas de la vérification de type au moment de la compilation offerte par les RDD, à partir de Spark 2.0, le DataSet fortement typé est également entièrement pris en charge par Spark SQL.

import org.apache.spark.sql.SparkSession

val url = "jdbc:mysql://yourIP:yourPort/test?user=yourUsername;password=yourPassword" // URL for your database server.
val spark = SparkSession.builder().getOrCreate() // Create a Spark session object

val df = spark
  .read
  .format("jdbc")
  .option("url", url)
  .option("dbtable", "people")
  .load()

df.printSchema() // Looks the schema of this DataFrame.
val countsByAge = df.groupBy("age").count() // Counts people by age

//or alternatively via SQL:
//df.createOrReplaceTempView("people")
//val countsByAge = spark.sql("SELECT age, count(*) FROM people GROUP BY age")

Diffusion Spark

Spark Streaming utilise la capacité de planification rapide de Spark Core pour effectuer des analyses de streaming . Il ingère les données dans des mini-lots et effectue des transformations RDD sur ces mini-lots de données. Cette conception permet au même ensemble de code d'application écrit pour l'analyse par lots d'être utilisé dans l'analyse en continu, facilitant ainsi la mise en œuvre facile de l' architecture lambda . Cependant, cette commodité s'accompagne d'une pénalité de latence égale à la durée du mini-lot. D'autres moteurs de données de streaming qui traitent événement par événement plutôt que par mini-lots incluent Storm et le composant de streaming de Flink . Spark Streaming a une prise en charge intégrée pour consommer à partir des sockets Kafka , Flume , Twitter , ZeroMQ , Kinesis et TCP/IP .

Dans Spark 2.x, une technologie distincte basée sur des ensembles de données, appelée Streaming structuré, qui possède une interface de niveau supérieur est également fournie pour prendre en charge le streaming.

Spark peut être déployé dans un centre de données traditionnel sur site ainsi que dans le cloud .

Bibliothèque d'apprentissage automatique MLlib

Spark MLlib est un framework d'apprentissage automatique distribué au -dessus de Spark Core qui, en grande partie grâce à l'architecture Spark basée sur la mémoire distribuée, est jusqu'à neuf fois plus rapide que l'implémentation sur disque utilisée par Apache Mahout (selon benchmarks effectués par les développeurs de MLlib par rapport aux implémentations des moindres carrés alternés (ALS), et avant que Mahout lui-même ne gagne une interface Spark), et évolue mieux que Vowpal Wabbit . De nombreux algorithmes d'apprentissage automatique et statistiques courants ont été implémentés et sont livrés avec MLlib, ce qui simplifie les pipelines d' apprentissage automatique à grande échelle , notamment :

• statistiques sommaires , corrélations , échantillonnage stratifié , test d' hypothèses , génération de données aléatoires
• classification et régression : soutien machines à vecteurs , régression logistique , régression linéaire , classification bayésienne naïve , Arbre de décision , Random Forest , arbre dégradé boosté
• techniques de filtrage collaboratif incluant les moindres carrés alternés (ALS)
• méthodes d'analyse de cluster, y compris k-means et allocation de Dirichlet latente (LDA)
• techniques de réduction de la dimensionnalité telles que la décomposition en valeur singulière (SVD) et l' analyse en composantes principales (ACP)
• extraction de caractéristiques et de transformation des fonctions
• algorithmes d' optimisation tels que la descente de gradient stochastique , BFGS à mémoire limitée (L-BFGS)

GraphX

GraphX ​​est un framework de traitement de graphes distribué au - dessus d'Apache Spark. Parce qu'il est basé sur des RDD, qui sont immuables, les graphes sont immuables et donc GraphX ​​ne convient pas aux graphes qui doivent être mis à jour, encore moins de manière transactionnelle comme une base de données de graphes . GraphX ​​fournit deux API distinctes pour la mise en œuvre d'algorithmes massivement parallèles (tels que PageRank ): une abstraction Pregel et une API plus générale de style MapReduce. Contrairement à son prédécesseur Bagel, qui était formellement obsolète dans Spark 1.6, GraphX ​​prend entièrement en charge les graphiques de propriétés (graphiques où les propriétés peuvent être attachées aux arêtes et aux sommets).

GraphX ​​peut être considéré comme la version Spark en mémoire d' Apache Giraph , qui utilisait MapReduce sur disque Hadoop.

Comme Apache Spark, GraphX ​​a d'abord commencé comme un projet de recherche à AMPLab et Databricks de l'UC Berkeley, et a ensuite été donné à l'Apache Software Foundation et au projet Spark.

Support linguistique

Apache Spark a une prise en charge intégrée de Scala, Java, R et Python avec une prise en charge tierce pour le .NET CLR, Julia, et plus encore.

Histoire

Spark a été initialement lancé par Matei Zaharia à l'AMPLab de l'UC Berkeley en 2009, et open source en 2010 sous une licence BSD .

En 2013, le projet a été donné à l'Apache Software Foundation et a basculé sa licence vers Apache 2.0 . En février 2014, Spark est devenu un projet Apache de premier niveau .

En novembre 2014, la société Databricks du fondateur de Spark, M. Zaharia, a établi un nouveau record mondial de tri à grande échelle à l'aide de Spark.

Spark comptait plus de 1000 contributeurs en 2015, ce qui en fait l'un des projets les plus actifs de l'Apache Software Foundation et l'un des projets de big data open source les plus actifs .

Développeurs

Apache Spark est développé par une communauté. Le projet est géré par un groupe appelé « Project Management Committee » (PMC). Le PMC actuel est Aaron Davidson, Andy Konwinski, Andrew Or, Ankur Dave, Robert Joseph Evans, DB Tsai, Dongjoon Hyun, Felix Cheung, Hyukjin Kwon, Haoyuan Li, Ram Sriharsha, Holden Karau , Herman van Hövell, Imran Rashid, Jason Dai , Joseph Kurata Bradley, Joseph E. Gonzalez, Josh Rosen, Jerry Shao, Kay Ousterhout, Cheng Lian, Xiao Li, Mark Hamstra, Michael Armbrust, Matei Zaharia , Xiangrui Meng, Nicholas Pentreath, Mosharaf Chowdhury, Mridul Muralidharan, Prashant Sharma, Patrick Wendell, Reynold Xin , Ryan LeCompte, Shane Huang, Shivaram Venkataraman, Sean McNamara, Sean R. Owen, Stephen Haberman, Tathagata Das, Thomas Graves, Thomas Dudziak, Takuya Ueshin, Marcelo Masiero Vanzin, Wenchen Fan, Charles Reiss, Andrew Xia, Yin Huai, Yanbo Liang, Shixiong Zhu.

Voir également

• Liste des API/Frameworks de programmation simultanée et parallèle

Remarques

Les références

Liens externes

• Site officiel