Databricks SDK für Java

In diesem Artikel erfahren Sie, wie Sie Azure Databricks-Vorgänge automatisieren und die Entwicklung mit dem Databricks SDK für Java beschleunigen. Dieser Artikel ergänzt dieREADME-Datei, API-Referenz und Beispiele zu Databricks SDK für Java.

Voraussetzungen

Zur Verwendung des Databricks SDK für Java muss Ihr Entwicklungscomputer die folgenden Voraussetzungen erfüllen:

• Die Azure Databricks-Authentifizierung ist konfiguriert.
• Ein Java Development Kit (JDK), das mit Java 8 oder höher kompatibel ist. CI-Tests (Continuous Integration) mit dem Databricks SDK für Java sind mit den Java-Versionen 8, 11, 17 und 20 kompatibel.
• Eine mit Java kompatible integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) wird empfohlen. Databricks empfiehlt IntelliJ IDEA.

Erste Schritte mit dem Databricks SDK für Java

1. Weisen Sie in der Datei Ihres Projekts pom.xml Ihr Buildsystem an, eine Abhängigkeit vom Databricks SDK für Java zu übernehmen. Fügen Sie hierzu dem vorhandenen <dependency> Abschnitt der pom.xml Datei Folgendes <dependencies> hinzu. Wenn der Abschnitt <dependencies> noch nicht in der Datei pom.xml vorhanden ist, müssen Sie auch das übergeordnete <dependencies>-Element zur Datei pom.xml hinzufügen.

   Wenn Sie beispielsweise die Datei Ihres Projekts pom.xml in IntelliJ IDEA öffnen möchten, klicken Sie auf Ansicht > Tool-Fenster > Projekt, und doppelklicken Sie dann, um ihren-Projektnamen> src > pom.xml zu öffnen.

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

   Hinweis

   Ersetzen Sie 0.0.1 unbedingt durch die neueste Version des Databricks SDK für Java. Sie finden die neueste Version im zentralen Maven-Repository.

2. Weisen Sie Ihr Projekt an, die deklarierte Abhängigkeit vom Databricks SDK für Java zu übernehmen. Klicken Sie z. B. in IntelliJ IDEA im Projekttoolfenster des Projekts mit der rechten Maustaste auf den Stammknoten Des Projekts, und klicken Sie dann auf "Projekt erneut laden".

3. Fügen Sie Code hinzu, um das Databricks SDK für Java zu importieren und alle Cluster in Ihrem Azure Databricks-Arbeitsbereich aufzulisten. In der Datei eines Projekts Main.java kann der Code z. B. wie folgt aussehen:

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

   Hinweis

   Wenn Sie keine Argumente im obigen WorkspaceClient w = new WorkspaceClient()-Aufruf angeben, verwendet das Databricks SDK für Java den Standardprozess zur Durchführung der Azure Databricks-Authentifizierung. Informationen zum Überschreiben dieses Standardverhaltens finden Sie im folgenden Abschnitt zur Authentifizierung.

4. Erstellen Sie das Projekt. Um diesen Schritt beispielsweise in IntelliJ IDEA auszuführen, klicken Sie im Hauptmenü auf Build > Build Project.

5. Führen Sie Ihre Hauptdatei aus. Klicken Sie beispielsweise im Hauptmenü von IntelliJ IDEA für die Main.java Datei eines Projekts auf >.

6. Die Liste der Cluster wird angezeigt. Diese befindet sich beispielsweise in IntelliJ IDEA im Toolfenster Run. Um dieses Toolfenster anzuzeigen, klicken Sie im Hauptmenü auf View > Tool Windows > Run.

Authentifizieren des Databricks SDK für Java bei Ihrem Azure Databricks-Konto oder -Arbeitsbereich

Das Databricks SDK für Java implementiert den einheitlichen Databricks-Authentifizierungsstandard , einen konsolidierten und konsistenten architektur- und programmgesteuerten Ansatz für die Authentifizierung. Dieser Ansatz trägt dazu bei, die Einrichtung und Automatisierung der Authentifizierung mit Azure Databricks zentralisierter und vorhersagbarer zu gestalten. Er ermöglicht Ihnen, die Databricks-Authentifizierung einmal zu konfigurieren und diese Konfiguration dann für mehrere Databricks-Tools und -SDKs ohne weitere Änderungen an der Authentifizierungskonfiguration zu verwenden. Weitere Informationen, einschließlich ausführlicherer Codebeispiele in Java, finden Sie unter "Databricks unified authentication".

Einige der verfügbaren Codierungsmuster zur Initialisierung der Databricks-Authentifizierung mit dem Databricks-SDK für Java umfassen:

• Verwenden Sie die Databricks-Standardauthentifizierung, indem Sie eine der folgenden Aktionen ausführen:

  • Erstellen oder identifizieren Sie ein benutzerdefiniertes Databricks-Konfigurationsprofil mit den erforderlichen Feldern für den Databricks-Zielauthentifizierungstyp. Legen Sie dann die DATABRICKS_CONFIG_PROFILE-Umgebungsvariable auf den Namen des benutzerdefinierten Konfigurationsprofils fest.
  • Legen Sie die erforderlichen Umgebungsvariablen für den Databricks-Zielauthentifizierungstyp fest.

  Instanziieren Sie dann z. B. ein WorkspaceClient-Objekt mit Databricks-Standardauthentifizierung wie folgt:

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

• Das harte Codieren der erforderlichen Felder wird unterstützt, aber nicht empfohlen, da dadurch vertrauliche Informationen in Ihrem Code verfügbar gemacht werden könnten, z. B. persönliche Azure Databricks-Zugriffstoken. Im folgenden Beispiel werden Azure Databricks-Host- und Zugriffstokenwerte für die Databricks-Tokenauthentifizierung hart codiert:

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

Siehe auch Authentifizierung im Databricks SDK für Java README.

Verwenden von Databricks Utilities und Java mit dem Databricks SDK für Java

Databricks Utilities bietet mehrere Hilfsfunktionen, um das effiziente Arbeiten mit Objektspeicher, Verketten und Parametrisieren von Notebooks sowie das Arbeiten mit geheimen Schlüsseln zu vereinfachen. Databricks stellt eine Databricks Utilities for Scala-Bibliothek bereit, die Sie mit Java-Code aufrufen können, damit Sie programmgesteuert auf Databricks Utilities zugreifen können.

Gehen Sie wie folgt vor, um Java-Code zum Aufrufen der Databricks Utilitys for Scala zu verwenden:

1. Deklarieren Sie in Ihrem Java-Projekt eine Abhängigkeit vom Databricks-SDK für Java, wie im vorherigen Abschnitt beschrieben.

2. Deklarieren Sie eine Abhängigkeit von der Databricks Utilitys for Scala-Bibliothek. Fügen Sie hierzu dem vorhandenen <dependency> Abschnitt der pom.xml Datei Folgendes <dependencies> hinzu:

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

   Hinweis

   Ersetzen Sie 0.1.4 unbedingt durch die neueste Version der Databricks Utilitys for Scala-Bibliothek. Sie finden die neueste Version im zentralen Maven-Repository.

3. Weisen Sie Ihr Projekt an, die deklarierte Abhängigkeit von der Databricks Utilitys for Scala-Bibliothek zu übernehmen. Klicken Sie z. B. in IntelliJ IDEA im Projekttoolfenster ihres Projekts auf den Stammknoten Des Projekts, und klicken Sie dann auf Maven > Reload Project.

4. Fügen Sie Code zum Importieren hinzu, und rufen Sie dann das Databricks Utility for Scala auf. Der folgende Code automatisiert z. B. ein Unity Catalog-Volume. In diesem Beispiel wird eine Datei mit dem Namen zzz_hello.txt im Verzeichnispfad des Volumes innerhalb des Arbeitsbereichs erstellt, die Daten aus der Datei werden gelesen und anschließend wird die Datei gelöscht.

   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. Erstellen Sie das Projekt, und führen Sie die Hauptdatei aus.

Codebeispiele

Die folgenden Codebeispiele veranschaulichen die Verwendung des Databricks SDK für Java zum Erstellen und Löschen von Clustern, Erstellen von Aufträgen und Auflisten von Gruppen auf Kontoebene. Diese Codebeispiele verwenden das Databricks SDK für den standardmäßigen Azure Databricks-Authentifizierungsprozess von Java.

Weitere Codebeispiele finden Sie im Ordner examples im Repository des Databricks SDK für Java auf GitHub.

