dbx par Databricks Labs

Article
03/13/2024

Important

Cette documentation a été mise hors service et peut ne pas être mise à jour.

Databricks vous recommande d’utiliser les packs de ressources Databricks plutôt que dbx par Databricks Labs. Consultez Que sont les packs de ressources Databricks ? et Effectuer une migration à partir dbx vers des packs.

Remarque

Cet article couvre dbx par Databricks Labs, qui est fourni tel quel et qui n’est pas pris en charge par Databricks par le biais des canaux de support technique client. Pour toute question ou demande de fonctionnalité, vous pouvez utiliser la page Problèmes du dépôt databrickslabs/dbx sur GitHub.

dbx by Databricks Labs est un outil open source conçu pour étendre l'ancienne interface de ligne de commande Databricks (Databricks CLI) et pour fournir des fonctionnalités pour un cycle de vie de développement rapide et une intégration continue et une livraison/déploiement continu (CI/CD) sur Azure Databricks plateforme.

dbx simplifie le lancement et le déploiement des travaux dans plusieurs environnements. Il permet également d’empaqueter votre projet et de le remettre à votre environnement Azure Databricks de manière versionnée. Conçu de manière initiale par l’interface CLI, il est pensé pour être utilisé activement à l’intérieur des pipelines CI/CD et dans le cadre d’outils locaux (comme les IDE locaux, notamment Visual Studio Code et PyCharm).

Le workflow de développement classique avec dbx :

Créez un dépôt distant avec un fournisseur Git pris en charge par Databricks si vous n’avez pas encore de dépôt distant disponible.
Clonez votre référentiel distant dans votre espace de travail Azure Databricks.
Créez ou déplacez un notebook Azure Databricks dans le dépôt cloné dans votre espace de travail Azure Databricks. Utilisez ce notebook pour commencer le prototypage du code que vous souhaitez que vos clusters Azure Databricks exécutent.
Pour améliorer et modulariser votre code de notebook en ajoutant des classes d’assistance et des fonctions distinctes, des fichiers de configuration et des tests, basculez vers l’utilisation d’un ordinateur de développement local avec dbx, votre IDE préféré et Git installé.
Clonez votre référentiel distant sur votre ordinateur de développement local.
Déplacez votre code hors de votre notebook dans un ou plusieurs fichiers de code locaux.
Lorsque vous codez localement, envoyez (demande push) votre travail de votre référentiel local vers votre référentiel distant. Synchronisez également votre référentiel distant avec votre espace de travail Azure Databricks.

Conseil

Vous pouvez également utiliser la synchronisation dbx pour synchroniser automatiquement les modifications de fichiers locaux avec les fichiers correspondants dans votre espace de travail, en temps réel.
Continuez à utiliser le notebook dans votre espace de travail Azure Databricks pour le prototypage rapide et continuez à déplacer le code validé de votre notebook vers votre ordinateur local. Continuez à utiliser votre IDE local pour des tâches comme la modularisation du code, la saisie semi-automatique du code, le linting, les tests unitaires et le débogage pas à pas de code et d’objets qui ne nécessitent pas de connexion active à Azure Databricks.
Utilisez dbx pour exécuter par lots votre code local sur vos clusters cibles, comme vous le souhaitez. (Cela est similaire à l’exécution du script spark-submit dans le répertoire bin de Spark pour lancer des applications sur un cluster Spark.)
Lorsque vous êtes prêt pour la production, utilisez une plateforme CI/CD comme GitHub Actions, Azure DevOps ou GitLab pour automatiser l’exécution du code de votre référentiel distant sur vos clusters.

Spécifications

Pour utiliser dbx, vous devez avoir installé les éléments suivants sur votre ordinateur de développement local, que votre code utilise Python, Scala ou Java :

Python version 3.8 ou ultérieure.

Si votre code utilise Python, vous devez utiliser une version de Python qui correspond à celle installée sur vos clusters cibles. Pour obtenir la version de Python installée sur un cluster existant, vous pouvez utiliser le terminal web du cluster pour exécuter la commande python --version. Consultez également la section « Environnement système » dans les versions des notes de publication de Databricks Runtime et la compatibilité de la version de Databricks Runtime pour vos clusters cibles.
pip.
Si votre code utilise Python, une méthode pour créer des environnements virtuels Python afin de vous assurer que vous utilisez les bonnes versions de Python et dépendances de package dans vos projets dbx. Cet article couvre pipenv.
Version dbx 0.8.0 ou ultérieure. Vous pouvez installer ce package à partir de Python Package Index (PyPI) en exécutant pip install dbx.

Pour déterminer si dbx est installé, exécutez la commande suivante :
```
dbx --version
```
Si le numéro de version est retourné, dbx est installé.

Si le numéro de version est inférieur à 0.8.0, mettez à niveau dbx en exécutant la commande suivante, puis vérifiez à nouveau le numéro de version :
```
pip install dbx --upgrade
dbx --version

# Or ...
python -m pip install dbx --upgrade
dbx --version
```
L’interface CLI Databricks version 0.18 ou antérieure, configurée avec l’authentification. L’interface CLI Databricks héritée (Databricks CLI version 0.17) est automatiquement installée lorsque vous installez dbx. Cette authentification peut être configurée sur votre ordinateur de développement local dans un des deux emplacements suivants (ou les deux) :
- Dans les variables d’environnement DATABRICKS_HOST et DATABRICKS_TOKEN (à partir de l’l’interface CLI Databricks héritée version 0.8.0).
- Dans un profil de configuration Azure Databricks de votre fichier .databrickscfg.
dbx recherche les informations d’identification d’authentification dans ces deux emplacements, respectivement. dbx utilise uniquement le premier ensemble d’informations d’identification correspondantes qu’il trouve.

Notes

dbx ne prend pas en charge l'utilisation d'un fichier .netrc pour l'authentification, à partir de l'ancienne version 0.17.2 de l'interface de ligne de commande Databricks. Pour vérifier la version de votre CLI Databricks héritée installée, exécutez la commande databricks --version.
git pour l’envoi (push) et la synchronisation des modifications de code local et distant.

Poursuivez avec les instructions pour l’un des IDE suivants :

Visual Studio Code
PyCharm
IntelliJ IDEA
Eclipse

Notes

Bien que dbx devrait fonctionner avec n’importe quel IDE, Databricks n’a jusqu’à présent validé que l’utilisation des IDE précédents avec dbx. Vous pouvez également utiliser Aucun IDE (terminal uniquement).

dbx est optimisé pour fonctionner avec des fichiers de code Python à fichier unique et des fichiers Scala et Java JAR compilés. dbx ne fonctionne pas avec les fichiers de code R à fichier unique ou les packages de code R compilés. Cela est dû au fait que dbx fonctionne avec l’API Jobs 2.0 et 2.1, et ces API ne peuvent pas exécuter de fichiers de code R à fichier unique ou des packages de code R compilés en tant que travaux.

