Questa pagina è stata tradotta dall'API Cloud Translation.

Scrivere ed eseguire job Spark Scala su Dataproc

Questo tutorial illustra diversi modi per creare e inviare un job Spark Scala a un cluster Dataproc, tra cui:

scrivere e compilare un'app "Hello World" Spark Scala su una macchina locale dalla riga di comando utilizzando lo strumento Scala REPL (Read-Evaluate-Print-Loop o interprete interattivo) o lo strumento di compilazione SBT
pacchetto di classi Scala compilate in un file JAR con un manifest
invia il file JAR Scala a un job Spark eseguito sul cluster Dataproc
esaminare l'output del job Scala dalla console Google Cloud

Questo tutorial mostra anche come:

scrivi ed esegui un job MapReduce "WordCount" Spark Scala direttamente su un cluster Dataproc utilizzando la REPL spark-shell
esegui esempi preinstallati di Apache Spark e Hadoop su un cluster

Configura un progetto Google Cloud Platform

Se non l'hai ancora fatto:

Scrivere e compilare codice Scala localmente

Come semplice esercizio per questo tutorial, scrivi un'app Scala "Hello World" utilizzando Scala REPL o l'interfaccia a riga di comando SBT localmente sulla tua macchina di sviluppo.

Utilizzare Scala
Utilizzare SBT

Utilizzare Scala

Scarica i file binari di Scala dalla pagina Installazione di Scala
Decomprimi il file, imposta la variabile di ambiente SCALA_HOME e aggiungila al percorso, come mostrato nelle istruzioni di installazione di Scala. Ad esempio:
```
export SCALA_HOME=/usr/local/share/scala
export PATH=$PATH:$SCALA_HOME/
```

Avvia il REPL di Scala

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

Copia e incolla il codice HelloWorld in Scala REPL

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

Salva HelloWorld.scala ed esci da REPL

scala> :save HelloWorld.scala
scala> :q

Compila con scalac
```
$ scalac HelloWorld.scala
```

Elenca i file .class compilati

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

Utilizzare SBT

Scarica SBT

Crea un progetto "HelloWorld", come mostrato di seguito

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

Crea un file di configurazione sbt.build per impostare artifactName (il nome del file JAR che genererai di seguito) su "HelloWorld.jar" (vedi Modifica degli artefatti predefiniti)
```
echo \
'artifactName := { (sv: ScalaVersion, module: ModuleID, artifact: Artifact) =>
"HelloWorld.jar" }' > \
build.sbt
```

Avvia SBT ed esegui il codice

$ 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 ...

Pacchettizza il codice in un file JAR con un manifest che specifica il punto di ingresso della classe principale (HelloWorld), poi esci
```
> package
... Packaging .../hello/target/scala-.../HelloWorld.jar ...
... Done packaging.
[success] Total time: ...
> exit
```

Creare un barattolo

Crea un file JAR con SBT o utilizzando il comando jar.

Crea un file JAR con SBT

Il comando SBT package crea un file JAR (vedi Utilizzare SBT).

Creare un barattolo manualmente

Cambia directory (cd) nella directory che contiene i file HelloWorld*.class compilati, quindi esegui il comando seguente per comprimere i file della classe in un file jar con un manifest che specifica il punto di ingresso della 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'estrazione e l'esame del manifest del file JAR (MANIFEST.MF) mostrano che elenca il punto di ingresso Main-Class HelloWorld:
```
Manifest-Version: ...
Created-By: ...
Main-Class: HelloWorld
```

Copia il file JAR in Cloud Storage

Utilizza Google Cloud CLI per copiare il file JAR in un bucket Cloud Storage nel tuo progetto.

Quando passi i nomi dei bucket a Google Cloud CLI, assicurati di specificare solo il nome del bucket dopo il prefisso gs://. Ad esempio, se un progetto contiene un bucket "my-most-unique-bucket-name", come mostrato nello screenshot Google Cloud di Storage Browser della console

il seguente comando elencherà i contenuti del 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

