dbx von Databricks Labs

Artikel
03/13/2024

Wichtig

Diese Dokumentation wurde eingestellt und wird unter Umständen nicht aktualisiert.

Databricks empfiehlt, Databricks-Ressourcenbündel anstelle von dbx von Databricks Labs zu verwenden. Lesen Sie Was sind Databricks-Ressourcenbündel? und Migrieren von dbx zu Bündeln.

Hinweis

Dieser Artikel behandelt dbx von Databricks Labs, das so wie es ist bereitgestellt wird und nicht von Databricks über Kanäle des technischen Supports von Kunden unterstützt wird. Fragen und Funktionsanfragen können über die Seite Issues des databrickslabs/dbx-Repository auf GitHub mitgeteilt werden.

dbx von Databricks Labs ist ein Open-Source-Tool zur Erweiterung der Databricks-Legacy-Befehlszeilenschnittstelle (Databricks CLI) und zur Bereitstellung von Funktionen für den schnellen Entwicklungslebenszyklus und Continuous Integration und Continuous Delivery (CI/CD) auf der Azure Databricks-Plattform.

dbx vereinfacht den Start und die Bereitstellung von Aufträgen in verschiedenen Umgebungen. Es hilft auch dabei, Ihr Projekt zu verpacken und es mit Versionsangabe an Ihre Azure Databricks-Umgebung zu liefern. Es wurde auf der Grundlage einer CLI entwickelt und kann sowohl innerhalb von CI/CD-Pipelines als auch als Teil lokaler Tools (z. B. lokaler IDEs, einschließlich Visual Studio Code und PyCharm) verwendet werden.

Der typische Entwicklungsworkflow mit dbx ist:

Erstellen Sie ein Remoterepository mit einem von Databricks unterstützten Git-Anbieter, wenn Sie noch nicht über ein Remoterepository verfügen.
Klonen Sie Ihr Remoterepository in Ihren Azure Databricks-Arbeitsbereich.
Erstellen oder verschieben Sie ein Azure Databricks-Notebook in das geklonte Repository in Ihrem Azure Databricks-Arbeitsbereich. Verwenden Sie dieses Notebook, um mit der Prototyperstellung des Codes zu beginnen, den Sie auf Ihren Azure Databricks-Clustern ausführen möchten.
Um Ihren Notebookcode zu verbessern und zu modularisieren, indem Sie separate Hilfsklassen und -funktionen, Konfigurationsdateien und Tests hinzufügen, wechseln Sie zu einem lokalen Entwicklungscomputer mit dbx, Ihrer bevorzugten IDE und installiertem Git.
Klonen Sie Ihr Remoterepository auf Ihren lokalen Entwicklungscomputer.
Verschieben Sie Ihren Code aus Ihrem Notebook in eine oder mehrere lokale Codedateien.
Während Sie lokal programmieren, pushen Sie Ihre Arbeit von Ihrem lokalen Repository in Ihr Remoterepository. Synchronisieren Sie außerdem Ihr Remoterepository mit Ihrem Azure Databricks-Arbeitsbereich.

Tipp

Alternativ können Sie die DBX-Synchronisierung verwenden, um lokale Dateiänderungen automatisch mit entsprechenden Dateien in Ihrem Arbeitsbereich in Echtzeit zu synchronisieren.
Verwenden Sie das Notebook weiterhin in Ihrem Azure Databricks-Arbeitsbereich für die schnelle Prototyperstellung, und verschieben Sie überprüften Code von Ihrem Notebook auf Ihren lokalen Computer. Verwenden Sie weiterhin Ihre lokale IDE für Aufgaben wie Codemodularisierung, Codevervollständigung, Linten, Unittests und schrittweises Debuggen von Code und Objekten, die keine Liveverbindung mit Azure Databricks erfordern.
Verwenden Sie dbx, um Ihren lokalen Code wie gewünscht auf Ihren Zielclustern auszuführen. (Dies ist vergleichbar mit dem Ausführen des Skripts spark-submit im bin-Verzeichnis von Spark, um Anwendungen auf einem Spark-Cluster zu starten.)
Wenn Sie bereit für die Produktion sind, verwenden Sie eine CI/CD-Plattform wie GitHub Actions, Azure DevOps oder GitLab, um den Code Ihres Remoterepositorys automatisch auf Ihren Clustern auszuführen.

Anforderungen

Um dbx zu verwenden, müssen Sie Folgendes auf Ihrem lokalen Computer installiert haben, unabhängig davon, ob Ihr Code Python, Scala oder Java verwendet:

Python (Version 3.8 oder höher)

Wenn Ihr Code Python verwendet, sollten Sie eine Python-Version verwenden, die mit der Version übereinstimmt, die auf Ihren Zielclustern installiert ist. Um die Version von Python zu erhalten, die auf einem bestehenden Cluster installiert ist, können Sie das Webterminal des Clusters verwenden, um den Befehl python --version auszuführen. Weitere Informationen zur Databricks Runtime-Version für Ihre Zielcluster finden Sie im Abschnitt „Systemumgebung“ unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität.
pip.
Wenn Ihr Code Python verwendet, können Sie mit dieser Methode virtuelle Python-Umgebungen erstellen, um sicherzustellen, dass Sie die richtigen Python-Versionen und Paketabhängigkeiten in Ihren dbx-Projekten verwenden. Dieser Artikel behandelt pipenv.
dbx Version 0.8.0 oder höher. Sie können dieses Paket aus dem Python Package Index (PyPI) installieren, indem Sie pip install dbx ausführen.

Führen Sie den folgenden Befehl aus, um die Installation von dbx zu bestätigen:
```
dbx --version
```
Wenn die Versionsnummer zurückgegeben wird, ist dbx installiert.

Wenn die Versionsnummer unter 0.8.0 liegt, führen Sie ein Upgrade von dbx durch, indem Sie den folgenden Befehl ausführen, und überprüfen Sie dann die Versionsnummer erneut:
```
pip install dbx --upgrade
dbx --version

# Or ...
python -m pip install dbx --upgrade
dbx --version
```
Version 0.18 oder niedriger der Databricks-Befehlszeilenschnittstelle mit eingerichteter Authentifizierung. Die Legacyversion der Databricks CLI (Databricks CLI-Versionen 0.17) wird bei der Installation von dbx automatisch installiert. Diese Authentifizierung kann auf Ihrem lokalen Entwicklungscomputer in einem oder beiden der folgenden Speicherorte eingerichtet werden:
- Innerhalb der Umgebungsvariablen DATABRICKS_HOST und DATABRICKS_TOKEN (ab Databricks CLI-Legacyversion 0.8.0).
- In einem Azure Databricks-Konfigurationsprofil in Ihrer .databrickscfg-Datei.
dbx sucht an diesen beiden Speicherorten jeweils nach Anmeldeinformationen für die Authentifizierung. dbx verwendet nur die erste Gruppe übereinstimmender Anmeldeinformationen, die es findet.