• Erstellen eines Clusters
  • Erstellen eines Clusters mit einer bestimmten JDK-Version
• Dauerhaftes Löschen eines Clusters
• Erstellen eines Auftrags
• Verwalten von Dateien in Unity Catalog-Volumes
• Auflisten von Gruppen auf Kontoebene

Erstellen eines Clusters

In diesem Codebeispiel wird ein Cluster mit der angegebenen Databricks Runtime-Version und dem angegebenen Clusterknotentyp erstellt. Dieser Cluster umfasst einen Worker, und der Cluster wird nach 15 Minuten Leerlauf automatisch beendet.

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

Erstellen eines Clusters mit einer bestimmten JDK-Version

Sie können einen Cluster erstellen, der eine bestimmte Version des Java Development Kit (JDK) verwendet.

Wenn Sie einen Cluster erstellen, geben Sie an, dass der Cluster JDK 17 oder JDK 21 sowohl für den Treiber als auch für den Executor verwendet, indem Sie die folgende Umgebungsvariable zu Advanced Options > Spark > Environment Variables hinzufügen.

Für JDK 17:

JNAME=zulu17-ca-amd64

Für JDK 21:

JNAME=zulu21-ca-amd64

Dauerhaftes Löschen eines Clusters

In diesem Codebeispiel wird der Cluster mit der angegebenen Cluster-ID dauerhaft aus dem Arbeitsbereich gelöscht.

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

Erstellen eines Auftrags

In diesem Codebeispiel wird ein Azure Databricks-Auftrag erstellt, der zum Ausführen des angegebenen Notebooks auf dem angegebenen Cluster verwendet werden kann. Wenn dieser Code ausgeführt wird, ruft er den Pfad des vorhandenen Notizbuchs, die vorhandene Cluster-ID und die zugehörigen Auftragseinstellungen vom Benutzer am Terminal ab.

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

Verwalten von Dateien in Unity Catalog-Volumes

In diesem Codebeispiel werden verschiedene Aufrufe von files-Funktionen innerhalb von WorkspaceClient den Zugriff auf ein Unity Catalog-Volume veranschaulicht.

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

Auflisten von Gruppen auf Kontoebene

In diesem Codebeispiel werden die Anzeigenamen für alle verfügbaren Gruppen im Azure Databricks-Konto aufgelistet.

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

Verwenden von Scala mit dem Databricks SDK für Java

Sie können Scala-Projekte mit dem Databricks SDK für Java verwenden. Ihr Entwicklungscomputer muss folgende Voraussetzungen erfüllen, bevor Sie loslegen:

• Die Azure Databricks-Authentifizierung ist konfiguriert.
• Eine mit Scala kompatible integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) wird empfohlen. Databricks empfiehlt IntelliJ IDEA mit dem Scala-Plug-In. Diese Anweisungen wurden mit IntelliJ IDEA Community Edition 2023.3.6 getestet. Wenn Sie eine andere Version oder Edition von IntelliJ IDEA verwenden, können die folgenden Anweisungen variieren.
• Ein Java Development Kit (JDK), das mit Java 8 oder höher kompatibel ist. Wenn Sie Ihre Anwendungen ausführen oder Ihre Bibliotheken in einem Azure Databricks-Cluster verwenden möchten, empfiehlt Databricks, eine JDK-Version zu verwenden, die der JDK-Version im Cluster entspricht. Informationen zur JDK-Version, die in einer bestimmten Databricks Runtime-Version enthalten ist, finden Sie unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität. Wenn Sie IntelliJ IDEA verwenden, können Sie während der Scala-Projekterstellung eine vorhandene lokale JDK-Installation auswählen oder ein neues JDK lokal installieren.
• Scala-Buildtool. Databricks empfiehlt sbt. Wenn Sie IntelliJ IDEA verwenden, können Sie die sbt-Version auswählen, die während der Scala-Projekterstellung verwendet werden soll.
• Scala. Wenn Sie Ihre Anwendungen ausführen oder Ihre Bibliotheken in einem Azure Databricks-Cluster verwenden möchten, empfiehlt Databricks, eine Scala-Version zu verwenden, die der Scala-Version im Cluster entspricht. Informationen zur Scala-Version, die in einer bestimmten Databricks Runtime-Version enthalten ist, finden Sie unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität. Wenn Sie IntelliJ IDEA verwenden, können Sie die Scala-Version auswählen, die während der Scala-Projekterstellung verwendet werden soll.

