Pular para o conteúdo principal

Databricks SDK para Java

nota

Databricks recomenda o Databricks ativo Bundles para criar, desenvolver, implantar e testar o Job e outros Databricks recursos como código-fonte. Veja o que são Databricks ativo Bundles?

Neste artigo, o senhor aprenderá como automatizar Databricks operações e acelerar o desenvolvimento com o Databricks SDK para Java. Este artigo complementa o Databricks SDK para Java README, API referência e exemplos.

nota

Esse recurso está na versão beta e não pode ser usado na produção.

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

Antes de começar​

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

  • Autenticação do Databricks configurada.
  • Um Java Development Kit (JDK) compatível com Java 8 ou acima. O teste de integração contínua (CI) com o Databricks SDK para Java é compatível com as versões 8, 11, 17 e 20 do Java.
  • Um ambiente de desenvolvimento integrado (IDE) compatível com Java é recomendado. A Databricks recomenda o IntelliJ IDEA.

Comece a usar o Databricks SDK para Java​

  1. No arquivo pom.xml do seu projeto, instrua o sistema de compilação a obter uma dependência do SDK da Databricks para Java. Para fazer isso, adicione o <dependency> a seguir à seção <dependencies> existente do 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 pom.xml do seu projeto em IntelliJ IDEA, clique em view > Tool Windows > Project e, em seguida, clique duas vezes para abrir your-project-name > src > pom.xml .

    XML
    <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 Databricks SDK for Java. O senhor pode encontrar a versão mais recente no repositório central do Maven.

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

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

    Java
    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 Databricks SDK para Java usa seu processo default para tentar realizar a autenticação Databricks. Para substituir esse comportamento do default, consulte a seção de autenticação a seguir.

  1. Crie seu projeto. Por exemplo, para fazer isso no IntelliJ IDEA, no menu principal, clique em Build > Build Project .

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

  3. A lista de clustering é exibida. Por exemplo, em IntelliJ IDEA, isso ocorre na janela da ferramenta de execução . Para exibir essa janela de ferramenta, no menu principal, clique em view > Tool Windows > execução .

Autentique o Databricks SDK para Java com seu Databricks account ou workspace​

O Databricks SDK 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 automatização da autenticação com o Databricks mais centralizada e previsível. Ele permite que o senhor configure a autenticação do Databricks uma vez e, em seguida, use essa configuração em várias ferramentas e SDKs do Databricks sem outras alterações na configuração da autenticação. Para obter mais informações, incluindo exemplos de código mais completos em Java, consulte Databricks autenticação unificada de cliente.

Alguns dos padrões de codificação disponíveis para inicializar a autenticação da Databricks com o SDK da Databricks para 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 de destino do Databricks. Em seguida, defina a variável de ambiente DATABRICKS_CONFIG_PROFILE com 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, instancie, por exemplo, um objeto WorkspaceClient com autenticação default do Databricks da seguinte maneira:

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

  • Embora seja possível codificar diretamente os campos necessários, não é aconselhável, pois isso pode expor informações confidenciais em seu código, como access tokens pessoais do Databricks. O exemplo a seguir codifica o host do Databricks e valores de access token para autenticação de token do Databricks:

    Java
    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 LEIAME do Databricks SDK para Java.

Use Databricks utilidades e Java com o Databricks SDK para Java​

Databricks O utilidades fornece várias funções auxiliares para facilitar o trabalho com o armazenamento de objetos de forma eficiente, encadear e parametrizar o Notebook e trabalhar com segredos. Databricks fornece um Databricks utilidades para Scala biblioteca, que pode ser chamado com o código Java, para permitir que o senhor acesse programaticamente Databricks utilidades.

Para usar o código Java para chamar as utilidades Databricks para Scala, faça o seguinte:

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

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

    XML
    <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 do site Databricks utilidades para Scala biblioteca. O senhor pode encontrar a versão mais recente no repositório central do Maven.

  1. Instrua seu projeto a assumir a dependência declarada no site Databricks utilidades para Scala. Por exemplo, no IntelliJ IDEA, na janela da ferramenta Projeto do seu projeto, clique no nó raiz do projeto e, em seguida, clique em Maven > Reload Project .

  2. Adicione código para importar e, em seguida, chame os utilitários Databricks para Scala. Por exemplo, o código a seguir automatiza um volume do Unity Catalog. Este exemplo cria um arquivo chamado zzz_hello.txt no caminho do volume dentro do site workspace, lê os dados do arquivo e, em seguida, exclui o arquivo:

    Java
    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);
      }
    }

  3. Compile seu projeto e execute seu arquivo principal.

Exemplos de código​

Os exemplos de código a seguir demonstram como usar o Databricks SDK para Java para criar e excluir clustering, criar Job e listar account-level groups. Esses exemplos de código usam o Databricks SDK para Javao default Databricks processo de autenticação do's .

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

Criar um clustering​

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

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

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

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

Criar um clustering que use o JDK 17​

nota

Para o Databricks Runtime 16.0 ou acima, o JDK 17 está geralmente disponível e o default. Para as versões 13.1 a 15.4 do Databricks Runtime, o JDK 8 é o default, e o JDK 17 está em Public Preview.

Esta seção fornece um guia para a criação de um clustering usando o Java Development Kit (JDK). Saiba como criar um clustering com o JDK 17 para usar o Java em seu Notebook e Job.

Quando o senhor criar um cluster, especifique que o cluster usa o JDK 17 para o driver e o site executor adicionando a seguinte variável de ambiente a Advanced Options > Spark > variável de ambiente :

Bash
JAVA_HOME=/usr/lib/jvm/zulu17-ca-amd64

Em seguida, aplique o seguinte init script. Consulte Script de inicialização com escopo de cluster para obter mais informações sobre o script de inicialização.

Bash
set -e

JNAME="zulu17-ca-amd64"

update-java-alternatives -s $JNAME

JNAME_PATH=`update-java-alternatives -l $JNAME | awk '{print $3}'`

echo "JAVA_HOME=$JNAME_PATH" >> /etc/environment

Excluir permanentemente um clustering​

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

Java
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​

Esse exemplo de código cria um trabalho Databricks que pode ser usado para executar o Notebook especificado no clustering especificado. Ao executar esse código, ele obtém o caminho do Notebook existente, o ID de clustering existente e as configurações de trabalho relacionadas do usuário no terminal.

Java
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 Unity Catalog volumes​

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

Java
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);
  }
}

Lista account-level groups​

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

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

Use o Scala com o SDK da Databricks para Java​

O senhor pode usar projetos Scala com o Databricks SDK para Java. Antes de começar, sua máquina de desenvolvimento deve ter:

  • Autenticação do Databricks configurada.
  • Recomenda-se um ambiente de desenvolvimento integrado (IDE) compatível com Scala. A Databricks recomenda o IntelliJ IDEA com o plug-in Scala. Essas instruções foram testadas com o IntelliJ IDEA Community Edition 2023.3.6. Se o senhor usar uma versão ou edição diferente do IntelliJ IDEA, as instruções a seguir poderão variar.
  • Um Java Development Kit (JDK) compatível com Java 8 ou acima. Se quiser executar seus aplicativos ou usar sua biblioteca em um cluster Databricks, o site Databricks recomenda que o senhor use uma versão do JDK que corresponda à versão do JDK no cluster. Para saber qual versão do JDK está incluída em um site específico Databricks Runtime, consulte Databricks Runtime notas sobre versões e compatibilidade. Se o senhor usar o IntelliJ IDEA, poderá escolher uma instalação local do JDK existente ou instalar um novo JDK localmente durante a criação do projeto Scala.
  • Uma ferramenta de construção Scala. A Databricks recomenda o site sbt. Se o senhor usar o IntelliJ IDEA, poderá escolher a versão do sbt a ser usada durante a criação do projeto Scala.
  • Scala. Se quiser executar seus aplicativos ou usar sua biblioteca em um cluster Databricks, o Databricks recomenda que o senhor use uma versão do Scala que corresponda à versão do Scala no cluster. Para encontrar a versão Scala que está incluída em um Databricks Runtime específico, consulte Databricks Runtime notas sobre versões e compatibilidade. Se o senhor usar o IntelliJ IDEA, poderá escolher a versão do Scala a ser usada durante a criação do projeto Scala.