Hinweis

dbx unterstützt nicht die Verwendung einer Datei vom Typ .netrc für die Authentifizierung, beginnend mit Databricks CLI-Legacyversion 0.17.2. Um die installierte Databricks CLI-Legacyversion zu überprüfen, führen Sie den Befehl databricks --version aus.
git zum Pushen und Synchronisieren von lokalen und Remotecodeänderungen.

Fahren Sie mit den Anweisungen für eine der folgenden IDEs fort:

Visual Studio Code
PyCharm
IntelliJ IDEA
Eclipse

Hinweis

Databricks hat die Verwendung der vorangegangenen IDEs mit dbx überprüft. dbx sollte jedoch mit jeder IDE funktionieren. Sie können auch Keine IDE (nur Terminal) verwenden.

dbx ist für die Arbeit mit Python-Codedateien aus einer einzelnen Datei und kompilierten Scala- und Java-JAR-Dateien optimiert. dbx funktioniert nicht mit einzelnen R-Code-Dateien oder mit kompilierten R-Code-Paketen. Dies liegt daran, dass dbx mit der Auftrags-API 2.0 und 2.1 arbeiten, und diese APIs können keine einzelnen R-Code-Dateien oder kompilierte R-Code-Pakete als Aufträge ausführen.

Visual Studio Code

Führen Sie die folgenden Anweisungen aus, um Visual Studio Code und Python mit dbx zu verwenden.

Auf Ihrem lokalen Computer müssen Sie zusätzlich zu den allgemeinen Anforderungen Folgendes installiert haben:

Visual Studio Code.
Python-Erweiterung für Visual Studio Code Weitere Informationen finden Sie unter Marketplace für Erweiterungen auf der Visual Studio Code-Website.

Weitere Informationen finden Sie unter Erste Schritte mit Python in VS Code in der Visual Studio Code-Dokumentation.

Führen Sie die folgenden Schritte aus, um mit der Einrichtung Ihrer dbx-Projektstruktur zu beginnen:

Erstellen Sie über das Terminal einen leeren Ordner. Diese Anweisungen verwenden einen Ordner namens dbx-demo. Sie können dem Stammordner Ihres dbx-Projekts jeden beliebigen Namen geben. Wenn Sie einen anderen Namen verwenden, ersetzen Sie den Namen während dieser Schritte. Nachdem Sie den Ordner erstellt haben, wechseln Sie zu diesem Ordner, und starten Sie dann Visual Studio Code aus diesem Ordner.

Für Linux und macOS:
```
mkdir dbx-demo
cd dbx-demo
code .
```
Tipp

Wenn command not found: code nach der Ausführung von code .angezeigt wird, lesen Sie Starten über die Befehlszeile auf der Microsoft-Website.

Windows:
```
md dbx-demo
cd dbx-demo
code .
```
Erstellen Sie in Visual Studio Code eine virtuelle Python-Umgebung für dieses Projekt:
1. Klicken Sie in der Menüleiste auf Ansicht > Terminal.
2. Führen Sie im Stammverzeichnis des Ordners dbx-demo den pipenv-Befehl mit der folgenden Option aus, wobei <version> die Zielversion von Python ist, die Sie bereits lokal installiert haben (und idealerweise eine Version, die mit der Python-Version Ihres Zielclusters übereinstimmt), z. B. 3.8.14.
```
pipenv --python <version>
```
  Notieren Sie sich den Virtualenv location-Wert in der Ausgabe des pipenv-Befehls, da Sie ihn im nächsten Schritt benötigen.
Wählen Sie den Python-Zielinterpreter aus, und aktivieren Sie dann die virtuelle Python-Umgebung:
1. Klicken Sie in der Menüleiste auf Ansicht > Befehlspalette, geben Sie Python: Select ein, und klicken Sie dann auf Python: Interpreter auswählen.
2. Wählen Sie den Python-Interpreter innerhalb des Pfads zur virtuellen Python-Umgebung aus, die Sie gerade erstellt haben. (Dieser Pfad wird als Virtualenv location-Wert in der Ausgabe des pipenv-Befehls aufgeführt.)
3. Klicken Sie auf der Menüleiste auf Ansicht > Befehlspalette, geben Sie Terminal: Create ein, und klicken Sie dann auf Terminal: Neues Terminal erstellen.
Weitere Informationen finden Sie unter Verwenden von Python-Umgebungen in VS Code in der Visual Studio Code-Dokumentation.
Fahren Sie mit dem Erstellen eines dbx-Projekts fort.

PyCharm

Führen Sie die folgenden Anweisungen aus, um mit der Verwendung von PyCharm und Python mit dbx zu beginnen.

Auf Ihrem lokalen Computer müssen Sie zusätzlich zu den allgemeinen Anforderungen PyCharm installiert haben.

Führen Sie die folgenden Schritte aus, um mit der Einrichtung Ihrer dbx-Projektstruktur zu beginnen:

Klicken Sie in PyCharm auf der Menüleiste auf Datei > Neues Projekt.
Wählen Sie im Dialogfeld Projekt erstellen einen Speicherort für Ihr neues Projekt aus.
Erweitern Sie Python-Interpreter: Neue Pipenv-Umgebung.
Wählen Sie Neue Umgebung mithilfe von aus, sofern dies nicht bereits ausgewählt ist, und wählen Sie dann Pipenv aus der Dropdownliste.
Wählen Sie unter Basisinterpreter den Speicherort aus, der den Python-Interpreter für die Zielversion von Python enthält, die Sie bereits lokal installiert haben (und idealerweise eine Version, die mit der Python-Version Ihres Zielclusters übereinstimmt).
Wählen Sie für die ausführbare Datei von Pipenv den Speicherort aus, der Ihre lokale Installation von pipenv enthält, wenn diese nicht bereits automatisch erkannt wird.
Wenn Sie ein minimales dbx-Projekt erstellen und die main.py-Datei mit diesem minimalen dbx-Projekt verwenden möchten, wählen Sie das Feld main.py-Willkommensskript erstellen aus. Andernfalls deaktivieren Sie dieses Feld.
Klicken Sie auf Erstellen.
Klicken Sie im Toolfenster Projekt mit der rechten Maustaste auf den Stammordner des Projekts, und klicken Sie dann auf Öffnen in > Terminal.
Fahren Sie mit dem Erstellen eines dbx-Projekts fort.