Visual Studio Code

Suivez ces instructions pour commencer à utiliser Visual Studio Code et Python avec dbx.

Sur votre ordinateur de développement local, vous devez disposer des éléments suivants installés en plus des exigences générales :

Visual Studio Code.
Extension Python pour Visual Studio Code. Pour plus d’informations, consultez Place de marché des extensions sur le site web Visual Studio Code.

Pour plus d’informations, consultez Bien démarrer avec Python dans VS Code dans la documentation Visual Studio Code.

Pour commencer à configurer la structure de votre projet dbx, procédez comme suit :

À partir de votre terminal, créez un dossier vide. Ces instructions utilisent un dossier nommé dbx-demo. Vous pouvez donner au dossier racine de votre projet dbx le nom souhaité. Si vous utilisez un autre nom, remplacez le nom tout au long de ces étapes. Après avoir créé le dossier, basculez vers celui-ci, puis démarrez Visual Studio Code à partir de ce dossier.

Pour Linux et macOS :
```
mkdir dbx-demo
cd dbx-demo
code .
```
Conseil

Si command not found: code s’affiche après l’exécution de code ., consultez Lancement à partir de la ligne de commande sur le site web Microsoft.

Pour Windows :
```
md dbx-demo
cd dbx-demo
code .
```
Dans Visual Studio Code, créez un environnement virtuel Python pour ce projet :
1. Dans la barre de menus, cliquez sur Affichage > Terminal.
2. À partir de la racine du dossier dbx-demo, exécutez la commande pipenv avec l’option suivante, où <version> est la version cible de Python que vous avez déjà installée localement (et, idéalement, une version qui correspond à la version de Python de vos clusters cibles), par exemple 3.8.14.
```
pipenv --python <version>
```
  Notez la valeur Virtualenv location dans la sortie de la commande pipenv, car vous en aurez besoin à l’étape suivante.
Sélectionnez l’interpréteur Python cible, puis activez l’environnement virtuel Python :
1. Dans la barre de menus, cliquez sur Afficher > Palette de commandes, tapez Python: Select, puis cliquez sur Python : Sélectionner l’interpréteur.
2. Sélectionnez l’interpréteur Python dans le chemin d’accès à l’environnement virtuel Python que vous venez de créer. (Ce chemin d’accès est répertorié comme valeur Virtualenv location dans la sortie de la commande pipenv.)
3. Dans la barre de menus, cliquez sur Afficher > Palette de commandes, tapez Terminal: Create, puis cliquez sur Terminal : Créer un terminal.
Pour plus d’informations, consultez Utilisation d’environnements Python dans VS Code dans la documentation Visual Studio Code.
Continuez avec Créer un projet dbx.

PyCharm

Suivez ces instructions pour commencer à utiliser PyCharm et Python avec dbx.

Sur votre ordinateur de développement local, pyCharm doit être installé en plus des exigences générales.

Pour commencer à configurer la structure de votre projet dbx, procédez comme suit :

Dans PyCharm, dans la barre de menus, cliquez sur Fichier > Nouveau projet.
Dans la boîte de dialogue Créer un projet, choisissez un emplacement pour votre nouveau projet.
Développez Interpréteur Python : Nouvel environnement Pipenv.
Sélectionnez Nouvel environnement avec, si ce n’est pas déjà sélectionné, puis Pipenv dans la liste déroulante.
Pour l’Interpréteur de base, sélectionnez l’emplacement qui contient l’interpréteur Python pour la version cible de Python que vous avez déjà installée localement (et, dans l’idéal, une version qui correspond à la version de vos clusters cibles de Python).
Pour l’Exécutable Pipenv, sélectionnez l’emplacement qui contient votre installation locale de pipenv, s’il n’est pas déjà détecté automatiquement.
Si vous souhaitez créer un projet dbx minimal et que vous souhaitez utiliser le fichier main.py avec ce projet dbx minimal, sélectionnez la zone Créer un script d’accueil main.py. Sinon, décochez cette case.
Cliquez sur Créer.
Dans la fenêtre de l’outil Projet, cliquez avec le bouton droit sur le dossier racine du projet, puis sur Ouvrir dans > Terminal.
Continuez avec Créer un projet dbx.

IntelliJ IDEA

Suivez ces instructions pour commencer à utiliser IntelliJ IDEA et Scala avec dbx. Ces instructions créent un projet Scala minimal basé sur sbt que vous pouvez utiliser pour démarrer un projet dbx.

Sur votre ordinateur de développement local, vous devez disposer des éléments suivants installés en plus des exigences générales :

IntelliJ IDEA.
Le plug-in Scala pour IntelliJ IDEA. Pour plus d’informations, consultez Découvrir IntelliJ IDEA pour Scala dans la documentation d’IntelliJ IDEA.
Java Runtime Environment (JRE) 8. Bien que toute édition de JRE 8 devrait fonctionner, Databricks n’a jusqu’à présent validé que l’utilisation de dbx et d’IntelliJ IDEA avec openJDK 8 JRE. Databricks n’a pas encore validé l’utilisation de dbx avec IntelliJ IDEA et Java 11. Pour plus d’informations, consultez Java Development Kit (JDK) dans la documentation IntelliJ IDEA.

Pour commencer à configurer la structure de votre projet dbx, procédez comme suit :

Étape 1 : Créer un projet Scala basé sur sbt

Dans IntelliJ IDEA, selon votre affichage, cliquez sur Projets > Nouveau projet ou Fichier > Nouveau > Projet.
Dans la boîte de dialogue Nouveau projet, cliquez sur Scala, puis sur sbt et sur Suivant.
Entrez un nom de projet et un emplacement où l’enregistrer.
Pour JDK, sélectionnez votre installation du JRE OpenJDK 8.
Pour sbt, choisissez la version disponible la plus élevée de sbt répertoriée.
Pour Scala, dans l’idéal, choisissez la version de Scala qui correspond à la version de vos clusters cibles Scala. Consultez la section « Environnement système » dans les notes de version de Databricks Runtime et la compatibilité pour la version de Databricks Runtime pour vos clusters cibles.
En regard de Scala, sélectionnez la zone Sources si elle n’est pas déjà sélectionnée.
Ajoutez un préfixe de package au Préfixe de package. Ces étapes utilisent le préfixe de package com.example.demo. Si vous spécifiez un préfixe de package différent, remplacez le préfixe du package tout au long de ces étapes.
Cliquez sur Terminer.

Étape 2 : Ajouter un objet au package

Vous pouvez ajouter tous les objets requis à votre package. Ce package contient un seul objet nommé SampleApp.

