Compartilhar via

SDK do Databricks para Java

  • Artigo

Neste artigo, você aprenderá como fazer para automatizar operações em contas, workspaces do Azure Databricks e recursos relacionados com o SDK do Databricks para Java. Este artigo complementa o LEIAME do Java, a referência de API e os exemplos do SDK do Databricks para Java.

Observação

Esse recurso está em Beta e pode ser usado na produção.

Durante o período Beta, o Databricks recomenda que você fixe uma dependência na versão secundária específica do SDK do Databricks para Java da qual seu código depende. Por exemplo, você pode fixar dependências em arquivos como pom.xml para Maven. Para obter mais informações sobre como fixar dependências, consulte Introdução ao Mecanismo de Dependência.

Antes de começar

Antes de começar a utilizar o SDK do Databricks para Java, seu computador de desenvolvimento deve ter:

  • A autenticação do Azure Databricks configurada.
  • Um kit de desenvolvimento Java (JDK) compatível com Java 8 ou superior. O teste de integração contínua (CI) com o SDK do Databricks para Java é compatível com as versões 8, 11, 17 e 20 do Java.
  • Recomenda-se um ambiente de desenvolvimento integrado (IDE) compatível com Java. O Databricks recomenda o IntelliJ IDEA.

Introdução ao SDK do Databricks para Java

  1. No arquivo pom.xml do seu projeto, instrua seu sistema de compilação a obter uma dependência do SDK do Databricks para Java. Para fazer isso, adicione o seguinte <dependency> à seção <dependencies> existente no arquivo pom.xml. Se a seção <dependencies> ainda não existir no arquivo pom.xml, você também deverá adicionar o elemento pai <dependencies> ao arquivo pom.xml.

    Por exemplo, para abrir o arquivo do projeto pom.xml no IntelliJ IDEA, clique em Exibir > Janelas de ferramentas > Projeto e clique duas vezes para abrir your-project-name> src >pom.xml.

    <dependencies>
  <dependency>
    <groupId>com.databricks</groupId>
    <artifactId>databricks-sdk-java</artifactId>
    <version>0.0.1</version>
  </dependency>
</dependencies>

    Observação

    Certifique-se de substituir 0.0.1 pela versão mais recente do SDK do Databricks para Java. Você pode encontrar a versão mais recente no repositório central do Maven.

  2. Instrua seu projeto a assumir a dependência declarada no SDK do Databricks para Java. Por exemplo, no IntelliJ IDEA, na janela de ferramentas Projeto do seu projeto, clique com o botão direito do mouse no nó raiz do projeto e, em seguida, clique em Recarregar Projeto.

  3. Adicione o código para importar o SDK do Databricks para Java e para listar todos os clusters em seu workspace do Azure Databricks. Por exemplo, no arquivo Main.java de um projeto, o código pode ser o seguinte:

    import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.compute.ClusterInfo;
import com.databricks.sdk.service.compute.ListClustersRequest;

public class Main {
  public static void main(String[] args) {
    WorkspaceClient w = new WorkspaceClient();

    for (ClusterInfo c : w.clusters().list(new ListClustersRequest())) {
      System.out.println(c.getClusterName());
    }
  }
}

    Observação

    Ao não definir nenhum argumento na chamada anterior para WorkspaceClient w = new WorkspaceClient(), o SDK do Databricks para Java usa seu processo padrão para tentar executar a autenticação do Azure Databricks. Para substituir esse comportamento padrão, consulte a seção autenticação a seguir.

  4. Compile o projeto. Por exemplo, para fazer isso no IntelliJ IDEA, no menu principal, clique em Compilar > Projeto de Compilação.

  5. Executar seu arquivo principal. Por exemplo, para fazer isso no IntelliJ IDEA para o arquivo Main.java de um projeto, no menu principal, clique em Executar >. Executar 'Main'.

  6. É exibida a lista de clusters. Por exemplo, no IntelliJ IDEA, isso ocorre na janela da ferramenta Executar. Para exibir essa janela de ferramentas, no menu principal, clique em Visualizar > Janelas de Ferramentas > Executar.

Autenticar o SDK do Databricks para Java com sua conta ou workspace do Azure Databricks

O SDK do Databricks para Java implementa o padrão de autenticação unificada de cliente do Databricks, uma abordagem arquitetônica e programática consolidada e consistente para autenticação. Essa abordagem ajuda a tornar a configuração e a automação da autenticação com o Azure Databricks mais centralizada e previsível. Ele permite que você configure a autenticação do Databricks uma vez e use essa configuração em várias ferramentas e SDKs do Databricks sem mais alterações na configuração da autenticação. Para obter mais informações, incluindo exemplos de código mais completos em Java, consulte Autenticação unificada de cliente do Databricks.

Observação

O SDK do Databricks para Java ainda não implementou a autenticação de identidades gerenciadas do Azure.

Alguns dos padrões de código disponíveis para inicializar a autenticação do Databricks com o SDK do Databricks para Java incluem:

  • Use a autenticação padrão do Databricks executando um destes procedimentos:

    • Criar ou identificar um perfil de configuração do Databricks personalizado com os campos obrigatórios para o tipo de autenticação do Databricks de destino. Em seguida, defina a variável de ambiente DATABRICKS_CONFIG_PROFILE para o nome do perfil de configuração personalizado.
    • Defina as variáveis de ambiente necessárias para o tipo de autenticação do Databricks de destino.

    Em seguida, crie uma instância, por exemplo, de um objeto WorkspaceClient com a autenticação padrão do Databricks da seguinte maneira:

    import com.databricks.sdk.WorkspaceClient;
// ...
WorkspaceClient w = new WorkspaceClient();
// ...

  • A codificação dos campos obrigatórios é suportada, mas não recomendada, pois corre o risco de expor informações confidenciais em seu código, como tokens de acesso pessoal do Azure Databricks. O exemplo a seguir codifica os valores de host e token de acesso do Azure Databricks para autenticação de token do Databricks:

    import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.core.DatabricksConfig;
// ...
DatabricksConfig cfg = new DatabricksConfig()
  .setHost("https://...")
  .setToken("...");
WorkspaceClient w = new WorkspaceClient(cfg);
// ...

Confira também Autenticação no LEIAME do SDK do Databricks para Java.

Usar Utilitários do Databricks e Java com o SDK do Databricks para Java

Os Utilitários do Databricks fornecem várias funções auxiliares para facilitar o trabalho com o armazenamento de objetos com eficiência, encadear e parametrizar notebooks e trabalhar com segredos. O Databricks fornece uma biblioteca de Utilitários do Databricks para Scala, que você pode chamar com código Java, para permitir que você acesse programaticamente os Utilitários do Databricks.

Para usar o código Java para chamar os Utilitários do Databricks para Scala, faça o seguinte:

  1. Em seu projeto Java, declare uma dependência do SDK do Databricks para Java, conforme descrito na seção anterior.

  2. Declare uma dependência nos Utilitários do Databricks para a biblioteca Scala. Para fazer isso, adicione o <dependency> a seguir à seção pom.xml existente do arquivo <dependencies>:

    <dependency>
  <groupId>com.databricks</groupId>
  <artifactId>databricks-dbutils-scala_2.12</artifactId>
  <version>0.1.4</version>
</dependency>

    Observação

    Certifique-se de substituir 0.1.4 pela versão mais recente da biblioteca de Utilitários do Databricks para Scala. Você pode encontrar a versão mais recente no repositório central do Maven.

  3. Instrua seu projeto a assumir a dependência declarada nos Utilitários do Databricks para Scala. Por exemplo, no IntelliJ IDEA, na janela de ferramentas Projeto do seu projeto, clique no nó raiz do projeto e, em seguida, clique em Maven > Recarregar Projeto.

  4. Adicione código para importar e, em seguida, chame o Utilitário do Databricks para Scala. Por exemplo, o código a seguir automatiza um volume do Catálogo do Unity. Este exemplo cria um arquivo denominado zzz_hello.txt no caminho do volume dentro do workspace, lê os dados do arquivo e exclui o arquivo:

    import com.databricks.sdk.core.DatabricksConfig;
import com.databricks.sdk.scala.dbutils.DBUtils;

public class Main {
  public static void main(String[] args) {
    String filePath = "/Volumes/main/default/my-volume/zzz_hello.txt";
    String fileData = "Hello, Databricks!";
    DBUtils dbutils = DBUtils.getDBUtils(new DatabricksConfig().setProfile("DEFAULT"));

    dbutils.fs().put(filePath, fileData, true);

    System.out.println(dbutils.fs().head(filePath, 18));

    dbutils.fs().rm(filePath, false);
  }
}

  5. Crie seu projeto e execute o arquivo principal.

Exemplos de código

Os exemplos de código a seguir demonstram como fazer para usar o SDK do Databricks para Java para criar e excluir clusters, criar trabalhos e listar grupos em nível de conta. Esses exemplos de código utilizam o SDK do Databricks para o processo padrão de autenticação do Azure Databricks para Java.

Para obter exemplos de código adicionais, consulte a pasta exemplos no repositório do SDK do Databricks para Java no GitHub.

Criar um cluster

Este exemplo de código cria um cluster com a versão especificada do Databricks Runtime e o tipo de nó do cluster. Esse cluster tem um trabalho e o cluster será encerrado automaticamente após 15 minutos de tempo ocioso.

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.compute.CreateCluster;
import com.databricks.sdk.service.compute.CreateClusterResponse;

public class Main {
  public static void main(String[] args) {
    WorkspaceClient w = new WorkspaceClient();

    CreateClusterResponse c = w.clusters().create(
      new CreateCluster()
        .setClusterName("my-cluster")
        .setSparkVersion("12.2.x-scala2.12")
        .setNodeTypeId("Standard_DS3_v2")
        .setAutoterminationMinutes(15L)
        .setNumWorkers(1L)
    ).getResponse();

    System.out.println("View the cluster at " +
      w.config().getHost() +
      "#setting/clusters/" +
      c.getClusterId() +
      "/configuration\n");
  }
}

Criar um cluster que usa o JDK 17

Observação

O JDK 8 é totalmente suportado. O JDK 17 está na Visualização Pública para Databricks Runtime versões 13.1 e superiores.

Esta seção fornece um guia para a criação de um cluster utilizando o Java Development Kit (JDK). Saiba como criar um cluster com o JDK 17 para usar Java em seus blocos de anotações e trabalhos.

Ao criar um cluster, especifique que o cluster usa o JDK 17 para o driver e o executor adicionando a seguinte variável de ambiente às Opções avançadas > variáveis de ambiente do >Spark:

JNAME=zulu17-ca-amd64

Excluir um cluster permanentemente

Este exemplo de código exclui permanentemente o cluster com a ID de cluster especificada do workspace.

import com.databricks.sdk.WorkspaceClient;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    System.out.println("ID of cluster to delete (for example, 1234-567890-ab123cd4):");

    Scanner in = new Scanner(System.in);
    String c_id = in.nextLine();
    WorkspaceClient w = new WorkspaceClient();

    w.clusters().permanentDelete(c_id);
  }
}

Criar um trabalho

Este exemplo de código cria um trabalho do Azure Databricks que pode ser utilizado para executar o notebook especificado no cluster especificado. À medida que esse código é executado, ele obtém o caminho do notebook existente, a ID do cluster existente e as configurações de trabalho relacionadas do usuário no terminal.

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.jobs.JobTaskSettings;
import com.databricks.sdk.service.jobs.NotebookTask;
import com.databricks.sdk.service.jobs.NotebookTaskSource;
import com.databricks.sdk.service.jobs.CreateResponse;
import com.databricks.sdk.service.jobs.CreateJob;

