Pular para o conteúdo principal

Criar clustering, Notebook e Job com Terraform

Este artigo mostra como usar o provedorDatabricks Terraform para criar um clustering, um Notebook e um Job em um Databricks existente. workspace.

Este artigo é um complemento do seguinte Databricks getting começar artigos:

O senhor também pode adaptar as configurações do Terraform neste artigo para criar clustering, Notebook e Job personalizados em seu espaço de trabalho.

Etapa 1: Criar e configurar o projeto Terraform​

  1. Crie um projeto Terraform seguindo as instruções na seção Requirements (Requisitos) dos artigos de visão geral do provedor Databricks Terraform .

  2. Para criar um clustering, crie um arquivo chamado cluster.tf e adicione o seguinte conteúdo ao arquivo. Esse conteúdo cria um clustering com a menor quantidade de recurso permitida. Esse clustering usa a versão mais recente do Databricks Runtime Long Term Support (LTS).

    Para um clustering que funcione com 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
}

Para um clusters todo-propósito:

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
}

  1. Para criar um clustering, crie outro arquivo chamado cluster.auto.tfvars e adicione o seguinte conteúdo ao arquivo. Esse arquivo contém valores variáveis para personalizar o clustering. Substitua os valores do espaço reservado pelos seus próprios valores.

    Para um clustering que funcione com Unity Catalog:

cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
cluster_data_security_mode      = "SINGLE_USER"

Para um clusters todo-propósito:

cluster_name                    = "My Cluster"
cluster_autotermination_minutes = 60
cluster_num_workers             = 1
  1. Para criar um Notebook, crie outro arquivo chamado notebook.tf e adicione o seguinte conteúdo ao arquivo:
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
}

  1. Se estiver criando um clustering, salve o seguinte código do Notebook em um arquivo no mesmo diretório do arquivo notebook.tf:

    Para o Notebook Python para execução de sua primeira carga de trabalho ETL em Databricks, um arquivo chamado notebook-getting-started-etl-quick-start.py com o seguinte conteúdo:

# Databricks notebook source
# Import functions
from pyspark.sql.functions import col, current_timestamp

# Define variables used in code below
file_path = "/databricks-datasets/structured-streaming/events"
username = spark.sql("SELECT regexp_replace(current_user(), '[^a-zA-Z0-9]', '_')").first()[0]
table_name = f"{username}_etl_quickstart"
checkpoint_path = f"/tmp/{username}/_checkpoint/etl_quickstart"

# Clear out data from previous demo execution
spark.sql(f"DROP TABLE IF EXISTS {table_name}")
dbutils.fs.rm(checkpoint_path, True)

# 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)
  .toTable(table_name))

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

df = spark.read.table(table_name)

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

display(df)

Para o SQL Notebook for Get começar: Consultar e visualizar dados de um Notebook, um arquivo chamado notebook-getting-started-quick-start.sql com o seguinte conteúdo:

-- Databricks notebook source
-- MAGIC %python
-- MAGIC diamonds = (spark.read
-- MAGIC   .format("csv")
-- MAGIC   .option("header", "true")
-- MAGIC   .option("inferSchema", "true")
-- MAGIC   .load("/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv")
-- MAGIC )
-- MAGIC 
-- MAGIC diamonds.write.format("delta").save("/mnt/delta/diamonds")

-- COMMAND ----------

DROP TABLE IF EXISTS diamonds;

CREATE TABLE diamonds USING DELTA LOCATION '/mnt/delta/diamonds/'

-- COMMAND ----------

SELECT color, avg(price) AS price FROM diamonds GROUP BY color ORDER BY COLOR

Para o Python Notebook for tutorial: execution an end-to-end lakehouse analítica pipeline, um arquivo chamado notebook-getting-started-lakehouse-e2e.py com o seguinte conteúdo:

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

  1. Se estiver criando um Notebook, crie outro arquivo chamado notebook.auto.tfvars e adicione o seguinte conteúdo ao arquivo. Esse arquivo contém valores variáveis para personalizar a configuração do Notebook.

    Para o Python Notebook para execução de sua primeira carga de trabalho ETL em Databricks:

notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-getting-started-etl-quick-start.py"
notebook_language     = "PYTHON"

Para o SQL Notebook for Get Começar: Consultar e visualizar dados de um Notebook:

notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-getting-started-quickstart.sql"
notebook_language     = "SQL"

Para o Python Notebook para tutorial: execução de uma lakehouse analítica de ponta a ponta pipeline:

notebook_subdirectory = "Terraform"
notebook_filename     = "notebook-getting-started-lakehouse-e2e.py"
notebook_language     = "PYTHON"

  1. Se estiver criando um Notebook, em seu Databricks workspace, certifique-se de configurar todos os requisitos para que o Notebook seja executado com êxito, consultando as instruções a seguir:

  2. Para criar o Job, crie outro arquivo chamado job.tf e adicione o seguinte conteúdo ao arquivo. Esse conteúdo cria um Job para executar o Notebook.

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
}
  1. Se estiver criando um trabalho, crie outro arquivo chamado job.auto.tfvars e adicione o seguinte conteúdo ao arquivo. Esse arquivo contém um valor variável para personalizar a configuração do trabalho.
job_name = "My Job"
task_key = "my_task"

Etapa 2: execução das configurações​

Nesta passo, você executa as configurações do Terraform para aprimorar os clusters, o Notebook e o Job em seu workspace do Databricks.

  1. Para verificar se as configurações do Terraform são válidas, execute o comando terraform validate. Se algum erro for relatado, corrija-o e execute o comando novamente.

    Bash
    terraform validate

  2. Verifique o que Terraform fará em seu workspace, antes que Terraform realmente o faça, executando o comando terraform plan.

    Bash
    terraform plan

  3. Implante o clustering, o Notebook e o Job em seu site workspace executando o comando terraform apply. Quando solicitado a implantá-lo, digite yes e pressione Enter .

    Bash
    terraform apply

    Terraform implantado o recurso que está especificado em seu projeto. A implantação desses recursos (especialmente um clustering) pode levar vários minutos.

Etapa 3: explore os resultados​

  1. Se o senhor criou um clustering, na saída do comando terraform apply, copie o link ao lado de cluster_url e cole-o na barra de endereços do navegador da Web.

  2. Se o senhor criou um Notebook, na saída do comando terraform apply, copie o link ao lado de notebook_url e cole-o na barra de endereços do navegador da Web.

nota

Antes de usar o Notebook, talvez seja necessário personalizar seu conteúdo. Consulte a documentação relacionada sobre como personalizar o Notebook.

  1. Se o senhor criou um Job, na saída do comando terraform apply, copie o link ao lado de job_url e cole-o na barra de endereços do navegador da Web.
nota

Antes de executar o Notebook, talvez o senhor precise personalizar seu conteúdo. Consulte os links no início deste artigo para obter documentação relacionada sobre como personalizar o Notebook.

  1. Se o senhor criou um Job, execute-o da seguinte forma:

    1. Clique em executar agora na página do trabalho.
    2. Depois que o trabalho terminar de ser executado, para view os resultados da execução do trabalho, na lista Execução concluída (últimos 60 dias) na página do trabalho, clique na entrada de tempo mais recente na coluna de tempo inicial . O painel Output mostra o resultado da execução do código do Notebook.

Etapa 4: limpar​

Nesta passo, você exclui os recursos anteriores de seu workspace.

  1. Verifique o que Terraform fará em seu workspace, antes que Terraform realmente o faça, executando o comando terraform plan.

    Bash
    terraform plan

  2. Exclua o clustering, o Notebook e o Job do site workspace executando o comando terraform destroy. Quando solicitado a excluir, digite yes e pressione Enter .

    Bash
    terraform destroy

    Terraform exclui o recurso especificado em seu projeto.

Última atualização em