web-dev-qa-db-fra.com

Qu'est-ce que le mode client-fil dans Spark?

Apache Spark a récemment mis à jour la version 0.8.1, dans laquelle le mode yarn-client Est disponible. Ma question est la suivante: que signifie réellement le mode client-fil? Dans la documentation, dit:

Avec le mode client-fil, l'application sera lancée localement. Tout comme l'exécution d'une application ou d'un shell-spark en mode Local/Mesos/Standalone. La méthode de lancement est également similaire avec ceux-ci, assurez-vous simplement que lorsque vous devez spécifier une URL principale, utilisez "yarn-client" à la place.

Que signifie "lancé localement"? Localement où? Sur le cluster Spark?
Quelle est la différence spécifique par rapport au mode autonome?

yarnapache-spark
44
zxz

Une application Spark comprend un pilote et un ou plusieurs exécuteurs. Le programme pilote est le programme principal (où vous instanciez SparkContext), qui coordonne les exécuteurs pour exécuter l’application Spark. Les exécuteurs exécutent les tâches assignées par le pilote.

Une application YARN joue les rôles suivants: client de fil, maître d’application de fil et liste des conteneurs exécutés sur les gestionnaires de nœuds.

Lorsque l'application Spark s'exécute sur YARN, elle possède sa propre implémentation de client de fil et de maître d'application de fil.

Avec ces antécédents, la principale différence réside dans l'emplacement du programme du pilote.

  1. Mode autonome du fil: votre programme de pilote s'exécute en tant que fil du maître de l'application de fil, qui s'exécute sur l'un des gestionnaires de nœuds du cluster. Le client Yarn extrait simplement le statut du maître de l'application. Ce mode est identique à un travail mapreduce, dans lequel le maître d’application MR coordonne les conteneurs pour exécuter les tâches de mappage/réduction.
  2. Mode client de fil: votre programme de pilote est exécuté sur le client de fil où vous tapez la commande pour soumettre l'application spark (il peut ne pas s'agir d'une machine du cluster de fils). Dans ce mode, bien que le programme de disque s'exécute sur la machine client, les tâches sont exécutées sur les exécuteurs dans les gestionnaires de noeud du cluster YARN.

Référence: http://spark.incubator.Apache.org/docs/latest/cluster-overview.html

45
Mingjiang Shi

Ainsi, dans spark, vous avez deux composants différents. Il y a le pilote et les ouvriers. En mode grappe de fils, le pilote s'exécute à distance sur un nœud de données et les ouvriers s'exécutent sur des nœuds de données distincts. En mode client, le pilote se trouve sur la machine qui a démarré le travail et les travailleurs sur les nœuds de données, tandis qu'en mode local, le pilote et les travailleurs se trouvent sur la machine qui a démarré le travail.

Lorsque vous exécutez .collect (), les données des nœuds de travail sont extraites dans le pilote. C'est essentiellement là que se passe le traitement final.

Pour moi-même, j’ai trouvé que le mode grappe de fils était préférable lorsque je suis à la maison sur un vpn, mais le mode client-fil est préférable lorsque je lance du code à partir du centre de données.

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

45
ben jarman

spark et le fil sont des structures distribuées, mais leurs rôles sont différents:

Le filé 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 demande/libération de ressource de Yarn pour l'application et le moniteur.

Tentative: une tentative est simplement un processus normal qui fait partie du travail de l'application. Par exemple, un travail mapreduce composé de plusieurs mappeurs et réducteurs, chaque mappeur et chaque réducteur constituant une tentative.

Un processus courant pour sommiter une application sur un fil est le suivant:

  1. Le client soumet la demande d’application au fil. Dans la demande, Yarn doit connaître la classe ApplicationMaster. Pour SparkApplication, il s'agit de org.Apache.spark.deploy.yarn.ApplicationMaster, pour le travail MapReduce, il s’agit de org.Apache.hadoop.mapreduce.v2.app.MRAppMaster.

  2. Yarn alloue des ressources pour le processus ApplicationMaster et démarre le processus ApplicationMaster dans l'un des nœuds du cluster;

  3. Après le démarrage d'ApplicationMaster, ApplicationMaster demandera une ressource à Yarn pour cette application et démarrera l'agent;

