Esta página foi traduzida pela API Cloud Translation.

Gravar e executar jobs do Spark Scala no Dataproc

Este tutorial ilustra maneiras diferentes de criar e enviar um job do Spark Scala a um cluster do Dataproc, incluindo:

gravar e compilar um app "Hello World" em Spark Scala em uma máquina local a partir da linha de comando usando o Scala REPL (Read-Evaluate-Print-Loop ou interpretador interativo) ou a ferramenta de build SBT
empacotar classes Scala compiladas em um arquivo jar com um manifesto;
enviar o jar do Scala a um job Spark que seja executado no cluster do Dataproc;
examinar o resultado do job do Scala no console Google Cloud .

Este tutorial também mostra como:

gravar e executar um job mapreduce "WordCount" do Spark Scala diretamente em um cluster do Dataproc usando o REPL spark-shell;
executar exemplos pré-instalados do Apache Spark e do Hadoop em um cluster.

Configure um projeto do Google Cloud Platform

Faça o seguinte, se ainda não tiver feito:

Escrever e compilar código em Scala localmente

Como um exercício simples para este tutorial, escreva um aplicativo "Hello World" em Scala usando o Scala REPL ou a interface de linha de comando SBT localmente na máquina de desenvolvimento.

Usar o Scala

Faça download dos binários do Scala da página de instalação do Scala.
Desempacote o arquivo, defina a variável de ambiente SCALA_HOME e adicione-a ao caminho, conforme mostrado nas instruções de instalação do Scala. Exemplo:
```
 export SCALA_HOME=/usr/local/share/scala export PATH=$PATH:$SCALA_HOME/ 
```

Inicie o Scala REPL.

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

Copie e cole o código HelloWorld no Scala REPL.

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

Salve HelloWorld.scala e saia do REPL.

 scala> :save HelloWorld.scala scala> :q

Compile com scalac.
```
 $ scalac HelloWorld.scala 
```

Liste os arquivos .class compilados.

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

Usar o SBT

Faça o download do SBT.

Crie um projeto "HelloWorld", como mostrado abaixo.

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

Crie um arquivo de configuração sbt.build para definir o artifactName (o nome do arquivo jar que você vai gerar abaixo) como "HelloWorld.jar" (consulte Como modificar os artefatos padrão).
```
 echo \ 'artifactName := { (sv: ScalaVersion, module: ModuleID, artifact: Artifact) => "HelloWorld.jar" }' > \ build.sbt 
```

Inicie o SBT e execute o código.

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

Empacote o código em um arquivo jar com um manifesto que especifique o ponto de entrada de classe principal (HelloWorld) e depois saia.
```
 > package ... Packaging .../hello/target/scala-.../HelloWorld.jar ... ... Done packaging. [success] Total time: ... > exit 
```

Criar um jar

Crie um arquivo jar com SBT ou usando o comando jar.

Criar um jar com o SBT

O comando package do SBT cria um arquivo jar (consulte Usar o SBT).

Criar um jar manualmente

Altere o diretório (cd) no diretório que contém os arquivos HelloWorld*.class compilados e execute o seguinte comando para empacotar os arquivos de classe em um jar com um manifesto que especifique o ponto de entrada de classe principal (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%) 
```
Descompactar e examinar o manifesto do jar (MANIFEST.MF) mostra que ele lista o ponto de entrada de classe principal HelloWorld:
```
 Manifest-Version: ... Created-By: ... Main-Class: HelloWorld 
```

Copiar o jar no Cloud Storage

Use a Google Cloud CLI para copiar o jar para um bucket do Cloud Storage no projeto.

Ao passar os nomes dos buckets para a Google Cloud CLI, especifique somente o nome do bucket após o prefixo gs://. Por exemplo, se um projeto contiver um bucket "my-most-unique-bucket-name", como mostrado na seguinte captura de tela do navegador do Storage do consoleGoogle Cloud ,

o comando a seguir listará o conteúdo desse 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

Enviar o jar a um job Spark do Dataproc

Use o consoleGoogle Cloud para enviar o arquivo jar ao job Spark do Dataproc. Preencha os campos na página Enviar um job da seguinte maneira:
- Cluster: selecione o nome do cluster na lista de clusters.
- Tipo de job: Spark.
- Classe ou jar principal: especifique o caminho do URI do Cloud Storage para o jar HelloWorld (gs://your-bucket-name/HelloWorld.jar).
  
  Se o arquivo JAR não incluir um manifesto que especifique o ponto de entrada do código ("Main-Class: HelloWorld"), o campo "Classe principal ou jar" vai indicar o nome da classe principal ("HelloWorld"), e você vai preencher o campo "Arquivos jar" com o caminho do URI para o arquivo JAR (gs://your-bucket-name/HelloWorld.jar).
Clique em Enviar para iniciar o job. Ao ser iniciado, o job entra na lista de jobs.
Clique no ID do job para abrir a página Jobs, em que você pode conferir a saída do driver do job.

Gravar e executar o código do Spark Scala usando o REPL `spark-shell`

Talvez convenha desenvolver apps em Scala diretamente no cluster do Dataproc. O Hadoop e o Spark são pré-instalados em clusters do Dataproc e configurados com o conector do Cloud Storage, que permite que seu código leia e grave dados diretamente no Cloud Storage.

Este exemplo mostra como incorporar o SSH ao nó mestre do cluster do Dataproc do projeto e usar o REPL spark-shell para criar e executar um aplicativo MapReduce de contagem de palavras em Scala.

Conecte-se por SSH ao nó mestre do cluster do Dataproc
1. Acesse a página Clusters do Dataproc no Google Cloud console e clique no nome do cluster.
2. Na página de detalhes do cluster, selecione a guia Instâncias de VM e clique na seleção SSH que aparece à direita da linha do nome do cluster.
  
  Uma janela de navegador é aberta no diretório principal do node mestre.

Inicie o 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>

Crie um RDD (conjunto de dados distribuído resiliente) a partir de um fragmento de texto de Shakespeare localizado no Cloud Storage público.
Snippet de texto de 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") 
```

Execute um mapreduce de contagem de palavras no texto e exiba o resultado 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))

Salve as contagens em <bucket-name>/wordcounts-out no Cloud Storage e saia do scala-shell.
```
 scala> wordCounts.saveAsTextFile("gs://<bucket-name>/wordcounts-out/") scala> exit 
```

Use a CLI gcloud para listar os arquivos de saída e mostrar o conteúdo deles.

 $ 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

Verifique o conteúdo 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)

Execução de código de exemplo pré-instalado

O nó mestre do Dataproc contém arquivos jar executáveis com exemplos padrão do Apache Hadoop e do Spark.

Tipo de jar	`Master node /usr/lib/ location`	Fonte no GitHub	Documentos do Apache
Hadoop	`hadoop-mapreduce/hadoop-mapreduce-examples.jar`	link da fonte	Tutorial do MapReduce
Spark	`spark/lib/spark-examples.jar`	link da fonte	Exemplos do Spark

Envio de exemplos ao cluster pela linha de comando

Os exemplos podem ser enviados da sua máquina de desenvolvimento local usando a ferramenta de linha de comando gcloud da Google Cloud CLI (consulte Como usar o console Google Cloud para enviar jobs do console Google Cloud ).

Exemplo de WordCount do 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

Exemplo de WordCount do 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

Encerrar o cluster

Para evitar cobranças contínuas, encerre o cluster e exclua os recursos do Cloud Storage (bucket e arquivos) usados neste tutorial.

Para encerrar um cluster:

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

Para excluir o arquivo jar do Cloud Storage:

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

Exclua um bucket e todos os respectivos arquivos e pastas usando o seguinte comando:

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