Aller au contenu principal
Dernière mise à jour le

Databricks SDK pour Java

remarque

Databricks recommande les Declarative Automation Bundles pour la création, le développement, le déploiement et le test de jobs et autres ressources Databricks en tant que code source. Consultez Que sont les Declarative Automation Bundles ?

Dans cet article, vous apprendrez comment automatiser les opérations Databricks et accélérer le développement avec le SDK Databricks pour Java. Cet article complète le README, la référence de l'API et les exemples du SDK Databricks pour Java.

remarque

Cette fonctionnalité est en Beta et peut être utilisée en production.

Pendant la période bêta, Databricks vous recommande de pin une dépendance à la version mineure spécifique du SDK Databricks pour Java dont votre code dépend. Par exemple, vous pouvez pin les dépendances dans des fichiers tels que pom.xml pour Maven. Pour plus d'informations sur l'épinglage des dépendances, consultez Introduction au mécanisme de dépendance.

Exigences​

Pour utiliser le SDK Databricks pour Java, votre machine de développement doit avoir :

  • Databricks authentication configured.
  • Un Java Development Kit (JDK) compatible avec Java 8 ou une version ultérieure. Les tests d'intégration continue (CI) avec le SDK Databricks pour Java sont compatibles avec les versions Java 8, 11, 17 et 20.
  • Un environnement de développement intégré (IDE) compatible Java est recommandé. Databricks vous recommande IntelliJ IDEA.

Démarrer avec le Databricks SDK pour Java​

  1. Dans le fichier pom.xml de votre projet, demandez à votre système de build de prendre une dépendance sur le SDK Databricks pour Java. Pour ce faire, ajoutez les <dependency> suivants à la section <dependencies> existante du fichier pom.xml. Si la section <dependencies> n'existe pas déjà dans le fichier pom.xml, vous devez également ajouter l'élément parent <dependencies> au fichier pom.xml.

    Par exemple, pour ouvrir le fichier de votre projet pom.xml dans IntelliJ IDEA, cliquez sur **View > Tool Windows > Project**, puis double-cliquez pour ouvrir **_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>
remarque

Veillez à remplacer 0.0.1 par la dernière version du Databricks SDK pour Java. Vous trouverez la dernière version dans le repository Maven Central.

  1. Demandez à votre projet de prendre la dépendance déclarée sur le SDK Databricks pour Java. Par exemple, dans IntelliJ IDEA, dans la fenêtre d’outil Projet de votre projet, faites un clic droit sur le nœud racine de votre projet, puis cliquez sur Recharger le projet .

  2. Ajoutez du code pour importer le SDK Databricks pour Java et pour lister tous les clusters dans votre workspace Databricks. Par exemple, dans le fichier Main.java d'un projet, le code pourrait être le suivant :

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

En ne définissant aucun argument dans l'appel précédent à WorkspaceClient w = new WorkspaceClient(), le SDK Databricks pour Java utilise son processus default pour tenter d'effectuer l'authentification Databricks. Pour annuler ce comportement par default, consultez la section authentification suivante.

  1. Construisez votre projet. Par exemple, pour ce faire dans IntelliJ IDEA, dans le menu principal, cliquez sur Build > Build Project .

  2. Exécutez votre fichier principal. Par exemple, pour ce faire dans IntelliJ IDEA pour le fichier d'un projet,Main.java dans le menu principal, cliquez sur **Exécuter > Exécuter 'Main'**.

  3. La liste des clusters apparaît. Par exemple, dans IntelliJ IDEA, cela se trouve dans la fenêtre d'outil Exécuter . Pour afficher cette fenêtre d'outil, dans le menu principal, cliquez sur Affichage > Tool Windows > Exécuter .

Authentifiez le Databricks SDK pour Java avec votre compte ou Workspace Databricks​

Le SDK Databricks pour Java implémente la norme d' authentification unifiée Databricks , une approche architecturale et programmatique consolidée et cohérente de l'authentification. Cette approche contribue à rendre la configuration et l'automatisation de l'authentification avec Databricks plus centralisées et prévisibles. Il vous permet de configurer l'authentification Databricks une seule fois, puis d'utiliser cette configuration sur plusieurs outils Databricks et SDK sans modifications supplémentaires de la configuration de l'authentification. Pour plus d'informations, y compris des exemples de code plus complets en Java, veuillez consulter l'authentification unifiée Databricks.