Dans la fenêtre de l’outil Projet (Affichage > Fenêtres Outil > Projet), cliquez avec le bouton droit sur le dossier nom-projet> src > main > scala, puis cliquez sur Nouveau > Classe Scala.
Choisissez Objet, puis entrez le nom de l’objet et puis appuyez sur Entrée. Par exemple, tapez SampleApp. Si vous entrez ici un autre nom d’objet, veillez à le remplacer tout au long de ces étapes.

Remplacez le contenu du fichier SampleApp.scala par le code suivant :

package com.example.demo

object SampleApp {
  def main(args: Array[String]) {
  }
}

Étape 3 : Générer le projet

Ajoutez tous les paramètres et dépendances de build de projet requis à votre projet. Cette étape suppose que vous créez un projet qui a été configuré dans les étapes précédentes et dépendant uniquement des bibliothèques suivantes.

Remplacez le contenu du fichier build.sbt du projet par le contenu suivant :

ThisBuild / version := "0.1.0-SNAPSHOT"

ThisBuild / scalaVersion := "2.12.14"

val sparkVersion = "3.2.1"

lazy val root = (project in file("."))
  .settings(
    name := "dbx-demo",
    idePackagePrefix := Some("com.example.demo"),
    libraryDependencies += "org.apache.spark" %% "spark-core" % sparkVersion withSources(),
    libraryDependencies += "org.apache.spark" %% "spark-sql" % sparkVersion withSources(),
    libraryDependencies += "org.apache.spark" %% "spark-hive" % sparkVersion withSources()
  )

Dans le fichier précédent, remplacez :

2.12.14 par la version de Scala que vous avez choisie précédemment pour ce projet.
3.2.1 par la version de Spark que vous avez choisie précédemment pour ce projet.
dbx-demo avec le nom de votre projet.
com.example.demo par le nom de votre préfixe de package.

Dans la barre de menus, cliquez sur Affichage > Fenêtres Outil > sbt.
Dans la fenêtre de l’outil sbt, cliquez avec le bouton droit sur le nom de votre projet, puis sur Recharger le projet sbt. Attendez que sbt finisse le téléchargement des dépendances du projet à partir d’un magasin d’artefacts Internet, comme Coursier ou Ivy par défaut, en fonction de votre version de sbt. Vous pouvez vérifier la progression du téléchargement dans la barre d’état. Si vous ajoutez ou modifiez d’autres dépendances à ce projet, vous devez répéter cette étape de rechargement de projet pour chaque ensemble de dépendances que vous ajoutez ou modifiez.
Dans la barre de menus, cliquez sur IntelliJ IDEA > Préférences.
Dans la boîte de dialogue Préférences, cliquez sur Build, Execution, Deployment > Build Tools > sbt.
Dans JVM, pour JRE, sélectionnez votre installation du JRE OpenJDK 8.
Dans Projets sbt, sélectionnez le nom de votre projet.
Dans Interpréteur de commandes sbt, sélectionnez builds.
Cliquez sur OK.
Dans la barre de menus, cliquez sur Générer > Générer le projet. Les résultats de la génération apparaissent dans la fenêtre de l’outil d’interpréteur de commandes sbt (Affichage > Fenêtres Outil > Interpréteur de commandes sbt).

Étape 4 - Ajouter du code au projet

Ajoutez le code requis à votre projet. Cette étape suppose que vous souhaitez uniquement ajouter du code au fichier SampleApp.scala dans le package example.

Dans le fichier src>main>scala>SampleApp.scala du projet, ajoutez le code que vous souhaitez que dbx exécute par lot sur vos clusters cibles. Pour les tests de base, utilisez l’exemple de code Scala dans la section Exemple de code.

Étape 5 : Exécuter le projet

Dans la barre de menus, cliquez sur Exécuter > Modifier les configurations.
Dans la boîte de dialogue Configurations d’exécution/débogage, cliquez sur l’icône + (Ajouter une nouvelle configuration) ou Ajouter ou Ajouter une nouvelle configuration d’exécution.
Dans la liste déroulante, cliquez sur Tâche sbt.
Pour Nom, entrez un nom pour la configuration, par exemple Exécuter le programme.
Pour Tâches, entrez ~run.
Sélectionnez Utiliser l’interpréteur de commandes sbt.
Cliquez sur OK.
Dans la barre de menus, cliquez sur Exécuter > Exécuter « Exécuter le programme ». Les résultats de l’exécution apparaissent dans la fenêtre de l’outil d’interpréteur de commandes sbt.

Étape 6 : Générer le projet en tant que JAR

Vous pouvez ajouter tous les paramètres de build JAR que vous souhaitez à votre projet. Cette étape suppose que vous souhaitez uniquement générer un fichier JAR basé sur le projet configuré dans les étapes précédentes.

Dans la barre de menus, cliquez sur Fichier > Structure du projet.
Dans la boîte de dialogue Structure du projet, cliquez sur Paramètres du projet > Artefacts.
Cliquez sur l’icône + (Ajouter).
Dans la liste déroulante, sélectionnez JAR > À partir des modules avec dépendances.
Dans la boîte de dialogue Créer un fichier JAR à partir de modules, pour Module, sélectionnez le nom de votre projet.
Pour Classe principale, cliquez sur l’icône de dossier.
Dans la boîte de dialogue Sélectionner la classe principale, sous l’onglet Rechercher par nom, sélectionnez SampleApp, puis cliquez sur OK.
Pour Fichiers JAR à partir de bibliothèques, sélectionnez Copier dans le répertoire de sortie et lier via le manifeste.
Cliquez sur OK pour fermer la boîte de dialogue Créer un fichier JAR à partir de modules.
Cliquez sur OK pour fermer la boîte de dialogue Structure de projet.
Dans la barre de menus, cliquez sur Générer > Artefacts.
Dans le menu contextuel qui s’affiche, sélectionnez nom-projet:jar > Build. Attendez pendant que sbt crée votre fichier JAR. Les résultats de la génération apparaissent dans la fenêtre de l’outil Sortie de génération (Affichage > Fenêtres Outil > Build).

Le fichier JAR est généré dans le dossier out>artifacts><project-name>_jar du projet. Le nom du fichier JAR est <project-name>.jar.

Étape 7 : Afficher le terminal dans l’IDE

Avec votre structure de projet dbx en place, vous êtes prêt à créer votre projet dbx.

Affichez le terminal IntelliJ IDEA en cliquant sur Afficher > Fenêtres Outil > Terminal dans la barre de menus, puis continuez avec Créer un projet dbx.

Eclipse

Suivez les instructions suivantes pour commencer à utiliser Eclipse et Java avec dbx. Ces instructions créent un projet Maven minimal basé sur Java que vous pouvez utiliser pour démarrer un projet dbx.

Sur votre ordinateur de développement local, vous devez disposer des éléments suivants installés en plus des exigences générales :

