Créez et exécutez des JAR sur un compute serverless

important

Databricks recommande fortement les Declarative Automation Bundles au lieu de créer et de déployer des JARs manuellement, comme décrit sur cette page. Declarative Automation Bundles facilite la création d'un projet à partir d'un Template qui a les versions Scala, JDK et Databricks Connect correctes déjà configurées pour le Serverless, et permet également le déploiement simple du JAR vers le Workspace Databricks. Voir Construire un JAR Scala avec Declarative Automation Bundles.

info

Aperçu

Les Jobs Serverless Scala et Java sont en Public Preview.

Une archive Java (JAR) package le code Java ou Scala en un seul fichier. Créez un JAR avec du code Spark et déployez-le en tant que tâche JAR sur le compute serverless dans un Lakeflow Job.

Exigences

Pour créer un JAR, votre environnement de développement local doit avoir les éléments suivants installés :

sbt 1.11.7 ou supérieur pour les JAR Scala
Maven 3.9.0 ou version ultérieure pour les fichiers JAR Java
Versions de JDK, Scala et Databricks Connect qui correspondent à votre environnement serverless. Consultez Versions des dépendances.

Versions des dépendances

important

Pour s'exécuter sur le compute serverless sans échec, vos versions JAR Scala et JDK doivent correspondre exactement aux versions Scala et JDK d'exécution. Consultez les versions de Databricks Connect.

L'exemple de cette page utilise la version 4 de l'environnement Serverless, cette page crée donc un JAR qui :

Est compilé avec Scala 2.13 ; chaque dépendance utilise le suffixe _2.13.
Est compilé contre JDK 17, version de fichier de classe 61.
Est compilé sur Databricks Connect 17.3, la surface d'API Spark pour le compute Serverless.
Utilise uniquement des Spark API publiques. Il n'utilise pas de RDD et aucun élément interne de Spark. Consultez les Limitations.
Inclut chaque dépendance dans le JAR ou attachée en tant que bibliothèque d'environnement serverless. Voir Gestion des dépendances.

Limitations

Le compute Serverless utilise Spark Connect. Votre JAR s'exécute par rapport à une bibliothèque cliente légère qui expose les Spark API publiques, tandis que le moteur Spark lui-même s'exécute côté serveur. Le code qui contourne l'API publique ne peut pas bénéficier de l'optimisation Catalyst ou de l'accélération Photon, même sur un compute classique. Le code basé sur RDD et dépendant des composants internes est généralement plus lent que le code DataFrame ou SQL équivalent.

Les éléments suivants ne sont pas disponibles :

API RDD (org.apache.spark.rdd.*) et SparkContext / JavaSparkContext. Utilisez SparkSession.builder().getOrCreate() et les opérations de DataFrame/Dataset à la place.
API Spark internes (org.apache.spark.catalyst.*, org.apache.spark.util.*, org.apache.spark.sql.util.*, org.apache.spark.sql.internal.*). Le code qui importe ces APIs échoue avec NoClassDefFoundError. Restructurer vers le Spark API. Si une bibliothèque tierce utilise des éléments internes, vérifiez si elle publie une version compatible avec Spark Connect.
Bibliothèques natives (.so, .dll, JNI). Le compute Serverless ne permet pas l'écriture de bibliothèques natives dans le système de fichiers. Les bibliothèques qui décompressent des binaires natifs au Startup échouent avec UnsatisfiedLinkError. Les scripts d'initialisation ne sont pas une solution de contournement. Utilisez un équivalent Java si l'un est disponible.

Si votre charge de travail exige l'un des éléments ci-dessus, exécutez-la plutôt sur compute standard ou dédié.

Étape 1 : Créer un JAR

Scala
Java

Exécutez la commande suivante pour créer un projet Scala :
Bash
```
sbt new scala/scala-seed.g8
```
Lorsque vous y êtes invité, saisissez un nom de projet, par exemple, my-spark-app.

Ensuite, supprimez les fichiers stub de la source et créez le répertoire de votre source :