IntelliJ IDEA

Führen Sie die folgenden Anweisungen aus, um mit der Verwendung von IntelliJ IDEA und Scala mit dbx zu beginnen. Mit dieser Anleitung erstellen Sie ein minimales sbt-basiertes Scala-Projekt, das Sie verwenden können, um ein dbx-Projekt zu starten.

Auf Ihrem lokalen Computer müssen Sie zusätzlich zu den allgemeinen Anforderungen Folgendes installiert haben:

IntelliJ IDEA.
Das Scala-Plug-In für IntelliJ IDEA. Weitere Informationen finden Sie unter Discover IntelliJ IDEA for Scala in der IntelliJ IDEA-Dokumentation.
Java Runtime Environment (JRE) 8. Obwohl jede Edition von JRE 8 funktionieren sollte, hat Databricks bisher nur die Verwendung von dbx und IntelliJ IDEA mit der OpenJDK 8 JRE validiert. Databricks hat die Verwendung von dbx mit IntelliJ IDEA und Java 11 noch nicht validiert. Weitere Informationen finden Sie in der IntelliJ IDEA-Dokumentation unter Java Development Kit (JDK).

Führen Sie die folgenden Schritte aus, um mit der Einrichtung Ihrer dbx-Projektstruktur zu beginnen:

Schritt 1: Erstellen eines sbt-basierten Scala-Projekts

Klicken Sie in IntelliJ IDEA je nach Ansicht auf Projekt > Neues Projekt oder Datei > Neu > Projekt.
Klicken Sie im Dialogfeld Neues Projekt auf Scala, klicken Sie auf sbt und dann auf Weiter.
Geben Sie einen Projektnamen und einen Speicherort für das Projekt ein.
Wählen Sie für JDK Ihre Installation des OpenJDK 8 JRE aus.
Wählen Sie für sbt die höchste verfügbare Version von sbt aus, die aufgeführt ist.
Wählen Sie für Scala idealerweise die Version von Scala aus, die mit der Scala-Version Ihres Zielclusters übereinstimmt. Weitere Informationen zur Databricks Runtime-Version für Ihre Zielcluster finden Sie im Abschnitt „Systemumgebung“ unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität.
Wählen Sie neben Scala das Feld Quellen aus, wenn es nicht bereits ausgewählt ist.
Fügen Sie dem Feld Paketpräfixein Paketpräfix hinzu. Diese Schritte verwenden das Paketpräfix com.example.demo. Wenn Sie ein anderes Paketpräfix angeben, ersetzen Sie das Paketpräfix in diesen Schritten.
Klicken Sie auf Fertig stellen.

Schritt 2: Hinzufügen eines Objekts zum Paket

Sie können Ihrem Paket alle erforderlichen Objekte hinzufügen. Dieses Paket enthält ein einzelnes Objekt namens SampleApp.

Klicken Sie im Toolfenster Projekt (Ansicht > Toolfenster > Projekt), klicken Sie mit der rechten Maustaste auf den Ordner Projektname> src > main > scala, und klicken Sie dann auf Neu > Skala-Klasse.
Wählen Sie Objekt aus, geben Sie den Namen des Objekts ein, und drücken Sie dann die EINGABETASTE. Geben Sie beispielsweise SampleApp. Wenn Sie hier einen anderen Objektnamen eingeben, stellen Sie sicher, dass Sie den Namen während dieser Schritte ersetzen.

Ersetzen Sie den Inhalt der Datei SampleApp.scala durch den folgenden Code:

package com.example.demo

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

Schritt 3: Erstellen des Projekts

Fügen Sie alle erforderlichen Einstellungen für das Erstellen von Projekten und Abhängigkeiten zu Ihrem Projekt hinzu. In diesem Schritt wird davon ausgegangen, dass Sie ein Projekt erstellen, das in den vorherigen Schritten festgelegt wurde und nur von den folgenden Bibliotheken abhängt.

Ersetzen Sie den Inhalt der Datei build.sbt des Projekts durch den folgenden Inhalt:

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

Ersetzen Sie in der vorhergehenden Datei Folgendes:

2.12.14 mit der Version von Scala, die Sie zuvor für dieses Projekt ausgewählt haben.
3.2.1 mit der Version von Spark, die Sie zuvor für dieses Projekt ausgewählt haben.
dbx-demo mit dem Namen Ihres Projekts.
com.example.demo mit dem Namen Ihres Paketpräfixes.

Klicken Sie in der Menüleiste auf Ansicht > Toolfenster > sbt.
Klicken Sie im Toolfenster sbt mit der rechten Maustaste auf den Namen Ihres Projekts, und klicken Sie auf sbt-Projekt neu laden. Warten Sie, bis sbt das Herunterladen der Abhängigkeiten des Projekts von einem Internet-Artefaktspeicher wie Coursier oder Ivy abgeschlossen hat, je nach Ihrer Version von sbt. Sie können den Fortschritt des Downloads in der Statusleiste verfolgen. Wenn Sie weitere Abhängigkeiten zu diesem Projekt hinzufügen oder ändern, müssen Sie diesen Schritt des erneuten Ladens des Projekts für jeden Satz von Abhängigkeiten, den Sie hinzufügen oder ändern, wiederholen.
Klicken Sie auf der Menüleiste auf IntelliJ IDEA > Einstellungen.
Klicken Sie im Dialogfeld Einstellungen auf Build, Ausführung, Bereitstellung > Buildtools > sbt.
Wählen Sie in JVM für JREIhre Installation der OpenJDK 8 JRE aus.
Wählen Sie in sbt-Projekten den Namen Ihres Projekts aus.
Wählen Sie in der sbt-Shell entsprechend Builds aus.
Klicken Sie auf OK.
Klicken Sie auf der Menüleiste auf Erstellen > Projekt erstellen. Die Ergebnisse des Erstellens werden im Toolfenster der sbt-Shell (Ansicht > Toolfenster > sbt-Shell) angezeigt.

Schritt 4: Hinzufügen von Code zum Projekt

Fügen Sie den erforderlichen Code zu Ihrem Projekt hinzu. In diesem Schritt wird davon ausgegangen, dass Sie der Datei SampleApp.scala im example-Paket nur Code hinzufügen möchten.

Fügen Sie in der Datei src>main>scala>SampleApp.scala des Projekts den Code hinzu, der von dbx auf Ihren Zielclustern als Batch ausgeführt werden soll. Für grundlegende Tests verwenden Sie den Scala-Beispielcode im Abschnitt Codebeispiel.