Inviare un file JAR a un job Spark di Dataproc

Utilizza la consoleGoogle Cloud per inviare il file JAR al job Spark Dataproc. Compila i campi nella pagina Invia un job come segue:
- Cluster: seleziona il nome del cluster dall'elenco dei cluster
- Tipo di job: Spark
- Classe o jar principale: specifica il percorso dell'URI Cloud Storage del file jar HelloWorld (gs://your-bucket-name/HelloWorld.jar).
  
  Se il file JAR non include un manifest che specifica il punto di ingresso del codice ("Main-Class: HelloWorld"), il campo "Classe o file JAR principale" deve indicare il nome della classe principale ("HelloWorld") e devi compilare il campo "File JAR" con il percorso URI del file JAR (gs://your-bucket-name/HelloWorld.jar).
Fai clic su Invia per avviare il job. Una volta avviato, il job viene aggiunto all'elenco dei job.
Fai clic sull'ID job per aprire la pagina Job, dove puoi visualizzare l'output del driver del job.

Scrivere ed eseguire codice Spark Scala utilizzando il REPL `spark-shell` del cluster

Potresti voler sviluppare app Scala direttamente sul cluster Dataproc. Hadoop e Spark sono preinstallati sui cluster Dataproc e sono configurati con il connettore Cloud Storage, che consente al codice di leggere e scrivere dati direttamente da e verso Cloud Storage.

Questo esempio mostra come connettersi tramite SSH al nodo master del cluster Dataproc del progetto, quindi utilizzare spark-shell REPL per creare ed eseguire un'applicazione Scala wordcount mapreduce.

Connettiti in SSH al nodo master del cluster Dataproc
1. Vai alla pagina Cluster di Dataproc del tuo progetto nella console Google Cloud , quindi fai clic sul nome del tuo cluster.
2. Nella pagina dei dettagli del cluster, seleziona la scheda Istanze VM, quindi fai clic sulla selezione SSH visualizzata a destra della riga del nome del cluster.
  
  Si apre una finestra del browser nella tua home directory sul nodo master.

Avvia 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>

Crea un RDD (Resilient Distributed Dataset) da un frammento di testo di Shakespeare che si trova in Cloud Storage pubblico

scala> val text_file = sc.textFile("gs://pub/shakespeare/rose.txt")

Esegui un MapReduce di conteggio delle parole sul testo, quindi visualizza il risultato 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))

Salva i conteggi in <bucket-name>/wordcounts-out in Cloud Storage, poi esci da scala-shell.
```
scala> wordCounts.saveAsTextFile("gs://<bucket-name>/wordcounts-out/")
scala> exit
```

Utilizza gcloud CLI per elencare i file di output e visualizzare i contenuti dei file

$ 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

Controlla i contenuti di 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)

Esecuzione del codice di esempio preinstallato

Il nodo master Dataproc contiene file JAR eseguibili con esempi standard di Apache Hadoop e Spark.

Tipo di barattolo	`Master node /usr/lib/ location`	Origine GitHub	Documenti Apache
Hadoop	`hadoop-mapreduce/hadoop-mapreduce-examples.jar`	source link	Tutorial su MapReduce
Spark	`spark/lib/spark-examples.jar`	source link	Esempi di Spark

Invio di esempi al cluster dalla riga di comando

Gli esempi possono essere inviati dalla macchina di sviluppo locale utilizzando lo strumento a riga di comando Google Cloud CLI gcloud (vedi Utilizzo della console per inviare job dalla console Google Cloud ). Google Cloud

Esempio di Hadoop WordCount

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

Esempio di conteggio parole di 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

Arrestare il cluster

Per evitare addebiti continui, arresta il cluster ed elimina le risorse Cloud Storage (bucket e file Cloud Storage) utilizzate per questo tutorial.

Per arrestare un cluster:

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

Per eliminare il file JAR Cloud Storage:

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

Puoi eliminare un bucket e tutte le relative cartelle e i relativi file con il seguente comando:

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