Pour Spark, l'infrastructure informatique distribuée, un travail informatique est divisé en plusieurs petites tâches. Chaque exécuteur est responsable de chaque tâche. Le pilote collecte le résultat de toutes les tâches de l'exécuteur et obtient un résultat global. Une application spark) ne comporte qu'un seul pilote avec plusieurs exécuteurs.

Le problème survient donc lorsque Spark utilise Yarn en tant qu’outil de gestion des ressources dans un cluster:

  • En mode grappe de fils, Spark, le client soumettra spark application au fil, les deux Spark Pilote et Spark Les exécuteurs sont sous la surveillance du fil. Dans la perspective du fil, Spark Pilote et Spark L'exécuteur n'a aucune différence, mais normal Java, à savoir un processus de travail d’application. Ainsi, lorsque le processus client est terminé, par exemple si le processus client est arrêté ou tué, l’application Spark sur fil est toujours en cours d’exécution.

  • En mode client filé, seuls les exécuteurs Spark sont sous le
    surveillance du fil. Yarn ApplicationMaster demandera une ressource pour seulement spark exécuteur. Le programme du pilote s'exécute dans le processus client qui n'a rien à voir avec le fil. Il s'agit simplement d'un processus qui soumet une application à yarn.So, lorsque le client partir, par exemple le client
    processus se termine, le pilote est arrêté et l’informatique est terminée.

11
wuchang

Avec le mode client-fil, votre application spark est exécutée sur votre machine locale. Avec le mode autonome ", votre application spark sera envoyée à ResourceManager de YARN en tant que yarn ApplicationMaster et votre application s'exécute dans un nœud de fil dans lequel ApplicationMaster est exécuté. Dans les deux cas, yarn sert de gestionnaire de grappes spark. Votre application (SparkContext) envoie des tâches à yarn.

5
Paul Wang

Tout d'abord, expliquons quelle est la différence entre exécuter Spark en mode autonome et exécuter Spark sur un gestionnaire de cluster (Mesos ou YARN).

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

  • a Spark noeud principal
  • certains nœuds esclaves Spark, qui ont été "enregistrés" auprès du maître Spark

Alors:

  • le nœud maître exécutera le pilote Spark) en envoyant des tâches aux exécuteurs et effectuera également toute négociation de ressources, ce qui est assez élémentaire. Par exemple, chaque travail consomme par défaut toutes les ressources existantes.
  • les nœuds esclaves exécuteront les exécuteurs Spark), exécutant les tâches qui leur sont soumises à partir du pilote.

Lorsque vous utilisez un gestionnaire de cluster (je vais décrire pour YARN 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 (conteneurs YARN)
  • YARN multiple Node Gestionnaires (fonctionnant en permanence), qui constituent le pool de travailleurs, où le gestionnaire de ressources attribuera des conteneurs.
  • Un maître d'application (fonctionnant pendant la durée d'une application YARN), chargé 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. En mode client, qui est celui que vous avez mentionné:

  • le pilote Spark sera exécuté sur la machine sur laquelle la commande est exécutée.
  • Le maître d'application sera exécuté dans un conteneur attribué dans le cluster.
  • Les exécuteurs Spark) seront exécutés dans des conteneurs attribués.
  • Le pilote Spark sera chargé de demander au maître d’application de demander des ressources et d’envoyer des commandes aux conteneurs attribués, de recevoir leurs résultats et de les fournir.

Donc, revenons à vos questions:

Que signifie "lancé localement"? Localement où? Sur le cluster Spark?

Localement signifie sur le serveur sur lequel vous exécutez la commande (ce qui pourrait être un spark-submit ou un spark-Shell). Cela signifie que vous pouvez éventuellement l'exécuter sur le nœud maître du cluster ou sur un serveur situé en dehors du cluster (votre ordinateur portable, par exemple), à ​​condition que la configuration appropriée soit 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 autonome?

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

3
Dimos