Creación y ejecución de JARs de Scala y Java en computación sin servidor

Un archivo de Java (JAR) empaqueta código Java o Scala en un único archivo. En esta página se muestra cómo crear un archivo JAR con código spark e implementarlo como trabajo de Lakeflow en un proceso sin servidor.

Requisitos

El entorno de desarrollo local debe tener lo siguiente:

• sbt 1.11.7 o superior (para Scala JAR)
• Maven 3.9.0 o posterior (para JAR de Java)
• Versiones de JDK, Scala y Databricks Connect que coinciden con el entorno sin servidor (en este ejemplo se usa JDK 17, Scala 2.13.16 y Databricks Connect 17.3.2)

Paso 1. Compilación de un archivo JAR

Scala

1. Ejecute el comando siguiente para crear un proyecto de Scala:

   sbt new scala/scala-seed.g8
   

   Cuando se le solicite, escriba un nombre de proyecto, por ejemplo, my-spark-app.

2. Reemplace el contenido del build.sbt archivo por lo siguiente:

   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. Edite o cree un project/assembly.sbt archivo y agregue esta línea:

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

4. Cree la clase principal en 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. Para compilar el archivo JAR, ejecute el siguiente comando:

   sbt assembly
   

Java

1. Ejecute los siguientes comandos para crear una estructura de proyecto de Maven:

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

2. Cree un pom.xml archivo en la raíz del proyecto con el siguiente contenido:

   <?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. Cree la clase principal en 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. Para compilar el archivo JAR, ejecute el siguiente comando:

   mvn clean package
   

   El ARCHIVO JAR compilado se encuentra en la target/ carpeta como my-spark-app-1.0-SNAPSHOT.jar.

Paso 2. Crear un trabajo para ejecutar el archivo JAR

1. En el área de trabajo, haga clic en Trabajos y canalizaciones en la barra lateral.

2. Haga clic en Crear y, a continuación, en Trabajo.

3. Haga clic en el icono jar para configurar la primera tarea. Si el icono jar no está disponible, haga clic en Agregar otro tipo de tarea y busque JAR.

4. Opcionalmente, reemplace el nombre del trabajo, que tiene New Job <date-time>como valor predeterminado , por el nombre del trabajo.

5. En Nombre de tarea, escriba un nombre para la tarea, por ejemplo JAR_example.

6. Si es necesario, seleccione JAR en el menú desplegable Tipo .

7. En Clase main, escriba el paquete y la clase del archivo JAR. Si ha seguido el ejemplo anterior, escriba com.examples.SparkJar.

8. En Proceso, seleccione Sin servidor.

9. Configure el entorno sin servidor:

   1. Elija un entorno y, a continuación, haga clic en Edite para configurarlo.
   2. Seleccione 4 o superior para la versión del entorno.
   3. Agregue el archivo JAR arrastrando y colocandolo en el selector de archivos, o busque para seleccionarlo desde una ubicación de volumen o área de trabajo del catálogo de Unity.

10. En Parámetros, escriba ["Hello", "World!"] para este ejemplo.

11. Haga clic en Create task (Crear tarea).

Paso 3: Ejecutar el trabajo y ver los detalles de ejecución del trabajo

Haga clic en para ejecutar el flujo de trabajo. Para ver los detalles de la ejecución, haga clic en Ver ejecución en el menú emergente Ejecución desencadenada o haga clic en el vínculo de la columna Hora de inicio de la ejecución en la vista de ejecuciones de trabajos.

Cuando se completa la ejecución, la salida aparece en el panel Salida , incluidos los argumentos pasados a la tarea.

Pasos siguientes

• Para obtener más información sobre las tareas jar, consulte Tarea JAR para trabajos.
• Para más información sobre cómo crear un archivo JAR compatible, consulte Creación de un archivo JAR compatible con Azure Databricks.
• Para más información sobre cómo crear y ejecutar trabajos, consulte Trabajos de Lakeflow.