Cette page a été traduite par l'API Cloud Translation.

Écrire et exécuter des tâches Spark Scala sur Dataproc

Ce tutoriel illustre différentes méthodes pour créer une tâche Spark Scala et l'envoyer à un cluster Dataproc. Vous allez ainsi découvrir comment :

écrire et compiler une application Spark Scala "Hello World" sur une machine locale à partir de la ligne de commande en utilisant le REPL Scala (Read-Evaluate-Print-Loop ou interpréteur interactif) ou l'outil de compilation SBT ;
empaqueter des classes Scala compilées dans un fichier JAR avec un fichier manifeste ;
envoyer le fichier JAR Scala à une tâche Spark qui s'exécute sur votre cluster Dataproc ;
examiner les résultats de la tâche Scala dans la console Google Cloud.

Ce tutoriel vous explique également comment :

écrire et exécuter un exemple de Spark Scala "WordCount" ; job MapReduce directement sur une instance Dataproc cluster à l'aide du REPL spark-shell
exécuter des exemples Apache Spark et Hadoop pré-installés sur un cluster.

Configurer un projet Google Cloud Platform

Si ce n'est pas déjà fait, effectuez les opérations suivantes :

Écrire et compiler le code Scala en local

À titre d'exercice simple pour ce tutoriel, écrivez un exemple l'application Scala à l'aide de la commande Scala REPL ou l'interface de ligne de commande SBT en local sur votre ordinateur de développement.

Utiliser Scala
Utiliser SBT

Utiliser Scala

Téléchargez les fichiers binaires Scala depuis la page d'installation de Scala.
Décompressez le fichier, définissez la variable d'environnement SCALA_HOME et ajoutez-la à votre chemin d'accès, affiché dans Installation de Scala instructions. Exemple :
```
export SCALA_HOME=/usr/local/share/scala
export PATH=$PATH:$SCALA_HOME/
```

Lancez le REPL Scala.

$ scala
Welcome to Scala version ...
Type in expressions to have them evaluated.
Type :help for more information.
scala>

Copiez et collez le code HelloWorld dans le REPL Scala.

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, world!")
  }
}

Enregistrez HelloWorld.scala et quittez le REPL.
```
scala> :save HelloWorld.scala
scala> :q
```
Effectuez la compilation avec scalac.
```
$ scalac HelloWorld.scala
```

Répertoriez les fichiers .class compilés.

$ ls HelloWorld*.class
HelloWorld$.class   HelloWorld.class

Utiliser SBT

Téléchargez SBT.

Créez un projet "HelloWorld", comme illustré ci-dessous.

$ mkdir hello
$ cd hello
$ echo \
'object HelloWorld {def main(args: Array[String]) = println("Hello, world!")}' > \
HelloWorld.scala

Créez un fichier de configuration sbt.build pour définir artifactName (le nom du fichier JAR que vous allez générer, ci-dessous) par "HelloWorld.jar". (voir Modifier les artefacts par défaut)
```
echo \
'artifactName := { (sv: ScalaVersion, module: ModuleID, artifact: Artifact) =>
"HelloWorld.jar" }' > \
build.sbt
```

Lancez SBT et exécutez le code.

$ sbt
[info] Set current project to hello ...
> run
... Compiling 1 Scala source to .../hello/target/scala-.../classes...
... Running HelloWorld
Hello, world!
[success] Total time: 3 s ...

Empaquetez le code dans un fichier JAR avec un fichier manifeste indiquant le point d'entrée de la classe principale (HelloWorld), puis quittez l'outil.
```
> package
... Packaging .../hello/target/scala-.../HelloWorld.jar ...
... Done packaging.
[success] Total time: ...
> exit
```

Créer un fichier JAR

Créer un fichier JAR avec SBT ou avec le fichier jar .

Créer un pot avec SBT

Le package SBT crée un fichier JAR (voir Utiliser SBT).

Créer un fichier JAR manuellement

