Spark Scala-Jobs in Dataproc schreiben und ausführen

In dieser Anleitung werden verschiedene Möglichkeiten zum Erstellen und Senden eines Spark-Scala-Jobs an einen Dataproc-Cluster erläutert:

  • Spark Scala-Anwendung und „Hello World“-Anwendung auf der lokalen Maschine über die Befehlszeile mit Scala REPL (Read-Evaluate-Print-Loop oder interaktiver Interpreter) oder dem SBT-Build-Tool schreiben und kompilieren
  • Kompilierte Scala-Klassen in eine JAR-Datei mit einem Manifest kompilieren
  • Scala-JAR-Datei an einen Spark-Job senden, der in Ihrem Dataproc-Cluster ausgeführt wird
  • Scala-Jobausgabe in der Google Cloud Console prüfen

In dieser Anleitung lernen Sie außerdem Folgendes:

  • Spark-Scala-Job schreiben und ausführen, u. h. MapReduce-Job direkt in einem Dataproc-Cluster mit dem REPL spark-shell ausführen

  • Vorinstallierte Apache Spark- und Hadoop-Beispiele auf einem Cluster ausführen

Google Cloud Platform-Projekt einrichten

Führen Sie ggf. die folgenden Aufgaben aus:

  1. Projekt einrichten
  2. Cloud Storage-Bucket erstellen
  3. Dataproc-Cluster erstellen

Scala-Code lokal schreiben und kompilieren

Als einfache Übung für diese Anleitung schreiben Sie eine „Hello World“-Scala-App über die Scala REPL oder die SBT-Befehlszeile lokal auf Ihrem Entwicklungscomputer.

Scala

  1. Laden Sie die Scala-Binärdateien von der Seite Scala-Installation herunter.
  2. Entpacken Sie die Datei, legen Sie die Umgebungsvariable SCALA_HOME fest und fügen Sie die Umgebungsvariable dem Pfad hinzu. Folgen Sie dazu der Anleitung für die Scala-Installation. Beispiel:

    export SCALA_HOME=/usr/local/share/scala
    export PATH=$PATH:$SCALA_HOME/
    

  3. Starten Sie die Scala-REPL

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

  4. HelloWorld-Code kopieren und in die Scala-REPL einfügen

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

  5. HelloWorld.scala speichern und REPL verlassen

    scala> :save HelloWorld.scala
    scala> :q
    

  6. Mit scalac kompilieren

    $ scalac HelloWorld.scala
    

  7. Liste der kompilierten .class-Dateien auflisten

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

SBT verwenden

  1. SBT herunterladen

  2. Erstellen Sie ein "HelloWorld"-Projekt (siehe unten)

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

  3. Erstellen Sie eine sbt.build-Konfigurationsdatei, um artifactName (den Namen der unten generierten JAR-Datei) auf "HelloWorld.jar" festzulegen (siehe Standardartefakte ändern).

    echo \
    'artifactName := { (sv: ScalaVersion, module: ModuleID, artifact: Artifact) =>
    "HelloWorld.jar" }' > \
    build.sbt
    

  4. Starten Sie SBT und führen Sie den Code aus

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

  5. Verpacken Sie den Code in eine JAR-Datei mit einem Manifest, das den Haupteinstiegspunkt für die Klasse angibt (HelloWorld), und beenden Sie ihn dann

    > package
    ... Packaging .../hello/target/scala-.../HelloWorld.jar ...
    ... Done packaging.
    [success] Total time: ...
    > exit
    

JAR-Datei erstellen

Erstelle eine JAR-Datei mit SBT oder mit dem Befehl jar.

JAR-Datei mit SBT erstellen

Mit dem SBT-Befehl package wird eine JAR-Datei erstellt (siehe SBT verwenden).

JAR-Datei manuell erstellen

  1. Ändern Sie das Verzeichnis (cd) in das Verzeichnis, das die kompilierten HelloWorld*.class-Dateien enthält. Führen Sie dann den folgenden Befehl aus, um die Klassendateien mit einem Manifest zu verpacken, das den Haupteinstiegspunkt für die Klasse angibt (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%)
    

JAR-Datei in Cloud Storage kopieren

  1. Verwenden Sie den gsutil-Befehl, um die JAR-Datei in einen Cloud Storage-Bucket in Ihrem Projekt zu kopieren.
$ 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

