Databricks SDK per Java

Nota

Databricks consiglia i bundle di asset di Databricks per la creazione, lo sviluppo, la distribuzione e il test di processi e altre risorse di Databricks come codice sorgente. Consulta Cosa sono i Databricks Asset Bundle?.

Questo articolo illustra come automatizzare le operazioni di Azure Databricks e accelerare lo sviluppo con Databricks SDK per Java. Questo articolo integra Databricks SDK per Java README, informazioni di riferimento sulle API ed esempi.

Nota

Questa funzionalità è in versione beta e può essere usata nell'ambiente di produzione.

Durante il periodo beta, Databricks consiglia di aggiungere una dipendenza dalla versione secondaria specifica di Databricks SDK per Java da cui dipende il codice. Ad esempio, è possibile aggiungere dipendenze nei file, pom.xml ad esempio per Maven. Per altre informazioni sull'aggiunta delle dipendenze, vedere Introduzione al meccanismo di dipendenza.

Operazioni preliminari

Prima di iniziare a usare Databricks SDK per Java, il computer di sviluppo deve avere:

Autenticazione di Azure Databricks configurata.
Java Development Kit (JDK) compatibile con Java 8 o versione successiva. I test di integrazione continua con Databricks SDK per Java sono compatibili con Java versioni 8, 11, 17 e 20.
È consigliabile un ambiente di sviluppo integrato compatibile con Java. Databricks consiglia IntelliJ IDEA.

Introduzione a Databricks SDK per Java

Nel file del tuo progetto pom.xml, istruisci il sistema di compilazione a includere come dipendenza il Databricks SDK per Java. A tale scopo, aggiungere quanto segue <dependency> alla pom.xml sezione esistente <dependencies> del file. Se la <dependencies> sezione non esiste già all'interno del pom.xml file, è necessario aggiungere anche l'elemento <dependencies> padre al pom.xml file.

Ad esempio, per aprire il file del pom.xml progetto in IntelliJ IDEA, fare clic su Visualizza > Finestre degli strumenti > Progetto e quindi fare doppio clic per aprire nome-progetto> src > pom.xml.
```
<dependencies>
  <dependency>
    <groupId>com.databricks</groupId>
    <artifactId>databricks-sdk-java</artifactId>
    <version>0.0.1</version>
  </dependency>
</dependencies>
```
Nota