Bash
cd my-spark-app
rm src/main/scala/example/Hello.scala
rm src/test/scala/example/HelloSpec.scala
rm project/Dependencies.scala
mkdir -p src/main/scala/com/examples

Remplacez le contenu de votre fichier build.sbt par ce qui suit :

Scala
name := "my-spark-app"

// Set the dependency versions
scalaVersion := "2.13.16"
javacOptions ++= Seq("--release", "17")
scalacOptions ++= Seq("-release", "17")

libraryDependencies += "com.databricks" %% "databricks-connect" % "17.3.2" % "provided"
// Your other dependencies go here. Use %% for Scala libraries so sbt picks the _2.13 artifact.

// Fork a new JVM on run so our javaOptions are applied.
fork := true
javaOptions += "--add-opens=java.base/java.nio=ALL-UNNAMED"

Modifiez ou créez un fichier project/plugins.sbt, et ajoutez cette ligne :
Scala
```
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.1")
```

Créez votre classe principale dans src/main/scala/com/examples/SparkJar.scala:

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(" "))
  }
}

Pour créer votre fichier JAR, exécutez la commande suivante :
Bash
```
sbt assembly
```
Le JAR compilé est créé dans le dossier target/ en tant que my-spark-app-assembly-0.1.0-SNAPSHOT.jar.

Exécutez les commandes suivantes pour créer une structure de projet Maven :
Bash
```
mkdir -p my-spark-app/src/main/java/com/examples
cd my-spark-app
```

Créez un fichier pom.xml dans la racine du projet avec le contenu suivant :

XML
<?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.release>17</maven.compiler.release>
    <scala.binary.version>2.13</scala.binary.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    
    <dependency>
      <groupId>com.databricks</groupId>
      <artifactId>databricks-connect_${scala.binary.version}</artifactId>
      <version>17.3.2</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      
      <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>

Créez votre classe principale dans src/main/java/com/examples/SparkJar.java:

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(" "))
    );
  }
}

Pour créer votre fichier JAR, exécutez la commande suivante :
Bash
```
mvn clean package
```
Le JAR compilé est créé dans le dossier target/ en tant que my-spark-app-1.0-SNAPSHOT.jar.

Gérer les dépendances

Pour rendre une bibliothèque disponible pour votre JAR sur le compute serverless :

Utilisez une bibliothèque fournie : Le compute Serverless inclut Databricks Connect et un ensemble organisé de bibliothèques courantes. Si votre version est compatible, déclarez-la provided dans votre build et ne l'incluez pas dans votre JAR.
Attacher en tant que bibliothèque d'environnement : ajoutez une bibliothèque à votre environnement serverless si elle n'est pas déjà fournie. Utilisez ceci pour les bibliothèques d'exécution uniquement que vous ne souhaitez pas inclure.
Connectez-vous à une base de données externe : pour les sources JDBC, utilisez une connexion JDBC au lieu d'inclure un driver. Les connexions JDBC sont gérées par Unity Catalog. Les informations d’identification, la traçabilité et la gouvernance sont gérées pour vous.

Bibliothèques fournies

Les bibliothèques suivantes sont des dépendances requises et sont disponibles par default sur le compute serverless. Déclarez-les provided dans votre build. L'intégration de vos propres versions de ces bibliothèques Trigger un NoSuchMethodError lors de l'exécution.

remarque

Les versions de bibliothèque listées ci-dessous sont pour la **version 4 de l'environnement serverless**. Pour les bibliothèques installées pour d'autres versions d'environnement, consultez la référence des notes de version de l'environnement serverless.

