Freigeben über

Databricks SDK für Java

  • Artikel

In diesem Artikel erfahren Sie, wie Sie Vorgänge in Azure Databricks-Konten und -Arbeitsbereichen und zugehörigen Ressourcen mit dem Databricks SDK für Java automatisieren können. Dieser Artikel ergänzt dieREADME-Datei, API-Referenz und Beispiele zu Databricks SDK für Java.

Hinweis

Dieses Feature befindet sich in der Betaphase und kann in der Produktion verwendet werden.

Während des Betazeitraums empfiehlt Databricks, eine Abhängigkeit von der spezifischen Nebenversion des Databricks SDK für Java anzuheften, von der Ihr Code abhängt. Beispielsweise können Sie Abhängigkeiten in Dateien wie pom.xml für Maven anheften. Weitere Informationen zum Anheften von Abhängigkeiten finden Sie unter Einführung in den Abhängigkeitsmechanismus.

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 ihr Buildsystem in der Datei pom.xml des Projekts an, eine Abhängigkeit vom Databricks SDK für Java zu übernehmen. Fügen Sie dazu <dependency> dem vorhandenen Abschnitt <dependencies> der Datei pom.xml 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.

    Um beispielsweise die Datei pom.xml des Projekts in IntelliJ IDEA zu öffnen, klicken Sie auf View > Tool Windows> Project, und doppelklicken Sie anschließend, um ihr-projektname> 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 beispielsweise in IntelliJ IDEA im Toolfenster Project Ihres Projekts auf den Stammknoten Ihres Projekts, und klicken Sie dann auf Reload Project.

  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 Main.java-Datei eines Projekts 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. Um diesen Schritt beispielsweise in IntelliJ IDEA für die Datei Main.java eines Projekts auszuführen, klicken Sie im Hauptmenü auf Run > Run ‘Main’.

  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 Standard für die einheitliche Databricks-Clientauthentifizierung, einen konsolidierten und konsistenten architektonischen 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 umfassenderer Codebeispiele in Java, finden Sie unter Einheitliche Databricks-Clientauthentifizierung.

Hinweis

Das Databricks SDK für Java hat noch keine Authentifizierung mit von Azure verwalteten Identitäten implementiert.

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 dazu <dependency> dem vorhandenen Abschnitt <dependencies> der Datei pom.xml 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 beispielsweise in IntelliJ IDEA im Toolfenster Project Ihres Projekts auf den Stammknoten Ihres 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 namens zzz_hello.txt erstellt, die sich im Pfad des Volumes innerhalb des Arbeitsbereichs befindet, die Daten aus der Datei liest und dann die Datei lö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. In diesen Codebeispielen wird der standardmäßige Azure Databricks-Authentifizierungsprozess des Databricks SDK für Java verwendet.

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

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, der JDK 17 verwendet

Hinweis

JDK 8 wird vollständig unterstützt. JDK 17 befindet sich für Databricks Runtime 13.1 und höher in der Public Preview.

Dieser Abschnitt enthält einen Leitfaden zum Erstellen eines Clusters mit Java Development Kit (JDK). Erfahren Sie, wie Sie einen Cluster mit JDK 17 erstellen, um Java in Ihren Notebooks und Aufträgen verwenden zu können.

Wenn Sie einen Cluster erstellen, geben Sie an, dass dieser JDK 17 sowohl für den Treiber als auch für den Executor verwendet, indem Sie die folgende Umgebungsvariable zu Erweiterte Optionen > Spark > Umgebungsvariablen hinzufügen:

JNAME=zulu17-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. Bei Ausführung dieses Codes werden der Pfad des vorhandenen Notebooks, die ID des vorhandenen Clusters und die zugehörigen Auftragseinstellungen vom Benutzer oder von der Benutzerin am Terminal abgerufen.

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. Verwenden Sie in der Datei build.sbt des Projekts eine Abhängigkeit von der Bibliothek des Databricks SDK für Java, indem Sie die folgende Zeile am Ende der Datei hinzufügen, und speichern Sie die Datei anschließend:

    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 Main.scala-Datei eines Projekts 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. Um diesen Schritt beispielsweise in IntelliJ IDEA für die Datei Main.scala eines Projekts auszuführen, klicken Sie im Hauptmenü auf Run > Run ‘Main.scala’.

  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 z. B. in der build.sbt-Datei ihres Projekts 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 namens zzz_hello.txt erstellt, die sich im Pfad des Volumes innerhalb des Arbeitsbereichs befindet, die Daten aus der Datei liest und dann die Datei lö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 Pseudoobjekts und übergibt dann das Pseudoobjekt 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);
  }
}

Zusätzliche Ressourcen

Weitere Informationen finden Sie unter: