Partilhar via

Databricks SDK para Java

  • Artigo

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

Nota

Este 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 o Maven. Para obter mais informações sobre fixar dependências, consulte Introdução ao mecanismo de dependência.

Antes de começar

Antes de começar a usar o Databricks SDK for Java, sua máquina de desenvolvimento deve ter:

  • Autenticação do Azure Databricks configurada.
  • Um Java Development Kit (JDK) compatível com Java 8 ou superior. O teste de integração contínua (CI) com o Databricks SDK for 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. A Databricks recomenda o IntelliJ IDEA.

Introdução ao SDK do Databricks para Java

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

    Por exemplo, para abrir o arquivo do pom.xml seu projeto no IntelliJ IDEA, clique em View > Tool Windows > Project e, em seguida, clique duas vezes para abrir o pom.xml src > do nome> do projeto.

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

    Nota

    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 da ferramenta Projeto do projeto, clique com o botão direito do mouse no nó raiz do projeto e clique em Recarregar Projeto.

  3. Adicione código para importar o SDK do Databricks para Java e listar todos os clusters em seu espaço de trabalho do Azure Databricks. Por exemplo, no arquivo de Main.java 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());
    }
  }
}

    Nota

    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 de autenticação a seguir.

  4. Recompile o seu projeto. Por exemplo, para fazer isso no IntelliJ IDEA, no menu principal, clique em Build > Build Project.

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

  6. A lista de clusters é exibida. Por exemplo, no IntelliJ IDEA, isso está na janela da ferramenta Executar . Para exibir essa janela de ferramenta, no menu principal, clique em Exibir > Ferramenta Executar do Windows>.

Autenticar o SDK do Databricks para Java com sua conta ou espaço de trabalho do Azure Databricks

O SDK do Databricks para Java implementa o padrão de autenticação unificada do cliente 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 centralizadas e previsíveis. Ele permite que você configure a autenticação do Databricks uma vez e, em seguida, use essa configuração em várias ferramentas e SDKs do Databricks sem mais alterações na configuração de autenticação. Para obter mais informações, incluindo exemplos de código mais completos em Java, consulte Autenticação unificada do cliente Databricks.

Nota

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

Alguns dos padrões de codificação disponíveis para inicializar a autenticação Databricks com o Databricks SDK for Java incluem:

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

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

    Em seguida, instancie, por exemplo, um WorkspaceClient objeto com a autenticação padrão do Databricks da seguinte maneira:

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

  • A codificação rígida 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 valores de token de host e acesso do Azure Databricks para autenticação de token Databricks:

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

Consulte também Autenticação no Databricks SDK for Java README.

Use utilitários Databricks e Java com o SDK Databricks para Java

O Databricks Utilities fornece várias funções auxiliares para facilitar o trabalho com armazenamento de objetos de forma eficiente, encadear e parametrizar notebooks e trabalhar com segredos. O Databricks fornece uma biblioteca Databricks Utilities for Scala , que você pode chamar com código Java, para permitir que você acesse programaticamente o Databricks Utilities.

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

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

  2. Declare uma dependência na biblioteca Databricks Utilities for Scala. Para fazer isso, adicione o seguinte <dependency> à seção existente <dependencies> do pom.xml arquivo:

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

    Nota

    Certifique-se de substituir 0.1.4 pela versão mais recente da biblioteca Databricks Utilities for 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 do Databricks Utilities for Scala. Por exemplo, no IntelliJ IDEA, na janela da ferramenta Project do seu projeto, clique no nó raiz do seu projeto e, em seguida, clique em Maven > Reload Project.

  4. Adicione código para importar e, em seguida, chame o utilitário Databricks para Scala. Por exemplo, o código a seguir automatiza um volume do Catálogo Unity. Este exemplo cria um arquivo nomeado zzz_hello.txt no caminho do volume dentro do espaço de trabalho, 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 seu arquivo principal.

Exemplos de código

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

Para obter exemplos de código adicionais, consulte a pasta de exemplos no repositório Databricks SDK for 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 trabalhador 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 use o JDK 17

Nota

O JDK 8 é totalmente suportado. O JDK 17 está no Public Preview for Databricks Runtime versões 13.1 e superiores.

Esta seção fornece um guia para criar um cluster usando 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 Variáveis de Ambiente do Spark > de Opções > Avançadas:

JNAME=zulu17-ca-amd64

Excluir permanentemente um cluster

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

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 usado para executar o bloco de anotações especificado no cluster especificado. À medida que esse código é executado, ele obtém o caminho do bloco de anotações existente, o 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 Unity

Este exemplo de código demonstra várias chamadas para files funcionalidade dentro WorkspaceClient para acessar um volume do Catálogo 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 para 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 usar projetos Scala com o Databricks SDK for Java. Antes de começar, sua máquina de desenvolvimento deve ter:

  • Autenticação do Azure Databricks configurada.
  • Recomenda-se um ambiente de desenvolvimento integrado (IDE) compatível com Scala. A Databricks recomenda o IntelliJ IDEA com o plugin Scala. Estas 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 podem variar.
  • Um Java Development Kit (JDK) compatível com Java 8 ou superior. Se você quiser executar seus aplicativos ou usar suas bibliotecas em um cluster do Azure Databricks, o Databricks recomenda que você use uma versão do JDK que corresponda à versão do JDK no cluster. Para localizar a versão do JDK incluída em um Databricks Runtime específico, consulte Versões e compatibilidade das notas de versão do Databricks Runtime. Se você usar 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 construção Scala. Databricks recomenda sbt. Se você usa o IntelliJ IDEA, pode escolher a versão a ser usada durante a criação do sbt projeto Scala.
  • Scala. Se você quiser executar seus aplicativos ou usar suas bibliotecas em um cluster do Azure Databricks, o Databricks recomenda que você use uma versão do Scala que corresponda à versão do Scala no cluster. Para localizar a versão do Scala incluída em um Databricks Runtime específico, consulte Versões e compatibilidade das notas de versão do Databricks Runtime. Se você usa o IntelliJ IDEA, pode escolher a versão Scala para usar durante a criação do projeto Scala.

Para configurar, compilar e executar seu projeto Scala:

  1. No arquivo do build.sbt seu projeto, dependa da biblioteca Databricks SDK for Java adicionando a seguinte linha ao final do arquivo e salve o arquivo:

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

    Nota

    Certifique-se de substituir 0.2.0 pela versão mais recente da biblioteca Databricks SDK for 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 código para importar o SDK do Databricks para Java e listar todos os clusters em seu espaço de trabalho do Azure Databricks. Por exemplo, no arquivo de Main.scala 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)
    }
  }
}

    Nota

    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 de autenticação a seguir.

  4. Recompile o seu projeto. Por exemplo, para fazer isso no IntelliJ IDEA, no menu principal, clique em Build > Build Project.

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

  6. A lista de clusters é exibida. Por exemplo, no IntelliJ IDEA, isso está na janela da ferramenta Executar . Para exibir essa janela de ferramenta, no menu principal, clique em Exibir > Ferramenta Executar do Windows>.

Usar utilitários Databricks e Scala com o SDK Databricks para Java

O Databricks Utilities fornece várias funções auxiliares para facilitar o trabalho com armazenamento de objetos de forma eficiente, encadear e parametrizar notebooks e trabalhar com segredos. O Databricks fornece uma biblioteca Databricks Utilities for Scala para permitir que você acesse programaticamente o Databricks Utilities com o Scala.

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

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

  2. Declare uma dependência na biblioteca Databricks Utilities for Scala. Por exemplo, no arquivo do build.sbt seu projeto, adicione a seguinte linha ao final do arquivo e salve o arquivo:

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

    Nota

    Certifique-se de substituir 0.1.4 pela versão mais recente da biblioteca Databricks Utilities for 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 do Databricks Utilities for 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 Databricks para Scala. Por exemplo, o código a seguir automatiza um volume do Catálogo Unity. Este exemplo cria um arquivo nomeado zzz_hello.txt no caminho do volume dentro do espaço de trabalho, 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)
  }
}

    Nota

    Ao não definir nenhum argumento na chamada anterior para val dbutils = DBUtils.getDBUtils(), o Databricks Utilities for Scala usa 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, consulte a seção de autenticação anterior.

    Observe, no entanto, que se seu código estiver sendo executado dentro do Databricks Runtime, esse DatabricksCfg objeto será ignorado. Isso ocorre porque os Utilitários Databricks para Scala delegam aos Utilitários Databricks internos quando executados dentro do Databricks Runtime.

  5. Crie seu projeto e execute seu arquivo principal.

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

Testar

Para testar seu código, use estruturas de teste 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 espaços de trabalho do Azure Databricks, use bibliotecas simuladas Java, como o Mockito.

Por exemplo, dado o seguinte arquivo chamado Helpers.java contendo uma createCluster função 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 createCluster função:

// 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 a seguir chamado HelpersTest.java testa se a createCluster função retorna a resposta esperada. Em vez de criar um cluster no espaço de trabalho de destino, esse teste simula um WorkspaceClient objeto, define as configurações do objeto simulado e, em seguida, passa o objeto simulado para a createCluster função. 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 obter mais informações, consulte: