Tworzenie i uruchamianie środowisk Scala i Java JAR na bezserwerowych obliczeniach

Archiwum Java (JAR) pakuje kod Java lub Scala w jeden plik. Na tej stronie pokazano, jak utworzyć plik JAR z kodem platformy Spark i wdrożyć go jako zadanie lakeflow na obliczeniach bezserwerowych.

Requirements

Lokalne środowisko programistyczne musi mieć następujące elementy:

• sbt 1.11.7 lub nowszy (dla plików JAR Scali)
• Maven w wersji 3.9.0 lub nowszej (w przypadku środowisk JAVA JAR)
• Wersje JDK, Scala i Databricks Connect pasujące do środowiska bezserwerowego (w tym przykładzie użyto zestawu JDK 17, Scala 2.13.16 i databricks Connect 17.3.2)

Krok 1. Tworzenie pliku JAR

Scala

1. Uruchom następujące polecenie, aby utworzyć projekt Scala:

   sbt new scala/scala-seed.g8
   

   Po wyświetleniu monitu wprowadź nazwę projektu, na przykład my-spark-app.

2. Zastąp zawartość build.sbt pliku następującym kodem:

   scalaVersion := "2.13.16"
   libraryDependencies += "com.databricks" %% "databricks-connect" % "17.3.+"
   // other dependencies go here...
   
   // to run with new jvm options, a fork is required otherwise it uses same options as sbt process
   fork := true
   javaOptions += "--add-opens=java.base/java.nio=ALL-UNNAMED"
   

3. Edytuj lub utwórz project/assembly.sbt plik i dodaj następujący wiersz:

   addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.1")
   

4. Utwórz klasę główną w pliku src/main/scala/example/DatabricksExample.scala:

   package com.examples
   
   import org.apache.spark.sql.SparkSession
   
   object SparkJar {
     def main(args: Array[String]): Unit = {
       val spark = SparkSession.builder().getOrCreate()
   
       // Prints the arguments to the class, which
       // are job parameters when run as a job:
       println(args.mkString(", "))
   
       // Shows using spark:
       println(spark.version)
       println(spark.range(10).limit(3).collect().mkString(" "))
     }
   }
   

5. Aby skompilować plik JAR, uruchom następujące polecenie:

   sbt assembly
   

Java

1. Uruchom następujące polecenia, aby utworzyć strukturę projektu Maven:

   # Create all directories at once
   mkdir -p my-spark-app/src/main/java/com/examples
   
   cd my-spark-app
   

2. pom.xml Utwórz plik w katalogu głównym projektu z następującą zawartością:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
            http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
     <groupId>com.examples</groupId>
     <artifactId>my-spark-app</artifactId>
     <version>1.0-SNAPSHOT</version>
   
     <properties>
       <maven.compiler.source>17</maven.compiler.source>
       <maven.compiler.target>17</maven.compiler.target>
       <scala.binary.version>2.13</scala.binary.version>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
   
     <dependencies>
       <!-- Databricks Connect for Spark -->
       <dependency>
         <groupId>com.databricks</groupId>
         <artifactId>databricks-connect_${scala.binary.version}</artifactId>
         <version>17.3.2</version>
       </dependency>
     </dependencies>
   
     <build>
       <plugins>
         <!-- Maven Shade Plugin - Creates fat JAR with all dependencies -->
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-shade-plugin</artifactId>
           <version>3.6.1</version>
           <executions>
             <execution>
               <phase>package</phase>
               <goals>
                 <goal>shade</goal>
               </goals>
               <configuration>
                 <transformers>
                   <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                     <mainClass>com.examples.SparkJar</mainClass>
                   </transformer>
                 </transformers>
               </configuration>
             </execution>
           </executions>
         </plugin>
       </plugins>
     </build>
   </project>
   

3. Utwórz klasę główną w pliku src/main/java/com/examples/SparkJar.java:

   package com.examples;
   
   import org.apache.spark.sql.SparkSession;
   import java.util.stream.Collectors;
   
   public class SparkJar {
     public static void main(String[] args) {
       SparkSession spark = SparkSession.builder().getOrCreate();
   
       // Prints the arguments to the class, which
       // are job parameters when run as a job:
       System.out.println(String.join(", ", args));
   
       // Shows using spark:
       System.out.println(spark.version());
       System.out.println(
         spark.range(10).limit(3).collectAsList().stream()
           .map(Object::toString)
           .collect(Collectors.joining(" "))
       );
     }
   }
   

4. Aby skompilować plik JAR, uruchom następujące polecenie:

   mvn clean package
   

   Skompilowany plik JAR znajduje się w folderze target/ jako my-spark-app-1.0-SNAPSHOT.jar.

Krok 2. Utwórz zadanie do uruchomienia pliku JAR

1. W obszarze roboczym kliknij Zadania i rury na pasku bocznym.

2. Kliknij pozycję Utwórz, a następnie pozycję Zadanie.

3. Kliknij kafelek JAR , aby skonfigurować pierwsze zadanie. Jeśli kafelek JAR jest niedostępny, kliknij pozycję Dodaj inny typ zadania i wyszukaj plik JAR.

4. Opcjonalnie zastąp nazwę zadania, która domyślnie ma wartość New Job <date-time>, swoją własną nazwą zadania.

5. W polu Nazwa zadania wprowadź nazwę zadania, na przykład JAR_example.

6. W razie potrzeby wybierz pozycję JAR z menu rozwijanego Typ .

7. W polu Klasa Main wprowadź pakiet i klasę JAR. Jeśli wcześniej wykonałeś przykład, wprowadź com.examples.SparkJar.

8. W obszarze Obliczenia wybierz pozycję Bezserwerowe.

9. Skonfiguruj środowisko bezserwerowe:

   1. Wybierz środowisko, a następnie kliknij Edytuj , aby go skonfigurować.
   2. Wybierz wartość 4 lub nowszą dla wersji Środowisko.
   3. Dodaj plik JAR, przeciągając i upuszczając go do selektora plików, lub przeglądaj i wybierz z woluminu Unity Catalog lub lokalizacji obszaru roboczego.

10. W przypadku parametrów , w tym przykładzie wprowadź ["Hello", "World!"].

11. Kliknij pozycję Utwórz zadanie.

Krok 3. Uruchamianie zadania i wyświetlanie szczegółów przebiegu zadania

Kliknij , aby uruchomić przepływ pracy. Aby wyświetlić szczegóły przebiegu, kliknij Widok przebiegu w oknie podręcznym Wyzwolony przebieg lub kliknij link w kolumnie Godzina rozpoczęcia dla przebiegu w widoku Uruchomienia zadania.

Po zakończeniu przebiegu dane wyjściowe pojawią się w okienku Dane wyjściowe , w tym argumenty przekazane do zadania.

Następne kroki

• Aby dowiedzieć się więcej o zadaniach JAR, zobacz jar task for jobs (Zadanie JAR dla zadań).
• Aby dowiedzieć się więcej na temat tworzenia zgodnego pliku JAR, zobacz Create an Azure Databricks compatible JAR (Tworzenie zgodnego pliku JAR usługi Azure Databricks).
• Aby dowiedzieć się więcej na temat tworzenia i uruchamiania zadań, zobacz Zadania Lakeflow.