JAR-Datei an einen Dataproc Spark-Job senden

  1. Verwenden Sie die Google Cloud Console, um die JAR-Datei an Ihren Dataproc Spark-Job zu senden. Füllen Sie die Felder auf der Seite Job senden so aus:

    • Cluster: Wählen Sie den Namen des Clusters aus der Clusterliste aus
    • Jobtyp: Spark
    • Hauptklasse oder JAR-Datei: Geben Sie den Cloud Storage-URI-Pfad zu Ihrer HelloWorld-JAR-Datei (gs://your-bucket-name/HelloWorld.jar) an.

      Wenn Ihre JAR-Datei kein Manifest enthält, das den Einstiegspunkt zu Ihrem Code angibt (&Hauptklasse: HelloWorld & Quot;), sollte &&t

  2. Klicken Sie auf Senden, um den Job zu starten. Nach dem Start wird der Job zur Jobliste hinzugefügt.

  3. Klicken Sie auf die Job-ID, um die Seite Jobs zu öffnen, auf der Sie die Treiberausgabe des Jobs ansehen können.

Spark Scala-Code mit der REPL spark-shell des Clusters schreiben und ausführen

Sie sollten Scala-Anwendungen direkt in Ihrem Dataproc-Cluster entwickeln. Hadoop und Spark sind auf Dataproc-Clustern vorinstalliert. Sie werden mit dem Cloud Storage-Connector konfiguriert. Damit kann der Code Daten direkt aus Cloud Storage lesen und in Cloud Storage schreiben.

In diesem Beispiel wird gezeigt, wie Sie eine SSH-Verbindung zum Master-Knoten des Dataproc-Clusters Ihres Projekts herstellen und dann das REPL-Tool spark-shell verwenden, um eine Scala-WordCount-Anwendung zur Zahl der Anwendung zu erstellen und auszuführen.

  1. Stellen Sie eine SSH-Verbindung zum Master-Knoten des Dataproc-Clusters her

    1. Gehen Sie in der Google Cloud Console zur Seite „Cluster Cluster und klicken Sie auf den Namen Ihres Clusters.

    2. Wählen Sie auf der Clusterdetailseite den Tab VM-Instanzen aus und klicken Sie dann auf die SSH-Auswahl, die rechts neben der Namenszeile des Clusters angezeigt wird.

      Im Stammverzeichnis des Master-Knotens wird ein Browserfenster angezeigt.

  2. spark-shell starten

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

  3. Erstellen Sie ein RDD (Resilient Distributed Dataset) aus einem Shakespeare-Text-Snippet, das sich im öffentlichen Cloud Storage befindet.

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

  4. Führe für den Text eine Mapcount-Reduzierung aus und zeig dann das wordcounts-Ergebnis an

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

  5. Speichern Sie die Anzahl in <bucket-name>/wordcounts-out in Cloud Storage und beenden Sie dann scala-shell

    scala> wordCounts.saveAsTextFile("gs://<bucket-name>/wordcounts-out/")
    scala> exit
    

  6. Verwenden Sie gsutil, um die Ausgabedateien aufzulisten und die Dateiinhalte anzuzeigen

    $ 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
    

  7. gs://<bucket-name>/wordcounts-out/part-00000-Inhalt prüfen

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

Vorinstallierten Beispielcode ausführen

Der Dataproc-Masterknoten enthält auszuführende JAR-Dateien mit Apache Apache Standard- und Spark-Standardbeispielen.

JAR-Typ Master node /usr/lib/ location GitHub-Quelle Apache-Dokumente
Hadoop hadoop-mapreduce/hadoop-mapreduce-examples.jar Quelllink MapReduce-Anleitung
Spark spark/lib/spark-examples.jar Quelllink Spark-Beispiele

Beispiele über die Befehlszeile an Cluster senden

Beispiele können von Ihrem lokalen Entwicklungscomputer mit dem Befehlszeilentool gcloud von Google Cloud CLI gesendet werden (siehe Google Cloud Console verwenden, um Jobs aus der Google Cloud Console einzureichen.

Beispiel für 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

Beispiel für Spark WordCount

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

Cluster herunterfahren

Um laufende Gebühren zu vermeiden, fahren Sie den Cluster herunter und löschen Sie die für diese Anleitung verwendeten Cloud Storage-Ressourcen (Cloud Storage-Bucket und -Dateien).

So fahren Sie den Cluster herunter:

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

So löschen Sie die Cloud Storage-JAR-Datei:

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

Mit dem folgenden Befehl können Sie einen Bucket sowie alle zugehörigen Ordner und Dateien löschen:

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

Weitere Informationen