dbx by Databricks Labs (英語)

important

このドキュメントは廃止されており、更新されない可能性があります。

Databricks では、Databricks Labs が dbx する代わりに、Databricks アセットバンドルを使用することをお勧めします。「Databricks アセットバンドルとは」および「dbx からバンドルへの移行」を参照してください。

注記

この記事では、現状のまま提供されており、顧客技術サポートチャネルを通じたDatabricksのサポートが提供されていない、Databricks Labsの dbx について説明します。ご質問や機能リクエストは、GitHub上のdatabrickslabs/dbxリポジトリの「問題」ページからお問い合わせください。

dbx byDatabricks Labs は、従来のDatabricks コマンドラインインターフェイスDatabricksCLI () を拡張し、プラットフォーム上での迅速な開発ライフサイクルと継続的インテグレーションと継続的デリバリー/デプロイ () の機能を提供するように設計されたオープンソースCI/CD Databricksツールです。

dbx 複数の環境でのジョブの立ち上げとデプロイのプロセスを簡素化します。また、プロジェクトをパッケージ化し、バージョン管理された方法で Databricks 環境に配信するのにも役立ちます。 CLIファーストの方法で設計されており、パイプラインCI/CD内とローカルツールの一部 (Visual Studio Code や Visual Studio Code や Visual Studio IDEsPyCharmなど) の一部としてアクティブに使用できるように構築されています。

dbx を使用した一般的な開発ワークフローは以下のとおりです。

Databricks がサポートする Git プロバイダーを使用してリモートリポジトリを作成します (使用可能なリモートリポジトリがまだない場合は)。
リモートリポジトリを Databricks ワークスペースに複製します。
Databricks ノートブックを作成するか、Databricks ワークスペースの複製されたリポジトリに移動します。このノートブックを使用して、 Databricks クラスターで実行するコードのプロトタイプ作成を開始します。
個別のヘルパークラスと関数、構成ファイル、テストを追加してノートブックコードを強化およびモジュール化するには、dbx、任意のIDE、およびGitがインストールされたローカル開発マシンの使用に切り替えます。
リモートリポジトリのクローンをローカル開発コンピューターに作成します。
コードをノートブックから1つ以上のローカルコードファイルに移動します。
ローカルでコーディングするときは、ローカルリポジトリからリモートリポジトリに作業をプッシュします。また、リモートリポジトリを Databricks ワークスペースと同期します。

ヒント

または、 dbx sync を使用して、ローカルファイルの変更をワークスペース内の対応するファイルとリアルタイムで自動的に同期することもできます。

迅速なプロトタイピングを行うためには、Databricksワークスペースでのノートブックの使用と、検証済みのコードのノートブックからローカルマシンへの移動を行い続けてください。コードのモジュール化、コード補完、lint、単体テスト、Databricksへのライブ接続を必要としないコードとオブジェクトのステップスルーデバッグなどのタスクには、ローカルIDEを引き続き使用します。
必要に応じて、 dbx を使用して、ターゲットクラスターでローカルコードをバッチ実行します。 (これは、Sparkのbin ディレクトリで spark-submit スクリプトを実行して、Spark クラスターでアプリケーションを起動するのと似ています。
本番運用の準備ができたら、CI/CD GitHub Actions、、などのAzureDevOps GitLabプラットフォームを使用して、クラスターでのリモートリポジトリのコードの実行を自動化します。

必要条件

dbx を使用するには、コードがPython、Scala、Javaのいずれを使用しているかに関わらず、ローカルの開発マシンに以下をインストールしておく必要があります。

Python：バージョン3.8以降

コードで Pythonを使用している場合は、ターゲットクラスターにインストールされているバージョンと一致するバージョンの Python を使用する必要があります。既存のクラスターにインストールされている Python のバージョンを取得するには、クラスターの Webターミナルを使用して python --version コマンドを実行します。 Databricks Runtimeリリースノートバージョンの「システム環境」セクションと、ターゲットクラスターのDatabricks Runtimeバージョンの互換性も参照してください。
pip
コードでPythonを使用している場合に、Python仮想環境を作成して dbx プロジェクト内で正しいバージョンのPythonとパッケージの依存関係を使用していることを確認する方法です。この記事では、Pipenvについて説明します。
dbx バージョン 0.8.0 以降。このパッケージは、Python Package Index (PyPI) から pip install dbxを実行してインストールできます。

dbx がインストールされていることを確認するには、以下のコマンドを実行します。
Bash
```
dbx --version
```
バージョン番号が返された場合は、dbx がインストールされています。

バージョン番号が0.8.0未満の場合は、次のコマンドを実行して dbx をアップグレードし、バージョン番号を再度確認します。
Bash
```
pip install dbx --upgrade
dbx --version

# Or ...
python -m pip install dbx --upgrade
dbx --version
```
Databricks CLI バージョン 0.18 以下で、認証を使用して設定されています。従来の Databricks CLI (Databricks CLI バージョン 0.17) は、 dbx. この認証は、ローカル開発マシンの次の場所のいずれかまたは両方で設定できます。
- DATABRICKS_HOST および DATABRICKS_TOKEN の環境変数内（従来の Databricks CLI バージョン0.8.0以降）
- .databrickscfg ファイル内の Databricks 構成プロファイル。
dbx は、これら2つの各ロケーションで認証資格情報を検索します。dbx は、一致する資格情報で最初に見つかったもののみを使用します。

注記

dbx .netrc の使用はサポートされていません認証用のファイルで、従来の Databricks CLI バージョン 0.17.2 以降です。インストールされている従来の Databricks CLI のバージョンを確認するには、コマンド databricks --versionを実行します。

ローカルとリモートのコード変更をプッシュして同期するためのgit

次のいずれかのIDEの手順に進みます。

Visual Studio Code
PyCharm
IntelliJ IDEA
Eclipse

注記

Databricks は、dbx で前の IDEs の使用を検証しました。ただし、dbxは任意の IDE で動作する必要があります。 IDEなし(端末のみ)を使用することもできます。

dbx は、単一ファイルの Python コードファイルとコンパイル済みの Scala および Java JAR ファイルで動作するように最適化されています。 dbx は、単一ファイルの R コードファイルまたはコンパイル済みの R コードパッケージでは機能しません。これは、がdbx API2.0 および2.1API のジョブ連携し、これらの単一ファイルの R コードファイルまたはコンパイル済みの R コードパッケージをジョブとして実行できないためです。

Visual Studio Code

Visual Studio Code と Python with dbxの使用を開始するには、次の手順を実行します。

ローカル開発マシンには、一般的な要件に加えて、次のものがインストールされている必要があります。

Visual Studio Code
Visual Studio CodeのPython拡張機能：詳細については、Visual Studio Codeウェブサイトの拡張機能マーケットプレイスを参照してください。

詳細については、Visual Studio Codeドキュメントの「VS CodeでPythonを開始する」を参照してください。

以下のステップに従い、dbx プロジェクト構造の設定を開始してください。

ターミナルから、空白のフォルダを作成します。これらの手順では、 dbx-demoという名前のフォルダを使用します。dbxプロジェクトのルートフォルダには、任意の名前を付けることができます。別の名前を使用する場合は、これらの手順全体で名前を置き換えます。フォルダーを作成したら、そのフォルダーに切り替えて、そのフォルダーから Visual Studio Code を起動します。

LinuxまたはmacOSの場合：
Bash
```
mkdir dbx-demo
cd dbx-demo
code .
```

ヒント

code . を実行した後に command not found: code が表示された場合は、Microsoftウェブサイトの「コマンドラインからの起動」を参照してください。

Windowsの場合：

PowerShell
md dbx-demo
cd dbx-demo
code .

Visual Studio Codeで、このプロジェクト用のPython仮想環境を作成します。
1. メニューバーで、 [表示] > [ターミナル] をクリックします。
2. dbx-demo フォルダのルートから、次のオプションを指定して pipenv コマンドを実行します。ここで、 <version>は、ローカルに既にインストールされている Python のターゲットバージョン (理想的には、ターゲットクラスターのバージョンと一致する Python) 3.8.14.
  Bash
```
pipenv --python <version>
```
  次のステップで必要になるため、 pipenv コマンドの出力にある Virtualenv location の値をメモしておきます。
ターゲットのPythonインタープリターを選択し、Python仮想環境をアクティブ化します。
1. メニューバーで [表示] > [コマンドパレット] をクリックし、Python: Select と入力して [Python：インタープリターの選択] をクリックします。
2. 作成したばかりのPython仮想環境へのパス内でPythonインタープリターを選択します。（このパスは、 pipenv コマンドの出力に Virtualenv location 値としてリストされます。）
3. メニューバーで、 [ビュー] > [コマンドパレット] をクリックし、Terminal: Create と入力して [ターミナル：新しいターミナルの作成] をクリックします。
詳しくはVisual Studio Codeドキュメントの「VS CodeにおけるPython環境の使用」を参照してください。
「dbx プロジェクトの作成」に進みます。

PyCharm

PyCharm と Python を dbxで使用を開始するには、次の手順を実行します。

ローカル開発マシンには、一般的な要件に加えてPyCharm がインストールされている必要があります。

以下のステップに従い、dbx プロジェクト構造の設定を開始してください。

PyCharmのメニューバーで、 [ファイル] > [新しいプロジェクト] をクリックします。
[プロジェクトの作成] ダイアログで、新しいプロジェクトのロケーションを選択します。
Pythonインタープリター：新しいPipenv環境 を開きます。
まだ選択されていない場合は 新しい環境 を選択し、ドロップダウンリストから Pipenv を選択します。
[Base interpreter ] で、ローカルに既にインストールされているターゲットバージョンの Python の Python インタープリタが含まれている場所を選択します (また、ターゲットクラスターのバージョンと一致するバージョンが理想的ですPython)。
Pipenv実行可能ファイル の場合、まだ自動検出されていない場合は、ローカルにインストールされた pipenv が含まれるロケーションを選択します。
最小限の dbx プロジェクトを作成し、その最小限の dbx プロジェクトで main.py ファイルを使用したい場合は、 [main.py welcomeスクリプトを作成] ボックスを選択します。それ以外の場合は、このチェックボックスをオフにします。
作成をクリックします。
プロジェクト ツールウィンドウで、プロジェクトのルートフォルダーを右クリックし、[ > ターミナルで開く ] をクリックします。
「dbx プロジェクトの作成」に進みます。

IntelliJ IDEAの

IntelliJ IDEA と Scala を dbxで使用を開始するには、次の手順を実行します。これらの手順では、 dbx プロジェクトを開始するために使用できる最小限の sbt ベースの Scala プロジェクトを作成します。

ローカル開発マシンには、一般的な要件に加えて、次のものがインストールされている必要があります。

IntelliJ IDEA
IntelliJ IDEA用のScalaプラグイン：詳細については、IntelliJ IDEAドキュメントの「ScalaでのIntelliJ IDEAの活用」を参照してください。
Java Runtime環境（JRE）8：JRE 8のどのエディションでも動作するはずですが、現時点でDatabricksがOpenJDK 8 JREでの使用を検証済みなのは dbx とIntelliJ IDEAのみです。Databricksは、IntelliJ IDEAおよびJava 11での dbx の使用をまだ検証していません。詳細については、IntelliJ IDEAドキュメントの「Java開発キット（JDK）」を参照してください。

以下のステップに従い、dbx プロジェクト構造の設定を開始してください。

ステップ 1: sbt-based の Scala プロジェクトを作成する

IntelliJ IDEAで、ビューの種類に応じて、 [プロジェクト] > [新しいプロジェクト] または [ファイル] > [新規] > [プロジェクト] をクリックします。
[新しいプロジェクト] ダイアログで、 [Scala] 、 [sbt] 、 [次へ] の順にクリックします。
プロジェクト名とプロジェクトのロケーションを入力します。
JDK の場合は、OpenJDK 8 JREのインストールを選択します。
sbt の場合は、記載されている sbt の利用可能な最新バージョンを選択します。
Scala については、ターゲットクラスターのバージョンと一致する Scala のバージョンを選択するのが理想的ですScala。Databricks Runtimeリリースノートのバージョンの「システム環境」のセクションと、対象のクラスターのDatabricks Runtimeバージョンとの互換性を参照してください。
[Scala] の横にある [ソース] ボックスがまだ選択されていない場合は選択します。
パッケージのプレフィックスを [パッケージプレフィックス] に追加します。これらの手順では、パッケージのプレフィックスとして com.example.demo を使用します。別のパッケージプレフィックスを指定する場合は、これらの手順全体でパッケージプレフィックスを置き換えてください。
[完了] をクリックします。

ステップ 2: パッケージにオブジェクトを追加する

パッケージに必要なオブジェクトを追加することができます。このパッケージには、SampleApp という名前の単一のオブジェクトが含まれています。

[プロジェクト] ツールウィンドウ（ [ビュー] >[ツールウィンドウ] > [プロジェクト] ）で、 [プロジェクト名] > [src] > [メイン] > [Scala] フォルダを右クリックし、 [新規作成] > [Scalaクラス] をクリックします。
[ オブジェクト ] を選択し、オブジェクトの名前を入力して Enter キーを押します。たとえば、「 SampleApp」と入力します。ここで別のオブジェクト名を入力する場合は、これらの手順全体で名前を置き換えてください。

SampleApp.scala ファイルの内容を以下のコードに置き換えます。

Scala
package com.example.demo

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

ステップ 3: プロジェクトをビルドする

プロジェクトのビルド設定と依存関係で必要とされるものをプロジェクトに追加します。このステップは、前のステップで設定されたプロジェクトをビルドしており、次のライブラリのみに依存していることを前提としています。

プロジェクトの build.sbt ファイルの内容を次の内容で置き換えます。

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

上記のファイルで、以下の通り置き換えます。

2.12.14 を、このプロジェクト用に以前に選択したScalaのバージョンに置き換えます。
3.2.1 を、このプロジェクト用に以前に選択したSparkのバージョンに置き換えます。
dbx-demo を、プロジェクトの名前に置き換えます。
com.example.demo を、パッケージプレフィックスの名前に置き換えます。

メニューバーで、 [ビュー] > [ツールウィンドウ] > [sbt] をクリックします。
sbt ツールウィンドウで、プロジェクトの名前を右クリックし、 Reload sbt Project をクリックする。sbt のバージョンに応じて、デフォルトで Coursier や Ivy などのインターネットアーティファクトストアからプロジェクトの依存関係のダウンロードが完了するまで待ちますsbt。ステータスバーでダウンロードの進行状況を確認できます。このプロジェクトにさらに依存関係を追加または変更する場合は、追加または変更する依存関係のセットごとに、このプロジェクトの再読み込み手順を繰り返す必要があります。
メニューバーで、 [IntelliJ IDEA] > [環境設定] をクリックします。
[環境設定] ダイアログで、 [ビルド、実行、デプロイメント] > [ビルドツール] > [sbt] をクリックします。
[JVM] で、 [JRE] に対しOpenJDK 8 JREのインストールを選択します。
[sbtプロジェクト] でプロジェクトの名前を選択します。
[sbtシェル] で ビルドを選択します。
「 OK 」をクリックします。
メニューバーで、[ビルド] > [プロジェクトのビルド ] をクリックします。ビルドの結果は sbt シェル ツールウィンドウ ( View > Tool Windows > sbt シェル ) に表示される。

ステップ 4: プロジェクトにコードを追加する

必要なコードをプロジェクトに追加します。このステップでは、example パッケージ内の SampleApp.scala ファイルにコードのみを追加することを前提としています。

プロジェクトの src > main > scala > SampleApp.scala ファイルに、ターゲットクラスターでバッチ実行 dbx コードを追加します。基本的なテストには、「コード例」セクションの Scala コードの例を使用します。

ステップ 5: プロジェクトを実行する

メニューバーで、 [実行] > [構成の編集] をクリックします。
[構成を実行/デバッグする] ダイアログで、 + （ [新しい構成を追加する] ）アイコン、 [新規追加] 、または [新しい実行構成を追加する] をクリックします。
ドロップダウンで、 [sbt タスク] をクリックします。
[名前] に、構成の名前を入力します。（例： [プログラムの実行]）
[タスク] に、~run と入力します。
[sbtシェルを使用する] を選択します。
「 OK 」をクリックします。
メニューバーで、[実行] > [プログラムの実行] をクリックします。実行の結果が sbt シェル ツールウィンドウに表示される。

ステップ 6: プロジェクトを JAR としてビルドする

プロジェクトに、好きなJARビルド設定を追加することができます。このステップは、前のステップで設定されたプロジェクトに基づいたJARのみをビルドすることを前提としています。

メニューバーで、 [ファイル] > [プロジェクトの構造] をクリックします。
[ プロジェクトの構造 ]ダイアログで、 [プロジェクトの設定] > [アーティファクト] 」をクリックします。
+ （ [追加] ）アイコンをクリックします。
ドロップダウンリストで、 [JAR] > [依存関係のあるモジュールから] を選択します。
[モジュールからJARを作成] ダイアログの [モジュール] で、プロジェクトの名前を選択します。
[メインクラス] の場合は、フォルダアイコンをクリックします。
[メインクラスの選択] ダイアログの [名前で検索] タブで、 [SampleApp] を選択し、 [OK] をクリックします。
[ライブラリからのJAR ファイル] の場合は、 [出力ディレクトリへのコピーを選択し、マニフェスト経由でリンクする] を選びます。
[OK] をクリックして [モジュールからJARを作成] ダイアログを閉じます。
[OK] をクリックして [プロジェクトの構造] ダイアログを閉じます。
メニューバーで、 [ビルド] > [アーティファクトのビルド] をクリックします。
表示されるコンテキストメニューで、 project-name を選択します >ビルド。 sbt が JAR をビルドする間、お待ちください。ビルドの結果は、 ビルド出力 ツールウィンドウ ( [表示] > [ツール] Windows > [ビルド]) に表示されます。

JAR は、プロジェクトの out > artifacts > <project-name>_jar フォルダにビルドされます。JARの名前は <project-name>.jarです。

ステップ7:IDEでターミナルを表示する

dbx プロジェクト構造が仕上げり、 dbx プロジェクトを作成する準備が整いました。

メニューIntelliJ IDEA バーの[表示] > [ツール]Windows > [ターミナル] をクリックしてターミナルを表示し、「dbx プロジェクトの作成」に進みます。

Eclipse

Eclipse と Java を Java で使用を開始するには、次の手順を完了dbx。これらの手順では、 dbx プロジェクトの開始に使用できる最小限の Maven ベースの Java プロジェクトを作成します。

ローカル開発マシンには、一般的な要件に加えて、次のものがインストールされている必要があります。

Eclipseのバージョンです。これらの手順では、Eclipse IDE for Java Developersエディションの Eclipse IDEを使用します。
Java Runtime Environment (JRE) または Java Development Kit (JDK) 11 のエディション (ローカルマシンのオペレーティングシステムによって異なります)。JRE または JDK 11 のどのエディションでも動作するはずですが、Databricks はこれまで、AdoptOpenJDK 11 を含む Eclipse 2022-03 R で Java 開発者向けの Java 開発者向けの dbx と Eclipse IDE の使用を検証しただけです。

以下のステップに従い、dbx プロジェクト構造の設定を開始してください。

ステップ 1: Maven ベースの Java プロジェクトを作成する

Eclipseで、 [ファイル] > [新規] > [プロジェクト] をクリックします。
[新規プロジェクト] ダイアログで、 [Maven] を展開し、 [Mavenプロジェクト] を選択して [次へ] をクリックします。
[新規Mavenプロジェクト] ダイアログで [簡易プロジェクトを作成する（アーキタイプの選択をスキップ）] を選択し、 [次へ] をクリックします。
「グループ ID 」には、Javaのパッケージ名ルールに準拠したグループ ID を入力します。これらの手順では、パッケージ名に com.example.demoを使用します。別のグループ ID を入力する場合は、これらの手順全体でその ID を置き換えます。
[アーティファクトId] には、JARファイルの名前からバージョン番号を除いたものを入力します。これらの手順では、dbx-demo というJAR名を使用します。JARファイルに別の名前を入力した場合は、以下の手順全体でその名前に置き換えてください。
[完了] をクリックします。

ステップ 2: パッケージにクラスを追加する

パッケージには好きなクラスを追加できます。このパッケージには、SampleAppという名前の単一のクラスが含まれます。

「プロジェクト・エクスプローラー 」ビュー ( 「ウィンドウ」>「ビューの表示」>プロジェクト・エクスプローラー ) で、 プロジェクト名の プロジェクト・アイコンを選択し、「 ファイル」>「新規>クラス 」をクリックします。
[新規Javaクラス] ダイアログの [パッケージ] に、com.example.demo と入力します。
[名前] に SampleApp と入力します。
[修飾子] で、 [public] を選択します。
[スーパークラス] 空白のままにします。
[どのメソッドのStubを作成しますか] では、 public static void Main（String[] args） を選択してください。
[完了] をクリックします。

ステップ 3: プロジェクトに依存関係を追加する

[プロジェクトエクスプローラー] ビューで、 project-name > pom.xml をダブルクリックします。

次の依存関係を <project> 要素の子要素として追加し、ファイルを保存します。

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

以下のように置き換えてください。

2.12 ターゲットクラスターの Scalaバージョンで。
3.2.1 ターゲットクラスターの Sparkバージョンで。

Databricks Runtimeリリースノートのバージョンの「システム環境」のセクションと、対象のクラスターのDatabricks Runtimeバージョンとの互換性を参照してください。

ステップ 4: プロジェクトをコンパイルする

プロジェクトの pom.xml ファイルに、次の Maven コンパイラプロパティを <project> 要素の子要素として追加し、ファイルを保存します。

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

「Project Explorer 」ビューで、 プロジェクト名の プロジェクト・アイコンを右クリックし、「 Run」> 「Run 」をクリックします。
[実行構成] ダイアログで、 [Mavenビルド] をクリックします。
[新しい起動構成] のアイコンをクリックします。
この起動構成の名前を入力します。（例: clean compile ）
[ ベースディレクトリ ] で [ ワークスペース ] をクリックし、プロジェクトのディレクトリを選択して [OK] をクリックします。
[目標] に、clean compileと入力します。
「実行 」をクリックします。実行の出力は、 コンソール ビュー ( コンソールのウィンドウ > ビューの表示> ) に表示されます。

ステップ 5: プロジェクトにコードを追加する

プロジェクトには好きなコードを追加できます。このステップでは、com.example.demo という名前のパッケージの SampleApp.java という名前のファイルにコードのみを追加することを前提としています。

プロジェクトの src/main/java > com.example.demo > SampleApp.java ファイルに、ターゲットクラスターでバッチ実行 dbx コードを追加します。 (手元にコードがない場合は、この記事の最後にあるコード例の Java コードを使用できます。

ステップ 6: プロジェクトを実行する

「Project Explorer 」ビューで、 プロジェクト名の プロジェクト・アイコンを右クリックし、「 Run」> 「Run 」をクリックします。
[実行構成] ダイアログで、 [Java アプリケーション] を開き、 [アプリ] をクリックします。
「実行 」をクリックします。実行の出力が [Console ] ビューに表示されます。

ステップ 7: プロジェクトを JAR としてビルドする

「Project Explorer 」ビューで、 プロジェクト名の プロジェクト・アイコンを右クリックし、「 Run」> 「Run 」をクリックします。
[実行構成] ダイアログで、 [Mavenビルド] をクリックします。
[新しい起動構成] のアイコンをクリックします。
この起動構成の名前を入力します。（例: clean package ）
[ ベースディレクトリ ] で [ ワークスペース ] をクリックし、プロジェクトのディレクトリを選択して [OK] をクリックします。
[目標] に、clean packageと入力します。
「実行 」をクリックします。実行の出力が [Console ] ビューに表示されます。

JAR は <project-name> > target フォルダに構築されます。JARの名前は <project-name>-0.0.1-SNAPSHOT.jarです。

注記

最初にJARが [プロジェクトエクスプローラー] ウィンドウの target フォルダに表示されない場合は、 project-name のプロジェクトアイコンを右クリックし、 [更新] をクリックしてJARが表示されるか試してみてください。

ステップ8:IDEでターミナルを表示する

dbx プロジェクト構造が仕上がり、 dbx プロジェクトを作成する準備が整いました。まず始めに、 [プロジェクトエクスプローラー] のビューを以下のように設定し、 dbx が生成する非表示のファイル（ドット（./）で始まるファイル）を表示します。

[プロジェクトエクスプローラー] のビューで、省略記号（ [メニューを表示] ）フィルターアイコンをクリックし、 [フィルターとカスタマイズ] をクリックします。
[フィルターとカスタマイズ] ダイアログの [プリセットフィルター] タブで、 .* resources ボックスをオフにします。
「 OK 」をクリックします。

次に、Eclipseターミナルを以下のようにして表示します。

メニューバーで、 [ウィンドウ] > [ビューの表示] > [ターミナル] の順にクリックします。
ターミナルのコマンドプロンプトが表示されない場合は、[ ターミナル ]ビューで[ ターミナルを開く ]アイコンをクリックします。
cdコマンドを使用して、プロジェクトのルートディレクトリに切り替えます。
「dbx プロジェクトの作成」に進みます。

IDEなし(端末のみ)

dbx でターミナルとPythonの使用を開始するには、以下の手順を実行します。

次の手順に従い、ターミナルを使用して dbx プロジェクト構造のセットアップを開始します。

ターミナルから、空白のフォルダを作成します。これらの手順では、 dbx-demo という名前のフォルダーを使用します (ただし、 dbx プロジェクトのルートフォルダーには任意の名前を付けることができます)。フォルダを作成したら、そのフォルダに切り替えます。

LinuxまたはmacOSの場合：
Bash
```
mkdir dbx-demo
cd dbx-demo
```
Windowsの場合：
PowerShell
```
md dbx-demo
cd dbx-demo
```
次のオプションを指定して、dbx-demo フォルダのルートから pipenv コマンドを実行し、このプロジェクトのPython仮想環境を作成します。ここでは、<version> はローカルに既にインストールされているPythonのターゲットバージョンです。（例：3.8.14）
Bash
```
pipenv --python <version>
```
pipenv shell を実行して、Python仮想環境をアクティブ化します。
Bash
```
pipenv shell
```
「dbx プロジェクトの作成」に進みます。

dbx プロジェクトの作成

前のセクションのいずれかで dbx プロジェクト構造を適切に配置したら、以下のプロジェクトタイプのいずれかを作成する準備が整いました。

Python 用の最小限の dbx プロジェクトを作成する
Scala または Java 用の最小限の dbx プロジェクトを作成する
CI/CD サポートを使用した Python 用の dbx テンプレートプロジェクトの作成

Python 用の最小限の dbx プロジェクトを作成する

次の最小限の dbx プロジェクトは、Pythonと dbxを始めるための最も簡単で最速のアプローチです。 PythonDatabricksこれは、 Databricksワークスペース内の既存の汎用クラスター上で、単一のコードファイルのバッチ実行を示しています。

注記

汎用クラスターとジョブクラスター、リモートコードアーティファクトデプロイ、プラットフォームのセットアップでのコードのバッチ実行を示す用のテンプレート dbxプロジェクトを作成するには、サポートを備えたPythonCI/CD の dbx テンプレートプロジェクトを作成するPythonCI/CDに進んでください。

この手順を完了するには、ワークスペースに既存の汎用クラスターが必要です。 ( View コンピュートまたはコンピュート設定リファレンスを参照してください。理想的には (必須ではありませんが)、Python 仮想環境の Python のバージョンは、このクラスターにインストールされているバージョンと一致する必要があります。クラスター上の Python のバージョンを特定するには、クラスターの Webターミナルを使用してコマンド python --versionを実行します。

Bash

python --version

ターミナルから、 dbx プロジェクトのルートフォルダから、次のオプションを指定して dbx configure コマンドを実行します。このコマンドは、dbx プロジェクトのルートフォルダー内に非表示の .dbx フォルダーを作成します。この .dbx フォルダには、 lock.json ファイルと project.json ファイルが含まれています。
Bash
```
dbx configure --profile DEFAULT --environment default
```

注記

project.json ファイルは、.databrickscfg ファイル内の DEFAULT プロファイルへの参照と共に、default という名前の環境を定義します。dbx別のプロファイルを使用する場合は、dbx configureコマンドで、--profile DEFAULTを--profileに置き換え、その後にターゲットプロファイルの名前を続けます。

たとえば、.databrickscfg ファイル内に DEV という名前のプロファイルがあり、 dbx で DEFAULT プロファイルの代わりにそれを使用したい場合、project.json ファイルは以下のようになります。この場合は dbx configure コマンド内の --environment dev に --environment default を置き換えることもできます。

JSON
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}

dbx で、.databrickscfg ファイル内のプロファイルの代わりに DATABRICKS_HOST および DATABRICKS_TOKEN 環境変数を使用する場合は、 dbx configure コマンドから --profile オプションを完全に省略します。

dbx プロジェクトのルートフォルダ内に conf という名前のフォルダを作成します。

LinuxまたはmacOSの場合：
Bash
```
mkdir conf
```
Windowsの場合：
PowerShell
```
md conf
```

以下の内容を含む deployment.yaml ファイルという名前のファイルを conf ディレクトリに追加します。

YAML
build:
  no_build: true
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_python_task:
          python_file: 'file://dbx-demo-job.py'

注記

deployment.yaml ファイルには、.databrickscfg ファイル内の大文字の DEFAULT プロファイルへの参照である小文字の単語 defaultが含まれています。dbx別のプロファイルを使用する場合は、default をターゲットプロファイルの名前に置き換えます。

たとえば、.databrickscfg ファイル内に DEV という名前のプロファイルがあり、dbx で DEFAULT プロファイルの代わりにそれを使用したい場合、 deployment.yaml ファイルは以下のようになります。

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

dbx で、 .databrickscfg ファイル内のプロファイルの代わりに DATABRICKS_HOST および DATABRICKS_TOKEN の環境変数を使用する場合は、 deployment.yaml 内の default をそのままにしておきます。dbx はデフォルトでこのリファレンスを使用します。

ヒント

Spark構成のキーと値のペアをジョブに追加するには、以下のように spark_conf フィールドを使用します。

YAML
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: '-verbose:gc -XX:+PrintGCDetails'
        # ...

ジョブに権限を追加するには、次のように access_control_list フィールドを使用します。以下に例を挙げます。

YAML
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'
        # ...

access_control_listフィールドは網羅的である必要があるため、ジョブの所有者をリストに追加し、他のユーザーとグループのアクセス許可を追加する必要があることに注意してください。

クラスターで実行するコードを dbx-demo-job.py という名前のファイルに追加し、そのファイルを dbx プロジェクトのルートフォルダーに追加します。 (手元にコードがない場合は、この記事の最後にあるコード例の Python コードを使用できます。

注記

このファイルに dbx-demo-job.pyという名前を付ける必要はありません。別のファイル名を選択した場合は、conf/deployment.yaml ファイルに一致するように python_file フィールドを必ず更新してください。

次のオプションを使用してコマンド dbx execute コマンドを実行します。このコマンドで、 <existing-cluster-id> をワークスペース内のターゲットクラスターの ID に置き換えます。 (ID を取得するには、「クラスター URL と ID」を参照してください)。
Bash
```
dbx execute --cluster-id=<existing-cluster-id> dbx-demo-job --no-package
```
実行の結果をローカルで表示するには、ターミナルの出力を参照してください。クラスターで実行結果を表示するには、クラスターの [ドライバーログ ] タブの [標準出力 ] ウィンドウに移動します。( コンピュートドライバーとワーカーのログを参照してください)。
「次のステップ」に進みます。

Scala または Java 用の最小限の dbx プロジェクトを作成する

次の最小限の dbx プロジェクトは、 dbx と Scala または Java を使い始めるための最も簡単で最速のアプローチです。 ScalaJavaJARこれは、1Databricks つのまたはJAR Databricksをワークスペースにデプロイし、そのデプロイされたをDatabricks ワークスペースのジョブクラスターで実行する方法を示しています。

注記

Databricksは、クラスター上でScalaおよびJavaコードを実行する方法を制限しています。

単一のPythonファイルの場合とは異なり、単一のScalaまたはJavaファイルをクラスター上のジョブとして実行することはできません。ScalaまたはJavaコードを実行するには、まず目的のコードをJARにビルドする必要があります。
JARは、既存の汎用クラスターのジョブとして実行できます。ただし、その JAR の更新プログラムを同じ汎用クラスターに再インストールすることはできません。この場合は、代わりにジョブクラスターを使用する必要があります。このセクションでは、ジョブクラスターアプローチを使用します。
DatabricksワークスペースにデプロイされたJARをそのワークスペース内の汎用クラスターまたはジョブクラスターで実行する前に、まずJARをDatabricksワークスペースにデプロイする必要があります。

ターミナルで、プロジェクトのルートフォルダから、次のオプションを指定して dbx configure コマンドを実行します。このコマンドは、プロジェクトのルートフォルダ内に非表示の .dbx フォルダを作成します。この .dbx フォルダには、 lock.json ファイルと project.json ファイルが含まれています。
Bash
```
dbx configure --profile DEFAULT --environment default
```

注記

JSON
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}

プロジェクトのルートフォルダ内に conf という名前のフォルダを作成します。

LinuxまたはmacOSの場合：
Bash
```
mkdir conf
```
Windowsの場合：
PowerShell
```
md conf
```
以下の最小限の内容を含む、 deployment.yaml ファイルという名前のファイルを conf ディレクトリに追加します。
YAML
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        new_cluster:
          spark_version: '10.4.x-scala2.12'
          node_type_id: 'i3.xlarge'
          aws_attributes:
            first_on_demand: 1
            availability: 'SPOT'
          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'
```
以下のように置き換えてください。
- spark_version の値を、ターゲットジョブクラスターの適切なランタイムバージョンに置き換えます。
- ターゲットジョブのクラスターに適したワーカーノードタイプを持つ node_type_id の値。
- instance_pool_id の値とワークスペース内の既存のインスタンスプールの ID を合わせ、ジョブの高速実行を可能にします。既存のインスタンス・プールが使用可能でない場合、またはインスタンス・プールを使用しない場合は、この行を完全に削除します。
- jar の値を、プロジェクト内のJARへのパスに置き換えます。Scalaを使用したIntelliJ IDEAの場合は、file://out/artifacts/dbx_demo_jar/dbx-demo.jar になる可能性があります。Javaを使用するEclipse IDEの場合、これは file://target/dbx-demo-0.0.1-SNAPSHOT.jar になる可能性があります。
- JAR内のメインクラスの名前を含む main_class_name の値（例：com.example.demo.SampleApp）

注記

deployment.yaml ファイルには、「default」という単語が含まれています。これは、 .dbx/project.json ファイル内の default 環境へのリファレンスであり、さらに、 .databrickscfg ファイル内の DEFAULT プロファイルへのリファレンスとなります。dbx で別のプロファイルを使用する場合は、この deployment.yaml ファイル内の default を .dbx/project.json ファイル内の対応するリファレンスに置き換えます。これにより、.databrickscfg ファイル内の対応するプロファイルが参照されます。

YAML
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        # ...
  dev:
    workflows:
      - name: '<some-other-job-name>'
        # ...

dbx で、 .databrickscfg ファイル内のプロファイルの代わりに DATABRICKS_HOST および DATABRICKS_TOKEN の環境変数を使用する場合は、 deployment.yaml 内の default をそのままにしておきます。dbx はデフォルトで、 .dbx/project.json ファイル内の default 環境設定（profile 値を除く）を使用します。

ヒント

Spark構成のキーと値のペアをジョブに追加するには、以下のように spark_conf フィールドを使用します。以下に例を挙げます。

YAML
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: '-verbose:gc -XX:+PrintGCDetails'
        # ...

ジョブに権限を追加するには、次のように access_control_list フィールドを使用します。以下に例を挙げます。

YAML
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'
        # ...

dbx deploy コマンドを実行します。dbx 、一致する環境の .dbx/project.json ファイルの artifact_location パス内の場所にJARをデプロイします。また、dbx は、プロジェクトのファイルをMLflow エクスペリメントの一部として、一致する環境の .dbx/project.json ファイルのworkspace_directoryパスにリストされている場所にデプロイします。
Bash
```
dbx deploy --no-package
```
次のオプションを指定して dbx launch コマンドを実行します。このコマンドは、 conf/deployment.yamlに一致する名前でジョブを実行します。ジョブの一部として実行するデプロイされたJARを見つけるために、 dbx は、一致する環境の .dbx/project.json ファイルの artifact_location パス内の場所を参照します。実行する特定のJARを決定するために、dbx は、一致する環境の .dbx/project.json ファイルのworkspace_directoryパスに一覧表示されている場所にあるMLflowエクスペリメントを参照します。
Bash
```
dbx launch dbx-demo-job
```
ジョブクラスターでジョブ実行の結果を表示するには、「ジョブとパイプラインの表示」を参照してください。
ジョブが参照したエクスペリメントを表示するには、「MLflow エクスペリメントを使用したトレーニング実行の整理」を参照してください。
「次のステップ」に進みます。

CI/CD サポートを使用した Python 用の dbx テンプレートプロジェクトの作成

次のdbx 用のテンプレート化されたプロジェクトは、Python PythonDatabricks汎用クラスターでのコードのバッチ実行と、ワークスペースでのジョブクラスター Databricks、リモートコードアーティファクトデプロイ、およびCI/CD プラットフォームのセットアップのサポートを示しています。(既存の汎用クラスターで単一のPythonコードファイルのバッチ実行のみを示すPythonの最小dbxプロジェクトを作成するには、Pythonの最小dbxプロジェクトの作成に戻る必要があります。

ターミナルから、 dbx プロジェクトのルートフォルダで dbx init コマンドを実行します。
Bash
```
dbx init
```
project_name には、プロジェクトの名前を入力するか、Enterキーを押してデフォルトのプロジェクト名をそのまま使用します。
version には、プロジェクトの開始バージョン番号を入力するか、Enterキーを押してデフォルトのプロジェクトバージョンをそのまま使用します。
cloud には、プロジェクトで使用するDatabricksクラウドのバージョンに対応する番号を選択するか、Enterキーを押してデフォルト設定をそのまま使用します。
cicd_tool では、プロジェクトで使用するサポートされているCI/CDツールに対応する番号を選択するか、Enterキーを押してデフォルト設定をそのまま使用します。
project_slug には、プロジェクト内のリソースに使用するプレフィックスを入力するか、Enterキーを押してデフォルト設定をそのまま使用します。
workspace_directory には、プロジェクトのワークスペースディレクトリへのローカルパスを入力するか、Enterキーを押してデフォルトの設定をそのまま使用します。
artifact_location の場合は、プロジェクトのアーティファクトが書き込まれる場所へのDatabricksワークスペースのパスを入力するか、Enterキーを押してデフォルトを受け入れます。
profile には、プロジェクトで使用するCLI認証プロファイルの名前を入力するか、Enterキーを押してデフォルトを受け入れます。

ヒント

ハードコーディングされたテンプレートパラメーターを指定して dbx init を実行すると、前の手順をスキップできます。以下に例を示します。

Bash
dbx init --template="python_basic" \
-p "project_name=cicd-sample-project" \
-p "cloud=AWS" \
-p "cicd_tool=GitHub Actions" \
-p "profile=DEFAULT" \
--no-input

dbx は、project_slug 、workspace_directory 、および artifact_location のパラメーターを自動的に計算します。これら3通りのパラメーターは任意で使用でき、より高度な使用例のみにおいて役立ちます。

dbx ドキュメントの CLI リファレンスの init コマンドを参照してください。

「次の手順」も参照してください。

コード例

dbx でバッチ実行できるコードがない場合は、dbx で以下のコードのバッチ実行をお試しください。このコードは、ワークスペースに小さなテーブルを作成し、そのテーブルに対してクエリを実行し、その後テーブルを削除します。

ヒント

テーブルを削除せずにワークスペースに残しておきたい場合は、dbx でバッチ実行する前に、この例のコードの最後の行をコメントアウトします。

Python
Scala
Java

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

次のステップ

conf/deployment.yamlファイルを拡張して、さまざまなタイプの汎用クラスター定義とジョブクラスター定義をサポートします。
マルチタスクジョブを conf/deployment.yaml ファイルで宣言します。
conf/deployment.yaml ファイル内の名前付きプロパティを参照します。
dbxexecuteコマンドを使用して、クラスター上でコードを新しいジョブとしてバッチ実行します。

追加のリソース

dbxdeployコマンドを使用して、コードのアーティファクトをDatabricksワークスペースのストレージにバッチでデプロイします。
dbx launchコマンドを使用して、クラスター上の既存のジョブをバッチ実行します。
dbxを使用して、アセットベースのワークフローのデプロイメントを実行し、起動します。
ワークフローのデプロイメントをスケジュールします。
dbxとCI/CDについてさらに詳しく学びます。
dbxドキュメント
GitHubのdatabrickslabs/dbxリポジトリ
dbxの制限事項

必要条件​

Visual Studio Code​

PyCharm​

IntelliJ IDEAの​

ステップ 1: sbt-based の Scala プロジェクトを作成する​

ステップ 2: パッケージにオブジェクトを追加する​

ステップ 3: プロジェクトをビルドする​

ステップ 4: プロジェクトにコードを追加する​

ステップ 5: プロジェクトを実行する​

ステップ 6: プロジェクトを JAR としてビルドする​

ステップ7:IDEでターミナルを表示する​

Eclipse​

ステップ 1: Maven ベースの Java プロジェクトを作成する​

ステップ 2: パッケージにクラスを追加する​

ステップ 3: プロジェクトに依存関係を追加する​

ステップ 4: プロジェクトをコンパイルする​

ステップ 5: プロジェクトにコードを追加する​

ステップ 6: プロジェクトを実行する​

ステップ 7: プロジェクトを JAR としてビルドする​

ステップ8:IDEでターミナルを表示する​

IDEなし(端末のみ)​

dbx プロジェクトの作成​

Python 用の最小限の dbx プロジェクトを作成する​

Scala または Java 用の最小限の dbx プロジェクトを作成する​

CI/CD サポートを使用した Python 用の dbx テンプレート プロジェクトの作成​

コード例​

次のステップ​

追加のリソース​

必要条件

Visual Studio Code

PyCharm

IntelliJ IDEAの

ステップ 1: sbt-based の Scala プロジェクトを作成する

ステップ 2: パッケージにオブジェクトを追加する

ステップ 3: プロジェクトをビルドする

ステップ 4: プロジェクトにコードを追加する

ステップ 5: プロジェクトを実行する

ステップ 6: プロジェクトを JAR としてビルドする

ステップ7:IDEでターミナルを表示する

Eclipse

ステップ 1: Maven ベースの Java プロジェクトを作成する

ステップ 2: パッケージにクラスを追加する

ステップ 3: プロジェクトに依存関係を追加する

ステップ 4: プロジェクトをコンパイルする

ステップ 5: プロジェクトにコードを追加する

ステップ 6: プロジェクトを実行する

ステップ 7: プロジェクトを JAR としてビルドする

ステップ8:IDEでターミナルを表示する

IDEなし(端末のみ)

dbx プロジェクトの作成

Python 用の最小限の dbx プロジェクトを作成する

Scala または Java 用の最小限の dbx プロジェクトを作成する

CI/CD サポートを使用した Python 用の dbx テンプレートプロジェクトの作成

コード例

次のステップ

追加のリソース