import java.util.Scanner;
import java.util.Map;
import java.util.Collection;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    System.out.println("Some short name for the job (for example, my-job):");
    Scanner in = new Scanner(System.in);
    String jobName = in.nextLine();

    System.out.println("Some short description for the job (for example, My job):");
    String description = in.nextLine();

    System.out.println("ID of the existing cluster in the workspace to run the job on (for example, 1234-567890-ab123cd4):");
    String existingClusterId = in.nextLine();

    System.out.println("Workspace path of the notebook to run (for example, /Users/someone@example.com/my-notebook):");
    String notebookPath = in.nextLine();

    System.out.println("Some key to apply to the job's tasks (for example, my-key): ");
    String taskKey = in.nextLine();

    System.out.println("Attempting to create the job. Please wait...");

    WorkspaceClient w = new WorkspaceClient();

    Map<String, String> map = Map.of("", "");

    Collection<JobTaskSettings> tasks = Arrays.asList(new JobTaskSettings()
      .setDescription(description)
      .setExistingClusterId(existingClusterId)
      .setNotebookTask(new NotebookTask()
        .setBaseParameters(map)
        .setNotebookPath(notebookPath)
        .setSource(NotebookTaskSource.WORKSPACE))
      .setTaskKey(taskKey)
    );

    CreateResponse j = w.jobs().create(new CreateJob()
      .setName(jobName)
      .setTasks(tasks)
    );

    System.out.println("View  the job at " +
      w.config().getHost() +
      "/#job/" +
      j.getJobId()
    );
  }
}

Gerenciar arquivos em volumes do Catálogo do Unity

Este exemplo de código demonstra várias chamadas para a funcionalidade files em WorkspaceClient a fim de acessar um volume do Catálogo do Unity.

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.files.DirectoryEntry;
import com.databricks.sdk.service.files.DownloadResponse;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Main {
  public static void main(String[] args) throws IOException {
    String catalog          = "main";
    String schema           = "default";
    String volume           = "my-volume";
    String volumePath       = "/Volumes/" + catalog + "/" + schema + "/" + volume; // /Volumes/main/default/my-volume
    String volumeFolder     = "my-folder";
    String volumeFolderPath = volumePath + "/" + volumeFolder; // /Volumes/main/default/my-volume/my-folder
    String volumeFile       = "data.csv";
    String volumeFilePath   = volumeFolderPath + "/" + volumeFile; // /Volumes/main/default/my-volume/my-folder/data.csv
    String uploadFilePath   = "./data.csv";

    WorkspaceClient w = new WorkspaceClient();

    // Create an empty folder in a volume.
    w.files().createDirectory(volumeFolderPath);

    // Upload a file to a volume.
    try {
      File uploadFile = new File(upload_file_path);
      InputStream uploadInputStream = Files.newInputStream(Paths.get(upload_file_path));
      w.files().upload(volumeFilePath, uploadInputStream);
    } catch (java.io.IOException e) {
      System.out.println(e.getMessage());
      System.exit(-1);
    }

    // List the contents of a volume.
    Iterable<DirectoryEntry> volumeItems = w.files().listDirectoryContents(volumePath);
    for (DirectoryEntry volumeItem: volumeItems) {
      System.out.println(volumeItem.getPath());
    }

    // List the contents of a folder in a volume.
    Iterable<DirectoryEntry> volumeFolderItems = w.files().listDirectoryContents(volumeFolderPath);
    for (DirectoryEntry volumeFolderItem: volumeFolderItems) {
      System.out.println(volumeFolderItem.getPath());
    }

    // Print the contents of a file in a volume.
    DownloadResponse resp = w.files().download(volumeFilePath);
    InputStream downloadedFile = resp.getContents();

    try {
      BufferedReader reader = new BufferedReader(new InputStreamReader(downloadedFile));
      String line;
      while ((line = reader.readLine()) != null) {
          System.out.println(line);
      }
    } catch (java.io.IOException e) {
      System.out.println(e.getMessage());
      System.exit(-1);
    }

    // Delete a file from a volume.
    w.files().delete(volumeFilePath);

    // Delete a folder from a volume.
    w.files().deleteDirectory(volumeFolderPath);
  }
}