Schritt 5: Ausführen des Projekts

Klicken Sie auf der Menüleiste auf Ausführen > Konfigurationen bearbeiten.
Klicken Sie im Dialogfeld Ausführen/Debugkonfigurationen auf das Symbol + (Neue Konfiguration hinzufügen) oder Neu hinzufügen oder Neue Ausführungskonfiguration hinzufügen.
Klicken Sie in der Dropdownliste auf sbt-Aufgabe.
Geben Sie unter Name einen Namen für die Konfiguration ein, z. B. Programm ausführen.
Geben Sie für Aufgaben die Option ~run ein.
Wählen Sie sbt-Shell verwenden aus.
Klicken Sie auf OK.
Klicken Sie auf der Menüleiste auf Ausführen > Ausführen von „Programm ausführen“. Die Ergebnisse der Ausführung werden im Toolfenster sbt-Shell angezeigt.

Schritt 6: Erstellen des Projekts als JAR

Sie können alle gewünschten Einstellungen für die JAR-Erstellung zu Ihrem Projekt hinzufügen. Bei diesem Schritt wird davon ausgegangen, dass Sie nur eine JAR erstellen möchten, die auf dem Projekt basiert, das in den vorherigen Schritten festgelegt wurde.

Klicken Sie auf der Menüleiste auf Datei > Projektstruktur.
Klicken Sie im Dialogfeld Projektstruktur auf Projekteinstellungen > Artefakte.
Klicken Sie auf das Symbol + (Hinzufügen).
Wählen Sie in der Dropdownliste JAR > Aus Modulen mit Abhängigkeiten aus.
Wählen Sie im Dialogfeld JAR aus Modulen erstellen für Modul den Namen Ihres Projekts aus.
Klicken Sie für Hauptklasse auf das Ordnersymbol.
Wählen Sie im Dialogfeld Hauptklasse auswählen auf der Registerkarte Nach Name suchen die Option SampleApp aus, und klicken Sie dann auf OK.
Wählen Sie für JAR-Dateien aus Bibliotheken die Option In das Ausgabeverzeichnis kopieren und über Manifest verknüpfen aus.
Klicken Sie auf OK, um das Dialogfeld JAR aus Modulen erstellen zu schließen.
Klicken Sie auf OK, um das Dialogfeld mit der Projektstruktur zu schließen.
Klicken Sie auf der Menüleiste auf Erstellen > Artefakte erstellen.
Wählen Sie im angezeigten Kontextmenü Projektname:jar > Erstellen aus. Warten Sie, während sbt Ihre JAR-Datei erstellt. Die Ergebnisse der Erstellung werden im Toolfenster Buildausgabe (Ansicht > Toolfenster > Erstellen) angezeigt.

Die JAR wird im Ordner out>artifacts><project-name>_jar des Projekts erstellt. Der Name der JAR lautet <project-name>.jar.

Schritt 7: Anzeigen des Terminals in der IDE

Da Ihre dbx-Projektstruktur jetzt feststeht, können Sie Ihr dbx-Projekt erstellen.

Zeigen Sie das IntelliJ IDEA-Terminal an, indem Sie in der Menüleiste auf Ansicht > Toolfenster > Terminal klicken, und fahren Sie dann mit dbx-Projekt erstellen fort.

Eclipse

Führen Sie die folgenden Anweisungen aus, um Eclipse und Java mit dbx zu verwenden. Mit dieser Anleitung erstellen Sie ein minimales Maven-basiertes Java-Projekt, das Sie verwenden können, um ein dbx-Projekt zu starten.

Auf Ihrem lokalen Computer müssen Sie zusätzlich zu den allgemeinen Anforderungen Folgendes installiert haben:

Eine Version von Eclipse. Diese Anweisungen verwendet die Edition „Eclipse-IDE für Java-Entwickler“ der Eclipse-IDE.
Eine Edition der Java Runtime Environment (JRE) oder des Java Development Kit (JDK) 11, je nach Betriebssystem Ihres Computers. Obwohl jede Edition von JRE oder JDK 11 funktionieren sollte, hat Databricks bisher nur die Verwendung von dbx und die Eclipse-IDE für Java-Entwickler mit Eclipse 2022-03 R validiert, die AdoptOpenJDK 11 enthält.

Führen Sie die folgenden Schritte aus, um mit der Einrichtung Ihrer dbx-Projektstruktur zu beginnen:

Schritt 1: Erstellen eines Maven-basierten Java-Projekts

Klicken Sie in Eclipse auf Datei > Neu > Projekt.
Erweitern Sie im Dialogfeld Neues Projekt die Option Maven, wählen Sie Maven-Projekt aus, und klicken Sie dann auf Weiter.
Wählen Sie im Dialogfeld Neues Maven-Projekt die Option Einfaches Projekt erstellen (Auswahl von Archetyp überspringen) aus, und klicken Sie dann auf Weiter.
Geben Sie für die Gruppen-ID eine Gruppen-ID ein, die den Regeln für Paketnamen in Java entspricht. Diese Schritte verwenden den Paketnamen com.example.demo. Wenn Sie eine andere Gruppen-ID eingeben, ersetzen Sie diese im Verlauf dieser Schritte.
Geben Sie für die Artefakt-ID einen Namen für die JAR-Datei ohne die Versionsnummer ein. Diese Schritte verwenden den JAR-Namen von dbx-demo. Wenn Sie einen anderen Namen für die JAR-Datei eingeben, ersetzen Sie ihn in diesen Schritten.
Klicken Sie auf Fertig stellen.

Schritt 2: Hinzufügen einer Klasse zum Paket

Sie können Ihrem Paket beliebige Klassen hinzufügen. Dieses Paket enthält eine einzelne Klasse namens SampleApp.

Wählen Sie in der Projekt-Explorer-Ansicht (Fenster > Ansicht anzeigen > Projekt-Explorer) das project-name-Projektsymbol aus, und klicken Sie dann auf Datei > Neu > Klasse.
Geben Sie im Dialogfeld Neue Java-Klasse für Paket entsprechend com.example.demo ein.
Geben Sie unter NameSampleApp ein.
Wählen Sie für Modifizierer die Option öffentlich aus.
Lassen Sie die Superklasse leer.
Für Welche Methodenstubs möchten Sie erstellen?, wählen Sie public static void Main(String[] args) aus.
Klicken Sie auf Fertig stellen.

Schritt 3: Hinzufügen von Abhängigkeiten zum Projekt

Doppelklicken Sie in der Projekt-Explorer auf Projektname> pom.xml.

Fügen Sie die folgenden Abhängigkeiten als untergeordnetes Element des <project>-Elements hinzu, und speichern Sie dann die Datei:

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

Ersetzen Sie:

2.12 mit der Version von Scala Ihres Zielclusters.
3.2.1 mit der Version von Spark Ihres Zielclusters.

Weitere Informationen zur Databricks Runtime-Version für Ihre Zielcluster finden Sie im Abschnitt „Systemumgebung“ unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität.

Schritt 4: Kompilieren des Projekts

Fügen Sie in der pom.xml-Datei des Projekts die folgenden Maven-Compilereigenschaften als untergeordnetes Element des <project>-Elements hinzu, und speichern Sie die Datei anschließend:

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

Klicken Sie in der Projekt-Explorer-Ansicht mit der rechten Maustaste auf das Projektsymbol Projektname, und klicken Sie dann auf Ausführen als > Ausführungskonfigurationen.
Klicken Sie im Dialogfeld Konfigurationen ausführen auf Maven-Build.
Klicken Sie auf das Symbol Neue Startkonfiguration.
Geben Sie einen Namen für diese Startkonfiguration ein, z. B. clean compile (bereinigte Kompilierung).
Klicken Sie für Basisverzeichnis, auf Arbeitsbereich, wählen Sie das Verzeichnis Ihres Projekts aus, und klicken Sie dann auf OK.
Geben Sie für Goals den Wert clean compile ein.
Klicken Sie auf Ausführen. Die Ausgabe der Ausführung wird in der Konsolenansicht (Window > Ansicht anzeigen > Konsole) angezeigt.

Schritt 5: Hinzufügen von Code zum Projekt

Sie können Ihrem Projekt jeden beliebigen Code hinzufügen. Dieser Schritt geht davon aus, dass Sie nur Code zu einer Datei namens SampleApp.java für ein Paket mit dem Namen com.example.demo hinzufügen möchten.

Fügen Sie in der Datei src/main/java>com.example.demo>SampleApp.java des Projekts den Code hinzu, der von dbx auf Ihren Zielclustern als Batch ausgeführt werden soll. (Wenn Sie keinen Code zur Hand haben, können Sie den Java-Code im Codebeispiel verwenden, das am Ende dieses Artikels aufgeführt ist.)

Schritt 6: Ausführen des Projekts

Klicken Sie in der Projekt-Explorer-Ansicht mit der rechten Maustaste auf das Projektsymbol Projektname, und klicken Sie dann auf Ausführen als > Ausführungskonfigurationen.
Erweitern Sie im Dialogfeld Ausführungskonfigurationen die Option Java-Anwendung, und klicken Sie dann auf App.
Klicken Sie auf Ausführen. Die Ausgabe der Ausführung wird in der Ansicht Konsole angezeigt.

Schritt 7: Erstellen des Projekts als JAR

Klicken Sie in der Projekt-Explorer-Ansicht mit der rechten Maustaste auf das Projektsymbol Projektname, und klicken Sie dann auf Ausführen als > Ausführungskonfigurationen.
Klicken Sie im Dialogfeld Konfigurationen ausführen auf Maven-Build.
Klicken Sie auf das Symbol Neue Startkonfiguration.
Geben Sie einen Namen für diese Startkonfiguration ein, z. B. clean package (bereinigtes Paket).
Klicken Sie für Basisverzeichnis, auf Arbeitsbereich, wählen Sie das Verzeichnis Ihres Projekts aus, und klicken Sie dann auf OK.
Geben Sie für Goals den Wert clean package ein.
Klicken Sie auf Ausführen. Die Ausgabe der Ausführung wird in der Ansicht Konsole angezeigt.

Die JAR wird im Ordner <project-name>>target erstellt. Der Name der JAR lautet <project-name>-0.0.1-SNAPSHOT.jar.

Hinweis

Wenn die JAR zunächst nicht im target-Ordner im Projekt-Explorer-Fenster angezeigt wird, können Sie versuchen, es anzuzeigen, indem Sie mit der rechten Maustaste auf das Projektsymbol Projektname klicken und dann auf Aktualisieren klicken.

Schritt 8: Anzeigen des Terminals in der IDE

Da Ihre dbx-Projektstruktur jetzt feststeht, können Sie Ihr dbx-Projekt erstellen. Legen Sie zunächst wie folgt fest, dass die Projekt-Explorer-Ansicht die ausgeblendeten Dateien (Dateien, die mit einem Punkt (./) beginnen) anzeigt, die von dbx generiert werden:

Klicken Sie in der Projekt-Explorer-Ansicht auf die Auslassungspunkte (Menü „Ansicht“) und dann auf Filter und Anpassung.
Deaktivieren Sie im Dialogfeld Filter und Anpassung auf der Registerkarte Voreingestellte Filter das Feld . resources*.
Klicken Sie auf OK.

Zeigen Sie dann das Eclipse-Terminal wie folgt an:

Klicken Sie auf der Menüleiste auf Fenster > Ansicht anzeigen > Terminal.
Wenn die Eingabeaufforderung des Terminals nicht angezeigt wird, klicken Sie in der Ansicht Terminal auf das Symbol Terminal öffnen.
Verwenden Sie den cd-Befehl, um in das Stammverzeichnis Ihres Projekts zu wechseln.
Fahren Sie mit dem Erstellen eines dbx-Projekts fort.

Keine IDE (nur Terminal)

Führen Sie die folgenden Anweisungen aus, um mit der Verwendung von Terminal und Python mit dbx zu beginnen.

Gehen Sie folgendermaßen vor, um ein Terminal zu verwenden, um Ihre dbx-Projektstruktur einzurichten:

Erstellen Sie über das Terminal einen leeren Ordner. Diese Anweisungen verwenden einen Ordner mit dem Namen dbx-demo (Sie können dem Stammordner Ihres dbx-Projekts jedoch jeden beliebigen Namen geben). Nachdem Sie den Ordner erstellt haben, wechseln Sie zu ihm.

Für Linux und macOS:
```
mkdir dbx-demo
cd dbx-demo
```
Windows:
```
md dbx-demo
cd dbx-demo
```
Erstellen Sie eine virtuelle Python-Umgebung für dieses Projekt, indem Sie den pipenv-Befehl mit der folgenden Option aus dem Stammverzeichnis des Ordners dbx-demo ausführen, wobei <version> die Zielversion von Python ist, die Sie bereits lokal installiert haben, z. B. 3.8.14.
```
pipenv --python <version>
```
Aktivieren Sie Ihre virtuelle Python-Umgebung durch Ausführen von pipenv shell.
```
pipenv shell
```
Fahren Sie mit dem Erstellen eines dbx-Projekts fort.