Une version d’Eclipse. Ces instructions utilisent l’IDE Eclipse pour l’édition Développeurs Java de l’IDE Eclipse.
Une édition du Java Runtime Environment (JRE) ou du Java Development Kit (JDK) 11, en fonction du système d’exploitation de votre ordinateur local. Bien que toute édition de JRE ou JDK 11 devrait fonctionner, Databricks n’a jusqu’à présent validé que l’utilisation de dbx et de l’IDE Eclipse pour développeurs Java avec Eclipse 2022-03 R, qui inclut AdoptOpenJDK 11.

Pour commencer à configurer la structure de votre projet dbx, procédez comme suit :

Étape 1 : Créer un projet Java basé sur Maven

Dans Eclipse, cliquez sur Fichier > Nouveau > Projet.
Dans la boîte de dialogue Nouveau projet, développez Maven, sélectionnez Projet Maven, puis cliquez sur Suivant.
Dans la boîte de dialogue Nouveau projet Maven, sélectionnez Créer un projet simple (ignorer la sélection de l’archétype) et cliquez sur Suivant.
Pour ID de groupe, entrez un ID de groupe conforme aux règles de nom de package de Java. Ces étapes utilisent le nom de package com.example.demo. Si vous entrez un ID de groupe différent, remplacez-le tout au long de ces étapes.
Pour ID d’artefact, entrez un nom pour le fichier JAR sans le numéro de version. Ces étapes utilisent le nom JAR dbx-demo. Si vous entrez un autre nom pour le fichier JAR, remplacez-le tout au long de ces étapes.
Cliquez sur Terminer.

Étape 2 : Ajouter une classe au package

Vous pouvez ajouter toutes les classes que vous souhaitez à votre package. Ce package contient une classe unique nommée SampleApp.

Dans la vue Explorateur de projet (Affichage > Afficher la vue > Explorateur de projet), sélectionnez l’icône nom-projet, puis cliquez sur Fichier > Nouveau > Classe.
Dans la boîte de dialogue Nouvelle classe Java, pour Package, entrez com.example.demo.
Pour Nom, entrez SampleApp.
Pour Modificateurs, sélectionnez public.
Laissez Superclasse vide.
Pour Stubs de méthode que vous souhaitez créer, sélectionnez public static void Main(String[] args).
Cliquez sur Terminer.

Étape 3 : Ajouter des dépendances au projet

Dans la vue Explorateur de projet, double-cliquez sur nom-projet> pom.xml.

Ajoutez les dépendances suivantes en tant qu’élément enfant de l’élément <project>, puis enregistrez le fichier :

<dependencies>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-sql_2.12</artifactId>
    <version>3.2.1</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_2.12</artifactId>
    <version>3.2.1</version>
  </dependency>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-hive_2.12</artifactId>
    <version>3.2.1</version>
    <scope>provided</scope>
  </dependency>
</dependencies>

Remplacez :

2.12 avec la version de Scala de vos clusters cibles.
3.2.1 avec la version de Spark de vos clusters cibles.

Consultez la section « Environnement système » dans les notes de version de Databricks Runtime et la compatibilité pour la version de Databricks Runtime pour vos clusters cibles.

Étape 4 - Compiler le projet

Dans le fichier pom.xml du projet, ajoutez les propriétés du compilateur Maven suivantes en tant qu’élément enfant de l’élément <project>, puis enregistrez le fichier :

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.6</maven.compiler.source>
  <maven.compiler.target>1.6</maven.compiler.target>
</properties>

Dans la vue Explorateur de projet, cliquez avec le bouton droit sur l’icône du nom de projet, puis sur Exécuter en tant que > Configurations d’exécution.
Dans la boîte de dialogue Exécuter les configurations, cliquez sur Build Maven.
Cliquez sur l’icône Nouvelle configuration de lancement.
Entrez un nom pour cette configuration de lancement, par exemple compilation propre.
Pour Répertoire de base, cliquez sur Espace de travail, choisissez le répertoire de votre projet, puis cliquez sur OK.
Dans Goals (Objectifs), entrez clean compile.
Cliquez sur Exécuter. La sortie de l’exécution s’affiche dans la vue Console (Fenêtre > Afficher la vue > Console).

Étape 5 - Ajouter du code au projet

Vous pouvez ajouter le code de votre choix à votre projet. Cette étape suppose que vous souhaitez uniquement ajouter du code à un fichier nommé SampleApp.java pour un package nommé com.example.demo.

Dans le fichier src/main/java>com.example.demo>SampleApp.java du projet, ajoutez le code que vous souhaitez que dbx exécute par lot sur vos clusters cibles. (Si vous n’avez pas de code à disposition, vous pouvez utiliser le code Java dans l’exemple de code, répertorié à la fin de cet article.)

Étape 6 : Exécuter le projet

Dans la vue Explorateur de projet, cliquez avec le bouton droit sur l’icône du nom de projet, puis sur Exécuter en tant que > Configurations d’exécution.
Dans la boîte de dialogue Configurations d’exécution, développez Application Java, puis cliquez sur Application.
Cliquez sur Exécuter. La sortie de l’exécution s’affiche dans la vue Console.

Étape 7 : Générer le projet en tant que fichier JAR

Dans la vue Explorateur de projet, cliquez avec le bouton droit sur l’icône du nom de projet, puis sur Exécuter en tant que > Configurations d’exécution.
Dans la boîte de dialogue Exécuter les configurations, cliquez sur Build Maven.
Cliquez sur l’icône Nouvelle configuration de lancement.
Entrez un nom pour cette configuration de lancement, par exemple package propre.
Pour Répertoire de base, cliquez sur Espace de travail, choisissez le répertoire de votre projet, puis cliquez sur OK.
Dans Goals (Objectifs), entrez clean package.
Cliquez sur Exécuter. La sortie de l’exécution s’affiche dans la vue Console.

Le fichier JAR est généré dans le dossier <project-name>>target. Le nom du fichier JAR est <project-name>-0.0.1-SNAPSHOT.jar.

Notes

Si le fichier JAR n’apparaît pas dans le dossier target de la fenêtre Explorateur de projet au début, vous pouvez essayer de l’afficher en cliquant avec le bouton droit sur l’icône nom-projet, puis sur Actualiser.

Étape 8 : Afficher le terminal dans l’IDE

Avec votre structure de projet dbx en place, vous êtes prêt à créer votre projet dbx. Pour démarrer, réglez la vue Explorateur de projet pour afficher les fichiers masqués (fichiers commençant par un point (./)) générés par dbx, comme suit :

Dans la vue Explorateur de projet, cliquez sur l’icône de filtre (menu Affichage), puis cliquez sur Filtres et personnalisation.
Dans la boîte de dialogue Filtres et personnalisation, sous l’onglet Filtres prédéfinis, désactivez la zone . resources*.
Cliquez sur OK.

