Questa pagina è stata tradotta dall'API Cloud Translation.

Scrivi ed esegui job Spark Scala su Dataproc

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

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

Questo tutorial spiega anche come:

scrivi ed esegui un job di MapReduce di Spark Scala "WordCount" direttamente su un cluster Dataproc utilizzando REPL spark-shell
eseguire 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 in locale

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
Usa SBT

Utilizza Scala

Scarica i programmi 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 per l'installazione di Scala. Ad esempio:
```
export SCALA_HOME=/usr/local/share/scala
export PATH=$PATH:$SCALA_HOME/
```

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

Usa 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" (consulta la sezione Modifica degli artefatti predefiniti)
```
echo \
'artifactName := { (sv: ScalaVersion, module: ModuleID, artifact: Artifact) =>
"HelloWorld.jar" }' > \
build.sbt
```

Avvia SBT ed esegui 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 ...

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

Crea un jar

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

Crea un jar con SBT

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

Crea manualmente un jar

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

Copia jar in Cloud Storage

Utilizza il comando gsutil per copiare il jar in un bucket Cloud Storage nel tuo progetto

Quando passi i nomi dei bucket a gsutil, 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 nel seguente screenshot del browser Storage della console Google Cloud,

il seguente comando elenca i contenuti del bucket:

gsutil ls gs://my-most-unique-bucket-name

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

Invia jar a un job Dataproc Spark

Utilizza la console Google Cloud per inviare il file jar al job di Dataproc Spark. Compila i campi della pagina Invia un job come segue:
- Cluster: seleziona il nome del cluster dall'elenco dei cluster
- Tipo di job: Spark
- Classe principale o jar: specifica il percorso dell'URI Cloud Storage del jar HelloWorld (gs://your-bucket-name/HelloWorld.jar).
  
  Se il tuo jar non include un manifest che specifica il punto di ingresso al tuo codice ("Main-Class: HelloWorld"), il campo "Classe principale o jar" 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.

Scrivi ed esegui codice Spark Scala utilizzando il REPL `spark-shell` del cluster

Puoi sviluppare app Scala direttamente sul tuo 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 accedere tramite SSH al nodo master del cluster Dataproc del progetto e utilizzare spark-shell per creare ed eseguire un'applicazione MapReduce del conteggio delle parole Scala.

SSH nel nodo master del cluster Dataproc
1. Vai alla pagina Cluster di Dataproc del 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 che appare a destra nella riga del nome del cluster.
  
  Si apre una finestra del browser nella 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 uno snippet di testo Shakespeare situato in Cloud Storage pubblico

Snippet di testo di 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")

Esegui una riduzione del conteggio delle parole sul testo, quindi visualizza il risultato di 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, quindi esci da scala-shell
```
scala> wordCounts.saveAsTextFile("gs://<bucket-name>/wordcounts-out/")
scala> exit
```

Utilizza gsutil per elencare i file di output e visualizzare i contenuti dei file

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

$ gsutil 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 di un 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	Documentazione di Apache
Hadoop	`hadoop-mapreduce/hadoop-mapreduce-examples.jar`	link di origine	Tutorial MapReduce
Spark	`spark/lib/spark-examples.jar`	link di origine	Esempi di Spark

Inviare esempi al cluster dalla riga di comando

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

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

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

Arresta il cluster

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

Per arrestare un cluster:

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

Per eliminare il file jar di Cloud Storage:

gsutil rm gs://bucket-name/HelloWorld.jar

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

gsutil rm -r gs://bucket-name/