Certains des modèles de codage disponibles pour initialiser l'authentification Databricks avec le Databricks SDK pour Java incluent :

  • Utilisez l'authentification par default de Databricks en procédant comme suit :

    • Créez ou identifiez un profil de configuration Databricks personnalisé avec les champs requis pour le type d'authentification Databricks cible. Définissez ensuite la variable d'environnement DATABRICKS_CONFIG_PROFILE sur le nom du profil de configuration personnalisé.
    • Définissez les variables d'environnement requises pour le type d'authentification Databricks cible.

    Instanciez ensuite par exemple un objet WorkspaceClient avec l'authentification default de Databricks comme suit :

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

  • Le codage en dur des champs obligatoires est pris en charge mais non recommandé, car il risque d'exposer des informations sensibles dans votre code, tels que les jetons d'accès personnel Databricks. L'exemple suivant code en dur les valeurs d'hôte Databricks et de jeton d'accès pour l'authentification par jeton 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);
    // ...

Voir aussi Authentification dans le README du Databricks SDK pour Java.

Utilisez les utilitaires Databricks et Java avec le SDK Databricks pour Java​

Utilitaires Databricks fournit plusieurs fonctions d'aide pour faciliter le travail efficace avec le stockage d'objets, l'enchaînement et le paramétrage des Notebooks, ainsi que le travail avec les secrets. Databricks fournit une bibliothèque Databricks Utilities for Scala, que vous pouvez appeler avec du code Java, pour vous permettre d'accéder par programme aux infrastructures publiques Databricks.

Pour utiliser le code Java pour appeler les utilitaires Databricks pour Scala, procédez comme suit :

  1. Dans votre projet Java, déclarez une dépendance au SDK Databricks pour Java, comme décrit dans la section précédente.

  2. Déclarez une dépendance envers la bibliothèque Databricks Utilities pour Scala. Pour ce faire, ajoutez le <dependency> suivant à la section <dependencies> existante du fichier pom.xml :

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

Assurez-vous de remplacer 0.1.4 par la dernière version de la bibliothèque Databricks Utilities for Scala. Vous trouverez la dernière version dans le repository Maven Central.

  1. Configurez votre projet pour qu'il prenne la dépendance déclarée sur les Databricks infrastructures publiques pour Scala. Par exemple, dans IntelliJ IDEA, dans la fenêtre d'outil Projet de votre projet, cliquez sur le nœud racine de votre projet, puis cliquez sur Maven > Recharger le projet .

  2. Ajoutez du code pour importer puis appeler l'utilitaire Databricks pour Scala. Par exemple, le code suivant automatise un volume Unity Catalog. Cet exemple crée un fichier nommé zzz_hello.txt dans le chemin du volume au sein du workspace, lit les données du fichier, puis supprime le fichier :

    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. Construisez votre projet et exécutez votre fichier principal.

Exemples de code​

Les exemples de code suivants montrent comment utiliser le Databricks SDK pour Java pour créer et supprimer des clusters, créer des jobs et lister les groupes au niveau du compte. Ces exemples de code utilisent le processus d'authentification Databricks par default du Databricks SDK pour Java.

Pour des exemples de code supplémentaires, consultez le dossier examples dans le repository Databricks SDK for Java sur GitHub.

Créer un cluster​

Cet exemple de code crée un cluster avec la version spécifiée de Databricks Runtime et le type de nœud de cluster. Ce cluster a un Worker, et le cluster sera automatiquement arrêté après 15 minutes d’inactivité.

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("i3.xlarge")
        .setAutoterminationMinutes(15L)
        .setNumWorkers(1L)
    ).getResponse();

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

Créer un cluster avec une version JDK spécifique​

Vous pouvez créer un cluster qui utilise une version spécifique du Java Development Kit (JDK).

remarque
  • Pour Databricks Runtime 19.0 et versions supérieures, seul JDK 21 est pris en charge. L'option fallback JDK 17 n'est plus disponible.
  • Pour Databricks Runtime 18.0, JDK 21 est généralement disponible et default, avec JDK 17 comme option de fallback.
  • Pour Databricks Runtime 17,3, JDK 21 est en aperçu public et JDK 17 est le default.
  • Pour Databricks Runtime 16.0 ou version ultérieure, JDK 17 est généralement disponible et default.
  • Pour les versions de Databricks Runtime 13,1 à 15,4, JDK 8 est le default, et JDK 17 est en aperçu public.

Lorsque vous créez un cluster, spécifiez que le cluster utilise le JDK 17 ou le JDK 21 pour le Driver et l'exécuteur en ajoutant la variable d'environnement suivante aux Options avancées > Spark > Variables d'environnement .

Pour JDK 17 :

Bash
JNAME=zulu17-ca-amd64

Pour JDK 21 :

Bash
JNAME=zulu21-ca-amd64

Si vous utilisez des clusters basés sur ARM (par exemple, des instances AWS Graviton), utilisez plutôt la variable d'environnement suivante.

Pour JDK 17 :

Bash
JNAME=zulu17-ca-arm64

Pour JDK 21 :

Bash
JNAME=zulu21-ca-arm64

Supprimer définitivement un cluster​

Cet exemple de code supprime définitivement le cluster avec l'ID de cluster spécifié du 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);
  }
}

Créer un Job​

Cet exemple de code crée un job Databricks qui peut être utilisé pour exécuter le notebook spécifié sur le cluster spécifié. Lorsque ce code s'exécute, il obtient le chemin du notebook existant, l'ID du cluster existant et les paramètres de job associés de l'utilisateur au 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()
    );
  }
}

Gérer les fichiers dans les volumes Unity Catalog​

Cet exemple de code montre divers appels à la fonctionnalité files dans WorkspaceClient pour accéder à un volume 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);
  }
}

Lister les groupes au niveau du compte​

Cet exemple de code liste les noms d'affichage de tous les groupes disponibles dans le compte 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());
    }
  }
}

Utilisez Scala avec le Databricks SDK pour Java​

Vous pouvez utiliser des projets Scala avec le SDK Databricks pour Java. Votre machine de développement doit disposer de :

  • Databricks authentication configured.
  • Un environnement de développement intégré (IDE) compatible Scala est recommandé. Databricks recommande IntelliJ IDEA avec le plug-in Scala. Ces instructions ont été testées avec IntelliJ IDEA Community Edition 2023.3.6. Si vous utilisez une version ou une édition différente d'IntelliJ IDEA, les instructions suivantes peuvent varier.
  • Un Java Development Kit (JDK) compatible avec Java 8 ou une version ultérieure. Si vous souhaitez exécuter vos applications ou utiliser vos bibliothèques sur un cluster Databricks, Databricks vous recommande d'utiliser une version de JDK qui correspond à la version de JDK sur le cluster. Pour trouver la version du JDK incluse avec un Databricks Runtime spécifique, consultez Databricks Runtime : versions et compatibilité des notes de publication. Si vous utilisez IntelliJ IDEA, vous pouvez choisir une installation JDK locale existante ou installer un nouveau JDK localement lors de la création d'un projet Scala.
  • Un outil de build Scala. Databricks recommande sbt. Si vous utilisez IntelliJ IDEA, vous pouvez choisir la version sbt à utiliser lors de la création du projet Scala.
  • Scala. Si vous souhaitez exécuter vos applications ou utiliser vos bibliothèques sur un cluster Databricks, Databricks vous recommande d'utiliser une version de Scala qui correspond à la version de Scala sur le cluster. Pour trouver la version de Scala incluse avec un Databricks Runtime spécifique, consultez notes de version et compatibilité de Databricks Runtime. Si vous utilisez IntelliJ IDEA, vous pouvez choisir la version de Scala à utiliser lors de la création du projet Scala.

Pour configurer, créer et exécuter votre projet Scala :

  1. Dans le fichier build.sbt de votre projet, ajoutez une dépendance à la bibliothèque Databricks SDK pour Java en ajoutant la ligne suivante à la fin du fichier, puis enregistrez le fichier :

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

Veillez à remplacer 0.2.0 par la dernière version de la bibliothèque Databricks SDK pour Java. Vous trouverez la dernière version dans le repository Maven Central.

  1. Demandez à votre projet de prendre la dépendance déclarée sur le SDK Databricks pour Java. Par exemple, dans IntelliJ IDEA, cliquez sur l'icône de notification Charger les modifications sbt .

  2. Ajoutez du code pour importer le SDK Databricks pour Java et pour lister tous les clusters dans votre workspace Databricks. Par exemple, dans le fichier Main.scala d'un projet, le code pourrait être le suivant :

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

En ne définissant aucun argument dans l'appel précédent à val w = new WorkspaceClient(), le SDK Databricks pour Java utilise son processus default pour tenter d'effectuer l'authentification Databricks. Pour annuler ce comportement par default, consultez la section authentification suivante.

  1. Construisez votre projet. Par exemple, pour ce faire dans IntelliJ IDEA, dans le menu principal, cliquez sur Build > Build Project .

  2. Exécutez votre fichier principal. Par exemple, pour ce faire dans IntelliJ IDEA pour le fichier Main.scala d'un projet, dans le menu principal, cliquez sur Run > Run 'Main.scala' .

  3. La liste des clusters apparaît. Par exemple, dans IntelliJ IDEA, cela se trouve dans la fenêtre d'outil Exécuter . Pour afficher cette fenêtre d'outil, dans le menu principal, cliquez sur Affichage > Tool Windows > Exécuter .

Utiliser les infrastructures publiques Databricks et Scala avec le SDK Databricks pour Java​

Utilitaires Databricks fournit plusieurs fonctions d'aide pour faciliter le travail efficace avec le stockage d'objets, l'enchaînement et le paramétrage des Notebooks, ainsi que le travail avec les secrets. Databricks fournit une bibliothèque Databricks Utilities for Scala pour vous permettre d'accéder par programme aux Utilities Databricks avec Scala.

Pour appeler les utilitaires Databricks pour Scala, procédez comme suit :

  1. Dans votre projet Scala, déclarez une dépendance au SDK Databricks pour Java, comme décrit dans la section précédente.

  2. Déclarez une dépendance envers la bibliothèque Databricks Utilities pour Scala. Par exemple, dans le fichier build.sbt de votre projet, ajoutez la ligne suivante à la fin du fichier, puis enregistrez le fichier :

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

Assurez-vous de remplacer 0.1.4 par la dernière version de la bibliothèque Databricks Utilities for Scala. Vous trouverez la dernière version dans le repository Maven Central.

  1. Configurez votre projet pour qu'il prenne la dépendance déclarée sur les Databricks infrastructures publiques pour Scala. Par exemple, dans IntelliJ IDEA, cliquez sur l'icône de notification Charger les modifications sbt .

  2. Ajoutez du code pour importer puis appeler l'utilitaire Databricks pour Scala. Par exemple, le code suivant automatise un volume Unity Catalog. Cet exemple crée un fichier nommé zzz_hello.txt dans le chemin du volume au sein du workspace, lit les données du fichier, puis supprime le fichier :

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

En n'indiquant aucun argument dans l'appel précédent à val dbutils = DBUtils.getDBUtils(), les Utilitaires Databricks pour Scala utilisent leur processus default pour tenter d'effectuer l'authentification Databricks.

Pour ignorer ce comportement par default, transmettez un objet DatabricksCfg instancié comme argument à getDBUtils. Pour plus d'information, consultez la section authentification précédente.

Notez, cependant, que si votre code s'exécute dans le Databricks Runtime, cet objet DatabricksCfg est ignoré. Cela est dû au fait que les Databricks Utilities pour Scala délèguent aux Databricks Utilities intégrés lorsqu'elles s'exécutent dans le Databricks Runtime.

  1. Construisez votre projet et exécutez votre fichier principal.

Pour accéder aux volumes Unity Catalog, utilisez files dans WorkspaceClient. Consultez Gérer les fichiers dans les volumes Unity Catalog. Vous ne pouvez pas utiliser DBUtils.getDBUtils() pour accéder aux volumes.

Test​

Pour tester votre code, utilisez des frameworks de test Java tels que JUnit. Pour tester votre code dans des conditions simulées sans appeler les endpoints de l'API REST Databricks ni modifier l'état de vos comptes ou workspaces Databricks, utilisez des bibliothèques de simulation Java telles que Mockito.

Par exemple, étant donné le fichier suivant nommé Helpers.java contenant une fonction createCluster qui renvoie des informations sur le nouveau 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();
  }
}

Et étant donné le fichier suivant nommé Main.java qui appelle la fonction 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());
  }
}

Le fichier suivant nommé HelpersTest.java teste si la fonction createCluster renvoie la réponse attendue. Plutôt que de créer un cluster dans le Workspace cible, ce test simule un objet WorkspaceClient, définit les paramètres de l'objet simulé, puis transmet l'objet simulé à la fonction createCluster. Le test vérifie ensuite si la fonction renvoie l'ID attendu du nouveau cluster simulé.

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

Dépannage​

Cette section décrit des solutions aux problèmes courants avec le Databricks SDK pour Java.

Pour signaler des problèmes ou tout autre feedback, créez un problème GitHub pour le SDK Databricks pour Java.

Erreur : Impossible d'analyser la réponse​

Si vous recevez l'erreur suivante en tentant d'utiliser le SDK Databricks pour Java, cela indique presque toujours un problème avec votre configuration d'authentification.

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

Si vous rencontrez cette erreur, vérifiez ce qui suit :

  • Assurez-vous que votre hôte Databricks est correctement configuré.
  • Confirmez que la méthode d’authentification dispose des autorisations requises pour l’opération d’API que vous tentez d’effectuer.
  • Si vous êtes derrière un pare-feu d'entreprise, assurez-vous qu'il ne bloque ni ne redirige le trafic API.

Une cause fréquente de cette erreur est le Link privé qui redirige le SDK vers une page de connexion, que le SDK ne peut pas traiter. Cela se produit généralement en essayant d'accéder à un Workspace compatible Link privé, configuré sans accès Internet public, à partir d'un réseau différent de celui auquel appartient l'Endpoint Virtual Private Cloud (VPC).

Pour plus de détails, consultez :

Ressources supplémentaires​

Pour plus d'informations, voir :

Sur cette page