Ensuite, affichez le terminal Eclipse comme suit :

Cliquez sur Fenêtre > Afficher la vue > Terminal dans la barre de menus.
Si l’invite de commandes du terminal n’apparaît pas, dans la vue Terminal, cliquez sur l’icône Ouvrir un terminal.
Utilisez la commande cd pour basculer vers le répertoire racine de votre projet.
Continuez avec Créer un projet dbx.

Aucun IDE (terminal uniquement)

Suivez ces instructions pour commencer à utiliser un terminal et Python avec dbx.

Procédez comme suit pour utiliser un terminal pour commencer à configurer la structure de votre projet dbx :

À partir de votre terminal, créez un dossier vide. Ces instructions utilisent un dossier nommé dbx-demo (mais vous pouvez donner au dossier racine de votre projet dbx le nom souhaité). Après avoir créé le dossier, basculez vers celui-ci.

Pour Linux et macOS :
```
mkdir dbx-demo
cd dbx-demo
```
Pour Windows :
```
md dbx-demo
cd dbx-demo
```
Créez un environnement virtuel Python pour ce projet en exécutant la commande pipenv, avec l’option suivante, à partir de la racine du dossier dbx-demo, où <version> est la version cible de Python que vous avez déjà installée localement, par exemple 3.8.14.
```
pipenv --python <version>
```
Activez votre environnement virtuel Python en exécutant pipenv shell.
```
pipenv shell
```
Continuez avec Créer un projet dbx.

Créer un projet dbx

Avec la structure de votre projet dbx en place à partir de l’une des sections précédentes, vous êtes maintenant prêt à créer l’un des types de projets suivants :

Créer un projet dbx minimal pour Python
Créer un projet dbx minimal pour Scala ou Java
Créer un projet avec modèle dbx pour Python avec prise en charge CI/CD

Créer un projet dbx minimal pour Python

Le projet minimal dbx suivant est l’approche la plus simple et la plus rapide pour commencer à utiliser Python et dbx. Il illustre l’exécution par lot sur un fichier de code Python unique sur un cluster Azure Databricks à usage général existant dans votre espace de travail Azure Databricks.

Notes

Pour créer un projet dbx avec modèle pour Python qui illustre l’exécution par lot de code sur des clusters de travaux et à usage général, des déploiements d’artefacts de code distant et une configuration de plateforme CI/CD, passez directement à Création d’un projet dbx avec modèle pour Python avec prise en charge de CI/CD.

Pour effectuer cette procédure, vous devez disposer d’un cluster à usage général existant dans votre espace de travail. (Consultez Afficher les calculs ou Informations de référence sur la configuration de calcul.) Dans l’idéal (mais pas obligatoirement), la version de Python dans votre environnement virtuel Python doit correspondre à la version installée sur ce cluster. Pour identifier la version de Python sur le cluster, utilisez le terminal web du cluster pour exécuter la commande python --version.

python --version

À partir de votre terminal, à partir du dossier racine de votre projet dbx, exécutez la commande dbx configure avec l’option suivante. Cette commande crée un dossier caché .dbx dans le dossier racine de votre projet dbx. Ce dossier .dbx contient les fichiers lock.json et project.json.
```
dbx configure --profile DEFAULT --environment default
```
Notes

Le fichier project.json définit un environnement nommé default avec une référence au profil DEFAULT dans votre fichier .databrickscfg. Si vous voulez que dbx utilise un autre profil, remplacez --profile DEFAULT par --profile suivi du nom de votre profil cible dans la commande dbx configure.

Par exemple, si vous avez un profil nommé DEV dans votre fichier .databrickscfg et que vous souhaitez dbx l'utiliser à la place du profil DEFAULT, votre fichier project.json pourrait ressembler à ceci, auquel cas vous remplaceriez --environment default également par --environment dev dans la commande dbx configure :
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}
```
Si vous souhaitez dbx utiliser les variables d'environnement DATABRICKS_HOST et DATABRICKS_TOKEN au lieu d'un profil dans votre fichier .databrickscfg, omettez complètement l'option --profile de la commande dbx configure.
Créez un dossier nommé conf dans le dossier racine de votre projet dbx.

Pour Linux et macOS :
```
mkdir conf
```
Pour Windows :
```
md conf
```
Ajouter un fichier nommé fichier deployment.yaml dans le répertoire conf, avec le contenu suivant :
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_python_task:
          python_file: "file://dbx-demo-job.py"
```
Notes

Le fichier deployment.yaml contient le mot en minuscules default, qui fait référence au profil DEFAULT en majuscules dans votre fichier .databrickscfg. Si vous voulez que dbx utilise un profil différent, remplacez default par le nom de votre profil cible.

Par exemple, si vous avez un profil nommé DEV dans votre fichier.databrickscfg et que vous souhaitez dbx l'utiliser à la place du profil DEFAULT, votre fichier deployment.yaml pourrait plutôt ressembler à ceci :
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_python_task:
          python_file: "file://dbx-demo-job.py"
  dev:
    workflows:
      - name: "<some-other-job-name>"
        spark_python_task:
          python_file: "file://<some-other-filename>.py"
```
Si vous souhaitez dbx utiliser les variables d'environnement DATABRICKS_HOST et DATABRICKS_TOKEN au lieu d'un profil dans votre fichier .databrickscfg, default laissez-les deployment.yaml telles quelles. dbx utilisera cette référence par défaut.
Conseil

Pour ajouter des paires clé-valeur de configuration Spark à un travail, utilisez le champ spark_conf, par exemple :
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: "-verbose:gc -XX:+PrintGCDetails"
        # ...
```
Pour ajouter des autorisations à un travail, utilisez le champ access_control_list, par exemple :
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        access_control_list:
          - user_name: "someone@example.com"
            permission_level: "IS_OWNER"
          - group_name: "some-group"
            permission_level: "CAN_VIEW"
        # ...
