Skapa kluster, notebook-filer och jobb med Terraform

Artikel
03/01/2024

Den här artikeln visar hur du använder Databricks Terraform-providern för att skapa ett kluster, en notebook-fil och ett jobb på en befintlig Azure Databricks-arbetsyta.

Den här artikeln är ett komplement till följande artiklar om att komma igång med Azure Databricks:

Självstudie: Kör en lakehouse-analyspipeline från slutpunkt till slutpunkt, som använder ett kluster som fungerar med Unity Catalog, en Python-notebook-fil och ett jobb för att köra notebook-filen.
Snabbstart: Kör ett Spark-jobb på Azure Databricks-arbetsytan med hjälp av Azure-portalen, som använder ett allmänt kluster och en Python-notebook-fil.

Du kan också anpassa Terraform-konfigurationerna i den här artikeln för att skapa anpassade kluster, notebook-filer och jobb på dina arbetsytor.

Steg 1: Skapa och konfigurera Terraform-projektet

Skapa ett Terraform-projekt genom att följa anvisningarna i avsnittet Krav i översiktsartikeln för Databricks Terraform-providern.

Skapa ett kluster genom att skapa en fil med namnet cluster.tfoch lägga till följande innehåll i filen. Det här innehållet skapar ett kluster med den minsta mängden resurser som tillåts. Det här klustret använder den senaste versionen av Databricks Runtime Long Term Support (LTS).

För ett kluster som fungerar med Unity Catalog:

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 ett kluster för alla syften:

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
}

Skapa ett kluster genom att skapa en annan fil med namnet cluster.auto.tfvarsoch lägga till följande innehåll i filen. Den här filen innehåller variabelvärden för att anpassa klustret. Ersätt platshållarvärdena med dina egna värden.

För ett kluster som fungerar med Unity Catalog:
```
cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
cluster_data_security_mode      = "SINGLE_USER"
```
För ett kluster för alla syften:
```
cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
```

Skapa en notebook-fil genom att skapa en annan fil med namnet notebook.tfoch lägga till följande innehåll i filen:

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
}

Om du skapar ett kluster sparar du följande notebook-kod i en fil i samma katalog som notebook.tf filen:

För Python-notebook-filen för Självstudie: Kör en lakehouse-analyspipeline från slutpunkt till slutpunkt, en fil med namnet notebook-getting-started-lakehouse-e2e.py med följande innehåll:

# 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ör Python-notebook-filen för snabbstart: Kör ett Spark-jobb på Azure Databricks-arbetsytan med hjälp av Azure-portalen, en fil med namnet notebook-quickstart-create-databricks-workspace-portal.py med följande innehåll:

# 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'))

Om du skapar en notebook-fil skapar du en annan fil med namnet notebook.auto.tfvarsoch lägger till följande innehåll i filen. Den här filen innehåller variabelvärden för att anpassa notebook-konfigurationen.

För Python-notebook-filen för Självstudie: Kör en lakehouse-analyspipeline från slutpunkt till slutpunkt:
```
notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-getting-started-lakehouse-e2e.py"
notebook_language     = "PYTHON"
```
För Python-notebook-filen för snabbstart: Kör ett Spark-jobb på Azure Databricks-arbetsytan med hjälp av Azure-portalen:
```
notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-quickstart-create-databricks-workspace-portal.py"
notebook_language     = "PYTHON"
```
Om du skapar en notebook-fil på din Azure Databricks-arbetsyta måste du konfigurera alla krav för att notebook-filen ska köras korrekt genom att läsa följande anvisningar för:
- Python-notebook-filen för självstudie: Kör en lakehouse-analyspipeline från slutpunkt till slutpunkt
- Python-anteckningsboken för snabbstart: Kör ett Spark-jobb på Azure Databricks-arbetsytan med hjälp av Azure-portalen

Skapa jobbet genom att skapa en annan fil med namnet job.tfoch lägga till följande innehåll i filen. Det här innehållet skapar ett jobb för att köra notebook-filen.

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
}

Om du skapar ett jobb skapar du en annan fil med namnet job.auto.tfvarsoch lägger till följande innehåll i filen. Den här filen innehåller ett variabelvärde för att anpassa jobbkonfigurationen.
```
job_name = "My Job"
```

Steg 2: Kör konfigurationerna

I det här steget kör du Terraform-konfigurationerna för att distribuera klustret, notebook-filen och jobbet till din Azure Databricks-arbetsyta.

Kontrollera om dina Terraform-konfigurationer är giltiga genom att terraform validate köra kommandot . Om några fel rapporteras kan du åtgärda dem och köra kommandot igen.
```
terraform validate
```
Kontrollera vad Terraform kommer att göra på din arbetsyta innan Terraform faktiskt gör det genom att köra terraform plan kommandot .
```
terraform plan
```
Distribuera klustret, notebook-filen och jobbet till din arbetsyta genom att terraform apply köra kommandot . När du uppmanas att distribuera skriver yes du och trycker på Retur.
```
terraform apply
```
Terraform distribuerar de resurser som anges i projektet. Det kan ta flera minuter att distribuera dessa resurser (särskilt ett kluster).

Steg 3: Utforska resultaten

Om du har skapat ett kluster kopierar du länken bredvid cluster_urli kommandots utdata terraform apply och klistrar in den i webbläsarens adressfält.
Om du har skapat en notebook-fil kopierar du länken bredvid notebook_urli kommandots utdata terraform apply och klistrar in den i webbläsarens adressfält.

Kommentar

Innan du använder notebook-filen kan du behöva anpassa dess innehåll. Se den relaterade dokumentationen om hur du anpassar notebook-filen.
Om du har skapat ett jobb kopierar du länken bredvid job_urli kommandots utdata terraform apply och klistrar in den i webbläsarens adressfält.

Kommentar

Innan du kör anteckningsboken kan du behöva anpassa dess innehåll. Se länkarna i början av den här artikeln för relaterad dokumentation om hur du anpassar anteckningsboken.
Om du har skapat ett jobb kör du jobbet på följande sätt:
1. Klicka på Kör nu på jobbsidan.
2. När jobbet har körts klickar du på den senaste tidsposten i kolumnen Starttid i listan Slutförda körningar (senaste 60 dagarna) på jobbsidan för att visa jobbkörningens resultat. Fönstret Utdata visar resultatet av att köra anteckningsbokens kod.

Steg 4: Rensa

I det här steget tar du bort föregående resurser från arbetsytan.

Kontrollera vad Terraform kommer att göra på din arbetsyta innan Terraform faktiskt gör det genom att köra terraform plan kommandot .
```
terraform plan
```
Ta bort klustret, notebook-filen och jobbet från arbetsytan genom att terraform destroy köra kommandot . När du uppmanas att ta bort skriver yes du och trycker på Retur.
```
terraform destroy
```
Terraform tar bort de resurser som anges i projektet.

Skapa kluster, notebook-filer och jobb med Terraform

Steg 1: Skapa och konfigurera Terraform-projektet

Steg 2: Kör konfigurationerna

Steg 3: Utforska resultaten

Steg 4: Rensa

Ytterligare resurser