Basculez vers le répertoire (commande cd) où sont stockés vos fichiers HelloWorld*.class compilés, puis exécutez la commande suivante pour empaqueter les fichiers de classe dans un fichier JAR avec un fichier manifeste qui spécifie le point d'entrée de la classe principale (HelloWorld).
```
$ jar cvfe HelloWorld.jar HelloWorld HelloWorld*.class
added manifest
adding: HelloWorld$.class(in = 637) (out= 403)(deflated 36%)
adding: HelloWorld.class(in = 586) (out= 482)(deflated 17%)
```
L'analyse du fichier manifeste du fichier JAR (MANIFEST.MF) montre indique le point d'entrée de la classe principale HelloWorld:
```
Manifest-Version: ...
Created-By: ...
Main-Class: HelloWorld
```

Copier le fichier JAR dans Cloud Storage

Utiliser la Google Cloud CLI pour copier le fichier JAR dans un bucket Cloud Storage bucket dans votre projet

Lorsque vous transmettez des noms de buckets à la Google Cloud CLI, veillez à n'utiliser spécifiez le nom du bucket après le préfixe gs://. Par exemple : si un projet contient un nom de bucket "mon-nom-de-bucket-le-plus-unique" bucket, comme indiqué dans suivi Navigateur Storage dans la console Google Cloud capture d'écran <ph type="x-smartling-placeholder">

</ph>

la commande suivante permet de lister le contenu de ce bucket:

gcloud storage ls gs://my-most-unique-bucket-name

$ gcloud storage cp HelloWorld.jar gs://<bucket-name>/
Copying file://HelloWorld.jar [Content-Type=application/java-archive]...
Uploading   gs://bucket-name/HelloWorld.jar:         1.46 KiB/1.46 KiB

Envoyer un fichier JAR à un job Spark Dataproc

Utilisez la console Google Cloud pour envoyer le fichier JAR à votre tâche Spark Dataproc. Remplissez les champs de la page Envoyer une tâche comme suit:
- Cluster : sélectionnez le nom de votre cluster dans la liste.
- Job type (Type de tâche) : Spark.
- Main class or jar (Classe principale ou fichier JAR) : indiquez le chemin de l'URI Cloud Storage à votre fichier JAR HelloWorld (gs://your-bucket-name/HelloWorld.jar).
  
  Si votre fichier jar n'inclut pas de fichier manifeste spécifie le point d'entrée de votre code ("Main-Class: HelloWorld"), "Classe principale ou fichier JAR" doit indiquer le nom de votre La classe principale ("HelloWorld") et vous devez remplir la "Fichiers JAR" avec le chemin d'accès à l'URI de votre fichier JAR (gs://your-bucket-name/HelloWorld.jar).
Cliquez sur Envoyer pour démarrer la tâche. Une fois le job démarré, il est ajouté liste.
Cliquez sur l'ID de la tâche pour ouvrir la page Jobs (Tâches) qui affiche les résultats du pilote de la tâche.

Écrire et exécuter du code Spark Scala à l'aide du REPL `spark-shell` du cluster

Vous pouvez développer des applications Scala directement sur votre cluster Dataproc. Hadoop et Spark sont préinstallés sur les clusters Dataproc et configurés avec l'API Cloud Storage qui permet à votre code de lire et d'écrire des données directement depuis et vers Cloud Storage.

Cet exemple vous montre comment vous connecter en SSH au nœud maître de cluster Dataproc de votre projet, puis comment utiliser le shell-spark REPL pour créer et exécuter une application MapReduce Scala "wordcount".

Se connecter en SSH au nœud maître du cluster Dataproc
1. Accédez à l'onglet Clusters Dataproc de la console Google Cloud, puis cliquez sur le nom cluster.
2. Sur la page des détails du cluster, sélectionnez l'onglet Instances de VM, puis cliquez sur le bouton Sélection SSH qui s'affiche à droite de la ligne du nom de votre cluster.
  
  Une fenêtre de navigateur s'ouvre dans votre répertoire d'accueil sur le nœud maître.

Lancez spark-shell.

$ spark-shell
...
Using Scala version ...
Type in expressions to have them evaluated.
Type :help for more information.
...
Spark context available as sc.
...
SQL context available as sqlContext.
scala>

Créez un ensemble de données distribué résilient (RDD, Resilient Distributed Dataset) à partir d'un extrait d'une œuvre de Shakespeare situé dans un bucket Cloud Storage public.
Extrait de texte sur Shakespeare:
```
What's in a name? That which we call a rose
By any other name would smell as sweet.
```
```
scala> val text_file = sc.textFile("gs://pub/shakespeare/rose.txt")
```

Exécutez une commande MapReduce "WordCount" sur le texte, puis affichez le résultat wordcounts.

scala> val wordCounts = text_file.flatMap(line => line.split(" ")).map(word =>
(word, 1)).reduceByKey((a, b) => a + b)
scala> wordCounts.collect
... Array((call,1), (What's,1), (sweet.,1), (we,1), (as,1), (name?,1), (any,1), (other,1),
(rose,1), (smell,1), (name,1), (a,2), (would,1), (in,1), (which,1), (That,1), (By,1))

Enregistrez les valeurs de <bucket-name>/wordcounts-out dans Cloud Storage, puis quittez scala-shell.
```
scala> wordCounts.saveAsTextFile("gs://<bucket-name>/wordcounts-out/")
scala> exit
```

Utiliser la gcloud CLI pour répertorier les fichiers de sortie et afficher leur contenu

$ gcloud storage ls gs://bucket-name/wordcounts-out/
gs://spark-scala-demo-bucket/wordcounts-out/
gs://spark-scala-demo-bucket/wordcounts-out/_SUCCESS
gs://spark-scala-demo-bucket/wordcounts-out/part-00000
gs://spark-scala-demo-bucket/wordcounts-out/part-00001

Vérifiez le contenu de gs://<bucket-name>/wordcounts-out/part-00000.

$ gcloud storage cat gs://bucket-name/wordcounts-out/part-00000
(call,1)
(What's,1)
(sweet.,1)
(we,1)
(as,1)
(name?,1)
(any,1)
(other,1)

Exécuter un exemple de code pré-installé

Le nœud maître Dataproc contient des fichiers JAR exécutables avec des exemples Apache Hadoop et Spark standards.

Type de fichier JAR	`Master node /usr/lib/ location`	Source GitHub	Documents Apache
Hadoop	`hadoop-mapreduce/hadoop-mapreduce-examples.jar`	lien source	Tutoriel MapReduce
Spark	`spark/lib/spark-examples.jar`	lien source	Exemples Spark

Envoyer des exemples à votre cluster à partir de la ligne de commande

Vous pouvez envoyer des exemples à partir de votre machine de développement locale à l'aide de l'outil de ligne de commande gcloud de Google Cloud CLI (consultez la section Utiliser la console Google Cloud pour envoyer des tâches à partir de la console Google Cloud).

Exemple d'application "WordCount" Hadoop

gcloud dataproc jobs submit hadoop --cluster=cluster-name \
    --region=region \
    --jars=file:///usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar \
    --class=org.apache.hadoop.examples.WordCount \
    -- URI of input file URI of output file

Exemple d'application "WordCount" Spark

gcloud dataproc jobs submit spark --cluster=cluster-name \
    --region=region \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.JavaWordCount \
    -- URI of input file

Arrêter votre cluster

Pour éviter les frais récurrents, arrêtez votre cluster et supprimez les ressources Cloud Storage (bucket et fichiers Cloud Storage) utilisées pour ce tutoriel.

Pour arrêter un cluster :

gcloud dataproc clusters delete cluster-name \
    --region=region

Pour supprimer le fichier JAR de Cloud Storage :

gcloud storage rm gs://bucket-name/HelloWorld.jar

Vous pouvez supprimer un bucket, ainsi que l'ensemble des dossiers et fichiers qu'il contient, à l'aide de la commande suivante :

gcloud storage rm gs://bucket-name/ --recursive

Étape suivante

Consultez l'article Gérer les dépendances Java pour les applications Apache Spark sur Dataproc.
Consultez Conseils pour régler des tâches Spark.