So konfigurieren und erstellen Sie Ihr Scala-Projekt und führen es aus

1. Fügen Sie im build.sbt-Datei Ihres Projekts eine Abhängigkeit vom Databricks SDK für Java hinzu, indem Sie die folgende Zeile am Ende der Datei einfügen und anschließend die Datei speichern:

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

   Hinweis

   Ersetzen Sie 0.2.0 unbedingt durch die neueste Version der Bibliothek des Databricks SDK für Java. Sie finden die neueste Version im zentralen Maven-Repository.

2. Weisen Sie Ihr Projekt an, die deklarierte Abhängigkeit vom Databricks SDK für Java zu übernehmen. Klicken Sie beispielsweise in IntelliJ IDEA auf das Benachrichtigungssymbol Load sbt changes.

3. Fügen Sie Code hinzu, um das Databricks SDK für Java zu importieren und alle Cluster in Ihrem Azure Databricks-Arbeitsbereich aufzulisten. In der Datei eines Projekts Main.scala kann der Code z. B. wie folgt aussehen:

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

   Hinweis

   Wenn Sie keine Argumente im obigen val w = new WorkspaceClient()-Aufruf angeben, verwendet das Databricks SDK für Java den Standardprozess zur Durchführung der Azure Databricks-Authentifizierung. Informationen zum Überschreiben dieses Standardverhaltens finden Sie im folgenden Abschnitt zur Authentifizierung.

4. Erstellen Sie das Projekt. Um diesen Schritt beispielsweise in IntelliJ IDEA auszuführen, klicken Sie im Hauptmenü auf Build > Build Project.

5. Führen Sie Ihre Hauptdatei aus. Klicken Sie z. B. im Hauptmenü von IntelliJ IDEA für die Datei eines Projekts Main.scala auf Run > 'Main.scala' ausführen.

6. Die Liste der Cluster wird angezeigt. Diese befindet sich beispielsweise in IntelliJ IDEA im Toolfenster Run. Um dieses Toolfenster anzuzeigen, klicken Sie im Hauptmenü auf View > Tool Windows > Run.

Verwenden von Databricks Utilities und Scala mit dem Databricks SDK für Java

Databricks Utilities bietet mehrere Hilfsfunktionen, um das effiziente Arbeiten mit Objektspeicher, Verketten und Parametrisieren von Notebooks sowie das Arbeiten mit geheimen Schlüsseln zu vereinfachen. Databricks stellt eine Databricks Utilities for Scala-Bibliothek bereit, damit Sie mit Scala programmgesteuert auf Databricks Utilities zugreifen können.

Gehen Sie wie folgt vor, um die Databricks Utilitys for Scala aufzurufen:

1. Deklarieren Sie in Ihrem Scala-Projekt eine Abhängigkeit vom Databricks-SDK für Java, wie im vorherigen Abschnitt beschrieben.

2. Deklarieren Sie eine Abhängigkeit von der Databricks Utilitys for Scala-Bibliothek. Fügen Sie beispielsweise in der Datei Ihres Projekts build.sbt die folgende Zeile am Ende der Datei hinzu, und speichern Sie die Datei:

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

   Hinweis

   Ersetzen Sie 0.1.4 unbedingt durch die neueste Version der Databricks Utilitys for Scala-Bibliothek. Sie finden die neueste Version im zentralen Maven-Repository.

3. Weisen Sie Ihr Projekt an, die deklarierte Abhängigkeit von der Databricks Utilitys for Scala-Bibliothek zu übernehmen. Klicken Sie beispielsweise in IntelliJ IDEA auf das Benachrichtigungssymbol Load sbt changes.

