Erstellen von Clustern, Notebooks und Aufträgen mit Terraform

Artikel
03/01/2024

In diesem Artikel wird gezeigt, wie Sie den Databricks Terraform-Anbieter verwenden, um einen Cluster, ein Notebook und einen Auftrag in einem vorhandenen Azure Databricks-Arbeitsbereich zu erstellen.

Dieser Artikel ist ein Begleitartikel zu den folgenden Ersten Artikeln zu Azure Databricks:

Tutorial: Ausführen einer End-to-End-Analysepipeline im Lakehouse. Hier wird ein Cluster verwendet, der mit Unity Catalog, einem Python-Notebook und einem Auftrag zum Ausführen des Notebooks arbeitet.
Schnellstart: Ausführen eines Spark-Auftrags auf Azure Databricks Workspace mithilfe der Azure-Portal, die einen allgemeinen Cluster und ein Python-Notizbuch verwendet.

Sie können auch die Terraform-Konfigurationen in diesem Artikel anpassen, um benutzerdefinierte Cluster, Notebooks und Jobs in Ihren Arbeitsbereichen zu erstellen.

Schritt 1: Erstellen und Konfigurieren des Terraform-Projekts

Erstellen Sie anhand der Anweisungen im Abschnitt Anforderungen des Übersichtsartikels zum Databricks Terraform-Anbieter ein Terraform-Projekt.

Zum Erstellen eines Clusters erstellen Sie eine Datei mit dem Namen cluster.tf und fügen darin folgenden Inhalt ein. Dieser Inhalt erstellt einen Cluster mit der kleinsten zulässigen Menge an Ressourcen. Dieser Cluster verwendet die neueste Databricks Runtime Long Term Support (LTS)-Version.

Für einen Cluster, der mit Unity Catalog funktioniert:

variable "cluster_name" {}
variable "cluster_autotermination_minutes" {}
variable "cluster_num_workers" {}
variable "cluster_data_security_mode" {}

# Create the cluster with the "smallest" amount
# of resources allowed.
data "databricks_node_type" "smallest" {
  local_disk = true
}

# Use the latest Databricks Runtime
# Long Term Support (LTS) version.
data "databricks_spark_version" "latest_lts" {
  long_term_support = true
}

resource "databricks_cluster" "this" {
  cluster_name            = var.cluster_name
  node_type_id            = data.databricks_node_type.smallest.id
  spark_version           = data.databricks_spark_version.latest_lts.id
  autotermination_minutes = var.cluster_autotermination_minutes
  num_workers             = var.cluster_num_workers
  data_security_mode      = var.cluster_data_security_mode
}

output "cluster_url" {
 value = databricks_cluster.this.url
}

Für einen Allzweckcluster:

variable "cluster_name" {
  description = "A name for the cluster."
  type        = string
  default     = "My Cluster"
}

variable "cluster_autotermination_minutes" {
  description = "How many minutes before automatically terminating due to inactivity."
  type        = number
  default     = 60
}

variable "cluster_num_workers" {
  description = "The number of workers."
  type        = number
  default     = 1
}

# Create the cluster with the "smallest" amount
# of resources allowed.
data "databricks_node_type" "smallest" {
  local_disk = true
}

# Use the latest Databricks Runtime
# Long Term Support (LTS) version.
data "databricks_spark_version" "latest_lts" {
  long_term_support = true
}

resource "databricks_cluster" "this" {
  cluster_name            = var.cluster_name
  node_type_id            = data.databricks_node_type.smallest.id
  spark_version           = data.databricks_spark_version.latest_lts.id
  autotermination_minutes = var.cluster_autotermination_minutes
  num_workers             = var.cluster_num_workers
}

output "cluster_url" {
 value = databricks_cluster.this.url
}

Zum Erstellen eines Clusters erstellen Sie eine weitere Datei mit dem Namen cluster.auto.tfvars und fügen darin folgenden Inhalt ein. Diese Datei enthält variable Werte zum Anpassen des Clusters. Ersetzen Sie die Platzhalterwerte durch eigene Werte.

Für einen Cluster, der mit Unity Catalog funktioniert:
```
cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
cluster_data_security_mode      = "SINGLE_USER"
```
Für einen Allzweckcluster:
```
cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
```

Zum Erstellen eines Notebooks erstellen Sie eine weitere Datei mit dem Namen notebook.tf und fügen darin folgenden Inhalt ein:

variable "notebook_subdirectory" {
  description = "A name for the subdirectory to store the notebook."
  type        = string
  default     = "Terraform"
}

variable "notebook_filename" {
  description = "The notebook's filename."
  type        = string
}

variable "notebook_language" {
  description = "The language of the notebook."
  type        = string
}

resource "databricks_notebook" "this" {
  path     = "${data.databricks_current_user.me.home}/${var.notebook_subdirectory}/${var.notebook_filename}"
  language = var.notebook_language
  source   = "./${var.notebook_filename}"
}

output "notebook_url" {
 value = databricks_notebook.this.url
}

Wenn Sie einen Cluster erstellen, speichern Sie den folgenden Notebookcode in einer Datei im selben Verzeichnis wie die Datei notebook.tf:

Beim Python-Notebook für Tutorial: Ausführen einer End-to-End-Analysepipeline im Lakehouse – eine Datei mit dem Namen notebook-getting-started-lakehouse-e2e.py und dem folgenden Inhalt:

# Databricks notebook source
external_location = "<your_external_location>"
catalog = "<your_catalog>"

dbutils.fs.put(f"{external_location}/foobar.txt", "Hello world!", True)
display(dbutils.fs.head(f"{external_location}/foobar.txt"))
dbutils.fs.rm(f"{external_location}/foobar.txt")

display(spark.sql(f"SHOW SCHEMAS IN {catalog}"))

# COMMAND ----------

from pyspark.sql.functions import col

# Set parameters for isolation in workspace and reset demo
username = spark.sql("SELECT regexp_replace(current_user(), '[^a-zA-Z0-9]', '_')").first()[0]
database = f"{catalog}.e2e_lakehouse_{username}_db"
source = f"{external_location}/e2e-lakehouse-source"
table = f"{database}.target_table"
checkpoint_path = f"{external_location}/_checkpoint/e2e-lakehouse-demo"

spark.sql(f"SET c.username='{username}'")
spark.sql(f"SET c.database={database}")
spark.sql(f"SET c.source='{source}'")

spark.sql("DROP DATABASE IF EXISTS ${c.database} CASCADE")
spark.sql("CREATE DATABASE ${c.database}")
spark.sql("USE ${c.database}")

# Clear out data from previous demo execution
dbutils.fs.rm(source, True)
dbutils.fs.rm(checkpoint_path, True)

# Define a class to load batches of data to source
class LoadData:

  def __init__(self, source):
    self.source = source

  def get_date(self):
    try:
      df = spark.read.format("json").load(source)
    except:
        return "2016-01-01"
    batch_date = df.selectExpr("max(distinct(date(tpep_pickup_datetime))) + 1 day").first()[0]
    if batch_date.month == 3:
      raise Exception("Source data exhausted")
      return batch_date

  def get_batch(self, batch_date):
    return (
      spark.table("samples.nyctaxi.trips")
        .filter(col("tpep_pickup_datetime").cast("date") == batch_date)
    )

  def write_batch(self, batch):
    batch.write.format("json").mode("append").save(self.source)

  def land_batch(self):
    batch_date = self.get_date()
    batch = self.get_batch(batch_date)
    self.write_batch(batch)

RawData = LoadData(source)

# COMMAND ----------

RawData.land_batch()

# COMMAND ----------

# Import functions
from pyspark.sql.functions import col, current_timestamp

# Configure Auto Loader to ingest JSON data to a Delta table
(spark.readStream
  .format("cloudFiles")
  .option("cloudFiles.format", "json")
  .option("cloudFiles.schemaLocation", checkpoint_path)
  .load(file_path)
  .select("*", col("_metadata.file_path").alias("source_file"), current_timestamp().alias("processing_time"))
  .writeStream
  .option("checkpointLocation", checkpoint_path)
  .trigger(availableNow=True)
  .option("mergeSchema", "true")
  .toTable(table))

# COMMAND ----------

df = spark.read.table(table_name)

# COMMAND ----------

display(df)

Führen Sie für das Python-Notizbuch für den Schnellstart einen Spark-Auftrag in Azure Databricks Workspace mit dem Azure-Portal aus, einer Datei notebook-quickstart-create-databricks-workspace-portal.py mit dem Namen folgenden Inhalt:

# Databricks notebook source
blob_account_name = "azureopendatastorage"
blob_container_name = "citydatacontainer"
blob_relative_path = "Safety/Release/city=Seattle"
blob_sas_token = r""

# COMMAND ----------

wasbs_path = 'wasbs://%s@%s.blob.core.windows.net/%s' % (blob_container_name, blob_account_name,blob_relative_path)
spark.conf.set('fs.azure.sas.%s.%s.blob.core.windows.net' % (blob_container_name, blob_account_name), blob_sas_token)
print('Remote blob path: ' + wasbs_path)

# COMMAND ----------

df = spark.read.parquet(wasbs_path)
print('Register the DataFrame as a SQL temporary view: source')
df.createOrReplaceTempView('source')

# COMMAND ----------

print('Displaying top 10 rows: ')
display(spark.sql('SELECT * FROM source LIMIT 10'))

Wenn Sie ein Notebook erstellen, erstellen Sie eine weitere Datei mit dem Namen notebook.auto.tfvars und fügen darin folgenden Inhalt ein. Diese Datei enthält Variablenwerte zum Anpassen der Notebook-Konfiguration.

Beim Python-Notebook für Tutorial: Ausführen einer End-to-End-Analysepipeline im Lakehouse:
```
notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-getting-started-lakehouse-e2e.py"
notebook_language     = "PYTHON"
```
Für das Python-Notebook für Schnellstart: Führen Sie einen Spark-Auftrag in Azure Databricks Workspace mithilfe des Azure-Portals aus:
```
notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-quickstart-create-databricks-workspace-portal.py"
notebook_language     = "PYTHON"
```
Wenn Sie ein Notebook erstellen, stellen Sie in Ihrem Azure Databricks-Arbeitsbereich sicher, dass Sie alle Anforderungen für die erfolgreiche Ausführung des Notebooks einrichten, indem Sie sich auf die folgenden Anweisungen beziehen:
- Python-Notebook für Tutorial: Ausführen einer End-to-End-Analysepipeline im Lakehouse
- Das Python-Notebook für Schnellstart: Ausführen eines Spark-Auftrags in Azure Databricks Workspace mithilfe des Azure-Portals

Zum Erstellen des Auftrags erstellen Sie eine weitere Datei mit dem Namen job.tf und fügen darin folgenden Inhalt ein. Dieser Inhalt erstellt einen Auftrag zum Ausführen des Notizbuchs.

variable "job_name" {
  description = "A name for the job."
  type        = string
  default     = "My Job"
}

resource "databricks_job" "this" {
  name = var.job_name
  existing_cluster_id = databricks_cluster.this.cluster_id
  notebook_task {
    notebook_path = databricks_notebook.this.path
  }
  email_notifications {
    on_success = [ data.databricks_current_user.me.user_name ]
    on_failure = [ data.databricks_current_user.me.user_name ]
  }
}

output "job_url" {
  value = databricks_job.this.url
}

Wenn Sie einen Cluster erstellen, erstellen Sie eine weitere Datei mit dem Namen job.auto.tfvars und fügen Sie der Datei den folgenden Inhalt hinzu. Diese Datei enthält einen Variablenwert zum Anpassen der Auftragskonfiguration.
```
job_name = "My Job"
```

Schritt 2: Führen Sie die Konfigurationen aus

In diesem Schritt führen Sie die Terraform-Konfigurationen aus, um den Cluster, das Notebook und den Auftrag in Ihrem Azure Databricks-Arbeitsbereich bereitzustellen.

Überprüfen Sie, ob Ihre Terraform-Konfigurationen gültig sind, indem Sie den Befehl terraform validate ausführen. Wenn Fehler gemeldet werden, beheben Sie diese und führen Sie den Befehl erneut aus.
```
terraform validate
```
Überprüfen Sie, was Terraform in Ihrem Arbeitsbereich tun wird, bevor Terraform es tatsächlich tut, indem Sie den Befehl terraform plan ausführen.
```
terraform plan
```
Stellen Sie den Cluster, das Notizbuch und den Auftrag in Ihren Arbeitsbereich bereit, indem Sie den terraform apply Befehl ausführen. Wenn Sie zum Bereitstellen aufgefordert werden, geben Sie yes ein und drücken Sie die Eingabetaste.
```
terraform apply
```
Terraform stellt die Ressourcen bereit, die in Ihrem Projekt angegeben sind. Die Bereitstellung dieser Ressourcen (insbesondere eines Clusters) kann mehrere Minuten dauern.

Schritt 3: Erkunden der Ressourcen

Wenn Sie einen Cluster erstellt haben, kopieren Sie den Link neben terraform applydem Befehl cluster_url und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.
Wenn Sie einen Cluster erstellt haben, kopieren Sie in der Ausgabe des Befehls terraform apply den Link neben notebook_url und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.

Hinweis

Bevor Sie das Notizbuch verwenden, müssen Sie möglicherweise den Inhalt anpassen. Weitere Informationen zum Anpassen des Notizbuchs finden Sie in der zugehörigen Dokumentation.
Wenn Sie einen Cluster erstellt haben, kopieren Sie in der Ausgabe des Befehls terraform apply den Link neben job_url und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.

Hinweis

Bevor Sie das Notizbuch verwenden, müssen Sie möglicherweise den Inhalt anpassen. Unter den Links am Anfang dieses Artikels finden Sie zugehörige Dokumentation zum Anpassen des Notizbuchs.
Wenn Sie einen Job erstellt haben, führen Sie den Job wie folgt aus:
1. Klicken Sie auf der Auftragsseite auf Jetzt ausführen.
2. Nachdem der Auftrag ausgeführt wurde, klicken Sie in der Liste Completed runs (past 60 days) auf der Auftragsseite auf den neuesten Zeiteintrag in der Spalte Start time, um die Ergebnisse der Auftragsausführung anzuzeigen. Der Bereich Output zeigt das Ergebnis, wenn Sie den Code des Notebooks ausführen.

Schritt 4: Bereinigen

In diesem Schritt löschen Sie die vorherigen Ressourcen aus Ihrem Arbeitsbereich.

Überprüfen Sie, was Terraform in Ihrem Arbeitsbereich tun wird, bevor Terraform es tatsächlich tut, indem Sie den Befehl terraform plan ausführen.
```
terraform plan
```
Stellen Sie den Cluster, das Notizbuch und den Auftrag in Ihren Arbeitsbereich bereit, indem Sie den terraform destroy Befehl ausführen. Wenn Sie zum Bereitstellen aufgefordert werden, geben Sie yes ein und drücken Sie die Eingabetaste.
```
terraform destroy
```
Terraform stellt die Ressourcen bereit, die in Ihrem Projekt angegeben sind.

Erstellen von Clustern, Notebooks und Aufträgen mit Terraform

Schritt 1: Erstellen und Konfigurieren des Terraform-Projekts

Schritt 2: Führen Sie die Konfigurationen aus

Schritt 3: Erkunden der Ressourcen

Schritt 4: Bereinigen

Zusätzliche Ressourcen