Para configurar, criar e executar seu projeto Scala:

  1. No arquivo build.sbt do seu projeto, crie uma dependência da biblioteca Databricks SDK for Java adicionando a seguinte linha ao final do arquivo e, em seguida, 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. O senhor pode encontrar a versão mais recente no repositório central do Maven.

  1. Instrua seu projeto a assumir a dependência declarada do Databricks SDK para Java. Por exemplo, no IntelliJ IDEA, clique no ícone de notificação Load sbt changes .

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

    Scala
    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 Databricks SDK para Java usa seu processo default para tentar realizar a autenticação Databricks. Para substituir esse comportamento do default, consulte a seção de autenticação a seguir.

  1. Crie seu projeto. Por exemplo, para fazer isso no IntelliJ IDEA, no menu principal, clique em Build > Build Project .

  2. execução de seu arquivo principal. Por exemplo, para fazer isso em IntelliJ IDEA para o arquivo Main.scala de um projeto, no menu principal, clique em execução > execução 'Main.Scala'.

  3. A lista de clustering é exibida. Por exemplo, em IntelliJ IDEA, isso ocorre na janela da ferramenta de execução . Para exibir essa janela de ferramenta, no menu principal, clique em view > Tool Windows > execução .

Use Databricks utilidades e Scala com o Databricks SDK para Java​

Databricks O utilidades fornece várias funções auxiliares para facilitar o trabalho com o armazenamento de objetos de forma eficiente, encadear e parametrizar o Notebook e trabalhar com segredos. Databricks fornece um Databricks utilidades para Scala biblioteca para permitir que o senhor acesse programaticamente Databricks utilidades com Scala.

Para chamar o Databricks utilidades 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. Declarar uma dependência do site Databricks utilidades para Scala biblioteca. Por exemplo, no arquivo build.sbt do seu projeto, adicione a seguinte linha ao final do arquivo e salve-o:

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

Certifique-se de substituir 0.1.4 pela versão mais recente do site Databricks utilidades para Scala biblioteca. O senhor pode encontrar a versão mais recente no repositório central do Maven.

  1. Instrua seu projeto a assumir a dependência declarada no site Databricks utilidades para Scala. Por exemplo, no IntelliJ IDEA, clique no ícone de notificação Load sbt changes .

  2. Adicione código para importar e, em seguida, chame os utilitários Databricks para Scala. Por exemplo, o código a seguir automatiza um volume do Unity Catalog. Este exemplo cria um arquivo chamado zzz_hello.txt no caminho do volume dentro do site workspace, lê os dados do arquivo e, em seguida, exclui o arquivo:

    Scala
    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(), Databricks utilidades para Scala usa seu processo default para tentar realizar a autenticação Databricks.

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

Observe, no entanto, que se o seu código estiver sendo executado dentro do Databricks Runtime, esse objeto DatabricksCfg será ignorado. Isso ocorre porque o Databricks utilidades for Scala delega ao Databricks utilidades integrado quando executado dentro do Databricks Runtime.

  1. Compile seu projeto e execute seu arquivo principal.

Para acessar os volumes do Unity Catalog, use files em WorkspaceClient. Consulte gerenciar arquivos em Unity Catalog volumes. Você não pode usar DBUtils.getDBUtils() para acessar volumes.

Testando​

Para testar seu código, use estruturas de teste Java, como o JUnit. Para testar seu código em condições simuladas sem chamar o endpoint Databricks REST API ou alterar o estado de sua conta ou espaço de trabalho Databricks, use a biblioteca de simulação Java, como o Mockito.

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

Java
// 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:

Java
// 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 seguinte arquivo chamado HelpersTest.java testa se a função createCluster retorna a resposta esperada. Em vez de criar um cluster no workspace de destino, este teste simula um objeto WorkspaceClient, define as configurações do objeto simulado e, em seguida, passa o objeto simulado para a função createCluster. O teste verifica se a função retorna o ID esperado do novo cluster simulado.

Java
// 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);
  }
}

Recurso adicional​

Para saber mais, consulte:

Última atualização em