Databricks Labsのdbx

[dbx by Databricks Labs \| Databricks on AWS](https://docs.databricks.com/dev-tools/dbx.html) [2022/10/11時点]の翻訳です。

:::note warn
本書は抄訳であり内容の正確性を保証するものではありません。正確な内容に関しては原文を参照ください。
:::

:::note info
**注意**
[Databricks Labs](https://databricks.com/learn/labs)の[dbx](https://github.com/databrickslabs/dbx/blob/main/README.rst)はas-isで提供されており、カスタマーテクニカルサポートチャネルを通じて、Databricksによって正式にはサポートされていません。サポート、質問、機能リクエストに関しては、Github上の[databrickslabs/dbx](https://github.com/databrickslabs/dbx)リポジトリの[Issues](https://github.com/databrickslabs/dbx/issues)ページを通じてコミュニケーションすることができます。
:::

Databricks Labsの[dbx](https://dbx.readthedocs.io/en/latest)は、Databricksコマンドラインインタフェース([Databricks CLI](https://docs.databricks.com/dev-tools/cli/index.html))を拡張し、Databricksプラットフォームにおける迅速な開発ライフサイクルと継続的インテグレーション/継続的デリバリー・デプロイメント(CI/CD)のための機能を提供することを目的として設計されたオープンソースツールです。

`dbx`は複数環境にまたがる[ジョブ](https://qiita.com/taka_yayoi/items/b3275a1983c51a8bbe1a)の起動とデプロイメントプロセスをシンプルにします。また、皆様のプロジェクトのパッケージングと、バージョン管理された状態でのDatabricks環境へのデリバリーを支援します。CLIファーストで設計されており、CI/CDパイプラインの内部、あるいはローカルツール(Visual Studio CodeやPyCharmのようなローカルIDEなど)の一部として積極的に使用できるように開発されています。

`dbx`の典型的な開発ワークフローは以下のようになります。

1. まだリモートのrepoを持っていないのであれば、Databricksの[Databricks ReposによるGit連携](https://qiita.com/taka_yayoi/items/b89f199ff0d3a4c16140)の要件に合致するGitプロバイダーのリモートリポジトリを作成します。
1. リモートリポジトリを*お使いの*Databricksワークスペースに[クローン](https://qiita.com/taka_yayoi/items/b89f199ff0d3a4c16140#%E3%83%AA%E3%83%A2%E3%83%BC%E3%83%88git%E3%83%AA%E3%83%9D%E3%82%B8%E3%83%88%E3%83%AA%E3%81%AE%E3%82%AF%E3%83%AD%E3%83%BC%E3%83%B3)します。
1. DatabricksワークスペースにクローンしたリポジトリにDatabricks[ノートブック](https://qiita.com/taka_yayoi/items/24a897cf40bba6d9e305)を[作成あるいは移動](https://qiita.com/taka_yayoi/items/b89f199ff0d3a4c16140#databricks-repo%E3%81%AB%E3%81%8A%E3%81%91%E3%82%8B%E3%83%8E%E3%83%BC%E3%83%88%E3%83%96%E3%83%83%E3%82%AF%E3%81%AE%E4%BD%9C%E6%A5%AD)します。お使いのDatabricks[クラスター](https://qiita.com/taka_yayoi/items/c5d99cd77fe4bfcf69f0)で実行するコードのプロトタイピングを始めるために、このノートブックを使用します。
1. 個別のヘルパークラスやヘルパー関数、設定ファイル、テストを追加することでお使いのノートブックをエンハンスし、モジュール化するために、`dbx`を使ってお気に入りのIDE、Gitがインストールされたローカル開発マシンにスイッチします。
1. お使いのローカル開発マシンにリモートのリポジトリをクローンします。
1. お使いのノートブックからコードを1台以上のローカルコードファイルに移動します。
1. ローカルでコーディングを行い、ローカルリポジトリから作業内容をリモートリポジトリにプッシュします。また、リモートリポジトリをお使いのDatabricksワークスペースに[同期](https://qiita.com/taka_yayoi/items/b89f199ff0d3a4c16140#%E3%83%AA%E3%83%A2%E3%83%BC%E3%83%88git%E3%83%AA%E3%83%9D%E3%82%B8%E3%83%88%E3%83%AA%E3%81%A8%E5%90%8C%E6%9C%9F%E3%81%99%E3%82%8B)します。

    :::note
    **ティップス**
    あるいは、リアルタイムでローカルファイルの変更を対応するワークスペースのファイルに同期する[dbx sync](https://docs.databricks.com/dev-tools/dbx-sync.html)を使用することができます。
   :::

1. 迅速なプロトタイピングのためにDatabricksワークスペース上でノートブックを使用し続け、ノートブックから検証されたコードをローカルマシンに移動し続けます。コードのモジュール化、コードコンプリート、linting、ユニットテスト、Databricksとのライブ接続を必要としないコード、オブジェクトのステップスルーのデバッギングのようなタスクのためにローカルIDEを使い続け、Databricksへのライブな接続を必要としないオブジェクトやコードのステップスルーのデバッグを行います。
1. 必要に応じて、お使いのローカルコードをターゲットのクラスターでのバッチ実行を行うために`dbx`を使用します(これは、Sparkクラスターでアプリケーションを起動するためにSparkの`bin`ディレクトリで[spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit)スクリプトを実行するものと似ています)。
1. プロダクションに移行する準備ができたら、クラスターでのリモートリポジトリのコードの実行を自動化するために、[GitHub Actions](https://docs.github.com/en/actions)や[Azure DevOps](https://docs.microsoft.com/azure/devops)、[GitLab](https://about.gitlab.com/get-started/)のようなCI/CDプラットフォームを使用します。

# 要件

`dbx`を使うためには、コードでPython、Scala、Javaを使っているのかに関係なく、ローカルの開発マシンに以下をインストールする必要があります。

- [Python](https://www.python.org/downloads/)バージョン3.6以降
    コードでPythonを使用している場合は、ターゲットのクラスターにインストールされているPythonのバージョンと一致させる必要があります。既存のクラスターにインストールされているPythonのバージョンを取得するには、クラスターの[webターミナル](https://docs.databricks.com/clusters/web-terminal.html)を使って、`python --version`コマンドを実行します。お使いのクラスターのDatabricksランタイムのバージョンに対しては、[Databricks runtime releases](https://docs.databricks.com/release-notes/runtime/releases.html)の「System environment」のセクションをご覧ください。
- [pip](https://pip.pypa.io/en/stable/installation/)
- コードでPythonを使用している場合には、ご自身の`dbx`プロジェクトで適切なPythonのバージョンを使用し、依存関係をパッケージングすることを確実にするために、Pythonの仮想環境を作成する手段。本書では[pipenv](https://pipenv.pypa.io/)をカバーします。
- [dbx](https://pypi.org/project/dbx/)バージョン0.7.0以降。`pip install dbx`を実行することでPython Package Index(PyPI)からインストールできます。

    `dbx`がインストールされているかどうかを確認するには以下のコマンドを実行します。

    ```bash:Bash
    dbx --version
    ```

    バージョン番号が返って来れば、`dbx`はインストールされています。

    バージョン番号が`0.7.0`未満の場合、以下のコマンドを実行して`dbx`をアップグレードしてバージョン番号を再度確認してください。

    ```bash:Bash
    pip install dbx --upgrade
    dbx --version
    
    # Or ...
    python -m pip install dbx --upgrade
    dbx --version
    ```

- [Databricks CLI](https://docs.databricks.com/dev-tools/cli/index.html)、[認証](https://docs.databricks.com/dev-tools/cli/index.html#set-up-authentication)を設定します。`dbx`をインストールする際に自動でDatabricks CLIがインストールされます。以下の場所のいずれか、あるいは両方でローカル開発マシンの認証を設定することができます。
    - 環境変数`DATABRICKS_HOST`と`DATABRICKS_TOKEN`(Databricks CLIバージョン0.8.0以降)
    - `.databrickscfg`ファイル内のプロファイル

    `dbx`は、これら二つの場所の認証クレディンシャルを検索します。`dbx`は最初にマッチしたもののみを使用します。

    :::note
    **注意**
    `dbx`は、Databricks CLI version 0.17.2以降を用いる場合、認証で[\.netrc](https://docs.databricks.com/dev-tools/api/latest/authentication.html#netrc)の使用をサポートしていません。インストールされているDatabricks CLIのバージョンを確認するには、コマンド`databricks --version`を実行してください。
:::

- ローカルとリモートの変更をプッシュ、同期するための[git](https://git-scm.com/downloads)

以下のIDEごとの指示に従ってください。

- [Visual Studio Code](#visual-studio-code)
- [PyCharm](#pycharm)
- [IntelliJ IDEA](#intellij-idea)
- [Eclipse](#eclipse)

:::note info
**注意**
Databricksでは、`dbx`と上述のIDEの利用を検証しています。しかし、`dbx`は任意のIDEでも動作します。[IDEを使わない(ターミナルのみ)](#ideなしターミナルのみ)という選択肢もあります。

`dbx`は、単一のPythonコードファイル、コンパイルされたScala、JavaのJARファイルでの動作に最適化されています。`dbx`は単一のRコードファイルやコンパイルされたRコードパッケージでは動作しません。これは、`dbx`がJobs API [2\.0](https://docs.databricks.com/dev-tools/api/2.0/jobs.html)と[2\.1](https://docs.databricks.com/dev-tools/api/latest/jobs.html)と連携しますが、これらのAPIが単一のRコードファイルやコンパイルされたRコードパッケージをジョブとして実行できないためです。
:::

# Visual Studio Code

`dbx`で[Visual Studio Code](https://code.visualstudio.com/)とPythonを使い始めるには以下の手順を完了してください。

ローカルの開発マシンでは、共通の[要件](#要件)に加えて以下のインストールが必要です。

- [Visual Studio Code](https://code.visualstudio.com/)
- Visual Studio Code向けの[Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python)拡張。詳細はVisual Studio Codeウェブサイトの[Extension Marketplace](https://code.visualstudio.com/docs/editor/extension-marketplace)をご覧ください。

    詳細はVisual Studio Codeドキュメントの[Getting Started with Python in VS Code](https://code.visualstudio.com/docs/python/python-tutorial)をご覧ください。

`dbx`プロジェクト構成をセットアップするためには、以下のステップを実施します。

1. お使いのターミナルで空のフォルダーを作成します。これらの手順では、`dbx-demo`というフォルダーを使用します。`dbx`プロジェクトのルートフォルダーにはお好きな名前をつけることができます。別な名前を使う際には、以下のステップでフォルダー名を置き換えてください。フォルダーを作成した後にそのフォルダーに移動し、そのフォルダーからVisual Studio Codeを起動します。

    LinuxあるいはmacOS

    ```bash:Bash
    mkdir dbx-demo
    cd dbx-demo
    code .
    ```

    :::note 
    **ティップ**
    `code .`を実行した後に`command not found: code`が表示される場合には、MicrosoftWebサイトの[Launching from the command line](https://code.visualstudio.com/docs/setup/mac#_launching-from-the-command-line)をご覧ください。
   :::

    Windows

    ```powershell:Powershell
    md dbx-demo
    cd dbx-demo
    code .
    ```

1. Visual Studio CodeでプロジェクトのためのPython仮想環境を作成します。
    1. メニューバーで**View > Terminal**をクリックします。
    1. `dbx-demo`フォルダーのルートから、以下のオプションを指定して`pipenv`コマンドを実行します。ここで`<version>`は、`3.7.5`のように、すでにローカルにインストールしている(そして、理想的にはターゲットのクラスターのPythonのバージョンにマッチする)Pythonのバージョンとなります。

    ```bash:Bash
    pipenv --python <version>
    ```

    次のステップで必要となるので、`pipenv`コマンドの出力にある`Virtualenv location`の値をメモしておきます。

1. ターゲットのPythonインタプリタを選択し、Python仮想環境を有効化します。
    1. メニューバーで**View > Command Palette**をクリックし、`Python: Select`とタイプし、**Python: Select Interpreter**をクリックします。
    1. 作成したPython仮想環境に対するパスの中でPythonインタプリタを選択します。(このパスは`pyenv`コマンドの出力の`Virtualenv location`として一覧されます)
    1. メニューバーで**View > Command Palette**をクリックし、`Terminal: Create`とタイプし、**Terminal: Create New Terminal**をクリックします。

    詳細に関しては、Visual Studio Codeドキュメントの[Using Python environments in VS Code](https://code.visualstudio.com/docs/python/environments)をご覧ください。

1. [dbxプロジェクトの作成](#dbxプロジェクトの作成)に進みます。

# PyCharm

[原文](https://docs.databricks.com/dev-tools/dbx.html#pycharm)を参照ください。

# IntelliJ IDEA

[原文](https://docs.databricks.com/dev-tools/dbx.html#intellij-idea)を参照ください。

# Eclipse

[原文](https://docs.databricks.com/dev-tools/dbx.html#eclipse)を参照ください。

# IDEなし(ターミナルのみ)

`dbx`でターミナルとPythonを使い始めるには、以下のステップを完了してください。

`dbx`プロジェクト構成をセットアップするためにターミナルを使用するには、以下のステップを実行します。

1. お使いのターミナルで空のフォルダーを作成します。これらの手順では、`dbx-demo`というフォルダーを使用します。`dbx`プロジェクトのルートフォルダーにはお好きな名前をつけることができます。別な名前を使う際には、以下のステップでフォルダー名を置き換えてください。フォルダーを作成した後にそのフォルダーに移動します。

    LinuxあるいはmacOS

    ```bash:Bash
    mkdir dbx-demo
    cd dbx-demo
    ```

    Windows

    ```powershell:Powershell
    md dbx-demo
    cd dbx-demo
    ```

1. `dbx-demo`フォルダーのルートで`pyenv`コマンドを実行することで、このプロジェクト向けのPython仮想環境を作成します。ここで`<version>`は、`3.7.5`のように、すでにローカルにインストールしている(そして、理想的にはターゲットのクラスターのPythonのバージョンにマッチする)Pythonのバージョンとなります。

    ```bash:Bash
    pipenv --python <version>
    ```

1. `pipenv shell`を実行してPython仮想環境を有効化します。

    ```bash:Bash
    pipenv shell
    ```

1. [dbxプロジェクトの作成](#dbxプロジェクトの作成)に進みます。

# dbxプロジェクトの作成

上のセクションで`dbx`プロジェクト構成を作成したので、以下のいずれかのタイプのプロジェクトを作成することができます。

- [Python向け最小構成dbxプロジェクトの作成](#python向け最小構成dbxプロジェクトの作成)
- [Scala、Java向け最小構成dbxプロジェクトの作成](#scalajava向け最小構成dbxプロジェクトの作成)
- [CI/CDサポートとPython向けのdbxテンプレートの作成](#cicdサポートとpython向けのdbxテンプレートの作成)

## Python向け最小構成dbxプロジェクトの作成

以下の最小構成の`dbx`プロジェクトはPythonと`dbx`を使い始める際の、最もシンプルかつ迅速なアプローチとなります。ここでは、お使いのDatabricksワークスペースの既存のDatabricks [all-purposeクラスター](https://qiita.com/taka_yayoi/items/c5d99cd77fe4bfcf69f0)上で単一のPythonコードファイルをバッチ実行する様子をデモンストレーションします。

:::note info
**注意**
all-purposeクラスター、jobクラスター上でのコードのバッチ実行、リモートコードアーティファクトのデプロイメント、CI/CDプラットフォームのセットアップをデモンストレーションするPytohn向け`dbx`テンプレートプロジェクトを作成したい場合には、[CI/CDサポートとPython向けのdbxテンプレートの作成](#cicdサポートとpython向けのdbxテンプレートの作成)までスキップしてください。
:::

この手順を完了するには、お使いのワークスペースにall-purposeクラスターが存在している必要があります([クラスターの表示](https://qiita.com/taka_yayoi/items/991aae376c089df58504#%E3%82%AF%E3%83%A9%E3%82%B9%E3%82%BF%E3%83%BC%E3%81%AE%E8%A1%A8%E7%A4%BA)、[クラスターの作成](https://qiita.com/taka_yayoi/items/d36a469a1e0c0cebaf1b)をご覧ください)。理想的には(必須ではありません)、お使いのPython仮想環境のPythonのバージョンはクラスターのPythonのバージョンと一致すべきです。クラスターのPythonバージョンを取得するには、クラスターの[Webターミナル](https://docs.databricks.com/clusters/web-terminal.html)で`python --version`コマンドを実行します。

```bash:Bash
python --version
```

1. ターミナルで、`dbx`プロジェクトのルートフォルダーから以下のオプションを指定して`dbx configure`コマンドを実行します。このコマンドによって、`dbx`プロジェクトのルートフォルダーに`.dbx`隠しフォルダーが作成されます。`.dbx`フォルダーには`lock.json`と`project.json`ファイルが格納されます。

    ```bash:Bash
    dbx configure --profile DEFAULT
    ```

    > **注意**
`project.json`ファイルには、Databricks CLIの`.databrickscfg`ファイル内の`DEFAULT`プロファイルへのリファレンスが含まれます。`dbx`に別のプロファイルを使わせたい場合には、`DEFAULT`をターゲットのプロファイル名で置き換えてください。
    > Databricks CLIの`.databrickscfg`ファイルのプロファイルではなく、`dbx`に環境変数`DATABRICKS_HOST`、`DATABRICKS_TOKEN`を使わせたい場合には、`project.json`の`DEFAULT`をそのままにしておきます。`dbx`はデフォルトでこのリファレンスを使用します。

1. `dbx`ルートフォルダーに`conf`というフォルダーを作成します。

    LinuxあるいはmacOS

    ```bash:Bash
    mkdir conf
    ```

    Windows

    ```powershell:Powershell
    md conf
    ```

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

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

    :::note 
    **注意**
    `deployment.yaml`には小文字の`default`が含まれており、これはDatabricks CLIの`.databrickscfg`ファイルの`DEFAULT`プロファイルへのリファレンスとなっています。`dbx`に別のプロファイルを使わせたい場合には、`DEFAULT`をターゲットのプロファイル名で置き換えてください。

     例えば、`dbx`で`DEFAULT`プロファイルではなく、Databricks CLIの`.databrickscfg`ファイルの`DEV`というプロファイルがある場合、お使いの`deployment.yaml`ファイルは以下の様になります。

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

    もし、Databricks CLIの`.databrickscfg`ファイルのプロファイルではなく、`dbx`に環境変数`DATABRICKS_HOST`、`DATABRICKS_TOKEN`を使わせたい場合には、`project.json`の`DEFAULT`をそのままにしておきます。`dbx`はデフォルトでこのリファレンスを使用します。
   :::

    :::note
    **ティップス**
    ジョブにSpark設定のキーバリューペアを追加するには、以下の様に`spark_conf`フィールドを使用します。

    ```yaml: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"
            # ...
    ```

    ジョブにアクセス権を追加するには、以下の様に`permissions`フィールドを使用します。

    ```yaml:YAML
    environments:
      default:
        workflows:
          - name: "dbx-demo-job"
            permissions:
              access_control_list:
                - user_name: "someone@example.com"
                  permission_level: "IS_OWNER"
                - group_name: "some-group"
                  permission_level: "CAN_VIEW"
            # ...
    ```

    `access_control_list`フィールドは網羅的である必要があることに注意してください。すなわち、リストには他のユーザーやグループのアクセス権も追加する必要があります。
   :::

1. `dbx-demo-job.py`というファイルにクラスターで実行するコードを追加し、ファイルを`dbx`プロジェクトのルートフォルダーに追加します。(すぐに使えそうなコードがない場合には、本書の後半にある[コードサンプル](#コードサンプル)のPythonコードを使用することができます。)

    :::note 
    **注意**
このファイルの名前を`dbx-demo-job.py`にする必要はありません。別のファイル名を指定した場合、`conf/deployment.yaml`ファイルの`python_file`フィールドが一致するようにしてください。

1. 以下のオプションを指定して`dbx execute`コマンドを実行します。このコマンドでは、`<existing-cluster-id>`をお使いのワークスペースのターゲットクラスターのIDで置き換えてください。(IDを取得するには[クラスターURLとID](https://qiita.com/taka_yayoi/items/7127cabac70dd994fcba#%E3%82%AF%E3%83%A9%E3%82%B9%E3%82%BF%E3%83%BC%E3%81%AEurlid)をご覧ください)

    ```bash:Bash
    dbx execute --cluster-id=<existing-cluster-id> --job=dbx-demo-job --no-rebuild --no-package
    ```

1. ローカルで実行結果を参照するには、ターミナルの出力をご覧ください。クラスター上で実行結果を参照するには、お使いのクラスターの**Driver logs**タブの**Standard output**を参照ください。([クラスターのドライバーノード、ワーカーノードのログ](https://qiita.com/taka_yayoi/items/991aae376c089df58504#%E3%82%AF%E3%83%A9%E3%82%B9%E3%82%BF%E3%83%BC%E3%81%AE%E3%83%89%E3%83%A9%E3%82%A4%E3%83%90%E3%83%BC%E3%83%8E%E3%83%BC%E3%83%89%E3%83%AF%E3%83%BC%E3%82%AB%E3%83%BC%E3%83%8E%E3%83%BC%E3%83%89%E3%81%AE%E3%83%AD%E3%82%B0)もご覧ください)

1. [次のステップ](#次のステップ)に進んでください。

## Scala、Java向け最小構成dbxプロジェクトの作成

[原文](https://docs.databricks.com/dev-tools/dbx.html#create-a-minimal-dbx-project-for-scala-or-java)を参照ください。

## CI/CDサポートとPython向けのdbxテンプレートの作成

以下のPython向け`dbx`テンプレートプロジェクトでは、DatabricksワークスペースでDatabricksのall-purposeクラスターやjobsクラスターでPythonコードのバッチ実行、リモートコードアーティファクトのデプロイメント、CI/CDプラットフォームセットアップをデモンストレーションします。(既存のall-purposeクラスターで単一のPythonコードファイルのバッチ実行をデモンストレーションするPython最小構成`dbx`プロジェクトを作成するには、[Python向け最小構成dbxプロジェクトの作成](#python向け最小構成dbxプロジェクトの作成)まで戻ってください)

1. ターミナル上で、`dbx`プロジェクトルートフォルダーから`dbx init`コマンドを実行します。

    ```bash:Bash
    dbx init
    ```

1. **project_name**では、プロジェクトの名前を入力するか、デフォルトのプロジェクト名を受け入れるためにEnterを押します。
1. **version**には、お使いのプロジェクトの開始バージョン番号を入力するか、デフォルトのプロジェクトバージョンを受け入れるためにEnterを押します。
1. **cloud**には、プロジェクトで使用するDatabricksクラウドバージョンに対応する番号を入力するか、デフォルトを受け入れるためにEnterを押します。
1. **cicd_tool**には、プロジェクトで使いたいCI/CDに対応する番号を入力するか、デフォルトを受け入れるためにEnterを押します。
1. **project_slug**には、プロジェクトで使用するリソーで使用したいプレフィックスを指定するか、デフォルトを受け入れるためにEnterを押します。
1. **workspace_dir**には、プロジェクト向けのワークスペースディレクトリに対するローカルパスを指定するか、デフォルトを受け入れるためにEnterを押します。
1. **artifact_location**には、プロジェクトのアーティファクトが書き込まれるDatabricksワークスペースのパスを入力するか、デフォルトを受け入れるためにEnterを押します。
1. **profile**には、プロジェクトで使用したいDatabricks CLI認証プロファイルの名前を入力するか、デフォルトを受け入れるためにEnterを押します。

:::note info
**ティップ**
以下のようにパラメーターをハードコードして、`dbx init`を実行することで上述のステップをスキップすることができます。

```bash: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_dir`、`artifact_location`を計算します。これら3つのパラメーターはオプションであり、より高度なユースケースでのみ有用なものとなります。

`dbx`ドキュメントの[CLI Reference](https://dbx.readthedocs.io/en/latest/cli.html)の`init`コマンドをご覧ください。
:::

新たなプロジェクトで使用する際には、`dbx`ドキュメントの[Basic Python Template](https://dbx.readthedocs.io/en/latest/templates/python_basic.html)をご覧ください。

[次のステップ](#次のステップ)もご覧ください。

# コードサンプル

`dbx`で使えるようなコードが手元にない場合には、以下のコードを`dbx`でバッチ実行することで実験することができます。このコードは、お使いのワークスペースに小さいテーブルを作成し、テーブルをクエリーし、テーブルを削除します。

:::note info
**ティップ**
テーブルを削除せずにそのままにしておきたい場合は、`dbx`でバッチ実行する前に、このサンプルコードの最後の行をコメントアウトしてください。
:::

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

# 次のステップ

- 様々なタイプのall-purpose、jobsクラスター定義をサポートするために、[お使いのconf/deployment\.yamlファイルを拡張します](https://dbx.readthedocs.io/en/latest/reference/deployment/)。
- `conf/deployment.yaml`ファイルで[マルチタスクジョブを宣言](https://dbx.readthedocs.io/en/latest/reference/deployment/)します。
- `conf/deployment.yaml`ファイルで[名前付きプロパティ](https://dbx.readthedocs.io/en/latest/features/named_properties/)を参照します。
- [dbx execute](https://dbx.readthedocs.io/en/latest/reference/cli/#dbx-execute)コマンドで、クラスター上で新規ジョブとしてコードをバッチ実行します。

# その他のリソース

- [dbx deploy](https://dbx.readthedocs.io/en/latest/reference/cli/#dbx-deploy)コマンドによるDatabricksワークスペースストレージへのコードアーティファクトのバッチデプロイ。
- [dbx launch](https://dbx.readthedocs.io/en/latest/reference/cli/#dbx-launch)コマンドによるクラスター上での既存ジョブのバッチ実行。
- [ジョブレスデプロイメントを行うためにdbxの活用](https://dbx.readthedocs.io/en/latest/features/assets/)
- [ワークフローデプロイメントをスケジュールする](https://dbx.readthedocs.io/en/latest/reference/deployment/?h=or#scheduling-workflows)
- [dbxとCI/CD](https://dbx.readthedocs.io/en/latest/guides/python/devops/package/)の詳細
- [dbxドキュメント](https://dbx.readthedocs.io/en/latest/)
- GitHub上の[databrickslabs/dbx](https://github.com/databrickslabs/dbx)リポジトリ
- [dbxの制限](https://dbx.readthedocs.io/en/latest/#limitations)


### Databricks 無料トライアル

[Databricks 無料トライアル](https://databricks.com/jp/try-databricks)