Que sont les travailleurs, les exécuteurs, les cœurs du cluster Spark Standalone?

J'ai lu Présentation du mode cluster et je ne comprends toujours pas les différents processus dans le cluster Spark Standalone et le parallélisme.

Le travailleur est-il un processus JVM ou non? J'ai couru le bin\start-slave.shet j'ai découvert qu'il engendrait le travailleur, qui est en fait une machine virtuelle Java.

Selon le lien ci-dessus, un exécuteur est un processus lancé pour une application sur un nœud de travail qui exécute des tâches. Un exécuteur est également une machine virtuelle Java.

Ce sont mes questions:

1. Les exécuteurs sont par application. Alors quel est le rôle d'un travailleur? Coordonne-t-il avec l'exécuteur testamentaire et communique-t-il le résultat au conducteur? Ou le conducteur parle-t-il directement à l'exécuteur testamentaire? Si oui, quel est le but du travailleur alors?

2. Comment contrôler le nombre d'exécuteurs pour une application?

3. Les tâches peuvent-elles être exécutées en parallèle à l'intérieur de l'exécuteur? Si oui, comment configurer le nombre de threads pour un exécuteur?

4. Quelle est la relation entre un travailleur, des exécuteurs et des cœurs d'exécuteur (--total-executor-cores)?

5. Que signifie avoir plus de travailleurs par nœud?

Actualisé

Prenons des exemples pour mieux comprendre.

Exemple 1: Un cluster autonome avec 5 nœuds de travail (chaque nœud ayant 8 cœurs) Lorsque je démarre une application avec des paramètres par défaut.

Exemple 2 Même configuration de cluster que l'exemple 1, mais j'exécute une application avec les paramètres suivants --executor-cores 10 --total-executor-cores 10.

Exemple 3 Même configuration de cluster que l'exemple 1, mais j'exécute une application avec les paramètres suivants --executor-cores 10 --total-executor-cores 50.

Exemple 4 Même configuration de cluster que l'exemple 1, mais j'exécute une application avec les paramètres suivants --executor-cores 50 --total-executor-cores 50.

Exemple 5 Même configuration de cluster que l'exemple 1, mais j'exécute une application avec les paramètres suivants --executor-cores 50 --total-executor-cores 10.

Dans chacun de ces exemples, combien d'exécuteurs? Combien de threads par exécuteur testamentaire? Combien de cœurs? Comment le nombre d'exécuteurs testamentaires est-il décidé par demande? Est-ce toujours le même que le nombre de travailleurs?

Spark utilise une architecture maître / esclave. Comme vous pouvez le voir sur la figure, il dispose d'un coordinateur central (Driver) qui communique avec de nombreux travailleurs distribués (exécuteurs). Le pilote et chacun des exécuteurs s'exécutent dans leurs propres processus Java.

CHAUFFEUR

Le pilote est le processus où s'exécute la méthode principale. D'abord, il convertit le programme utilisateur en tâches et ensuite il planifie les tâches sur les exécuteurs.

EXECUTEURS

Les exécuteurs sont des processus de nœuds de travail chargés d'exécuter des tâches individuelles dans un travail Spark donné. Ils sont lancés au début d'une application Spark et s'exécutent généralement pendant toute la durée de vie d'une application. Une fois la tâche exécutée, ils envoient les résultats au pilote. Ils fournissent également un stockage en mémoire pour les RDD mis en cache par les programmes utilisateur via Block Manager.

FLUX D'EXÉCUTION DE L'APPLICATION

Dans cet esprit, lorsque vous soumettez une application au cluster avec spark-submit, voici ce qui se passe en interne:

1. Une application autonome démarre et instancie une SparkContextinstance (et c'est seulement alors que vous pouvez appeler l'application un pilote).
2. Le programme du pilote demande des ressources au gestionnaire de cluster pour lancer les exécuteurs.
3. Le gestionnaire de cluster lance les exécuteurs.
4. Le processus du pilote s'exécute via l'application utilisateur. Selon les actions et les transformations sur les RDD, la tâche est envoyée aux exécuteurs.
5. Les exécuteurs exécutent les tâches et enregistrent les résultats.
6. Si un travailleur tombe en panne, ses tâches seront envoyées à différents exécuteurs pour être traitées à nouveau. Dans le livre "Learning Spark: Big Data Fast-Light Analysis", ils parlent de Spark et de la tolérance aux pannes:

Spark traite automatiquement les machines en panne ou lentes en réexécutant les tâches en panne ou lentes. Par exemple, si le nœud exécutant une partition d'une opération map () tombe en panne, Spark la réexécutera sur un autre nœud; et même si le nœud ne plante pas mais est tout simplement beaucoup plus lent que les autres nœuds, Spark peut lancer de manière préventive une copie «spéculative» de la tâche sur un autre nœud, et prendre son résultat si cela se termine.

7. Avec SparkContext.stop () à partir du pilote ou si la méthode principale se ferme / se bloque, tous les exécuteurs seront arrêtés et les ressources du cluster seront libérées par le gestionnaire de cluster.

VOS QUESTIONS

1. Lorsque les exécuteurs sont démarrés, ils s'enregistrent auprès du pilote et à partir de là, ils communiquent directement. Les travailleurs sont chargés de communiquer au responsable du cluster la disponibilité de leurs ressources.

2. Dans un cluster YARN, vous pouvez le faire avec --num-executors. Dans un cluster autonome, vous obtiendrez un exécuteur par travailleur, sauf si vous jouez avec spark.executor.cores et qu'un travailleur a suffisamment de cœurs pour contenir plus d'un exécuteur. (Comme l'a souligné @JacekLaskowski, --num-executors n'est plus utilisé dans YARN https://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

3. Vous pouvez attribuer le nombre de cœurs par exécuteur avec --executor-cores

4. --total-executor-cores est le nombre maximum de cœurs d'exécuteur par application

5. Comme l'a dit Sean Owen dans ce fil de discussion : "il n'y a pas de bonne raison d'exécuter plus d'un travailleur par machine". Par exemple, vous auriez de nombreuses machines virtuelles Java sur une seule machine.

METTRE À JOUR

Je n'ai pas pu tester ces scénarios, mais selon la documentation:

EXEMPLE 1: Spark acquiert goulûment autant de cœurs et d'exécuteurs que le planificateur le propose. Donc, au final, vous obtiendrez 5 exécuteurs avec 8 cœurs chacun.

EXEMPLES 2 à 5: Spark ne pourra pas allouer autant de cœurs que demandé dans un même travailleur, donc aucun exécuteur ne sera lancé.

Voici comment Apache Spark fonctionne en interne: