1. Introduction
SparkContext est le principal point d'entrée du programme Spark et est utilisé pour se connecter au cluster Spark. Toutes les opérations du cluster Spark sont effectuées via le SparkContext, qui peut être utilisé pour créer des RDD, des compteurs et des variables de diffusion sur le cluster Spark. Tous les programmes Spark doivent créer un objet SparkContext. Le StreamingContext utilisé pour le streaming informatique et le SQLContext utilisé pour le SQL computing seront également associés à un SparkContext existant ou créer implicitement un objet SparkContext. Le code source est le suivant:
/ ** * Point d'entrée principal pour la fonctionnalité Spark. Un SparkContext représente la connexion à un
cluster Spark * et peut être utilisé pour créer des RDD, des accumulateurs et des variables de diffusion sur ce cluster. * * Un seul SparkContext peut être actif par JVM. Vous devez `arrêter ()` le SparkContext actif avant * d'en créer un nouveau. Cette limitation peut éventuellement être supprimée; voir SPARK-2243 pour plus de détails. * * @param config un objet Spark Config décrivant la configuration de l'application. Tous les paramètres de * cette configuration remplacent les configurations par défaut ainsi que les propriétés du système. * / class SparkContext (config: SparkConf) étend la journalisation { //Le site d'appel où ce SparkContext a été construit. private val creationSite: CallSite = Utils.getCallSite () // Si vrai, consigner les avertissements au lieu de lancer des exceptions lorsque plusieurs SparkContexts sont actifs val privé allowMultipleContexts: Boolean = config.getBoolean ( " spark.driver.allowMultipleContexts " , false ) // In afin d'empêcher plusieurs SparkContexts d'être actifs en même temps, marquez ce // contexte comme ayant commencé la construction. // REMARQUE: cela doit être placé au début du constructeur SparkContext. SparkContext.markPartiallyConstructed (this , allowMultipleContexts) val startTime = System.currentTimeMillis () private [spark] val arrêtée: AtomicBoolean = new AtomicBoolean ( false ) private [spark] def assertNotStopped (): Unit = { if (arrêté. get ()) { val activeContext = SparkContext.activeContext. get () val activeCreationSite = if (activeContext == null ) { " (Aucun SparkContext actif.) " } else { activeContext.creationSite.longForm } lancer de nouveaux IllegalStateException ( s "" » . Ne peut pas appeler des méthodes sur un arrêt SparkContext | Cet arrêté SparkContext a été créé: | | $ {} creationSite.longForm | | Le SparkContext actuellement actif a été créé à: | | $ activeCreationSite "" " .stripMargin) } } def this () = this ( new SparkConf ()) defthis (master: String, appName: String, conf: SparkConf) = this (SparkContext.updatedConf (conf, master, appName)) def this ( master: String, appName: String, sparkHome: String = null , jars: Seq [String ] = Nil, environnement: Map [String, String] = Map ()) = { this (SparkContext.updatedConf ( new SparkConf (), master, appName, sparkHome, jars, environment)) }
private [spark] def this (master) : String, appName: String) = this (master, appName,null , Nil, Map ()) private [spark] def this (master: String, appName: String, sparkHome: String) = this (master, appName, sparkHome, Nil, Map ())
private [spark] def this (master : String, appName: String, sparkHome: String, jars: Seq [String]) = this (master, appName, sparkHome, jars, Map ()) // se déconnecter de la version Spark dans le journal du pilote Spark logInfo (s " Running Spark version $ SPARK_VERSION " )
2. Configuration SparkConf
Lors de l'initialisation de SparkContext, un seul objet de configuration SparkConf est nécessaire en tant que paramètre. La définition de la classe SparkConf pour enregistrer la configuration se trouve dans le fichier SparkConf.scala dans le même répertoire. Son membre principal est une table de hachage, où les types de clé et de valeur sont tous deux des types de chaîne:
Bien que SparkConf fournisse des interfaces simples pour la configuration, en fait, toutes les configurations sont stockées dans les paramètres sous la forme de paires <clé, valeur>. Par exemple, définir la méthode principale consiste à définir l'élément de configuration spark.master.
Par conséquent, vous pouvez utiliser l'élément de configuration spark.master dans le fichier de configuration, ou l'option --master dans la liste des paramètres, ou la méthode setMaster () pour définir l'adresse maître, mais leurs priorités sont différentes.
Un seul SparkContext est autorisé à démarrer par JVM, sinon une exception sera levée par défaut. Par exemple, dans un environnement de programmation interactif démarré via spark-shell, un objet SparkContext nommé sc a été créé par défaut. Signaler une erreur. Une solution simple consiste à arrêter d'abord le sc par défaut.
Bien sûr, vous pouvez également ignorer cette erreur en définissant spark.driver.allowMultipleContext sur true, comme suit:
3. Processus d'initialisation
Pendant la construction de SparkContext, tous les services ont été lancés. En raison des caractéristiques de la syntaxe Scala, tous les constructeurs appellent le constructeur par défaut et le code du constructeur par défaut est directement dans la définition de classe. Outre l'initialisation de diverses configurations et journaux, l'une des opérations d'initialisation les plus importantes consiste à démarrer le planificateur de tâches et le planificateur DAG. Le code est le suivant:
La différence entre la planification DAG et la planification des tâches est que DAG est une planification de haut niveau, dessine un graphique acyclique dirigé pour chaque travail, suit la sortie de chaque étape, calcule le chemin le plus court pour terminer le travail et soumet la tâche au planificateur de tâches Pour exécuter. Le planificateur de tâches est uniquement responsable d'accepter la demande du planificateur DAG et est responsable de l'exécution de la planification réelle de la tâche, donc l'initialisation du DAGScheduler doit se faire après le planificateur de tâches.
L'avantage de la conception distincte de DAG et de Task est que Spark peut concevoir de manière flexible sa propre planification DAG et peut également être combiné avec d'autres systèmes de planification de ressources, tels que YARN et Mesos.
Le planificateur de tâches lui-même est créé dans la fonction createTaskScheduler. Selon les différents modes spécifiés lors de la soumission du programme Spark, différents types de planificateurs peuvent être démarrés. Et pour des raisons de tolérance aux pannes, createTaskScheduler renverra un planificateur avec deux planificateurs. En prenant le mode de cluster YARN comme exemple, les planificateurs maître et de secours correspondent à différents types d'instances, mais la même configuration est chargée. Le code est le suivant:
case masterUrl => val cm = getClusterManager (masterUrl) match { case Some (clusterMgr) => clusterMgr case None => lancer une nouvelle SparkException ( " Impossible d'analyser l'URL maître: ' " + maître + " ' " ) } essayer { ordonnanceur val = cm.createTaskScheduler (sc, masterUrl) val backend = cm.createSchedulerBackend (sc, masterUrl, scheduler) cm.initialize (scheduler, backend) (backend, scheduler) } catch { case se: SparkException => throw se case NonFatal (e) => throw new SparkException ( " Le planificateur externe ne peut pas être instancié " , e) } }
4. Autres interfaces fonctionnelles
En plus d'initialiser l'environnement et de se connecter au cluster Spark, SparkContext fournit également de nombreuses entrées fonctionnelles, comme suit:
1. Créez un RDD. Toutes les méthodes de création de RDD sont définies dans SparkContext, telles que parallelize et textFilenewAPIHadoopFile.
2. Persistance RDD. Les méthodes d'opération persistante de RDD persistRDD et unpersistRDD sont également définies dans SparkContext.
3. Créez des variables partagées. Y compris les compteurs et les variables de diffusion.
4. arrêt (). Arrêtez SparkContext.
5. runJob. Soumettez l'opération RDD Action, qui est le point d'entrée pour toutes les exécutions planifiées.