apache-spark - tutorial - spark vs hadoop



Que sont les travailleurs, les exécuteurs, les cœurs dans le cluster Spark Standalone? (1)

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

Le travailleur est-il un processus JVM ou non? J'ai couru le bin\start-slave.sh et bin\start-slave.sh constaté qu'il a engendré le travailleur, qui est en fait une machine virtuelle.

Selon le lien ci-dessus, un exécuteur est un processus lancé pour une application sur un nœud de travail exécutant des tâches. Executor est également une JVM.

Ce sont mes questions:

  1. Les exécuteurs sont par application. Alors quel est le rôle d'un travailleur? Est-ce que cela se coordonne avec l'exécuteur et communique le résultat au chauffeur? ou le conducteur parle-t-il directement à l'exécuteur? Si oui, quel est le but du travailleur alors?

  2. Comment contrôler le nombre d'exécuteurs pour une application? 3.Peut-on exécuter les tâches en parallèle dans l'exécuteur? Si oui, comment configurer le nombre de threads pour un exécuteur?

  3. Quelle est la relation entre les noyaux travailleur, exécuteurs et exécuteurs (--total-executor-cores)?

  4. Qu'est-ce que cela signifie d'avoir plus de travailleurs par nœud?

Mis à jour

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 lance 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? Combien de cœurs? Comment le nombre d'exécuteurs est-il déterminé par application? 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 (pilote) qui communique avec de nombreux travailleurs répartis (exécuteurs). Le pilote et chacun des exécuteurs s'exécutent dans leurs propres processus Java.

CHAUFFEUR

Le pilote est le processus d'exécution de la méthode principale. Tout 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 noeuds 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 le gestionnaire de blocs.

FLUX D'EXÉCUTION D'APPLICATION

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

  1. Une application autonome démarre et instancie une instance de SparkContext (et ce n’est SparkContext que vous pouvez appeler l’application un pilote).
  2. Le programme de pilote demande des ressources au gestionnaire de clusters pour lancer les exécuteurs.
  3. Le gestionnaire de cluster lance les exécuteurs.
  4. Le processus de pilote s'exécute dans l'application utilisateur. Selon les actions et les transformations effectuées sur les RDD, les tâches sont envoyées aux exécuteurs.
  5. Les exécuteurs exécutent les tâches et sauvegardent les résultats.
  6. Si un travailleur se bloque, ses tâches seront envoyées à différents exécutants pour être traitées à nouveau. Dans le livre "Learning Spark: Analyse ultra-rapide de données volumineuses", ils parlent de tolérance aux étincelles et aux défaillances:

Spark prend automatiquement en charge les machines défaillantes ou lentes en réexécutant les tâches défaillantes ou lentes. Par exemple, si le nœud exécutant une partition d'une opération map () se bloque, Spark l'exécutera de nouveau sur un autre nœud. et même si le nœud ne tombe pas en panne 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 s'il se termine.

  1. Avec SparkContext.stop () à partir du pilote ou si la méthode principale se ferme / se bloque, tous les exécuteurs seront terminé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 eux-mêmes auprès du chauffeur et communiquent directement entre eux. Les travailleurs sont chargés de communiquer au gestionnaire de grappes 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 ouvrier a suffisamment de cœurs pour contenir plus d'un exécuteur. (Comme @JacekLaskowski l'a souligné, --num-executors n'est plus utilisé dans YARN https://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

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

  4. --total-executor-cores est le nombre maximal de cœurs exécuteurs par application

  5. Comme l'a dit Sean Owen dans ce thread : "il n'y a pas de bonne raison de faire fonctionner plus d'un ouvrier par machine". Vous auriez beaucoup de JVM assis dans une machine par exemple.

METTRE À JOUR

Je n'ai pas pu tester ce scénario, mais d'après la documentation:

EXEMPLE 1: Spark va acquérir avidement autant de cœurs et d'exécuteurs que le planificateur lui propose. Donc, à la fin, vous aurez 5 exécuteurs avec 8 noyaux chacun.

Exemples 2 à 5: Spark ne pourra pas allouer autant de cœurs que demandé dans un seul ouvrier. Aucun exécuteur ne sera donc lancé.





distributed-computing