Assicurarsi di sostituire 0.0.1 con la versione più recente di Databricks SDK per Java. È possibile trovare la versione più recente nel repository centrale Maven.
Indicare al progetto di accettare la dipendenza dichiarata da Databricks SDK per Java. Ad esempio, in IntelliJ IDEA, nella finestra dello strumento Progetto del progetto fare clic con il pulsante destro del mouse sul nodo radice del progetto e quindi scegliere Ricarica progetto.
Aggiungere il codice per importare Databricks SDK per Java e elencare tutti i cluster nell'area di lavoro di Azure Databricks. Ad esempio, nel file di Main.java un progetto il codice potrebbe essere il seguente:
```
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

Non impostando argomenti nella chiamata precedente a WorkspaceClient w = new WorkspaceClient(), Databricks SDK per Java usa il processo predefinito per tentare di eseguire l'autenticazione di Azure Databricks. Per eseguire l'override di questo comportamento predefinito, consultare la sezione di autenticazione seguente.
Crea il progetto. Ad esempio, per eseguire questa operazione in IntelliJ IDEA, scegliere Compila > progetto di compilazione dal menu principale.
Eseguire il file principale. Ad esempio, per eseguire questa operazione in IntelliJ IDEA per il file di Main.java un progetto, dal menu principale fare clic su Esegui > 'Main'.
Viene visualizzato l'elenco dei cluster. Ad esempio, in IntelliJ IDEA si trova nella finestra degli strumenti Esegui. Per visualizzare questa finestra degli strumenti, dal menu principale fare clic su Visualizza finestra strumenti >> Esegui.

Autenticare Databricks SDK per Java con l'account o l'area di lavoro di Azure Databricks

Databricks SDK per Java implementa lo standard di autenticazione unificata di Databricks , un approccio architetturale consolidato e coerente e programmatico all'autenticazione. Questo approccio consente di configurare e automatizzare l'autenticazione con Azure Databricks più centralizzato e prevedibile. Consente di configurare l'autenticazione di Databricks una sola volta e quindi di usarla tra più strumenti e SDK di Databricks senza ulteriori modifiche alla configurazione dell'autenticazione. Per altre informazioni, inclusi esempi di codice più completi in Java, vedere Autenticazione unificata di Databricks.

Nota

Databricks SDK per Java non ha ancora implementato l'autenticazione con le identità gestite di Azure.

Alcuni dei modelli di codifica disponibili per inizializzare l'autenticazione di Databricks con Databricks SDK per Java includono:

Usare l'autenticazione predefinita di Databricks eseguendo una delle operazioni seguenti:
- Creare o identificare un profilo di configurazione di Databricks personalizzato con i campi obbligatori per il tipo di autenticazione databricks di destinazione. Impostare quindi la variabile di ambiente DATABRICKS_CONFIG_PROFILE sul nome del profilo di configurazione personalizzato.
- Impostare le variabili di ambiente necessarie per il tipo di autenticazione di Databricks di destinazione.
Creare quindi un'istanza di un oggetto WorkspaceClient con l'autenticazione predefinita di Databricks come indicato di seguito:
```
import com.databricks.sdk.WorkspaceClient;
// ...
WorkspaceClient w = new WorkspaceClient();
// ...
```
L’hardcoded dei campi obbligatori è supportato ma non consigliato, perché rischia di esporre informazioni riservate nel codice, ad esempio i token di accesso personale di Azure Databricks. L'esempio seguente codifica in modo fisso i valori dell'host di Azure Databricks e del token di accesso per l'autenticazione del token di Databricks:
```
import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.core.DatabricksConfig;
// ...
DatabricksConfig cfg = new DatabricksConfig()
  .setHost("https://...")
  .setToken("...");
WorkspaceClient w = new WorkspaceClient(cfg);
// ...
```

Vedere anche Autenticazione in Databricks SDK per Java README.

Usare le utilità di Databricks e Java con Databricks SDK per Java

Databricks Utilities offre diverse funzioni helper per semplificare l'uso dell'archiviazione di oggetti in modo efficiente, concatenare e parametrizzare i notebook e usare segreti. Databricks offre una libreria Databricks Utilities per Scala , che è possibile chiamare con codice Java, per consentire di accedere a livello di codice alle utilità di Databricks.

Per usare il codice Java per chiamare le utilità di Databricks per Scala, eseguire le operazioni seguenti:

Nel progetto Java dichiarare una dipendenza da Databricks SDK per Java, come descritto nella sezione precedente.
Dichiarare una dipendenza dalle utilità di Databricks per la libreria Scala. A tale scopo, aggiungere quanto segue <dependency> alla pom.xml sezione esistente <dependencies> del file:
```
<dependency>
  <groupId>com.databricks</groupId>
  <artifactId>databricks-dbutils-scala_2.12</artifactId>
  <version>0.1.4</version>