com.databricks:databricks-connect_2.13, version 17.3.2
org.scala-lang:scala-library_2.13, version 2.13.16
org.scala-lang:scala-reflect_2.13, version 2.13.16
org.slf4j:slf4j-api, version 2.0.10
org.apache.logging.log4j:log4j-api, version 2.20.0
org.apache.logging.log4j:log4j-core, version 2.20.0
org.apache.httpcomponents:httpclient, version 4.5.14
org.apache.httpcomponents:httpcore, version 4.4.16
com.fasterxml.jackson.core:jackson-databind, version 2.15.2
com.fasterxml.jackson.core:jackson-core, version 2.15.2
com.fasterxml.jackson.core:jackson-annotations, version 2.15.2
com.fasterxml.jackson.datatype:jackson-datatype-jsr310, version 2.15.2
com.google.guava:guava, version 32.0.1-jre
commons-io:commons-io, version 2,14,0
org.json4s:json4s-jackson_2.13, version 4.0.7
org.apache.commons:commons-lang3, version 3,14.0
org.apache.commons:commons-configuration2, version 2.11.0
org.apache.commons:commons-text, version 1.12.0
com.databricks:databricks-sdk-java, version 0,52,0
com.databricks:databricks-dbutils-scala_2.13, version 0,1,4

Étape 2 : Créez un job pour exécuter le JAR

Dans votre Workspace, cliquez sur **Tâches et pipelines** dans la barre latérale.
Cliquez sur Créer , puis sur Job .
Cliquez sur la tuile JAR pour configurer la première tâche. Si la vignette JAR n'est pas disponible, cliquez sur Ajouter un autre type de tâche et recherchez JAR .
En option, remplacez le nom du Job, qui est par default New Job <date-time> , par le nom de votre Job.
Dans Nom de la tâche , entrez un nom pour la tâche, par exemple JAR_example.
Si nécessaire, sélectionnez JAR dans le menu déroulant Type .
Pour la classe Main , saisissez le package et la classe de votre JAR. Si vous avez suivi l'exemple précédent, saisissez com.examples.SparkJar.
Pour **Compute**, sélectionnez **Serverless**.
Configurez l'environnement serverless :
1. Sélectionnez un environnement, puis cliquez sur Modifier pour le configurer.
2. Sélectionnez **4** ou une version supérieure pour la **Version de l'environnement**.
3. Ajoutez votre fichier JAR en le faisant glisser dans le sélecteur de fichiers, ou naviguez pour le sélectionner à partir d'un volume Unity Catalog ou d'un emplacement de Workspace.
Pour les Paramètres , pour cet exemple, saisissez ["Hello", "World!"].
Cliquez sur Enregistrer la tâche .

Étape 3 : Exécutez le Job et affichez les détails d’exécution du Job

Cliquez sur pour exécuter le workflow. Pour afficher les détails de l'exécution, cliquez sur View run dans la fenêtre contextuelle Triggered run ou cliquez sur le Link dans la colonne Start time pour l'exécution dans la vue des Job runs.

Une fois l'exécution terminée, le résultat apparaît dans le volet Sortie , y compris les arguments que vous avez transmis à la tâche.

Dépannage

Le tableau suivant fournit des informations de dépannage pour les exceptions courantes.

Exception	Cause	Corriger
`NoSuchMethodError` en référence à une classe `scala.*`	JAR compilé pour Scala 2.12 ; serverless exécute Scala 2.13	Recompilez avec `scalaVersion := "2.13.16"`. Assurez-vous que chaque dépendance Scala utilise le suffixe de version croisée `_2.13`.
`NoClassDefFoundError: scala/...`	Incompatibilité Scala 2.12 vs 2.13	Recompilez avec `scalaVersion := "2.13.16"`. Assurez-vous que chaque dépendance Scala utilise le suffixe de version croisée `_2.13`.
`UnsupportedClassVersionError` (une version de fichier de classe supérieure à 61)	Compilé avec JDK 18 ou supérieur ; Serverless exécute JDK 17	Utilisez `<maven.compiler.release>17</maven.compiler.release>` (Maven) ou `--release 17` (sbt / javac)
`NoClassDefFoundError: org/apache/spark/...` pour un package interne (`catalyst`, `util`, `sql/util`, `sql/internal`, `api/java`, ou `rdd`)	Les internes Spark ou l'API RDD ont été utilisés. Ceux-ci ne sont pas disponibles sur Serverless.	Utilisez le Spark API public (DataFrame/Dataset/SQL). Consultez les limites sur serverless.
`ClassNotFoundException` pour une classe de Driver JDBC (par exemple, `oracle.jdbc.OracleDriver`)	Driver JDBC non présent dans le classpath	Utilisez une connexion JDBC pour la base de données externe.
`ClassNotFoundException` pour une classe tierce (par exemple, `kotlin.jvm.internal.*`)	La bibliothèque ne se trouve pas dans le classpath serverless.	Ajoutez-le à votre JAR, ou fournissez-le en tant que JAR supplémentaire en utilisant l'environnement serverless.
`UnsatisfiedLinkError` référençant un fichier sous `/tmp/`	Bibliothèque native incluse dans le JAR	Les bibliothèques natives ne sont pas prises en charge sur Serverless. Utilisez un équivalent purement Java, ou exécutez sur un compute classique.
`NoSuchMethodError` depuis une bibliothèque tierce (Apache Commons, Guava, Jackson, etc.)	Votre version incluse est en conflit avec la version fournie par serverless.	Utilisez la version fournie. Marquez-le `provided` dans votre build et ne l'incluez pas dans votre JAR.

