Pular para o conteúdo principal
Última atualização em

Crie um arquivo JAR compatível com o Databricks.

Um arquivo Java (JAR) contendo código Java ou Scala para implantação em Jobs LakeFlow . Este artigo aborda os requisitos de compatibilidade JAR e a configuração de projetos para diferentes tipos compute .

dica

Para implantação automatizada e fluxo de trabalho de integração contínua, use Databricks ativo Bundles para criar um projeto padrão com configurações de construção e implantação pré-configuradas. Consulte Criar um JAR Scala usando Databricks ativo Bundles e Bundle que carrega um arquivo JAR para o Unity Catalog. Este artigo descreve a abordagem manual para compreender os requisitos JAR e as configurações personalizadas.

Em linhas gerais, seu arquivo JAR deve atender aos seguintes requisitos de compatibilidade:

  • Compatibilidade de versões : Use as mesmas versões Java Development Kit (JDK), Scala e Spark que seu compute
  • Forneça as dependências : Inclua as bibliotecas necessárias no seu JAR ou instale-as no seu compute
  • Use a sessão Spark do Databricks : Chame SparkSession.builder().getOrCreate() para acessar a sessão.
  • Adicione seu JARà lista de permissões (somente compute padrão): Adicione seu JAR à lista de permissões
info

Beta

As funcionalidades serverless Scala e Java Job estão em versão Beta. Você pode usar JAR tarefa para implantar seu JAR. Consulte a opção "Gerenciar pré-visualizações Databricks caso ainda não esteja ativada.

arquitetura de computação​

Os métodos serverless e computepadrão utilizam a arquiteturaSpark Connect para isolar o código do usuário e aplicar a governança Unity Catalog . O Databricks Connect fornece acesso às APIs do Spark Connect. Os modelos serverless e compute padrão não são compatíveis com APIs Spark Context ou Spark RDD . Consulte as limitações do modeloserverless e as limitações do modo de acesso padrão.

computededicada utiliza a arquitetura clássica Spark e fornece acesso a todas APIs Spark .

Encontre suas versões do JDK, Scala e Spark.​

Verifique se as versões do JDK, Scala e Spark em execução no seu computesão compatíveis.

Ao criar um JAR, as versões do JDK, Scala e Spark devem corresponder às versões em execução no seu compute. Essas três versões estão interligadas: a versão do Spark determina a versão compatível do Scala, e ambas dependem de uma versão específica do JDK.

Siga estes passos para encontrar as versões corretas para o seu tipo compute :

  1. Utilize o ambiente serverless versão 4 ou superior.
  2. Encontre a versão Databricks Connect para o seu ambiente na tabela de versões de ambientesserverless . A versão do Databricks Connect corresponde à sua versão do Spark.
  3. Consulte as versões correspondentes do JDK, Scala e Spark na matriz de suporte de versões.
nota

Usar versões incompatíveis do JDK, Scala ou Spark pode causar comportamentos inesperados ou impedir a execução do seu código.

Configuração do projeto​

Após conhecer os requisitos de versão, configure seus arquivos de compilação e empacote seu JAR.

Defina as versões do JDK e do Scala.​

Configure seu arquivo de compilação para usar as versões corretas do JDK e do Scala. Os exemplos a seguir mostram as versões do Databricks Runtime 17.3 LTS e do ambiente serverless versão 4 -Scala-preview.

Em build.sbt:

Scala
scalaVersion := "2.13.16"

javacOptions ++= Seq("-source", "17", "-target", "17")

Dependências do Spark​

Adicione uma dependência Spark para acessar APIs Spark sem precisar incluí Spark no seu JAR.

Use o Databricks Connect

Adicione uma dependência do Databricks Connect (recomendado). A versão Databricks Connect deve corresponder à versão Databricks Connect no seu ambienteserverless. Marque como provided porque está incluído no tempo de execução. Não inclua dependências do Apache Spark como spark-core ou outros artefatos org.apache.spark em seu arquivo de compilação. O Databricks Connect fornece todas as APIs do Spark necessárias.

Maven pom.xml:

