Clusters, notebooks en taken maken met Terraform

Artikel
03/01/2024

In dit artikel wordt beschreven hoe u de Databricks Terraform-provider gebruikt om een cluster, een notebook en een taak te maken in een bestaande Azure Databricks-werkruimte.

Dit artikel is een aanvulling op de volgende aan de slag-artikelen van Azure Databricks:

Zelfstudie: Een end-to-end lakehouse-analysepijplijn uitvoeren, die gebruikmaakt van een cluster dat werkt met Unity Catalog, een Python-notebook en een taak om het notebook uit te voeren.
Quickstart: Een Spark-taak uitvoeren in Azure Databricks Workspace met behulp van Azure Portal, dat gebruikmaakt van een cluster voor algemeen gebruik en een Python-notebook.

U kunt ook de Terraform-configuraties in dit artikel aanpassen om aangepaste clusters, notebooks en taken in uw werkruimten te maken.

Stap 1: Het Terraform-project maken en configureren

Maak een Terraform-project door de instructies te volgen in het gedeelte Vereisten van het overzichtsartikel van de Databricks Terraform-provider.

Als u een cluster wilt maken, maakt u een bestand met de naam cluster.tfen voegt u de volgende inhoud toe aan het bestand. Met deze inhoud wordt een cluster gemaakt met de kleinste hoeveelheid resources die is toegestaan. Dit cluster maakt gebruik van de laatste Versie van Databricks Runtime Long Term Support (LTS).

Voor een cluster dat werkt met 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
}

Voor een cluster voor alle doeleinden:

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
}

Als u een cluster wilt maken, maakt u een ander bestand met de naam cluster.auto.tfvarsen voegt u de volgende inhoud toe aan het bestand. Dit bestand bevat variabele waarden voor het aanpassen van het cluster. Vervang de tijdelijke aanduidingen door uw eigen waarden.

Voor een cluster dat werkt met Unity Catalog:
```
cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
cluster_data_security_mode      = "SINGLE_USER"
```
Voor een cluster voor alle doeleinden:
```
cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
```

Als u een notitieblok wilt maken, maakt u een ander bestand met de naam notebook.tfen voegt u de volgende inhoud toe aan het bestand:

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
}

Als u een cluster maakt, slaat u de volgende notebookcode op in een bestand in dezelfde map als het notebook.tf bestand:

Voor het Python-notebook voor zelfstudie: Voer een end-to-end lakehouse-analysepijplijn uit, een bestand notebook-getting-started-lakehouse-e2e.py met de volgende inhoud:

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

Voor de Python-notebook voor quickstart: Een Spark-taak uitvoeren in Azure Databricks Workspace met behulp van Azure Portal, een bestand notebook-quickstart-create-databricks-workspace-portal.py met de volgende inhoud:

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

Als u een notitieblok maakt, maakt u een ander bestand met de naam notebook.auto.tfvarsen voegt u de volgende inhoud toe aan het bestand. Dit bestand bevat variabele waarden voor het aanpassen van de notebookconfiguratie.

Voor het Python-notebook voor zelfstudie: Een end-to-end lakehouse-analysepijplijn uitvoeren:
```
notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-getting-started-lakehouse-e2e.py"
notebook_language     = "PYTHON"
```
Voor de Python-notebook voor quickstart: Een Spark-taak uitvoeren in Azure Databricks Workspace met behulp van Azure Portal:
```
notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-quickstart-create-databricks-workspace-portal.py"
notebook_language     = "PYTHON"
```
Als u een notebook maakt, moet u in uw Azure Databricks-werkruimte eventuele vereisten instellen voor het uitvoeren van het notebook, door te verwijzen naar de volgende instructies voor:
- Het Python-notebook voor zelfstudie: Een end-to-end lakehouse-analysepijplijn uitvoeren
- Het Python-notebook voor quickstart: Een Spark-taak uitvoeren in Azure Databricks Workspace met behulp van Azure Portal

Als u de taak wilt maken, maakt u een ander bestand met de naam job.tfen voegt u de volgende inhoud toe aan het bestand. Met deze inhoud maakt u een taak om het notebook uit te voeren.

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

variable "task_key" {
  description = "A name for the task."
  type        = string
  default     = "my_task"
}

resource "databricks_job" "this" {
  name = var.job_name
  task {
    task_key = var.task_key
    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
}

Als u een taak maakt, maakt u een ander bestand met de naam job.auto.tfvarsen voegt u de volgende inhoud toe aan het bestand. Dit bestand bevat een variabele waarde voor het aanpassen van de taakconfiguratie.
```
job_name = "My Job"
task_key = "my_task"
```

Stap 2: de configuraties uitvoeren

In deze stap voert u de Terraform-configuraties uit om het cluster, het notebook en de taak te implementeren in uw Azure Databricks-werkruimte.

Controleer of uw Terraform-configuraties geldig zijn door de opdracht uit te terraform validate voeren. Als er fouten worden gerapporteerd, herstelt u deze en voert u de opdracht opnieuw uit.
```
terraform validate
```
Controleer of Terraform in uw werkruimte zal doen voordat Terraform dit daadwerkelijk doet door de opdracht uit te terraform plan voeren.
```
terraform plan
```
Implementeer het cluster, het notebook en de taak in uw werkruimte door de opdracht uit te terraform apply voeren. Wanneer u wordt gevraagd om te implementeren, typt yes u en drukt u op Enter.
```
terraform apply
```
Terraform implementeert de resources die zijn opgegeven in uw project. Het implementeren van deze resources (met name een cluster) kan enkele minuten duren.

Stap 3: De resultaten verkennen

Als u een cluster hebt gemaakt, kopieert u in de uitvoer van de terraform apply opdracht de koppeling naast cluster_urlen plakt u deze in de adresbalk van uw webbrowser.
Als u een notitieblok hebt gemaakt, kopieert u in de uitvoer van de terraform apply opdracht de koppeling naast notebook_urlen plakt u deze in de adresbalk van uw webbrowser.

Notitie

Voordat u het notitieblok gebruikt, moet u mogelijk de inhoud ervan aanpassen. Zie de gerelateerde documentatie over het aanpassen van het notitieblok.
Als u een taak hebt gemaakt, kopieert u in de uitvoer van de terraform apply opdracht de koppeling naast job_urlen plakt u deze in de adresbalk van uw webbrowser.

Notitie

Voordat u het notebook uitvoert, moet u mogelijk de inhoud ervan aanpassen. Zie de koppelingen aan het begin van dit artikel voor verwante documentatie over het aanpassen van het notitieblok.
Als u een taak hebt gemaakt, voert u de taak als volgt uit:
1. Klik op Nu uitvoeren op de taakpagina.
2. Nadat de taak is uitgevoerd, klikt u in de lijst Voltooide uitvoeringen (afgelopen 60 dagen) op de taakpagina op de meest recente tijdvermelding in de kolom Begintijd om de resultaten van de taakuitvoering weer te geven. In het deelvenster Uitvoer ziet u het resultaat van het uitvoeren van de code van het notebook.

Stap 4: Opschonen

In deze stap verwijdert u de voorgaande resources uit uw werkruimte.

Controleer of Terraform in uw werkruimte zal doen voordat Terraform dit daadwerkelijk doet door de opdracht uit te terraform plan voeren.
```
terraform plan
```
Verwijder het cluster, het notebook en de taak uit uw werkruimte door de opdracht uit te terraform destroy voeren. Wanneer u wordt gevraagd om te verwijderen, typt yes u en drukt u op Enter.
```
terraform destroy
```
Terraform verwijdert de resources die zijn opgegeven in uw project.

Share via