Partage via

SDK Databricks pour Java

  • Article

Dans cet article, vous apprenez à automatiser les opérations dans les comptes, les espaces de travail et les ressources associées Azure Databricks avec le kit de développement logiciel (SDK) Databricks pour Java. Cet article complète le Kit de développement logiciel (SDK) Databricks pour Java README, référence d’APIet exemples.

Remarque

Cette fonctionnalité est en version bêta et peut être utilisée en production.

Pendant la période bêta, Databricks vous recommande d’épingler une dépendance à la version mineure spécifique du Kit de développement logiciel (SDK) Databricks pour Java dont dépend votre code. Par exemple, vous pouvez épingler des dépendances dans des fichiers tels que pom.xml pour Maven. Pour plus d’informations sur l’épinglage des dépendances, consultez Présentation du mécanisme de dépendance.

Avant de commencer

Avant de commencer à utiliser le kit de développement logiciel (SDK) Databricks pour Java, assurez-vous que votre ordinateur de développement dispose des éléments suivants :

  • L’authentification Azure Databricks configurée
  • Un kit de développement Java (JDK) compatible avec Java 8 ou une version ultérieure. Les tests d’intégration continue (CI) avec le kit de développement logiciel (SDK) Databricks pour Java sont compatibles avec les versions 8, 11, 17 et 20 de Java.
  • Un environnement de développement intégré (Integrated Development Environment/IDE) compatible Java est recommandé. Databricks recommande IntelliJ IDEA.

Prise en main du Kit de développement logiciel (SDK) Databricks pour Java

  1. Dans le fichier pom.xml de votre projet, indiquez à votre système de build de prendre une dépendance sur le kit de développement logiciel (SDK) Databricks pour Java. Pour ce faire, ajoutez ce qui suit <dependency> à 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 pom.xml de votre projet dans IntelliJ IDEA, cliquez sur Afficher > Fenêtre Outil > Projet, puis double-cliquez pour ouvrir your-project-name> src > pom.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 version du kit de développement logiciel (SDK) Databricks pour Java la plus récente. Vous trouverez la version la plus récente dans le référentiel central Maven.

  2. Demandez à votre projet d’utiliser la dépendance déclarée sur le kit de développement logiciel (SDK) Databricks pour Java. Par exemple, dans IntelliJ IDEA, dans la fenêtre Outil Projet de votre projet, cliquez avec le bouton droit sur le nœud racine de votre projet, puis sur Recharger le projet.

  3. Ajoutez du code pour importer le kit de développement logiciel (SDK) Databricks pour Java et pour répertorier tous les clusters de votre espace de travail Azure Databricks. Par exemple, dans le fichier Main.java d’un projet, le code peut être comme suit :

    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 kit de développement logiciel (SDK) Databricks pour Java utilise son processus par défaut pour tenter d'effectuer l'authentification Azure Databricks. Pour remplacer ce comportement par défaut, consultez la section d’authentification suivante.

  4. Générez votre projet. Par exemple, pour effectuer cette opération dans IntelliJ IDEA, depuis le menu principal, cliquez sur Générer > Générer un projet.

  5. Exécutez votre fichier main. Par exemple, pour effectuer cette opération dans IntelliJ IDEA pour le fichier Main.java d’un projet, depuis le menu principal, cliquez sur Exécuter > Exécuter « Main ».

  6. La liste des clusters s’affiche. Par exemple, dans IntelliJ IDEA, il s’agit de la fenêtre Outil Exécuter. Pour afficher cette fenêtre Outil, dans le menu principal, cliquez sur Afficher > Fenêtres Outil > Exécuter.

Authentifier le kit de développement logiciel (SDK) Databricks pour Java avec votre compte ou espace de travail Azure Databricks

Le kit de développement logiciel (SDK) Databricks pour Java implémente la norme d’authentification unifiée du client Databricks standard, une approche architecturale et programmatique, consolidée et cohérente, pour l’authentification. Cette approche permet de rendre la configuration et l’automatisation de l’authentification avec Azure Databricks plus centralisées et prévisibles. Elle vous permet de configurer une fois l’authentification Databricks, puis d’utiliser cette configuration sur plusieurs outils Databricks et kits de développement logiciel sans modifier la configuration de l’authentification. Pour plus d’informations, dont des exemples de code plus complets dans Java, consultez Authentification unifiée du client Databricks.

Remarque

Le SDK Databricks pour Java n’a pas encore implémenté l’authentification avec des identités managées Azure.

Voici quelques-uns des modèles de codage disponibles pour initialiser l’authentification Databricks avec le kit de développement logiciel (SDK) Databricks pour Java :

  • Utilisez l’authentification par défaut de Databricks en effectuant l’une des opérations suivantes :

    • Créez ou identifiez un profil de configuration Databricks personnalisé avec les champs requis pour le type d’authentification Databricks cible. Ensuite, définissez 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 un objet WorkspaceClient avec l’authentification par défaut Databricks comme suit :

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

  • Le codage des champs requis effectué de manière irréversible est pris en charge, mais non recommandé, car il risque d’exposer des informations sensibles dans votre code, telles que les jetons d’accès personnels Azure Databricks. L’exemple suivant montre le codage de l’hôte Azure Databricks et des valeurs de jeton d’accès effectué de manière irréversible pour l’authentification par jeton Databricks :

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

Consultez également authentification dans le Kit de développement logiciel (SDK) Databricks pour Java README.

Utiliser Databricks Utilities et Java avec le SDK Databricks pour Java

Databricks Utilities fournit plusieurs fonctions d’assistance pour faciliter l’utilisation efficace du stockage d’objets, chaîner et paramétrer des notebooks et utiliser les secrets. Databricks fournit une bibliothèque Databricks Utilities pour Scala, que vous pouvez appeler avec du code Java, pour vous permettre d’accéder par programme à Databricks Utilities.

Pour utiliser du code Java pour appeler Databricks Utilities pour Scala, procédez comme suit :

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

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

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

    Remarque

    Veillez à remplacer 0.1.4 par la dernière version de la bibliothèque Databricks Utilities pour Scala. Vous trouverez la version la plus récente dans le référentiel central Maven.

  3. Demandez à votre projet d’utiliser la dépendance déclarée sur Databricks Utilities pour Scala. Par exemple, dans IntelliJ IDEA, dans la fenêtre Outil Projet de votre projet, cliquez sur le nœud racine de votre projet, puis sur Maven > Recharger le projet.

  4. Ajoutez du code à importer, puis appelez Databricks Utilities 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 d’accès du volume dans l’espace de travail, lit les données du fichier, puis supprime le fichier :

    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. Générez le projet et exécutez le fichier principal.

Exemples de code

Les exemples de code suivants montrent comment utiliser le kit de développement logiciel (SDK) Databricks pour Java pour créer et supprimer des clusters, créer des tâches et répertorier les groupes de niveau de comptes. Ces exemples de code utilisent le processus d’authentification Azure Databricks par défaut du kit de développement logiciel (SDK) Databricks pour Java.

Pour obtenir d’autres exemples de code, consultez le dossier Exemples du référentiel du kit de développement logiciel (SDK) Databricks pour Java sur GitHub.

Créer un cluster

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

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

Créer un cluster qui utilise JDK 17

Remarque

JDK 8 est entièrement pris en charge. JDK 17 est en préversion publique pour Databricks Runtime versions 13.1 et ultérieures.

Cette section fournit un guide pour créer un cluster à l'aide du kit de développement Java (JDK). Découvrez comment créer un cluster avec JDK 17 pour utiliser Java dans vos notebooks et travaux.

Quand vous créez un cluster, spécifiez que le cluster utilise JDK 17 pour le pilote et l’exécuteur en ajoutant la variable d’environnement suivante à Options avancées > Spark > Variables d’environnement :

JNAME=zulu17-ca-amd64

Supprimer définitivement un cluster

Cet exemple de code supprime définitivement de l’espace de travail le cluster possédant l’ID spécifié.

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 travail

Cet exemple de code crée une tâche Azure Databricks qui peut être utilisée pour exécuter le notebook spécifié sur le cluster spécifié. En cours d’exécution, ce code récupère le chemin du notebook existant, l’ID du cluster existant et les paramètres de tâche associés depuis l’utilisateur sur le terminal.

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 de catalogue Unity

Cet exemple de code illustre différents appels aux files fonctionnalités au sein WorkspaceClient pour accéder à un volume de catalogue Unity.

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

Répertorier les groupes au niveau du compte

Cet exemple de code répertorie les noms complets de tous les groupes disponibles dans le compte 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());
    }
  }
}

Utiliser Scala avec le kit de développement logiciel (SDK) Databricks pour Java

Vous pouvez utiliser des projets Scala avec le kit de développement logiciel (SDK) Databricks pour Java. Avant de commencer, vérifiez que votre ordinateur de développement dispose des éléments suivants :

  • L’authentification Azure Databricks configurée
  • Un environnement de développement intégré (Integrated Development Environment/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 kit de développement Java (JDK) compatible avec Java 8 ou une version supérieure. Si vous souhaitez exécuter vos applications ou utiliser vos bibliothèques sur un cluster Azure Databricks, Databricks vous recommande d’utiliser une version du JDK qui correspond à la version du JDK sur le cluster. Pour trouver la version du JDK incluse dans un Databricks Runtime spécifique, consultez Versions des notes de publication et compatibilité Databricks Runtime. Si vous utilisez IntelliJ IDEA, vous pouvez choisir une installation du JDK locale existante ou installer un nouveau JDK localement lors de la création du projet Scala.
  • Un outil de génération Scala. Databricks recommande sbt. Si vous utilisez IntelliJ IDEA, vous pouvez choisir d’utiliser la version sbt lors de la création du projet Scala.
  • Scala. Si vous souhaitez exécuter vos applications ou utiliser vos bibliothèques sur un cluster Azure Databricks, Databricks vous recommande d’utiliser une version de Scala qui correspond à la version de Scala sur le cluster. Pour trouver la version Scala incluse dans un Databricks Runtime spécifique, consultez Versions des notes de publication et compatibilité Databricks Runtime. Si vous utilisez IntelliJ IDEA, vous pouvez choisir la version Scala à utiliser lors de la création du projet Scala.

Pour configurer, générer et exécuter votre projet Scala :

  1. Dans le fichier build.sbt de votre projet, prenez une dépendance sur la bibliothèque du kit de développement logiciel (SDK) Databricks 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 version du kit de développement logiciel (SDK) Databricks pour bibliothèque Java. Vous trouverez la version la plus récente dans le référentiel central Maven.

  2. Demandez à votre projet d’utiliser la dépendance déclarée sur le kit de développement logiciel (SDK) Databricks pour Java. Par exemple, dans IntelliJ IDEA, cliquez sur l’icône de notification Charger sbt changes.

  3. Ajoutez du code pour importer le kit de développement logiciel (SDK) Databricks pour Java et pour répertorier tous les clusters de votre espace de travail Azure Databricks. Par exemple, dans le fichier Main.scala d’un projet, le code peut être comme suit :

    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 kit de développement logiciel (SDK) Databricks pour Java utilise son processus par défaut pour tenter d'effectuer l'authentification Azure Databricks. Pour remplacer ce comportement par défaut, consultez la section d’authentification suivante.

  4. Générez votre projet. Par exemple, pour effectuer cette opération dans IntelliJ IDEA, depuis le menu principal, cliquez sur Générer > Générer un projet.

  5. Exécutez votre fichier main. Par exemple, pour effectuer cette opération dans IntelliJ IDEA pour le fichier Main.scala d’un projet, depuis le menu principal, cliquez sur Exécuter > Exécuter « Main.scala ».

  6. La liste des clusters s’affiche. Par exemple, dans IntelliJ IDEA, il s’agit de la fenêtre Outil Exécuter. Pour afficher cette fenêtre Outil, dans le menu principal, cliquez sur Afficher > Fenêtres Outil > Exécuter.

Utiliser Databricks Utilities et Scala avec le SDK Databricks pour Java

Databricks Utilities fournit plusieurs fonctions d’assistance pour faciliter l’utilisation efficace du stockage d’objets, chaîner et paramétrer des notebooks et utiliser les secrets. Databricks fournit une bibliothèque Databricks Utilities pour Scala pour vous permettre d’accéder par programme à Databricks Utilities avec Scala.

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

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

  2. Déclarez une dépendance sur 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

    Veillez à remplacer 0.1.4 par la dernière version de la bibliothèque Databricks Utilities pour Scala. Vous trouverez la version la plus récente dans le référentiel central Maven.

  3. Demandez à votre projet d’utiliser la dépendance déclarée sur Databricks Utilities pour Scala. Par exemple, dans IntelliJ IDEA, cliquez sur l’icône de notification Charger sbt changes.

  4. Ajoutez du code à importer, puis appelez Databricks Utilities 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 d’accès du volume dans l’espace de travail, lit les données du fichier, puis supprime le fichier :

    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 ne définissant aucun argument dans l’appel précédent à val dbutils = DBUtils.getDBUtils(), Databricks Utilities pour Scala utilise son processus par défaut pour tenter d’effectuer l’authentification Azure Databricks.

    Pour remplacer ce comportement par défaut, transmettez un objet DatabricksCfg instancié en tant qu’argument à getDBUtils. Pour plus d’informations, consultez la section précédente sur l’authentification.

    Toutefois, si votre code s’exécute dans Databricks Runtime, cet objet DatabricksCfg est ignoré. En effet, Databricks Utilities pour Scala délègue à Databricks Utilities intégré lors de l’exécution dans Databricks Runtime.

  5. Générez le projet et exécutez le fichier principal.

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

Test

Pour tester votre code, utilisez des infrastructures de test Java telles que JUnit. Pour tester votre code dans des conditions simulées sans appeler des points de terminaison d’API REST d’Azure Databricks ni modifier l’état de vos comptes ou espaces de travail Azure Databricks, utilisez des bibliothèques fictives Java telles que Mockito.

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

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

Le fichier suivant nommé HelpersTest.java teste si la fonction createCluster retourne la réponse attendue. Au lieu de créer un cluster dans l’espace de travail cible, ce test simule un objet WorkspaceClient, définit les paramètres de l’objet fictif, puis transmet l’objet fictif à la fonction createCluster. Le test vérifie ensuite si la fonction retourne l’ID attendu du nouveau cluster fictif.

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

Ressources supplémentaires

Pour plus d'informations, consultez les pages suivantes :