4. Fügen Sie Code zum Importieren hinzu, und rufen Sie dann das Databricks Utility for Scala auf. Der folgende Code automatisiert z. B. ein Unity Catalog-Volume. In diesem Beispiel wird eine Datei mit dem Namen zzz_hello.txt im Verzeichnispfad des Volumes innerhalb des Arbeitsbereichs erstellt, die Daten aus der Datei werden gelesen und anschließend wird die Datei gelöscht.

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

   Hinweis

   Wenn Sie keine Argumente im obigen val dbutils = DBUtils.getDBUtils()-Aufruf angeben, verwendet Databricks Utilitys for Scala den Standardprozess zur Durchführung der Azure Databricks-Authentifizierung.

   Um dieses Standardverhalten außer Kraft zu setzen, übergeben Sie ein instanziiertes DatabricksCfg-Objekt als Argument an getDBUtils. Weitere Informationen finden Sie im vorherigen Abschnitt Authentifizierung.

   Beachten Sie jedoch, dass dieses DatabricksCfg-Objekt ignoriert wird, wenn Ihr Code innerhalb der Databricks Runtime ausgeführt wird. Dies liegt daran, dass die Databricks Utilitys for Scala beim Ausführen innerhalb der Databricks Runtime an die integrierten Databricks Utilitys delegiert werden.

5. Erstellen Sie das Projekt, und führen Sie die Hauptdatei aus.

Um auf Unity Catalog-Volumes zuzugreifen, verwenden Sie files in WorkspaceClient. Weitere Informationen finden Sie unter Verwalten von Dateien in Unity Catalog-Volumes. Sie können DBUtils.getDBUtils() nicht für den Zugriff auf Volumes verwenden.

Testen

Verwenden Sie Java-Testframeworks wie JUnit, um Ihren Code zu testen. Um Ihren Code unter simulierten Bedingungen zu testen, ohne Azure Databricks-REST-API-Endpunkte aufzurufen oder den Status Ihrer Azure Databricks-Konten oder -Arbeitsbereiche zu ändern, können Sie Java-Modellbibliotheken wie Mockito verwenden.

Angenommen, die folgende Datei mit dem Namen Helpers.java enthält eine createCluster-Funktion, die Informationen über den neuen Cluster zurückgibt:

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

Und die folgende Datei mit dem Namen Main.java, die die createCluster Funktion aufruft:

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

Die folgende Datei mit dem Namen HelpersTest.java testet, ob die createCluster Funktion die erwartete Antwort zurückgibt. Anstatt einen Cluster im Zielarbeitsbereich zu erstellen, simuliert dieser Test ein WorkspaceClient Objekt, definiert die Einstellungen des simulierten Objekts und übergibt dann das simulierte Objekt an die createCluster Funktion. Der Test überprüft dann, ob die Funktion die erwartete ID des neuen simulierten Clusters zurückgibt.

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

Problembehandlung

In diesem Abschnitt werden Lösungen für häufige Probleme mit dem Databricks SDK für Java beschrieben.

Um Probleme oder ein anderes Feedback zu melden, erstellen Sie ein GitHub-Problem für das Databricks SDK für Java.

Fehler: Die Antwort kann nicht analysiert werden.

Wenn Sie beim Versuch, das Databricks SDK für Java zu verwenden, den folgenden Fehler erhalten, weist es fast immer auf ein Problem mit Ihrer Authentifizierungskonfiguration hin.

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

Wenn dieser Fehler auftritt, überprüfen Sie Folgendes:

• Stellen Sie sicher, dass Ihr Databricks-Host ordnungsgemäß festgelegt ist.
• Vergewissern Sie sich, dass die Authentifizierungsmethode über die erforderlichen Berechtigungen für den API-Vorgang verfügt, den Sie ausführen möchten.
• Wenn Sie sich hinter einer Unternehmensfirewall befinden, stellen Sie sicher, dass der API-Datenverkehr nicht blockiert oder umgeleitet wird.

Eine häufige Ursache für diesen Fehler ist das umleitende private Link, der das SDK auf eine Anmeldeseite umleitet, die vom SDK nicht verarbeitet werden kann. Dies geschieht in der Regel, wenn Sie versuchen, auf einen privaten, linkfähigen Arbeitsbereich zuzugreifen, der ohne öffentlichen Internetzugriff von einem anderen Netzwerk konfiguriert ist als der VORGANGsendpunkt.

Weitere Informationen finden Sie unter:

• Einheitliche Databricks-Authentifizierung

• Konfigurieren Sie die private Back-End-Konnektivität mit Azure Databricks.

Zusätzliche Ressourcen

Weitere Informationen finden Sie unter:

• Databricks SDK für Java README
• Databricks SDK für Java API-Referenz
• Zusätzliche Codebeispiele
• Protokollierung
• Zeitintensive Vorgänge
• Paginierte Antworten