Crie e execute JARs em compute serverless

importante

Databricks recomenda enfaticamente o uso de Pacotes de Automação Declarativa em vez da criação e implantação manual de arquivos JAR, conforme descrito nesta página. O Declarative Automation Bundles facilita a criação de um projeto a partir de um padrão que já tenha as versões corretas Scala, JDK e Databricks Connect configuradas para serverless, além de permitir a implantação simples do JAR no workspace Databricks . Consulte Criar um JAR Scala com Pacotes de Automação Declarativa.

info

Visualização

As funcionalidades serverless Scala e Java Job estão em versão prévia pública.

Um arquivoJava (JAR) empacota código Java ou Scala em um único arquivo. Esta página mostra como criar um JAR com código Spark e implantá-lo como um LakeFlow Job em computeserverless. Você pode usar JAR tarefa para implantar seu JAR.

Requisitos

Para criar um arquivo JAR, seu ambiente de desenvolvimento local deve ter os seguintes itens instalados:

sbt 1.11.7 ou superior para JARs Scala
Maven 3.9.0 ou superior para arquivos JAR do Java
Versões do JDK, Scala e Databricks Connect que correspondam ao seu ambienteserverless. Consulte Versões de dependência.

Versões de dependência

importante

Para que a execução em compute serverless ocorra sem falhas, as versões Scala e do JDK em seus arquivos JAR devem corresponder exatamente às versões Scala e do JDK em tempo de execução. Veja as versões do Databricks Connect.

O exemplo nesta página usa o ambiente serverless versão 4, portanto, esta página cria um arquivo JAR que:

É compilado com Scala 2.13; todas as dependências usam o sufixo _2.13 .
Foi compilado com o JDK 17, versão 61 do arquivo de classe.
É compilado com base no Databricks Connect 17.3, a interface Spark API para compute serverless .
Utiliza apenas APIs públicas do Spark. Não utiliza RDDs nem componentes internos do Spark. Consulte as limitações.
Inclui todas as dependências presentes no JAR ou anexadas como uma biblioteca de ambiente serverless . Consulte Gerenciando dependências.

Limitações

compute sem servidor utiliza Spark Connect. Sua execução JAR em uma biblioteca thin client que expõe as APIs públicas Spark , enquanto o próprio mecanismo Spark é executado no lado do servidor. Códigos que ignoram a API pública não podem se beneficiar da otimização Catalyst ou da aceleração Photon , mesmo em compute clássica. O código baseado em RDD e dependente de componentes internos geralmente é mais lento do que o código equivalente em DataFrame ou SQL.

Os seguintes itens não estão disponíveis:

API RDD (org.apache.spark.rdd.*) e SparkContext / JavaSparkContext. Use SparkSession.builder().getOrCreate() e DataFrame/dataset operações.
APIs internas do Spark (org.apache.spark.catalyst.*, org.apache.spark.util.*, org.apache.spark.sql.util.*, org.apache.spark.sql.internal.*). O código que importa essas APIs falha com NoClassDefFoundError. Refatorar para a Spark API. Se uma biblioteca de terceiros utiliza componentes internos, verifique se ela publica uma versão compatível com o Spark Connect.
Biblioteca nativa (.so, .dll, JNI). compute sem servidor não permite a gravação de bibliotecas nativas no sistema de arquivos. biblioteca que descompacta binários nativos na startup falha com UnsatisfiedLinkError. Scripts de inicialização não são uma solução alternativa. Use um equivalente em Java, se disponível.

Se a sua carga de trabalho exigir alguma das opções acima, execute-a em computepadrão ou dedicado .

o passo 1: Criar um JAR

Scala
Java

execute o seguinte comando para criar um projeto Scala :
Bash
```
sbt new scala/scala-seed.g8
```
Quando solicitado, insira um nome de projeto, por exemplo, my-spark-app.

Em seguida, exclua os arquivos stub da seed e crie o diretório para sua fonte:

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

Substitua o conteúdo do seu arquivo build.sbt pelo seguinte:

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"

Edite ou crie um arquivo project/plugins.sbt e adicione esta linha:
Scala
```
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.1")
```

Crie sua classe principal em 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(" "))
  }
}

Para construir seu arquivo JAR , execute o seguinte comando:
Bash
```
sbt assembly
```
O JAR compilado é criado na pasta target/ como my-spark-app-assembly-0.1.0-SNAPSHOT.jar.

execute o seguinte comando para criar uma estrutura de projeto Maven :
Bash
```
mkdir -p my-spark-app/src/main/java/com/examples
cd my-spark-app
```

Crie um arquivo pom.xml na raiz do projeto com o seguinte conteúdo:

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>

Crie sua classe principal em 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(" "))
    );
  }
}

Para construir seu arquivo JAR , execute o seguinte comando:
Bash
```
mvn clean package
```
O JAR compilado é criado na pasta target/ como my-spark-app-1.0-SNAPSHOT.jar.

Gerenciando dependências

Para disponibilizar uma biblioteca para seu JAR em compute serverless :

Utilize uma biblioteca fornecida : compute sem servidor inclui Databricks Connect e um conjunto selecionado de bibliotecas comuns. Se a sua versão for compatível, declare-a provided na sua compilação e não a inclua no seu JAR.
Anexar como biblioteca de ambiente : Adicione uma biblioteca ao seu ambienteserverless caso ela ainda não esteja presente. Use isso para bibliotecas que são somente de tempo de execução e que você não deseja incluir.
Conectar a um banco de dados externo : Para fontes JDBC, use uma conexão JDBC em vez de incluir um driver. As conexões JDBC são gerenciadas pelo catálogo Unity. Credenciais, linhagem e governança são gerenciadas para você.

Biblioteca fornecida

As seguintes bibliotecas são dependências obrigatórias e estão disponíveis por default em compute serverless . Declare-os provided em sua compilação. Incluir suas próprias versões dessas bibliotecas gera um erro NoSuchMethodError em tempo de execução.

nota

As versões da biblioteca listadas abaixo são para a versão 4 do ambienteserverless . Para obter informações sobre a biblioteca instalada em outras versões do ambiente, consulte as notas de referência da versão do ambienteserverless .

com.databricks:databricks-connect_2.13, versão 17.3.2
org.scala-lang:scala-library_2.13, versão 2.13.16
org.scala-lang:scala-reflect_2.13, versão 2.13.16
org.slf4j:slf4j-api, versão 2.0.10
org.apache.logging.log4j:log4j-api, versão 2.20.0
org.apache.logging.log4j:log4j-core, versão 2.20.0
org.apache.httpcomponents:httpclient, versão 4.5.14
org.apache.httpcomponents:httpcore, versão 4.4.16
com.fasterxml.jackson.core:jackson-databind, versão 2.15.2
com.fasterxml.jackson.core:jackson-core, versão 2.15.2
com.fasterxml.jackson.core:jackson-annotations, versão 2.15.2
com.fasterxml.jackson.datatype:jackson-datatype-jsr310, versão 2.15.2
com.google.guava:guava, versão 32.0.1-jre
commons-io:commons-io, versão 2.14.0
org.json4s:json4s-jackson_2.13, versão 4.0.7
org.apache.commons:commons-lang3, versão 3.14.0
org.apache.commons:commons-configuration2, versão 2.11.0
org.apache.commons:commons-text, versão 1.12.0
com.databricks:databricks-sdk-java, versão 0.52.0
com.databricks:databricks-dbutils-scala_2.13, versão 0.1.4

o passo 2: Crie um Job para executar o JAR

Em seu site workspace, clique em Jobs & pipeline na barra lateral.
Clique em Create e depois em Job .
Clique no bloco JAR para configurar a primeira tarefa. Se o bloco JAR não estiver disponível, clique em Adicionar outro tipo de tarefa e pesquise por JAR .
Opcionalmente, substitua o nome do trabalho, cujo padrão é New Job <date-time> pelo seu nome de trabalho.
Em nome da tarefa , digite um nome para a tarefa, por exemplo, JAR_example.
Se necessário, selecione JAR no menu suspenso Type (Tipo ).
Para a classe principal , insira o pacote e a classe do seu arquivo JAR. Se você seguiu o exemplo anterior, digite com.examples.SparkJar.
Para computação , selecione sem servidor .
Configure o ambiente serverless :
1. Selecione um ambiente e clique em Edite para configurar.
2. Selecione 4 ou superior para a versão do Ambiente .
3. Adicione seu arquivo JAR arrastando e soltando-o no seletor de arquivos ou navegue até ele para selecioná-lo em um volume Unity Catalog ou em um local workspace .
Em Parâmetros , neste exemplo, digite ["Hello", "World!"].
Clique em Criar tarefa .

o passo 3: execute o Job e view os detalhes de execução do Job

Clique em para executar o fluxo de trabalho. Para acessar view detalhes da execução, clique em view execution (visualizar execução ) na janela pop-up Triggered execution (execução acionada ) ou clique no link na coluna começar time (tempo ) para a execução no Job execution (execução de trabalho) view.

Quando a execução for concluída, o resultado aparecerá no painel Saída , incluindo os argumentos que você passou para a tarefa.

Solução de problemas

A tabela a seguir fornece informações para a resolução de problemas em exceções comuns.

Exceção	Causa	Consertar
`NoSuchMethodError` referenciando uma classe `scala.*`	JAR compilado em Scala 2.12; execução serverless Scala 2.13	Recompile com `scalaVersion := "2.13.16"`. Garanta que todas as dependências Scala usem o sufixo de versão cruzada `_2.13` .
`NoClassDefFoundError: scala/...`	Incompatibilidade entre Scala 2.12 e 2.13	Recompile com `scalaVersion := "2.13.16"`. Garanta que todas as dependências Scala usem o sufixo de versão cruzada `_2.13` .
`UnsupportedClassVersionError` (uma versão de arquivo de classe superior a 61)	Compilado com JDK 18 ou superior; execução serverless JDK 17	Use `<maven.compiler.release>17</maven.compiler.release>` (Maven) ou `--release 17` (sbt / javac)
`NoClassDefFoundError: org/apache/spark/...` para um pacote interno (`catalyst`, `util`, `sql/util`, `sql/internal`, `api/java`, ou `rdd`)	Foram utilizados os mecanismos internos do Spark ou a API RDD. Essas opções não estão disponíveis em serverless.	Use a Spark API (DataFrame/dataset/SQL). Veja as limitações do modelo serverless.
`ClassNotFoundException` para uma classe de driver JDBC (por exemplo, `oracle.jdbc.OracleDriver`)	O driver JDBC não está no classpath.	Utilize uma conexão JDBC para o banco de dados externo.
`ClassNotFoundException` para uma classe de terceiros (por exemplo, `kotlin.jvm.internal.*`)	A biblioteca não está no classpath do ambiente serverless.	Adicione-o ao seu JAR ou forneça-o como um JAR adicional usando o ambienteserverless.
`UnsatisfiedLinkError` referenciando um arquivo em `/tmp/`	Biblioteca nativa incluída no JAR	Bibliotecas nativas não são suportadas em serverless. Use um equivalente em Java puro ou execute em compute clássica.
`NoSuchMethodError` de uma biblioteca de terceiros (Apache Commons, Guava, Jackson, etc.)	A versão incluída por você entra em conflito com a versão fornecida pelo serverless.	Utilize a versão fornecida. Marque-o como `provided` em sua compilação e não o inclua em seu JAR.

Próximas etapas

Para saber mais sobre tarefas JAR , consulte TarefasJAR para Job.
Para saber mais sobre como criar um JAR compatível, consulte Criar um JAR compatível com o Databricks.
Para saber mais sobre como criar e executar o Job, consulte LakeFlow Jobs.

Requisitos​

Versões de dependência​

Limitações​

o passo 1: Criar um JAR​

Gerenciando dependências​

Biblioteca fornecida​

o passo 2: Crie um Job para executar o JAR​

o passo 3: execute o Job e view os detalhes de execução do Job​

Solução de problemas​

Próximas etapas​