Erstellen eines dbx-Projekts

Mit Ihrer dbx-Projektstruktur aus einem der vorherigen Abschnitte sind Sie jetzt bereit, einen der folgenden Projekttypen zu erstellen:

Erstellen eines minimalen dbx-Projekts für Python
Erstellen eines minimalen dbx-Projekts für Scala oder Java
Erstellen eines vorlagenbasierten dbx-Projekts für Python mit CI/CD-Unterstützung

Erstellen eines minimalen dbx-Projekts für Python

Das folgende minimale dbx-Projekt ist der einfachste und schnellste Ansatz für die ersten Schritte mit Python und dbx. Es veranschaulicht die Batchausführung einer einzelnen Python-Codedatei auf einem bestehenden universellen Azure Databricks-Cluster in Ihrem Azure Databricks-Arbeitsbereich.

Hinweis

Um ein dbx-Vorlagenprojekt für Python zu erstellen, das die Batchausführung von Code auf universellen Clustern und Auftragsclustern, Remotebereitstellungen von Codeartefakten und die Einrichtung einer CI/CD-Plattform veranschaulicht, fahren Sie mit Erstellen eines dbx-Vorlagenprojekts für Python mit CI/CD-Unterstützung fort.

Damit Sie diesen Vorgang durchführen können, muss in Ihrem Arbeitsbereich ein universeller Cluster vorhanden sein. (Weitere Informationen finden Sie unter Anzeigen von Clustern oder Computekonfigurationsreferenz.) Idealerweise (aber nicht zwingend) sollte die Version von Python in Ihrer virtuellen Python-Umgebung mit der Version übereinstimmen, die auf diesem Cluster installiert ist. Um die Version von Python auf dem Cluster zu identifizieren, verwenden Sie das Webterminal des Clusters, um den Befehl python --version auszuführen.

python --version

Führen Sie in Ihrem Terminal im Stammverzeichnis Ihres dbx-Projekts den Befehl dbx configure mit der folgenden Option aus. Mit diesem Befehl erstellen Sie einen ausgeblendeten .dbx-Ordner im Stammordner Ihres dbx-Projekts. Dieser .dbx-Ordner enthält lock.json- und project.json-Dateien.
```
dbx configure --profile DEFAULT --environment default
```
Hinweis

Die Datei project.json definiert eine Umgebung namens defaultzusammen mit einem Verweis auf das DEFAULT-Profil in der .databrickscfg-Datei. Wenn dbx ein anderes Profil verwenden soll, ersetzen Sie --profile DEFAULT im Befehl dbx configure durch --profile gefolgt vom Namen Ihres Zielprofils.

Wenn z. B. ein Profil mit dem Namen DEV in der .databrickscfg-Datei vorhanden ist und Sie dbx anstelle des DEFAULT-Profils verwenden möchten, sieht Ihre project.json-Datei möglicherweise stattdessen wie folgt aus. In diesem Fall würden Sie im Befehl dbx configure auch --environment default durch --environment dev ersetzen:
```
{
  "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>"
      }
    }
  }
}
```
Wenn dbx die Umgebungsvariablen DATABRICKS_HOST und DATABRICKS_TOKEN anstelle eines Profils in der .databrickscfg-Datei verwenden soll, dann lassen Sie die Option --profile ganz aus dem Befehl dbx configure weg.
Erstellen Sie einen Ordner mit dem Namen conf im Stammordner Ihres dbx-Projekts.

Für Linux und macOS:
```
mkdir conf
```
Windows:
```
md conf
```
Fügen Sie eine Datei namens deployment.yaml zum Verzeichnis conf mit dem folgenden Dateiinhalt hinzu:
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_python_task:
          python_file: "file://dbx-demo-job.py"
```
Hinweis

Die deployment.yaml-Datei enthält das kleingeschriebene Wort default, das ein Verweis auf das großgeschriebene DEFAULT-Profil in der .databrickscfg-Datei ist. Wenn dbx ein anderes Profil verwenden soll, ersetzen Sie default durch den Namen Ihres Zielprofils.

Wenn z. B. ein Profil mit dem Namen DEV in der .databrickscfg-Datei vorhanden ist und Sie dbx anstelle des DEFAULT-Profils verwenden möchten, sieht Ihre deployment.yaml-Datei möglicherweise stattdessen wie folgt aus:
```
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"
```
Wenn dbx die Umgebungsvariablen DATABRICKS_HOST und DATABRICKS_TOKEN anstelle eines Profils in der .databrickscfg-Datei verwenden soll, dann lassen Sie default in deployment.yaml unverändert. dbx verwendet diesen Verweis standardmäßig.
Tipp

Um Schlüssel-Wert-Paare für die Spark-Konfiguration zu einem Auftrag hinzuzufügen, können Sie beispielsweise das Feld spark_conf verwenden:
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: "-verbose:gc -XX:+PrintGCDetails"
        # ...
```
Um Berechtigungen zu einem Auftrag hinzuzufügen, können Sie beispielsweise das Feld access_control_list verwenden:
```
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"
        # ...
```
Beachten Sie, dass das Feld access_control_list vollständig sein muss. Der Besitzer des Auftrags sowie andere Benutzer- und Gruppenberechtigungen sollten also der Liste hinzugefügt werden.
Fügen Sie den Code, der auf dem Cluster ausgeführt werden soll, in eine Datei mit dem Namen dbx-demo-job.py hinzu, und fügen Sie die Datei zum Stammordner Ihres dbx-Projekts hinzu. (Wenn Sie keinen Code zur Hand haben, können Sie den Python-Code im Codebeispiel verwenden, das am Ende dieses Artikels aufgeführt ist.)

Hinweis

Sie müssen diese Datei nicht mit dbx-demo-job.py benennen. Wenn Sie einen anderen Dateinamen wählen, stellen Sie sicher, dass Sie das python_file-Feld in der conf/deployment.yaml-Datei entsprechend aktualisieren.
Führen Sie den Befehl dbx execute mit den folgenden Optionen aus. Ersetzen Sie in diesem Befehl <existing-cluster-id> durch die ID des Zielclusters in Ihrem Arbeitsbereich. (Informationen zum Abrufen der ID finden Sie unter Cluster-URL und -ID.)
```
dbx execute --cluster-id=<existing-cluster-id> dbx-demo-job --no-package
```
Um die Ergebnisse der Ausführung lokal anzuzeigen, betrachten Sie die Ausgabe Ihres Terminals. Um die Ergebnisse der Ausführung in Ihrem Cluster anzuzeigen, wechseln Sie zum Bereich Standardausgabe auf der Registerkarte Treiberprotokolle für Ihren Cluster. (Weitere Informationen finden Sie unter Berechnen von Treiber- und Arbeitsprotokollen.)
Fahren Sie mit Nächste Schritte fort.

Erstellen eines minimalen dbx-Projekts für Scala oder Java

Das folgende minimale dbx-Projekt ist der einfachste und schnellste Ansatz für die ersten Schritte mit dbx und Scala oder Java. Es demonstriert die Bereitstellung einer einzelnen Scala- oder Java-JAR in Ihrem Azure Databricks-Arbeitsbereich und das anschließende Ausführen dieser bereitgestellten JAR in einem Azure Databricks-Auftragscluster in Ihrem Azure Databricks-Arbeitsbereich.

Hinweis

Azure Databricks schränkt ein, wie Sie Scala- und Java-Code auf Clustern ausführen können:

Sie können eine einzelne Scala- oder Java-Datei nicht als Auftrag in einem Cluster ausführen, wie Sie es mit einer einzelnen Python-Datei können. Damit Sie Scala- oder Java-Code ausführen können, müssen Sie ihn zunächst in einer JAR-Datei erstellen.
Sie können eine JAR als Auftrag auf einem bestehenden universellen Cluster ausführen. Sie können jedoch keine Aktualisierungen dieser JAR-Datei auf demselben universellen Cluster neu installieren. In diesem Fall müssen Sie stattdessen einen Auftragscluster verwenden. In diesem Abschnitt wird der Ansatz des Auftragsclusters verwendet.
Sie müssen die JAR-Datei zunächst in Ihrem Azure Databricks-Arbeitsbereich bereitstellen, bevor Sie die bereitgestellte JAR-Datei in einem beliebigen universellen Cluster oder Auftragscluster in diesem Arbeitsbereich ausführen können.

Führen Sie in Ihrem Terminal im Stammverzeichnis Ihres Projekts den Befehl dbx configure mit der folgenden Option aus. Mit diesem Befehl erstellen Sie einen ausgeblendeten .dbx-Ordner im Stammordner Ihres Projekts. Dieser .dbx-Ordner enthält lock.json- und project.json-Dateien.
```
dbx configure --profile DEFAULT --environment default
```
Hinweis

Die Datei project.json definiert eine Umgebung namens defaultzusammen mit einem Verweis auf das DEFAULT-Profil in der .databrickscfg-Datei. Wenn dbx ein anderes Profil verwenden soll, ersetzen Sie --profile DEFAULT im Befehl dbx configure durch --profile gefolgt vom Namen Ihres Zielprofils.

Wenn z. B. ein Profil mit dem Namen DEV in der .databrickscfg-Datei vorhanden ist und Sie dbx anstelle des DEFAULT-Profils verwenden möchten, sieht Ihre project.json-Datei möglicherweise stattdessen wie folgt aus. In diesem Fall würden Sie im Befehl dbx configure auch --environment default durch --environment dev ersetzen:
```
{
  "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>"
      }
    }
  }
}
```
Wenn dbx die Umgebungsvariablen DATABRICKS_HOST und DATABRICKS_TOKEN anstelle eines Profils in der .databrickscfg-Datei verwenden soll, dann lassen Sie die Option --profile ganz aus dem Befehl dbx configure weg.
Erstellen Sie einen Ordner mit dem Namen conf im Stammordner Ihres Projekts.

Für Linux und macOS:
```
mkdir conf
```
Windows:
```
md conf
```
Fügen Sie eine Datei namens deployment.yaml zum Verzeichnis conf mit dem folgenden minimalen Dateiinhalt hinzu:
```
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"
```
Ersetzen Sie:
- Der Wert von spark_version mit der entsprechenden Laufzeitversion für Ihren Zielauftragscluster.
- Der Wert von node_type_id mit dem entsprechenden Worker- und Treiberknotentyp für Ihren Zielauftragscluster.
- Der Wert von instance_pool_id mit der ID eines bestehenden Instanzenpools in Ihrem Arbeitsbereich, damit Aufträge schneller ausgeführt werden können. Wenn Sie keinen Instanzenpool zur Verfügung haben oder keinen Instanzenpool verwenden möchten, entfernen Sie diese Zeile vollständig.
- Der Wert von jar mit dem Pfad im Projekt zur JAR-Datei. Für IntelliJ IDEA mit Scala könnte es file://out/artifacts/dbx_demo_jar/dbx-demo.jar sein. Für die Eclipse-IDE mit Java könnte es file://target/dbx-demo-0.0.1-SNAPSHOT.jar sein.
- Der Wert von main_class_name mit dem Namen der Hauptklasse in der JAR-Datei, z. B. com.example.demo.SampleApp.
Hinweis

Die deployment.yaml-Datei enthält das Wort default, das ein Verweis auf die default-Umgebung in der .dbx/project.json-Datei ist, die wiederum ein Verweis auf das DEFAULT-Profil in der .databrickscfg-Datei ist. Wenn dbx ein anderes Profil verwenden soll, ersetzen Sie default in dieser deployment.yaml-Datei durch den entsprechenden Verweis in der .dbx/project.json-Datei, die wiederum auf das entsprechende Profil in der .databrickscfg-Datei verweist.

Wenn z. B. ein Profil mit dem Namen DEV in der .databrickscfg-Datei vorhanden ist und Sie dbx anstelle des DEFAULT-Profils verwenden möchten, sieht Ihre deployment.yaml-Datei möglicherweise stattdessen wie folgt aus:
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        # ...
  dev:
    workflows:
      - name: "<some-other-job-name>"
        # ...
```
Wenn dbx die Umgebungsvariablen DATABRICKS_HOST und DATABRICKS_TOKEN anstelle eines Profils in der .databrickscfg-Datei verwenden soll, dann lassen Sie default in deployment.yaml unverändert. dbx verwendet standardmäßig die default-Umgebungseinstellungen (bis auf den profile-Wert) in der .dbx/project.json-Datei.
Tipp

Um Schlüssel-Wert-Paare für die Spark-Konfiguration zu einem Auftrag hinzuzufügen, können Sie beispielsweise das Feld spark_conf verwenden:
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: "-verbose:gc -XX:+PrintGCDetails"
        # ...
```
Um Berechtigungen zu einem Auftrag hinzuzufügen, können Sie beispielsweise das Feld access_control_list verwenden:
```
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"
        # ...
```
Beachten Sie, dass das Feld access_control_list vollständig sein muss. Der Besitzer des Auftrags sowie andere Benutzer- und Gruppenberechtigungen sollten also der Liste hinzugefügt werden.
Führen Sie den Befehl dbx deploy aus. dbx stellt die JAR-Datei an dem Speicherort bereit, der im artifact_location-Pfad der .dbx/project.json-Datei für die entsprechende Umgebung angegeben ist. dbx stellt auch die Projektdateien als Teil eines MLflow-Experiments bereit, und zwar an dem Speicherort, der im workspace_directory-Pfad der .dbx/project.json-Datei für die entsprechende Umgebung angegeben ist.
```
dbx deploy --no-package
```
Führen Sie den Befehl dbx launch mit den folgenden Optionen aus. Dieser Befehl führt den Auftrag mit dem übereinstimmenden Namen in conf/deployment.yaml aus. Um die bereitgestellte JAR-Datei zu finden, die als Teil des Auftrags ausgeführt werden soll, verweist dbx auf den Speicherort im artifact_location-Pfad der .dbx/project.json-Datei für die entsprechende Umgebung. Um festzustellen, welche JAR-Datei ausgeführt werden soll, verweist dbx auf das MLflow-Experiment an dem Speicherort, der im workspace_directory-Pfad der .dbx/project.json-Datei für die entsprechende Umgebung angegeben ist.
```
dbx launch dbx-demo-job
```
Informationen zum Anzeigen der Ergebnisse der Auftragsausführung in Ihrem Auftragscluster finden Sie unter Anzeigen von Aufträgen.
Informationen zum Anzeigen des Experiments, auf das der Auftrag verweist, finden Sie unter Organisieren von Trainingsausführungen mit MLflow-Experimenten.
Fahren Sie mit Nächste Schritte fort.

Erstellen eines vorlagenbasierten dbx-Projekts für Python mit CI/CD-Support

Die folgende dbx-Vorlagenprojekt für Python demonstriert die Unterstützung für das Ausführen von Python-Code auf universellen Clustern und Auftragsclustern von Azure Databricks in Ihren Azure Databricks-Arbeitsbereichen, die Remotebereitstellung von Codeartefakten und die Einrichtung einer CI/CD-Plattform. (Wenn Sie ein minimales dbx-Projekt für Python erstellen möchten, das lediglich die Batchausführung einer einzelnen Python-Codedatei auf einem vorhandenen universellen Cluster veranschaulicht, wechseln Sie zurück zu Erstellen eines minimalen dbx-Projekts für Python).

Führen Sie in Ihrem Terminal im Stammverzeichnis Ihres dbx-Projekts den Befehl dbx init aus.
```
dbx init
```
Geben Sie für Projektname einen Namen für Ihr Projekt ein oder drücken Sie die EINGABETASTE, um den Standardprojektnamen zu akzeptieren.
Geben Sie für Version eine Startversionsnummer für Ihr Projekt ein, oder drücken Sie die EINGABETASTE, um die Standardprojektversion zu akzeptieren.
Wählen Sie für Cloud die Nummer aus, die der Azure Databricks-Cloudversion entspricht, die Ihr Projekt verwenden soll, oder drücken Sie die EINGABETASTE, um die Standardeinstellung zu akzeptieren.
Wählen Sie fürcicd_tool die Nummer des unterstützten CI/CD-Tools aus, das Ihr Projekt verwenden soll, oder drücken Sie die EINGABETASTE, um die Standardeinstellung zu akzeptieren.
Geben Sie fürproject_slug ein Präfix ein, das Sie für die Ressourcen in Ihrem Projekt verwenden möchten, oder drücken Sie die EINGABETASTE, um die Standardeinstellung zu akzeptieren.
Geben Sie für workspace_directoryden lokalen Pfad zum Workspace-Verzeichnis für Ihr Projekt ein oder drücken Sie die Eingabetaste, um die Standardeinstellung zu akzeptieren.
Geben Sie für artifact_location den Pfad in Ihrem Azure Databricks-Arbeitsbereich ein, in den die Artefakte Ihres Projekts geschrieben werden sollen, oder drücken Sie die EINGABETASTE, um die Standardeinstellung zu akzeptieren.
Geben Sie für profile den Namen des CLI-Authentifizierungsprofils ein, das Ihr Projekt verwenden soll, oder drücken Sie die EINGABETASTE, um die Standardeinstellung zu akzeptieren.

Tipp

Sie können die vorangehenden Schritte überspringen, indem Sie z. B. dbx init mit hartcodierten Vorlagenparametern ausführen:

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 berechnet die Parameter project_slug, workspace_directory und artifact_location automatisch. Diese drei Parameter sind optional und nur für fortgeschrittene Anwendungsfälle nützlich.

Sehen Sie sich den init-Befehl in der CLI-Referenz in der dbx-Dokumentation an.

Weitere Informationen finden Sie auch unter Nächste Schritte.

Codebeispiel

Wenn Sie keinen Code für die Batchausführung mit dbx zur Hand haben, können Sie experimentieren, indem dbx den folgenden Code für die Batchausführung verwendet. Dieser Code erstellt eine kleine Tabelle in Ihrem Arbeitsbereich, fragt die Tabelle ab und löscht sie dann.

Tipp

Wenn Sie die Tabelle in Ihrem Arbeitsbereich belassen möchten, anstatt sie zu löschen, kommentieren Sie die letzte Zeile des Codes in diesem Beispiel aus, bevor Sie es mit dbx für die Batchausführung verwenden.

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

Nächste Schritte

Erweitern Sie Ihre Datei conf/deployment.yaml, um verschiedene Arten von universellen und Auftragsclusterdefinitionen zu unterstützen.
Deklarieren Sie Multitaskaufträge in Ihrer conf/deployment.yaml-Datei.
Verweisen Sie auf benannte Eigenschaften in Ihrer conf/deployment.yaml-Datei.
Führen Sie Code als Batch als neue Aufträge auf Clustern mit dem Befehl dbx execute aus.

Zusätzliche Ressourcen

Stellen Sie Codeartefakte als Batch im Azure Databricks-Arbeitsbereich mit dem Befehl dbx deploy bereit.
Führen Sie vorhandene Aufträge als Batch auf Clustern mit dem Befehl dbx launch aus.
Verwenden Sie dbx, um die ressourcenbasierte Workflowbereitstellung durchzuführen und zu starten.
Planen sie Workflowbereitstellungen.
Erfahren Sie mehr über dbx und CI/CD.
dbx-Dokumentation
databrickslabs/dbx-Repository auf GitHub
dbx-Einschränkungen