Listar grupos no nível da conta

Este exemplo de código lista os nomes de exibição de todos os grupos disponíveis na conta do Azure Databricks.

import com.databricks.sdk.AccountClient;
import com.databricks.sdk.core.DatabricksConfig;
import com.databricks.sdk.service.iam.Group;
import com.databricks.sdk.service.iam.ListAccountGroupsRequest;

public class Main {
  public static void main(String[] args) {
    AccountClient a = new AccountClient();

    for (Group g : a.groups().list((new ListAccountGroupsRequest()))) {
      System.out.println(g.getDisplayName());
    }
  }
}

Usar o Scala com o SDK do Databricks para Java

Você pode utilizar projetos Scala com o SDK do Databricks para Java. Antes de começar, seu computador de desenvolvimento deve ter:

  • A autenticação do Azure Databricks configurada.
  • Recomenda-se um ambiente de desenvolvimento integrado (IDE) compatível com o Scala. A Databricks recomenda o IntelliJ IDEA com o plugin Scala. Essas instruções foram testadas com o IntelliJ IDEA Community Edition 2023.3.6. Se você usar uma versão ou edição diferente do IntelliJ IDEA, as instruções a seguir poderão variar.
  • Um kit de desenvolvimento Java (JDK) compatível com Java 8 ou superior. Se você deseja executar seus aplicativos ou usar suas bibliotecas em um cluster do Azure Databricks, o Databricks recomenda que você utilize uma versão do JDK que corresponda à versão do JDK no cluster. Para encontrar a versão do JDK incluída em um Databricks Runtime específico, consulte Compatibilidade, versões e notas sobre a versão do Databricks Runtime. Se você utilizar o IntelliJ IDEA, poderá escolher uma instalação local existente do JDK ou instalar um novo JDK localmente durante a criação do projeto Scala.
  • Uma ferramenta de build do Scala. O Databricks recomenda sbt. Se você usar o IntelliJ IDEA, poderá escolher a versão sbt que será utilizada durante a criação do projeto Scala.
  • Scala. Se você deseja executar seus aplicativos ou usar suas bibliotecas em um cluster do Azure Databricks, a Databricks recomenda que você utilize uma versão do Scala que corresponda à versão do Scala no cluster. Para encontrar a versão do Scala incluída em um Databricks Runtime específico, consulte Compatibilidade, notas sobre a versão e versão do Databricks Runtime. Se você usar o IntelliJ IDEA, poderá escolher a versão do Scala a ser utilizada durante a criação do projeto Scala.

Para configurar, compilar e executar seu projeto Scala:

  1. No arquivo build.sbt do seu projeto, crie uma dependência na biblioteca do SDK do Databricks para Java, adicionando a seguinte linha ao final do arquivo e, em seguida, salve o arquivo:

    libraryDependencies += "com.databricks" % "databricks-sdk-java" % "0.2.0"

    Observação

    Certifique-se de substituir 0.2.0 pela versão mais recente da biblioteca do SDK do Databricks para Java. Você pode encontrar a versão mais recente no repositório central do Maven.

  2. Instrua seu projeto a assumir a dependência declarada no SDK do Databricks para Java. Por exemplo, no IntelliJ IDEA, clique no ícone de notificação Carregar alterações do sbt.

  3. Adicione o código para importar o SDK do Databricks para Java e para listar todos os clusters em seu workspace do Azure Databricks. Por exemplo, no arquivo Main.scala de um projeto, o código pode ser o seguinte:

    import com.databricks.sdk.WorkspaceClient
import com.databricks.sdk.service.compute.ListClustersRequest

object Main {
  def main(args: Array[String]): Unit = {
    val w = new WorkspaceClient()

    w.clusters().list(new ListClustersRequest()).forEach{
      elem => println(elem.getClusterName)
    }
  }
}

    Observação

    Ao não definir nenhum argumento na chamada anterior para val w = new WorkspaceClient(), o SDK do Databricks para Java usa seu processo padrão para tentar executar a autenticação do Azure Databricks. Para substituir esse comportamento padrão, consulte a seção autenticação a seguir.

  4. Compile o projeto. Por exemplo, para fazer isso no IntelliJ IDEA, no menu principal, clique em Compilar > Projeto de Compilação.

  5. Executar seu arquivo principal. Por exemplo, para fazer isso no IntelliJ IDEA para o arquivo Main.scala de um projeto, no menu principal, clique em Executar >. Executar 'Main.scala'.

  6. É exibida a lista de clusters. Por exemplo, no IntelliJ IDEA, isso ocorre na janela da ferramenta Executar. Para exibir essa janela de ferramentas, no menu principal, clique em Visualizar > Janelas de Ferramentas > Executar.

Usar os Utilitários do Databricks e o Scala com o SDK do Databricks para Java

Os Utilitários do Databricks fornecem várias funções auxiliares para facilitar o trabalho com o armazenamento de objetos com eficiência, encadear e parametrizar notebooks e trabalhar com segredos. O Databricks fornece uma biblioteca de Utilitários do Databricks para Scala para permitir que você acesse programaticamente os Utilitários do Databricks com o Scala.

Para chamar os Utilitários do Databricks para Scala, faça o seguinte:

  1. Em seu projeto Scala, declare uma dependência do SDK do Databricks para Java, conforme descrito na seção anterior.

  2. Declare uma dependência na biblioteca de Utilitários do Databricks para Scala. Por exemplo, no arquivo build.sbt do projeto, adicione a seguinte linha ao final do arquivo e salve o arquivo:

    libraryDependencies += "com.databricks" % "databricks-dbutils-scala_2.12" % "0.1.4"

    Observação

    Certifique-se de substituir 0.1.4 pela versão mais recente da biblioteca de Utilitários do Databricks para Scala. Você pode encontrar a versão mais recente no repositório central do Maven.

  3. Instrua seu projeto a assumir a dependência declarada nos Utilitários do Databricks para Scala. Por exemplo, no IntelliJ IDEA, clique no ícone de notificação Carregar alterações do sbt.

  4. Adicione código para importar e, em seguida, chame o Utilitário do Databricks para Scala. Por exemplo, o código a seguir automatiza um volume do Catálogo do Unity. Este exemplo cria um arquivo denominado zzz_hello.txt no caminho do volume dentro do workspace, lê os dados do arquivo e exclui o arquivo:

    import com.databricks.sdk.scala.dbutils.DBUtils

object Main {
  def main(args: Array[String]): Unit = {
    val filePath = "/Volumes/main/default/my-volume/zzz_hello.txt"
    val fileData = "Hello, Databricks!"
    val dbutils = DBUtils.getDBUtils()

    dbutils.fs.put(
      file = filePath,
      contents = fileData,
      overwrite = true
    )

    println(dbutils.fs.head(filePath))

    dbutils.fs.rm(filePath)
  }
}

    Observação

    Ao não definir argumentos na chamada anterior para val dbutils = DBUtils.getDBUtils(), os Utilitários do Databricks para Scala usam seu processo padrão para tentar executar a autenticação do Azure Databricks.

    Para substituir esse comportamento padrão, passe um objeto instanciado DatabricksCfg como um argumento para getDBUtils. Para obter mais informações, confira a seção de autenticação anterior.

    No entanto, observe que, se o código estiver em execução dentro do Databricks Runtime, esse objeto DatabricksCfg será ignorado. Isso ocorre porque os Utilitários do Databricks para Scala são delegados aos utilitários internos do Databricks ao serem executados dentro do Databricks Runtime.

  5. Crie seu projeto e execute o arquivo principal.