</dependency>
```
Nota

Assicurarsi di sostituire 0.1.4 con la versione più recente della libreria Databricks Utilities for Scala. È possibile trovare la versione più recente nel repository centrale Maven.
Indicare al progetto di accettare la dipendenza dichiarata dalle utilità di Databricks per Scala. Ad esempio, in IntelliJ IDEA, nella finestra dello strumento Project del progetto fare clic sul nodo radice del progetto e quindi su Maven > Reload Project.

Aggiungere il codice da importare e quindi chiamare l'utilità Databricks per Scala. Ad esempio, il codice seguente automatizza un volume del catalogo Unity. Questo esempio crea un file denominato zzz_hello.txt nel percorso del volume all'interno dell'area di lavoro, legge i dati dal file e quindi elimina il file:

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

Compilare il progetto ed eseguire il file principale.

Esempi di codice

Gli esempi di codice seguenti illustrano come usare Databricks SDK per Java per creare ed eliminare cluster, creare processi ed elencare gruppi a livello di account. Questi esempi di codice usano il processo di autenticazione predefinito di Azure Databricks SDK per Java.

Per altri esempi di codice, vedere la cartella degli esempi nel repository Databricks SDK per Java in GitHub.

Creare un cluster
- Creare un cluster con una versione JDK specifica
Eliminare in modo definitivo un cluster
Creare un processo
Gestire i file nei volumi del catalogo Unity
Elencare i gruppi a livello di account

Creare un cluster

Questo esempio di codice crea un cluster con la versione di Databricks Runtime e il tipo di nodo del cluster specificati. Questo cluster ha un ruolo di lavoro e il cluster terminerà automaticamente dopo 15 minuti di inattività.

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

Creare un cluster con una versione JDK specifica

È possibile creare un cluster che usa una versione specifica di Java Development Kit (JDK).

Nota

Per Databricks Runtime 18.0, JDK 21 è generalmente disponibile ed è l'impostazione predefinita, con JDK 17 come opzione di fallback.
Per Databricks Runtime 17.3, JDK 21 è in anteprima pubblica e JDK 17 è l'impostazione predefinita.
Per Databricks Runtime 16.0 o versione successiva, JDK 17 è generalmente disponibile ed è il valore predefinito.
Per Databricks Runtime versioni da 13.1 a 15.4, JDK 8 è l'impostazione predefinita e JDK 17 è in anteprima pubblica.

Quando si crea un cluster, specificare che il cluster usa JDK 17 o JDK 21 sia per il driver che per l'executor aggiungendo la variabile di ambiente seguente a Opzioni avanzate Variabili > di ambiente Spark>.

Per JDK 17:

JNAME=zulu17-ca-amd64

Per JDK 21:

JNAME=zulu21-ca-amd64

Eliminare in modo definitivo un cluster

Questo esempio di codice elimina definitivamente il cluster con l'ID cluster specificato dall'area di lavoro.

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

Creare un processo

Questo esempio di codice crea un processo di Azure Databricks che può essere usato per eseguire il notebook specificato nel cluster specificato. Durante l'esecuzione di questo codice, ottiene il percorso del notebook esistente, l'ID cluster esistente e le impostazioni del processo correlate dall'utente nel terminale.

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

Gestire i file nei volumi di Unity Catalog

Questo esempio di codice illustra varie chiamate alla funzionalità di files all'interno di WorkspaceClient per accedere a un volume di Unity Catalog.

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

Elencare i gruppi a livello di account

Questo esempio di codice elenca i nomi visualizzati per tutti i gruppi disponibili all'interno dell'account 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());
    }
  }
}

Usare Scala con Databricks SDK per Java

È possibile usare progetti Scala con Databricks SDK per Java. Prima di iniziare, il computer di sviluppo deve avere:

Autenticazione di Azure Databricks configurata.
È consigliabile un ambiente di sviluppo integrato compatibile con Scala. Databricks consiglia IntelliJ IDEA con il plug-in Scala. Queste istruzioni sono state testate con IntelliJ IDEA Community Edition 2023.3.6. Se si usa una versione o un'edizione diversa di IntelliJ IDEA, le istruzioni seguenti possono variare.
Java Development Kit (JDK) compatibile con Java 8 o versione successiva. Se si vogliono eseguire le applicazioni o usare le librerie in un cluster Azure Databricks, Databricks consiglia di usare una versione di JDK corrispondente alla versione JDK nel cluster. Per trovare la versione di JDK inclusa in un runtime di Databricks specifico, vedere Versioni e compatibilità delle note sulla versione di Databricks Runtime. Se si usa IntelliJ IDEA, è possibile scegliere un'installazione JDK locale esistente o installare un nuovo JDK in locale durante la creazione del progetto Scala.
Strumento di compilazione Scala. Databricks consiglia sbt. Se si usa IntelliJ IDEA, è possibile scegliere la versione da usare durante la sbt creazione del progetto Scala.
Scala. Se si vogliono eseguire le applicazioni o usare le librerie in un cluster Di Azure Databricks, Databricks consiglia di usare una versione di Scala corrispondente alla versione scala nel cluster. Per trovare la versione scala inclusa in un runtime di Databricks specifico, vedere Versioni e compatibilità delle note sulla versione di Databricks Runtime. Se si usa IntelliJ IDEA, è possibile scegliere la versione scala da usare durante la creazione del progetto Scala.

Per configurare, compilare ed eseguire il progetto Scala:

Nel file del build.sbt progetto, aggiungere una dipendenza dalla libreria Databricks SDK per Java aggiungendo la riga seguente alla fine del file, quindi salvare.
```
libraryDependencies += "com.databricks" % "databricks-sdk-java" % "0.2.0"
```
Nota

Assicurarsi di sostituire 0.2.0 con la versione più recente della libreria Databricks SDK per Java. È possibile trovare la versione più recente nel repository centrale Maven.
Indicare al progetto di accettare la dipendenza dichiarata da Databricks SDK per Java. Ad esempio, in IntelliJ IDEA fare clic sull'icona di notifica Carica modifiche sbt .
Aggiungere il codice per importare Databricks SDK per Java e elencare tutti i cluster nell'area di lavoro di Azure Databricks. Ad esempio, nel file di Main.scala un progetto il codice potrebbe essere il seguente:
```
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