XML
<dependency>
  <groupId>com.databricks</groupId>
  <artifactId>databricks-connect_2.13</artifactId>
  <version>17.0.2</version>
  <scope>provided</scope>
</dependency>

sbt build.sbt:

Scala
libraryDependencies += "com.databricks" %% "databricks-connect" % "17.0.2" % "provided"

Alternativa: API Spark SQL

Você pode compilar usando spark-sql-api em vez de Databricks Connect, mas Databricks recomenda o uso do Databricks Connect porque as APIs Spark executadas em compute serverless podem diferir ligeiramente do código aberto Spark. Essas bibliotecas estão incluídas no tempo de execução, então marque-as como provided.

Maven pom.xml:

XML
<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-sql-api</artifactId>
  <version>4.0.1</version>
  <scope>provided</scope>
</dependency>

sbt build.sbt:

Scala
libraryDependencies += "org.apache.spark" %% "spark-sql-api" % "4.0.1" % "provided"

Dependências do aplicativo​

Adicione a biblioteca necessária para sua aplicação ao seu arquivo de compilação. A forma como você gerencia esses elementos depende do seu tipo compute :

O serverless compute fornece Databricks Connect e um conjunto limitado de dependências (consulte as notas sobre a versão). Inclua todas as outras bibliotecas no seu JAR usando o sbt-assembly ou o pluginMaven Shade, ou adicione-as ao seu ambienteserverless.

Por exemplo, para empacotar uma biblioteca em seu JAR:

Maven pom.xml:

XML
<dependency>
  <groupId>io.circe</groupId>
  <artifactId>circe-core_2.13</artifactId>
  <version>0.14.10</version>
</dependency>

sbt build.sbt:

Scala
libraryDependencies += "io.circe" %% "circe-core" % "0.14.10"

Requisitos do código​

Ao escrever seu código JAR , siga estes padrões para garantir a compatibilidade com o Job Databricks .

Use a sessão Databricks Spark​

Ao executar um JAR em um Job, você deve usar a sessão Spark fornecida pelo Databricks. O código a seguir mostra como acessar a sessão a partir do seu código:

Java
SparkSession spark = SparkSession.builder().getOrCreate();

Use blocos try-finally para limpeza de tarefas​

Se você deseja um código que seja executado de forma confiável no final do seu Job, por exemplo, para limpar arquivos temporários, use um bloco try-finally . Não utilize um gancho de desligamento (shutdown hook), pois estes não são executados de forma confiável em um Job.

Considere um JAR que consiste em duas partes:

  • jobBody() que contém a parte principal do Trabalho.
  • jobCleanup() que deve ser executada após jobBody(), independentemente de a função ter sucesso ou retornar uma exceção.

Por exemplo, jobBody() cria tabelas e jobCleanup() exclui essas tabelas.

A maneira segura de garantir que o método de limpeza seja chamado é inserir um bloco try-finally no código:

Scala
try {
  jobBody()
} finally {
  jobCleanup()
}

Não tente limpar usando sys.addShutdownHook(jobCleanup) ou o seguinte código:

Scala
// Do NOT clean up with a shutdown hook like this. This will fail.
val cleanupThread = new Thread { override def run = jobCleanup() }
Runtime.getRuntime.addShutdownHook(cleanupThread)

Databricks gerencia os tempos de vida dos contêineres Spark de uma forma que impede que os ganchos de desligamento sejam executados de forma confiável.

Leia os parâmetros do trabalho​

Databricks passa os parâmetros para o seu Job JAR como uma matriz de strings JSON . Para acessar esses parâmetros, inspecione a matriz String passada para sua função main .

Para obter mais detalhes sobre os parâmetros, consulte Parametrizar Tarefa.

Configuração adicional​

Dependendo do seu tipo compute , você pode precisar de configurações adicionais:

  • Modo de acesso padrão : Por motivos de segurança, um administrador deve adicionar as coordenadas e os caminhos Maven para a biblioteca JAR a uma lista de permissões.
  • computesem servidor : Se o seu Job acessar recursos privados (bancos de dados, APIs, armazenamento), configure a rede com uma Configuração de Conectividade de Rede (NCC). Veja segurança de rede sem servidor.

Próximos passos​