Para acessar volumes do Catálogo do Unity, use files em WorkspaceClient. Consulte Gerenciar arquivos em volumes do Catálogo do Unity. Não é possível usar DBUtils.getDBUtils() para acessar volumes.

Testando

Para testar seu código, use estruturas de teste do Java, como JUnit. Para testar seu código em condições simuladas sem chamar pontos de extremidade da API REST do Azure Databricks ou alterar o estado de suas contas ou workspaces do Azure Databricks, use bibliotecas de simulação do Java, como Mockito.

Por exemplo, dado o seguinte arquivo nomeado Helpers.java contendo uma função createCluster que retorna informações sobre o novo cluster:

// Helpers.java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.compute.CreateCluster;
import com.databricks.sdk.service.compute.CreateClusterResponse;

public class Helpers {
  static CreateClusterResponse createCluster(
    WorkspaceClient w,
    CreateCluster   createCluster,
    String          clusterName,
    String          sparkVersion,
    String          nodeTypeId,
    Long            autoTerminationMinutes,
    Long            numWorkers
  ) {
    return w.clusters().create(
      createCluster
        .setClusterName(clusterName)
        .setSparkVersion(sparkVersion)
        .setNodeTypeId(nodeTypeId)
        .setAutoterminationMinutes(autoTerminationMinutes)
        .setNumWorkers(numWorkers)
    ).getResponse();
  }
}

E dado o seguinte arquivo chamado Main.java que chama a função createCluster:

// Main.java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.compute.CreateCluster;
import com.databricks.sdk.service.compute.CreateClusterResponse;

public class Main {
  public static void main(String[] args) {
    WorkspaceClient w = new WorkspaceClient();
    // Replace <spark-version> with the target Spark version string.
    // Replace <node-type-id> with the target node type string.
    CreateClusterResponse c = Helpers.createCluster(
      w,
      new CreateCluster(),
      "My Test Cluster",
      "<spark-version>",
      "<node-type-id>",
      15L,
      1L
    );
    System.out.println(c.getClusterId());
  }
}

O arquivo nomeado HelpersTest.java a seguir testa se a função createCluster retorna a resposta esperada. Em vez de criar um cluster no workspace de destino, esse teste simula um objeto WorkspaceClient, define as configurações do objeto simulado e, em seguida, passa o objeto simulado para a função createCluster. Em seguida, o teste verifica se a função retorna a ID esperada do novo cluster simulado.

// HelpersTest.java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.mixin.ClustersExt;
import com.databricks.sdk.service.compute.ClusterDetails;
import com.databricks.sdk.service.compute.CreateCluster;
import com.databricks.sdk.support.Wait;
import com.databricks.sdk.service.compute.CreateClusterResponse;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class HelpersTest {
  @Test
  public void testCreateCluster() {
    WorkspaceClient mockWorkspaceClient = Mockito.mock(WorkspaceClient.class);
    ClustersExt mockClustersExt = Mockito.mock(ClustersExt.class);
    CreateCluster mockCreateCluster = new CreateCluster();
    Wait<ClusterDetails, CreateClusterResponse> mockWait = Mockito.mock(Wait.class);
    CreateClusterResponse mockResponse = Mockito.mock(CreateClusterResponse.class);

    Mockito.when(mockWorkspaceClient.clusters()).thenReturn(mockClustersExt);
    Mockito.when(mockClustersExt.create(Mockito.any(CreateCluster.class))).thenReturn(mockWait);
    Mockito.when(mockWait.getResponse()).thenReturn(mockResponse);

    // Replace <spark-version> with the target Spark version string.
    // Replace <node-type-id> with the target node type string.
    CreateClusterResponse response = Helpers.createCluster(
      mockWorkspaceClient,
      mockCreateCluster,
      "My Test Cluster",
      "<spark-version>",
      "<node-type-id>",
      15L,
      1L
    );
    assertEquals(mockResponse, response);
  }
}

Recursos adicionais

Para saber mais, veja: