web-dev-qa-db-fra.com

Comment exécuter un programme Spark Java

J'ai écrit un programme Java pour Spark. Mais comment l'exécuter et le compiler à partir d'une ligne de commande Unix. Dois-je inclure un fichier jar lors de la compilation pour pouvoir l'exécuter?

javaapache-spark
41
Pooja3101

En combinant les étapes officielles Guide de démarrage rapide et en lançant Spark sur YARN , nous obtenons:

Nous allons créer une application très simple Spark, SimpleApp.Java:

/*** SimpleApp.Java ***/
import org.Apache.spark.api.Java.*;
import org.Apache.spark.api.Java.function.Function;

public class SimpleApp {
  public static void main(String[] args) {
    String logFile = "$YOUR_SPARK_HOME/README.md"; // Should be some file on your system
    JavaSparkContext sc = new JavaSparkContext("local", "Simple App",
      "$YOUR_SPARK_HOME", new String[]{"target/simple-project-1.0.jar"});
    JavaRDD<String> logData = sc.textFile(logFile).cache();

    long numAs = logData.filter(new Function<String, Boolean>() {
      public Boolean call(String s) { return s.contains("a"); }
    }).count();

    long numBs = logData.filter(new Function<String, Boolean>() {
      public Boolean call(String s) { return s.contains("b"); }
    }).count();

    System.out.println("Lines with a: " + numAs + ", lines with b: " + numBs);
  }
}

Ce programme ne compte que le nombre de lignes contenant "a" et le nombre contenant "b" dans un fichier texte. Notez que vous devrez remplacer $ YOUR_SPARK_HOME par l’emplacement où Spark est installé. Comme avec l'exemple Scala, nous initialisons un SparkContext, bien que nous utilisions la classe spéciale JavaSparkContext pour en obtenir une compatible avec Java. Nous créons également des RDD (représentés par JavaRDD) et leur effectuons des transformations. Enfin, nous passons des fonctions à Spark en créant des classes qui étendent spark.api.Java.function.Function. Le guide de programmation Java décrit ces différences plus en détail.

Pour construire le programme, nous écrivons également un fichier Maven pom.xml qui répertorie Spark comme dépendance. Notez que les artefacts Spark sont marqués avec une version Scala.

<project>
  <groupId>edu.berkeley</groupId>
  <artifactId>simple-project</artifactId>
  <modelVersion>4.0.0</modelVersion>
  <name>Simple Project</name>
  <packaging>jar</packaging>
  <version>1.0</version>
  <repositories>
    <repository>
      <id>Akka repository</id>
      <url>http://repo.akka.io/releases</url>
    </repository>
  </repositories>
  <dependencies>
    <dependency> <!-- Spark dependency -->
      <groupId>org.Apache.spark</groupId>
      <artifactId>spark-core_2.10</artifactId>
      <version>0.9.0-incubating</version>
    </dependency>
  </dependencies>
</project>

Si vous souhaitez également lire les données de HDFS de Hadoop, vous devez également ajouter une dépendance sur hadoop-client pour votre version de HDFS:

<dependency>
  <groupId>org.Apache.hadoop</groupId>
  <artifactId>hadoop-client</artifactId>
  <version>...</version>
</dependency>

Nous organisons ces fichiers selon la structure canonique de répertoires Maven:

$ find .
./pom.xml
./src
./src/main
./src/main/Java
./src/main/Java/SimpleApp.Java

Maintenant, nous pouvons exécuter l'application à l'aide de Maven:

$ mvn package
$ mvn exec:Java -Dexec.mainClass="SimpleApp"
...
Lines with a: 46, Lines with b: 23

Et puis suivez les étapes de Lancer Spark sur YARN :

Construction d'un fichier JAR d'assemblage activé par YARN

Nous avons besoin d'un fichier JAR Spark consolidé (qui regroupe toutes les dépendances requises) pour exécuter les travaux Spark sur un cluster YARN. Cela peut être construit en définissant la version Hadoop et la variable d’environnement SPARK_YARN, comme suit:

SPARK_HADOOP_VERSION=2.0.5-alpha SPARK_YARN=true sbt/sbt Assembly

Le fichier JAR assemblé doit ressembler à ceci: ./Assembly/target/scala-2.10/spark-Assembly_0.9.0-incubating-hadoop2.0.5.jar.

Le processus de construction prend désormais également en charge les nouvelles versions de YARN (2.2.x). Voir ci-dessous.

Préparations

  • Construction d’un assemblage utilisant YARN (voir ci-dessus).
  • Le pot assemblé peut être installé dans HDFS ou utilisé localement.
  • Votre code d'application doit être emballé dans un fichier JAR séparé.

Si vous souhaitez tester le mode de déploiement YARN, vous pouvez utiliser les exemples actuels de Spark. Un fichier spark-examples_2.10-0.9.0-incubating peut être généré en lançant:

sbt/sbt Assembly

REMARQUE: puisque la documentation que vous lisez est pour Spark version 0.9.0-incubante, nous supposons que vous avez téléchargé Spark 0.9.0-incubant ou contrôlé hors du contrôle source. Si vous utilisez une version différente de Spark, les numéros de version dans le fichier jar générés par la commande de package sbt seront évidemment différents.

Configuration

La plupart des configurations sont les mêmes pour Spark sur YARN que pour les autres déploiements. Voir la page de configuration pour plus d'informations sur ceux-ci. Ce sont des configurations spécifiques à SPARK sur YARN.

Variables d'environnement:

  • SPARK_YARN_USER_ENV , pour ajouter des variables d'environnement aux processus Spark lancés sur YARN. Il peut s’agir d’une liste de variables d’environnement séparée par des virgules, par exemple.
SPARK_YARN_USER_ENV="Java_HOME=/jdk64,FOO=bar"

Propriétés système:

  • spark.yarn.applicationMaster.waitTries, propriété permettant de définir le nombre de fois où ApplicationMaster attend le maître spark, puis le nombre d'essais qu'il attend pour le Spark Contexte à initialiser. La valeur par défaut est 10.
  • spark.yarn.submit.file.replication, niveau de réplication HDFS pour les fichiers téléchargés dans HDFS pour l'application. Ceux-ci incluent des éléments tels que le fichier spark, le fichier jar de l'application et tous les fichiers/archives de cache distribués.
  • spark.yarn.preserve.staging.files, défini sur true pour conserver les fichiers mis en scène (fichier spark, fichier jar de l'application, fichiers de cache distribué) à la fin du travail plutôt que de les supprimer.
  • spark.yarn.scheduler.heartbeat.interval-ms, intervalle en ms dans lequel les pulsations du maître d'application Spark dans le gestionnaire de ressources YARN. La valeur par défaut est 5 secondes.
  • spark.yarn.max.worker.failures, nombre maximal d'échecs de travail avant l'échec de l'application. La valeur par défaut est le nombre de travailleurs demandé 2 fois avec un minimum de 3.

Lancer Spark sur YARN

Assurez-vous que HADOOP_CONF_DIR ou YARN_CONF_DIR pointe vers le répertoire qui contient le (client). côté) les fichiers de configuration du cluster hadoop. Cela serait utilisé pour se connecter au cluster, écrire dans le fichier DFS et soumettre des travaux au gestionnaire de ressources.

Deux modes de planification peuvent être utilisés pour lancer l’application spark sur YARN.

Lancez l'application spark par YARN Client en mode autonome.

La commande pour lancer le client YARN est la suivante:

SPARK_JAR=<SPARK_Assembly_JAR_FILE> ./bin/spark-class org.Apache.spark.deploy.yarn.Client \
  --jar <YOUR_APP_JAR_FILE> \
  --class <APP_MAIN_CLASS> \
  --args <APP_MAIN_ARGUMENTS> \
  --num-workers <NUMBER_OF_WORKER_MACHINES> \
  --master-class <ApplicationMaster_CLASS>
  --master-memory <MEMORY_FOR_MASTER> \
  --worker-memory <MEMORY_PER_WORKER> \
  --worker-cores <CORES_PER_WORKER> \
  --name <application_name> \
  --queue <queue_name> \
  --addJars <any_local_files_used_in_SparkContext.addJar> \
  --files <files_for_distributed_cache> \
  --archives <archives_for_distributed_cache>

Par exemple:

# Build the Spark Assembly JAR and the Spark examples JAR
$ SPARK_HADOOP_VERSION=2.0.5-alpha SPARK_YARN=true sbt/sbt Assembly

# Configure logging
$ cp conf/log4j.properties.template conf/log4j.properties

# Submit Spark's ApplicationMaster to YARN's ResourceManager, and instruct Spark to run the SparkPi example
$ SPARK_JAR=./Assembly/target/scala-2.10/spark-Assembly-0.9.0-incubating-hadoop2.0.5-alpha.jar \
    ./bin/spark-class org.Apache.spark.deploy.yarn.Client \
      --jar examples/target/scala-2.10/spark-examples-Assembly-0.9.0-incubating.jar \
      --class org.Apache.spark.examples.SparkPi \
      --args yarn-standalone \
      --num-workers 3 \
      --master-memory 4g \
      --worker-memory 2g \
      --worker-cores 1

# Examine the output (replace $YARN_APP_ID in the following with the "application identifier" output by the previous command)
# (Note: YARN_APP_LOGS_DIR is usually /tmp/logs or $HADOOP_HOME/logs/userlogs depending on the Hadoop version.)
$ cat $YARN_APP_LOGS_DIR/$YARN_APP_ID/container*_000001/stdout
Pi is roughly 3.13794

Ce qui précède démarre un programme client YARN qui lance le maître d’application par défaut. Ensuite, SparkPi sera exécuté en tant que thread enfant du maître d’application. YARN Client interrogera périodiquement le maître d’application à la recherche de mises à jour de statut et les affichera dans la console. Le client se ferme une fois que votre application est en cours d'exécution.

Avec ce mode, votre application est réellement exécutée sur la machine distante sur laquelle est exécuté Application Master. Ainsi, les applications qui impliquent une interaction locale ne fonctionneront pas bien, par ex. étincelle-coquille.

57
Viacheslav Rodionov

J'avais la même question il y a quelques jours et j'ai réussi hier à la résoudre.
C'est ce que j'ai fait:

  1. Téléchargez sbt, décompressez et décompressez-le : http: //www.scala-sbt.org/download.html
  2. J'ai téléchargé le package Spark Prebuild pour Hadoop 2, décompressé et décompressé: http://www.Apache.org/dyn/closer.cgi/spark/spark-1.0. 2/spark-1.0.2-bin-hadoop2.tgz
  3. J'ai créé l'application autonome SimpleApp.scala comme décrit dans: http://spark.Apache.org/docs/latest/quick-start.html#standalone-applications avec le fichier simple.sbt approprié ( juste copié de la description) et la disposition de répertoire appropriée
  4. Assurez-vous que vous avez sbt en votre chemin. Allez dans le répertoire avec votre application et construisez votre paquet en utilisant sbt package
  5. Démarrer Spark Serveur utilisant SPARK_HOME_DIR/sbin/spark_master.sh
  6. Aller à localhost:8080 et assurez-vous que votre serveur est en cours d'exécution. Copier le lien à partir de l'URL (à partir de la description du serveur, pas de l'hôte local. Ce doit être quelque chose avec le port 7077 ou similaire)
  7. Démarrer les travailleurs en utilisant SPARK_HOME_DIR/bin/spark-class org.Apache.spark.deploy.worker.Worker spark://IP:PORT où IP: PORT est l’URL copiée dans 6
  8. Déployez votre application sur le serveur: SPARK_HOME_DIR/bin/spark-submit --class "SimpleApp" --master URL target/scala-2.10/simple-project_2.10-1.0.jar

Cela a fonctionné pour moi et j'espère vous aider.
Pawel

8
psmith

En plus de la réponse sélectionnée, si vous souhaitez vous connecter à une instance autonome autonome Spark par exemple:

SparkConf conf =
new SparkConf()
     .setAppName("Simple Application")
     .setMaster("spark://10.3.50.139:7077");

JavaSparkContext sc = new JavaSparkContext(conf);

Ici vous pouvez trouver plus de configuration "maître" en fonction de l'endroit où Spark est en cours d'exécution: http://spark.Apache.org/docs/latest/submitting-applications.html#master -urls

5
Alexis Gamarra

Cette réponse concerne Spark 2.3.Si vous souhaitez tester votre Spark en local, c’est-à-dire sans les prérequis d’un cluster Hadoop, et même sans avoir pour démarrer l’un des services autonomes Spark, vous pouvez le faire:

JavaSparkContext jsc = new JavaSparkContext(new SparkConf().setAppName("Simple App"));

Et ensuite, pour exécuter votre application localement:

$SPARK_HOME/bin/spark-submit --class SimpleApp --master local target/scala-2.10/simple-project_2.10-1.0.jar

Pour que cela fonctionne, il vous suffit d'extraire le fichier Spark tar dans $ SPARK_HOME et de définir $ SPARK_HOME dans Spark .profile de l'utilisateur

1
Binita Bharati