```
Notez que le champ access_control_list doit être exhaustif, donc le propriétaire du travail doit être ajouté à la liste, ainsi que les autres autorisations d’utilisateur et de groupe.
Ajoutez le code à exécuter sur le cluster à un fichier nommé dbx-demo-job.py et ajoutez-le au dossier racine de votre projet dbx. (Si vous n’avez pas de code à disposition, vous pouvez utiliser le code dans l’exemple de code Python, répertorié à la fin de cet article.)

Notes

Il n’est pas nécessaire de nommer ce fichier dbx-demo-job.py. Si vous choisissez un autre nom de fichier, veillez à mettre à jour le champ python_file dans le fichier conf/deployment.yaml pour qu’il corresponde.
Exécutez la commande dbx execute avec les options suivantes. Dans cette commande, remplacez <existing-cluster-id> par l’ID du cluster cible dans votre espace de travail. (Pour obtenir l’ID, consultez URL et ID du cluster.)
```
dbx execute --cluster-id=<existing-cluster-id> dbx-demo-job --no-package
```
Pour afficher les résultats de l’exécution localement, consultez la sortie de votre terminal. Pour afficher les résultats de l’exécution sur votre cluster, accédez au volet Sortie standard sous l’onglet Journaux du pilote de votre cluster. (Consultez Pilote de calcul et journaux du Worker.)
Passez aux Étapes suivantes.

Créer un projet dbx minimal pour Scala ou Java

Le projet minimal dbx suivant est l’approche la plus simple et la plus rapide pour commencer à utiliser dbx et Scala ou Java. Cela illustre le déploiement d’un fichier JAR Scala ou Java unique sur votre espace de travail Azure Databricks, puis l’exécution de ce fichier JAR déployé sur un cluster de travaux Azure Databricks dans votre espace de travail Azure Databricks.

Notes

Azure Databricks limite la façon dont vous pouvez exécuter du code Scala et Java sur des clusters :

Vous ne pouvez pas exécuter un seul fichier Scala ou Java en tant que travail sur un cluster comme vous pourriez le faire avec un seul fichier Python. Pour exécuter du code Scala ou Java, vous devez d’abord le générer dans un fichier JAR.
Vous pouvez exécuter un fichier JAR en tant que travail sur un cluster à usage général existant. Toutefois, vous ne pouvez pas réinstaller les mises à jour de ce fichier JAR sur le même cluster à usage général. Dans ce cas, vous devez utiliser un cluster de travaux à la place. Cette section utilise l’approche du cluster de travaux.
Vous devez d’abord déployer le fichier JAR sur votre espace de travail Azure Databricks avant de pouvoir exécuter ce fichier JAR déployé sur n’importe quel cluster à usage général ou cluster de travaux dans cet espace de travail.

À partir de votre terminal, à partir du dossier racine de votre projet, exécutez la commande dbx configure avec l’option suivante. Cette commande crée un dossier caché .dbx dans le dossier racine de votre projet. Ce dossier .dbx contient les fichiers lock.json et project.json.
```
dbx configure --profile DEFAULT --environment default
```
Notes

Le fichier project.json définit un environnement nommé default avec une référence au profil DEFAULT dans votre fichier .databrickscfg. Si vous voulez que dbx utilise un autre profil, remplacez --profile DEFAULT par --profile suivi du nom de votre profil cible dans la commande dbx configure.

Par exemple, si vous avez un profil nommé DEV dans votre fichier .databrickscfg et que vous souhaitez dbx l'utiliser à la place du profil DEFAULT, votre fichier project.json pourrait ressembler à ceci, auquel cas vous remplaceriez --environment default également par --environment dev dans la commande dbx configure :
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}
```
Si vous souhaitez dbx utiliser les variables d'environnement DATABRICKS_HOST et DATABRICKS_TOKEN au lieu d'un profil dans votre fichier .databrickscfg, omettez complètement l'option --profile de la commande dbx configure.
Créez un dossier nommé conf dans le dossier racine de votre projet.

Pour Linux et macOS :
```
mkdir conf
```
Pour Windows :
```
md conf
```
Ajouter un fichier nommé fichier minimal deployment.yaml dans le répertoire conf, avec le contenu suivant :
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        new_cluster:
          spark_version: "10.4.x-scala2.12"
          node_type_id: "Standard_DS3_v2"
          num_workers: 2
          instance_pool_id: "my-instance-pool"
        libraries:
          - jar: "file://out/artifacts/dbx_demo_jar/dbx-demo.jar"
        spark_jar_task:
          main_class_name: "com.example.demo.SampleApp"
```
Remplacez :
- La valeur de spark_version avec la version de runtime appropriée pour votre cluster de travaux cible.
- Valeur de node_type_id avec le Type de nœud de travail et de pilote approprié pour votre cluster de travaux cible.
- Valeur de instance_pool_id avec l’ID d’un pool d’instances existant dans votre espace de travail afin d’accélérer l’exécution des travaux. Si vous n’avez pas de pool d’instances existant disponible ou si vous ne souhaitez pas utiliser un pool d’instances, supprimez complètement cette ligne.
- Valeur de jar avec le chemin d’accès dans le projet au fichier JAR. Pour IntelliJ IDEA avec Scala, cela devrait être file://out/artifacts/dbx_demo_jar/dbx-demo.jar. Pour l’IDE Eclipse avec Java, cela devrait être file://target/dbx-demo-0.0.1-SNAPSHOT.jar.
- Valeur de main_class_name avec le nom de la classe principale dans le fichier JAR, par exemple com.example.demo.SampleApp.
Notes

Le fichier deployment.yaml contient le mot default, qui est une référence à l'environnement default dans le fichier .dbx/project.json, qui à son tour est une référence au profil DEFAULT dans votre fichier .databrickscfg. Si vous souhaitez dbx utiliser un profil différent, remplacez default dans ce fichier deployment.yaml par la référence correspondante dans le fichier .dbx/project.json, qui à son tour fait référence au profil correspondant dans votre fichier .databrickscfg.

Par exemple, si vous avez un profil nommé DEV dans votre fichier.databrickscfg et que vous souhaitez dbx l'utiliser à la place du profil DEFAULT, votre fichier deployment.yaml pourrait plutôt ressembler à ceci :
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        # ...
  dev:
    workflows:
      - name: "<some-other-job-name>"
        # ...
```
Si vous souhaitez dbx utiliser les variables d'environnement DATABRICKS_HOST et DATABRICKS_TOKEN au lieu d'un profil dans votre fichier .databrickscfg, default laissez-les deployment.yaml telles quelles. dbx utilise les paramètres d’environnement default (à l’exception de la valeur profile) dans le fichier .dbx/project.json par défaut.
Conseil

Pour ajouter des paires clé-valeur de configuration Spark à un travail, utilisez le champ spark_conf, par exemple :
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: "-verbose:gc -XX:+PrintGCDetails"
        # ...
```
Pour ajouter des autorisations à un travail, utilisez le champ access_control_list, par exemple :
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        access_control_list:
          - user_name: "someone@example.com"
            permission_level: "IS_OWNER"
          - group_name: "some-group"
            permission_level: "CAN_VIEW"
        # ...
```
Notez que le champ access_control_list doit être exhaustif, donc le propriétaire du travail doit être ajouté à la liste, ainsi que les autres autorisations d’utilisateur et de groupe.
Exécutez la commande dbx deploy. dbx déploie le fichier JAR à l’emplacement dans le chemin d’accès .dbx/project.json du fichier artifact_location pour l’environnement correspondant. dbx déploie également les fichiers du projet dans le cadre d’une expérience MLflow, à l’emplacement répertorié dans le chemin d’accès workspace_directory au fichier .dbx/project.json pour l’environnement correspondant.
```
dbx deploy --no-package
```
Exécutez la commande dbx launch avec les options suivantes. Cette commande exécute le travail avec le nom correspondant dans conf/deployment.yaml. Pour rechercher le fichier JAR déployé à exécuter dans le cadre du travail, dbx référence l’emplacement dans le chemin d’accès artifact_location du fichier .dbx/project.json pour l’environnement correspondant. Pour déterminer quel fichier JAR spécifique exécuter, dbx référence l’expérience MLflow à l’emplacement répertorié dans le chemin d’accès workspace_directory du fichier .dbx/project.json pour l’environnement correspondant.
```
dbx launch dbx-demo-job
```
Pour afficher les résultats de l’exécution du travail sur votre cluster de travaux, consultez Afficher les travaux.
Pour afficher l’expérience référencée par le travail, consultez Organiser les exécutions d’entraînement avec des expériences MLflow.
Passez aux Étapes suivantes.

Créer un projet avec modèle dbx pour Python avec prise en charge CI/CD

Le projet à modèle pour Python dbx suivant illustre la prise en charge de l’exécution par lots de code Python sur des clusters à usage général et de travaux Azure Databricks dans vos espaces de travail Azure Databricks, les déploiements d’artefacts de code distant et la configuration d’une plateforme de CI/CD. (Pour créer un projet minimal pour Python dbx qui illustre uniquement l’exécution par lot d’un fichier de code Python sur un cluster à usage général existant, revenez à Créer un projet dbx minimal pour Python.)

À partir de votre terminal, dans le dossier racine de votre projet dbx, exécutez la commande dbx init.
```
dbx init
```
Pour project_name, entrez un nom pour votre projet ou appuyez sur Entrée pour accepter le nom du projet par défaut.
Pour version, entrez un numéro de version de départ pour votre projet, ou appuyez sur Entrée pour accepter la version de projet par défaut.
Pour cloud, sélectionnez le numéro correspondant à la version cloud d’Azure Databricks que vous souhaitez utiliser pour votre projet, ou appuyez sur Entrée pour accepter la valeur par défaut.
Pour cicd_tool, sélectionnez le numéro correspondant à l’outil CI/CD pris en charge que votre projet doit utiliser, ou appuyez sur Entrée pour accepter la valeur par défaut.
Pour project_slug, entrez un préfixe que vous souhaitez utiliser pour les ressources de votre projet, ou appuyez sur Entrée pour accepter la valeur par défaut.
Pour workspace_directory, entrez le chemin d’accès local au répertoire de l’espace de travail de votre projet, ou appuyez sur Entrée pour accepter la valeur par défaut.
Pour artifact_location, entrez le chemin d’accès dans votre espace de travail Azure Databricks où les artefacts de votre projet seront écrits, ou appuyez sur Entrée pour accepter la valeur par défaut.
Pour profile, entrez le nom du profil d'authentification CLI que vous souhaitez que votre projet utilise ou appuyez sur Entrée pour accepter la valeur par défaut.

Conseil

Vous pouvez ignorer les étapes précédentes en exécutant dbx init avec des paramètres de modèle codés en dur, par exemple :

dbx init --template="python_basic" \
-p "project_name=cicd-sample-project" \
-p "cloud=Azure" \
-p "cicd_tool=Azure DevOps" \
-p "profile=DEFAULT" \
--no-input

dbx calcule les paramètres project_slug, workspace_directory et artifact_location automatiquement. Ces trois paramètres sont facultatifs et ne sont utiles que pour les cas d’usage plus avancés.

Voir la commande init dans Référence d’interface de ligne de commande dans la documentation dbx.

Voir aussi Étapes suivantes.

Exemple de code

Si vous n’avez pas de code facilement disponible pour l’exécution par lots avec dbx, vous pouvez expérimenter en exécutant par lot dbx sur le code suivant. Ce code crée une petite table dans votre espace de travail, interroge la table, puis la supprime.

Conseil

Si vous souhaitez laisser la table dans votre espace de travail au lieu de la supprimer, commentez la dernière ligne de code dans cet exemple avant de l’exécuter par lot avec dbx.

Python

# For testing and debugging of local objects, run
# "pip install pyspark=X.Y.Z", where "X.Y.Z"
# matches the version of PySpark
# on your target clusters.
from pyspark.sql import SparkSession

from pyspark.sql.types import *
from datetime import date

spark = SparkSession.builder.appName("dbx-demo").getOrCreate()

# Create a DataFrame consisting of high and low temperatures
# by airport code and date.
schema = StructType([
   StructField('AirportCode', StringType(), False),
   StructField('Date', DateType(), False),
   StructField('TempHighF', IntegerType(), False),
   StructField('TempLowF', IntegerType(), False)
])

data = [
   [ 'BLI', date(2021, 4, 3), 52, 43],
   [ 'BLI', date(2021, 4, 2), 50, 38],
   [ 'BLI', date(2021, 4, 1), 52, 41],
   [ 'PDX', date(2021, 4, 3), 64, 45],
   [ 'PDX', date(2021, 4, 2), 61, 41],
   [ 'PDX', date(2021, 4, 1), 66, 39],
   [ 'SEA', date(2021, 4, 3), 57, 43],
   [ 'SEA', date(2021, 4, 2), 54, 39],
   [ 'SEA', date(2021, 4, 1), 56, 41]
]

temps = spark.createDataFrame(data, schema)

# Create a table on the cluster and then fill
# the table with the DataFrame's contents.
# If the table already exists from a previous run,
# delete it first.
spark.sql('USE default')
spark.sql('DROP TABLE IF EXISTS demo_temps_table')
temps.write.saveAsTable('demo_temps_table')

# Query the table on the cluster, returning rows
# where the airport code is not BLI and the date is later
# than 2021-04-01. Group the results and order by high
# temperature in descending order.
df_temps = spark.sql("SELECT * FROM demo_temps_table " \
   "WHERE AirportCode != 'BLI' AND Date > '2021-04-01' " \
   "GROUP BY AirportCode, Date, TempHighF, TempLowF " \
   "ORDER BY TempHighF DESC")
df_temps.show()

# Results:
#
# +-----------+----------+---------+--------+
# |AirportCode|      Date|TempHighF|TempLowF|
# +-----------+----------+---------+--------+
# |        PDX|2021-04-03|       64|      45|
# |        PDX|2021-04-02|       61|      41|
# |        SEA|2021-04-03|       57|      43|
# |        SEA|2021-04-02|       54|      39|
# +-----------+----------+---------+--------+

# Clean up by deleting the table from the cluster.
spark.sql('DROP TABLE demo_temps_table')

Scala

package com.example.demo

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.types._
import org.apache.spark.sql.Row
import java.sql.Date

object SampleApp {
  def main(args: Array[String]) {
    val spark = SparkSession.builder().master("local").getOrCreate()

    val schema = StructType(Array(
      StructField("AirportCode", StringType, false),
      StructField("Date", DateType, false),
      StructField("TempHighF", IntegerType, false),
      StructField("TempLowF", IntegerType, false)
    ))

    val data = List(
      Row("BLI", Date.valueOf("2021-04-03"), 52, 43),
      Row("BLI", Date.valueOf("2021-04-02"), 50, 38),
      Row("BLI", Date.valueOf("2021-04-01"), 52, 41),
      Row("PDX", Date.valueOf("2021-04-03"), 64, 45),
      Row("PDX", Date.valueOf("2021-04-02"), 61, 41),
      Row("PDX", Date.valueOf("2021-04-01"), 66, 39),
      Row("SEA", Date.valueOf("2021-04-03"), 57, 43),
      Row("SEA", Date.valueOf("2021-04-02"), 54, 39),
      Row("SEA", Date.valueOf("2021-04-01"), 56, 41)
    )

    val rdd = spark.sparkContext.makeRDD(data)
    val temps = spark.createDataFrame(rdd, schema)

    // Create a table on the Databricks cluster and then fill
    // the table with the DataFrame's contents.
    // If the table already exists from a previous run,
    // delete it first.
    spark.sql("USE default")
    spark.sql("DROP TABLE IF EXISTS demo_temps_table")
    temps.write.saveAsTable("demo_temps_table")

    // Query the table on the Databricks cluster, returning rows
    // where the airport code is not BLI and the date is later
    // than 2021-04-01. Group the results and order by high
    // temperature in descending order.
    val df_temps = spark.sql("SELECT * FROM demo_temps_table " +
      "WHERE AirportCode != 'BLI' AND Date > '2021-04-01' " +
      "GROUP BY AirportCode, Date, TempHighF, TempLowF " +
      "ORDER BY TempHighF DESC")
    df_temps.show()

    // Results:
    //
    // +-----------+----------+---------+--------+
    // |AirportCode|      Date|TempHighF|TempLowF|
    // +-----------+----------+---------+--------+
    // |        PDX|2021-04-03|       64|      45|
    // |        PDX|2021-04-02|       61|      41|
    // |        SEA|2021-04-03|       57|      43|
    // |        SEA|2021-04-02|       54|      39|
    // +-----------+----------+---------+--------+

    // Clean up by deleting the table from the Databricks cluster.
    spark.sql("DROP TABLE demo_temps_table")
  }
}

Java

package com.example.demo;

import java.util.ArrayList;
import java.util.List;
import java.sql.Date;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.*;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.Dataset;

public class SampleApp {
  public static void main(String[] args) {
    SparkSession spark = SparkSession
      .builder()
      .appName("Temps Demo")
      .config("spark.master", "local")
      .getOrCreate();

    // Create a Spark DataFrame consisting of high and low temperatures
    // by airport code and date.
    StructType schema = new StructType(new StructField[] {
      new StructField("AirportCode", DataTypes.StringType, false, Metadata.empty()),
      new StructField("Date", DataTypes.DateType, false, Metadata.empty()),
      new StructField("TempHighF", DataTypes.IntegerType, false, Metadata.empty()),
      new StructField("TempLowF", DataTypes.IntegerType, false, Metadata.empty()),
    });

    List<Row> dataList = new ArrayList<Row>();
    dataList.add(RowFactory.create("BLI", Date.valueOf("2021-04-03"), 52, 43));
    dataList.add(RowFactory.create("BLI", Date.valueOf("2021-04-02"), 50, 38));
    dataList.add(RowFactory.create("BLI", Date.valueOf("2021-04-01"), 52, 41));
    dataList.add(RowFactory.create("PDX", Date.valueOf("2021-04-03"), 64, 45));
    dataList.add(RowFactory.create("PDX", Date.valueOf("2021-04-02"), 61, 41));
    dataList.add(RowFactory.create("PDX", Date.valueOf("2021-04-01"), 66, 39));
    dataList.add(RowFactory.create("SEA", Date.valueOf("2021-04-03"), 57, 43));
    dataList.add(RowFactory.create("SEA", Date.valueOf("2021-04-02"), 54, 39));
    dataList.add(RowFactory.create("SEA", Date.valueOf("2021-04-01"), 56, 41));

    Dataset<Row> temps = spark.createDataFrame(dataList, schema);

    // Create a table on the Databricks cluster and then fill
    // the table with the DataFrame's contents.
    // If the table already exists from a previous run,
    // delete it first.
    spark.sql("USE default");
    spark.sql("DROP TABLE IF EXISTS demo_temps_table");
    temps.write().saveAsTable("demo_temps_table");

    // Query the table on the Databricks cluster, returning rows
    // where the airport code is not BLI and the date is later
    // than 2021-04-01. Group the results and order by high
    // temperature in descending order.
    Dataset<Row> df_temps = spark.sql("SELECT * FROM demo_temps_table " +
      "WHERE AirportCode != 'BLI' AND Date > '2021-04-01' " +
      "GROUP BY AirportCode, Date, TempHighF, TempLowF " +
      "ORDER BY TempHighF DESC");
    df_temps.show();

    // Results:
    //
    // +-----------+----------+---------+--------+
    // |AirportCode|      Date|TempHighF|TempLowF|
    // +-----------+----------+---------+--------+
    // |        PDX|2021-04-03|       64|      45|
    // |        PDX|2021-04-02|       61|      41|
    // |        SEA|2021-04-03|       57|      43|
    // |        SEA|2021-04-02|       54|      39|
    // +-----------+----------+---------+--------+

    // Clean up by deleting the table from the Databricks cluster.
    spark.sql("DROP TABLE demo_temps_table");
  }
}

Étapes suivantes

Étendez votre fichier conf/deployment.yaml pour prendre en charge différents types de définitions de clusters à usage général et de travaux.
Déclarez des travaux multitâche dans votre fichier conf/deployment.yaml.
Référencez les propriétés nommées dans votre fichier conf/deployment.yaml.
Exécutez le code par lots en tant que nouveaux travaux sur les clusters avec la commande dbx execute.

Ressources supplémentaires

Déployez par lots les artefacts de code vers le stockage de l’espace de travail Azure Databricks avec la commande dbx deploy.
Exécutez par lots des travaux existants sur des clusters avec la commande dbx launch.
Utilisez dbx pour effectuer le déploiement et le lancement de workflow basés sur les ressources.
Planifiez les déploiements de workflow.
En savoir plus sur dbx et CI/CD.
dbx documentation
Référentiel databrickslabs/dbx sur GitHub
Limitations de dbx