Donc, dans spark, vous avez deux composants différents. Il y a le conducteur et les travailleurs. En mode yarn-cluster, le pilote s'exécute à distance sur un nœud de données et les travailleurs s'exécutent sur des nœuds de données distincts. En mode yarn-client, le pilote est sur la machine qui a démarré le travail et les travailleurs sont sur les nœuds de données. En mode local, le conducteur et les travailleurs sont sur la machine qui a démarré le travail.

Lorsque vous exécutez .collect() les données des nœuds de travail sont tirées dans le pilote. C'est fondamentalement, où le dernier bit de traitement se produit.

Pour moi, j'ai trouvé que le mode yarn-cluster était meilleur quand je suis à la maison sur le vpn, mais le mode yarn-client est meilleur quand j'exécute du code depuis le centre de données.

Le mode yarn-client signifie également que vous attachez un nœud de travail de moins pour le pilote.

Une application Spark s'exécutant dans

Mode client Fil:

1. Le programme pilote s'exécute sur la machine cliente ou sur la machine locale où l'application a été lancée.

2. L'allocation des ressources est effectuée par yarn resource manager en fonction de la localité des données sur les nœuds de données et le programme de pilote de la machine locale contrôlera les exécuteurs sur le cluster spark (gestionnaires de nœuds).

Veuillez vous référer à cet article de cloudera pour plus d'informations.

Le différence entre le mode autonome et le mode de déploiement yarn,

1. l'optimisation des ressources ne sera pas efficace en mode autonome.
2. en mode autonome, le programme pilote lance un exécuteur dans chaque nœud d'un cluster, quelle que soit la localité de données.
3. standalone est bon pour le cas d'utilisation, où seule votre application spark est en cours d'exécution et le cluster n'a pas besoin d'allouer des ressources pour d'autres tâches de manière efficace.

Les deux spark et yarn sont distribués cadre, mais leurs rôles sont différents:

Yarn est un cadre de gestion des ressources, pour chaque application, il a les rôles suivants:

ApplicationMaster: gestion des ressources d'une seule application, y compris demander/libérer la ressource de Yarn pour l'application et le moniteur.

Tentative: une tentative est juste un processus normal qui fait une partie de l'ensemble du travail de l'application. Par exemple, une tâche mapreduce qui consiste en plusieurs mappeurs et réducteurs, chaque mappeur et réducteur est une tentative.

Un processus commun de sommation d'une application au fil est:

1. Le client soumet la demande de demande à yarn. Dans le demande, Yarn devrait connaître la classe ApplicationMaster; pour SparkApplication, il est org.apache.spark.deploy.yarn.ApplicationMaster, pour le travail MapReduce , c'est org.apache.hadoop.mapreduce.v2.app.MRAppMaster.

2. Yarn alloue une ressource pour le processus ApplicationMaster et démarrer le processus ApplicationMaster dans L'un des clusters les nœuds;

3. Après le démarrage D'ApplicationMaster, ApplicationMaster demandera des ressources à Yarn pour cette Application et démarrera le travailleur;

Pour Spark, le framework de calcul distribué, un travail de calcul est divisé en plusieurs petites tâches et chaque exécuteur sera responsable de chaque tâche, le pilote recueillera le résultat de toutes les tâches de L'exécuteur et obtiendra un résultat global. Une application spark n'a qu'un seul pilote avec plusieurs exécuteurs.

Donc, alors, le le problème vient quand Spark utilise Yarn comme outil de gestion des ressources dans un cluster:

• En mode Cluster Yarn, le client Spark soumettra l'application spark à le fil, le conducteur D'étincelle et L'exécuteur D'étincelle sont sous la supervision de fil. Dans la perspective de yarn, Spark Driver et Spark Executor ont pas de différence, mais les processus java normaux, à savoir une application processus de travail. Ainsi, lorsque le processus client est parti , par exemple, le client le processus est terminé ou tué, L'étincelle L'Application sur le fil est toujours en cours d'exécution.

• En mode client yarn, seul L'exécuteur Spark est sous
  la surveillance de fil. Le fil ApplicationMaster demandera des ressources pour juste Spark executor. Le programme pilote est en cours d'exécution dans le client processus qui n'ont rien à voir avec le fil, juste un processus de soumission application à yarn.So , lorsque le client quitte, par exemple le client
  le processus se termine, le pilote est en panne et le calcul terminé.

Avec le mode yarn-client, votre application spark s'exécute sur votre machine locale. Avec le mode yarn-standalone, votre application spark sera soumise au ResourceManager de YARN en tant que Yarn ApplicationMaster, et votre application s'exécute dans un nœud yarn où ApplicationMaster est en cours d'exécution. Dans les deux cas, yarn Sert de gestionnaire de cluster de spark. Votre application (SparkContext) envoie des tâches à yarn.

Tout d'abord, précisons Quelle est la différence entre l'exécution de Spark en mode autonome et L'exécution de Spark sur un gestionnaire de cluster (Mesos ou YARN).

Lorsque vous exécutez Spark en mode autonome, vous avez:

• un nœud maître Spark
• certains nœuds esclaves Spark, qui ont été "enregistrés" avec le maître Spark

Donc:

• le nœud maître exécutera le pilote Spark en envoyant des tâches aux exécuteurs et effectuera également n'importe quelle ressource la négociation, qui est assez basique. Par exemple, par défaut, chaque tâche consomme toutes les ressources existantes.
• les nœuds esclaves exécuteront les exécuteurs Spark, en exécutant les tâches qui leur sont soumises par le pilote.

Lorsque vous utilisez un gestionnaire de cluster (je décrirai pour YARN qui est le cas le plus courant), vous avez:

• un gestionnaire de ressources YARN (fonctionnant en permanence), qui accepte les demandes de nouvelles applications et de nouvelles ressources (YARN conteneurs)
• gestionnaires de nœuds de fil multiples (en cours d'exécution en permanence), qui consistent en un pool de travailleurs, où le Gestionnaire de ressources allouera des conteneurs.
• un maître D'Application (en cours d'exécution pendant la durée D'une application YARN), qui est responsable de demander des conteneurs au gestionnaire de ressources et d'envoyer des commandes aux conteneurs alloués.

Notez qu'il existe 2 modes dans ce cas: cluster-mode et client-mode. Dans le mode client, qui est celui que vous mentionné:

• le pilote Spark sera exécuté sur la machine, où la commande est exécutée.
• Le Maître D'Application sera exécuté dans un conteneur alloué dans le cluster.
• les exécuteurs Spark seront exécutés dans des conteneurs alloués.
• le pilote Spark sera chargé de demander au maître de L'Application de demander des ressources et d'envoyer des commandes aux conteneurs alloués, de recevoir leurs résultats et de fournir les résultats.

Donc, retour à vos questions:

Qu'est-ce que cela signifie "lancé localement"? Localement où? Sur L'étincelle cluster?

Signifie localement dans le serveur dans lequel vous exécutez la commande (qui pourrait être un spark-submit ou un spark-shell). Cela signifie que vous pouvez éventuellement l'exécuter dans le nœud maître du cluster ou vous pouvez également l'exécuter dans un serveur en dehors du cluster (par exemple votre ordinateur portable) tant que la configuration appropriée est en place, de sorte que ce serveur puisse communiquer avec le cluster et vice-versa.

Quelle est la différence spécifique par rapport au mode yarn-standalone?

Comme décrit ci-dessus, la différence est que dans le mode autonome, il n'y a pas de gestionnaire de cluster du tout. Une analyse et une catégorisation plus élaborées de toutes les différences concrètes pour chaque mode sont disponibles dans cet article .