Exception	Cause	Corriger
`NoSuchMethodError` en référence à une classe `scala.*`	JAR compilé pour Scala 2.12 ; serverless exécute Scala 2.13	Recompilez avec `scalaVersion := "2.13.16"`. Assurez-vous que chaque dépendance Scala utilise le suffixe de version croisée `_2.13`.
`NoClassDefFoundError: scala/...`	Incompatibilité Scala 2.12 vs 2.13	Recompilez avec `scalaVersion := "2.13.16"`. Assurez-vous que chaque dépendance Scala utilise le suffixe de version croisée `_2.13`.
`UnsupportedClassVersionError` (une version de fichier de classe supérieure à 61)	Compilé avec JDK 18 ou supérieur ; Serverless exécute JDK 17	Utilisez `<maven.compiler.release>17</maven.compiler.release>` (Maven) ou `--release 17` (sbt / javac)
`NoClassDefFoundError: org/apache/spark/...` pour un package interne (`catalyst`, `util`, `sql/util`, `sql/internal`, `api/java`, ou `rdd`)	Les internes Spark ou l'API RDD ont été utilisés. Ceux-ci ne sont pas disponibles sur Serverless.	Utilisez le Spark API public (DataFrame/Dataset/SQL). Consultez les limites sur serverless.
`ClassNotFoundException` pour une classe de Driver JDBC (par exemple, `oracle.jdbc.OracleDriver`)	Driver JDBC non présent dans le classpath	Utilisez une connexion JDBC pour la base de données externe.
`ClassNotFoundException` pour une classe tierce (par exemple, `kotlin.jvm.internal.*`)	La bibliothèque ne se trouve pas dans le classpath serverless.	Ajoutez-le à votre JAR, ou fournissez-le en tant que JAR supplémentaire en utilisant l'environnement serverless.
`UnsatisfiedLinkError` référençant un fichier sous `/tmp/`	Bibliothèque native incluse dans le JAR	Les bibliothèques natives ne sont pas prises en charge sur Serverless. Utilisez un équivalent purement Java, ou exécutez sur un compute classique.
`NoSuchMethodError` depuis une bibliothèque tierce (Apache Commons, Guava, Jackson, etc.)	Votre version incluse est en conflit avec la version fournie par serverless.	Utilisez la version fournie. Marquez-le `provided` dans votre build et ne l'incluez pas dans votre JAR.

Étapes suivantes

Pour en savoir plus sur les tâches JAR, voir Tâche JAR pour les Jobs.
Pour en savoir plus sur la création d'un JAR compatible, consultez Créer un JAR compatible Databricks.
Pour en savoir plus sur la création et l’exécution de tâches, consultez Lakeflow Jobs.

Exigences​

Versions des dépendances​

Limitations​

Étape 1 : Créer un JAR​

Gérer les dépendances​

Bibliothèques fournies​

Étape 2 : Créez un job pour exécuter le JAR​

Étape 3 : Exécutez le Job et affichez les détails d’exécution du Job​

Dépannage​

Étapes suivantes​