Non impostando argomenti nella chiamata precedente a val w = new WorkspaceClient(), Databricks SDK per Java usa il processo predefinito per tentare di eseguire l'autenticazione di Azure Databricks. Per eseguire l'override di questo comportamento predefinito, consultare la sezione di autenticazione seguente.
Crea il progetto. Ad esempio, per eseguire questa operazione in IntelliJ IDEA, scegliere Compila > progetto di compilazione dal menu principale.
Eseguire il file principale. Ad esempio, per eseguire questa operazione in IntelliJ IDEA per il file di Main.scala un progetto, dal menu principale fare clic su Esegui ' > Main.scala'.
Viene visualizzato l'elenco dei cluster. Ad esempio, in IntelliJ IDEA si trova nella finestra degli strumenti Esegui. Per visualizzare questa finestra degli strumenti, dal menu principale fare clic su Visualizza finestra strumenti >> Esegui.

Usare le utilità di Databricks e Scala con Databricks SDK per Java

Databricks Utilities offre diverse funzioni helper per semplificare l'uso dell'archiviazione di oggetti in modo efficiente, concatenare e parametrizzare i notebook e usare segreti. Databricks fornisce una libreria Databricks utilities per Scala per consentire l'accesso a livello di codice alle utilità di Databricks con Scala.

Per chiamare le utilità di Databricks per Scala, eseguire le operazioni seguenti:

Nel progetto Scala dichiarare una dipendenza da Databricks SDK per Java, come descritto nella sezione precedente.
Dichiarare una dipendenza dalle utilità di Databricks per la libreria Scala. Ad esempio, nel file del build.sbt progetto aggiungere la riga seguente alla fine del file e quindi salvare il file:
```
libraryDependencies += "com.databricks" % "databricks-dbutils-scala_2.12" % "0.1.4"
```
Nota

Assicurarsi di sostituire 0.1.4 con la versione più recente della libreria Databricks Utilities for Scala. È possibile trovare la versione più recente nel repository centrale Maven.
Indicare al progetto di accettare la dipendenza dichiarata dalle utilità di Databricks per Scala. Ad esempio, in IntelliJ IDEA fare clic sull'icona di notifica Carica modifiche sbt .
Aggiungere il codice da importare e quindi chiamare l'utilità Databricks per Scala. Ad esempio, il codice seguente automatizza un volume del catalogo Unity. Questo esempio crea un file denominato zzz_hello.txt nel percorso del volume all'interno dell'area di lavoro, legge i dati dal file e quindi elimina il file:
```
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

Non impostando argomenti nella chiamata precedente a val dbutils = DBUtils.getDBUtils(), Databricks Utilities for Scala usa il processo predefinito per tentare di eseguire l'autenticazione di Azure Databricks.

Per eseguire l'override di questo comportamento predefinito, passare un oggetto di cui è stata creata DatabricksCfg un'istanza come argomento a getDBUtils. Per altre informazioni, vedere la sezione relativa all'autenticazione precedente.

Si noti, tuttavia, che se il codice è in esecuzione all'interno di Databricks Runtime, questo DatabricksCfg oggetto viene ignorato. Ciò è dovuto al fatto che le utilità di Databricks per i delegati Scala alle utilità databricks predefinite durante l'esecuzione all'interno del runtime di Databricks.
Compilare il progetto ed eseguire il file principale.

Per accedere ai volumi del catalogo Unity, usare files all'interno di WorkspaceClient. Consultare Gestire i file nei volumi di Unity Catalog. Non è possibile usare DBUtils.getDBUtils() per accedere ai volumi.

Test

Per testare il codice, usare framework di test Java come JUnit. Per testare il codice in condizioni simulate senza chiamare gli endpoint dell'API REST di Azure Databricks o modificare lo stato degli account o delle aree di lavoro di Azure Databricks, usare librerie java fittizie come Mockito.

Ad esempio, dato il file seguente denominato Helpers.java contenente una funzione createCluster che restituisce informazioni sul nuovo 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 dato il file seguente denominato Main.java che chiama la funzione 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());
  }
}

Il file seguente denominato HelpersTest.java verifica se la funzione createCluster restituisce la risposta prevista. Anziché creare un cluster nell'area di lavoro di destinazione, questo test simula un WorkspaceClient oggetto, definisce le impostazioni dell'oggetto fittizio e quindi passa l'oggetto fittizio alla createCluster funzione. Il test verifica quindi se la funzione restituisce l'ID previsto del nuovo cluster fittizio.

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

Risoluzione dei problemi

Questa sezione descrive le soluzioni ai problemi comuni relativi a Databricks SDK per Java.

Per segnalare problemi o altri commenti e suggerimenti, creare un problema di GitHub per Databricks SDK per Java.

Errore: Impossibile analizzare la risposta

Se viene visualizzato l'errore seguente quando si tenta di usare Databricks SDK per Java, indica quasi sempre un problema con la configurazione di autenticazione.

Error: unable to parse response. This is likely a bug in the Databricks SDK for Java or the underlying REST API.

Se si verifica questo errore, verificare quanto segue:

Verificare che l'host Databricks sia impostato correttamente.
Verificare che il metodo di autenticazione disponga delle autorizzazioni necessarie per l'operazione API che si sta tentando di eseguire.
Se si è protetti da un firewall aziendale, assicurarsi che non blocchi o reindirizzi il traffico dell'API.

Una causa comune di questo errore è il collegamento privato che reindirizza l'SDK a una pagina di accesso, che l'SDK non può elaborare. Ciò si verifica in genere quando si tenta di accedere a un'area di lavoro abilitata per il collegamento privato configurata senza accesso a Internet pubblico da una rete diversa da quella a cui appartiene l'endpoint VPC.

Per altri dettagli, vedere:

Autenticazione unificata di Databricks

Configurare la connettività privata di back-end ad Azure Databricks.

Risorse aggiuntive

Per altre informazioni, vedi:

DATAbricks SDK per Java README
Informazioni di riferimento su Databricks SDK per l'API Java
Esempi di codice aggiuntivi
Registrazione
Operazioni a esecuzione prolungata
Risposte impaginate

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-12-09

Condividi tramite

Databricks SDK per Java

Operazioni preliminari

Introduzione a Databricks SDK per Java

Autenticare Databricks SDK per Java con l'account o l'area di lavoro di Azure Databricks

Usare le utilità di Databricks e Java con Databricks SDK per Java

Esempi di codice

Creare un cluster

Creare un cluster con una versione JDK specifica

Eliminare in modo definitivo un cluster

Creare un processo

Gestire i file nei volumi di Unity Catalog

Elencare i gruppi a livello di account

Usare Scala con Databricks SDK per Java

Usare le utilità di Databricks e Scala con Databricks SDK per Java

Test

Risoluzione dei problemi

Errore: Impossibile analizzare la risposta

Risorse aggiuntive

Commenti e suggerimenti

Risorse aggiuntive