Databricks fundamental: Unity Catalog, Jobs và Orchestration

- 26 mins

Bài viết này tổng hợp những kiến thức nền tảng khi làm việc với Databricks, đi theo thứ tự: cách tổ chức data với Unity Catalog, cách xây dựng một Job (workflow), cách orchestrate các task, cách chọn compute, và cuối cùng là các best practices khi đưa pipeline lên production.

Các ví dụ trong bài ưu tiên hai hướng triển khai:

Unity Catalog và data namespace

Catalog → Schema → Table/Volume

Catalog → Schema → Tables/Volumes là đường dẫn bạn sẽ dùng mỗi khi làm việc với data trong Databricks. Đây là namespace ba cấp (catalog.schema.object) giúp Unity Catalog mạnh về governance và security.

Unity Catalog là gì

Unity Catalog là lớp governance tập trung của Databricks cho toàn bộ data và AI asset. Nó quản lý:

Khi bạn tạo một table trong một schema, Unity Catalog tự động ghi nhận owner, thời điểm tạo và quyền truy cập.

Một vài câu lệnh cơ bản

Khám phá cấu trúc:

SHOW CATALOGS;
SHOW SCHEMAS IN dev;
SHOW TABLES IN dev.sales;
SHOW VOLUMES IN dev.sales;

-- Liệt kê file trong volume
LIST '/Volumes/dev/sales/raw_files/';

Đọc file thô từ volume và tạo table bằng CTAS (CREATE TABLE AS SELECT):

CREATE OR REPLACE TABLE dev.sales.orders_bronze AS
SELECT *
FROM read_files(
  '/Volumes/dev/sales/raw_files/orders/',
  format => 'csv',
  header => true
);

Khi đọc file bằng read_files (hoặc Auto Loader), những dòng/cột không khớp với schema sẽ không bị mất mà được đưa vào cột _rescued_data dưới dạng JSON. Đây là cách để phát hiện schema drift hay dữ liệu bẩn mà không làm fail pipeline:

-- Tìm các record có dữ liệu không parse được
SELECT * FROM dev.sales.orders_bronze
WHERE _rescued_data IS NOT NULL;

Khai báo schema và volume bằng bundle

Thay vì tạo tay bằng UI, ta khai báo schema và volume trong databricks.yml:

bundle:
  name: sales_pipeline

targets:
  dev:
    mode: development
    default: true
    workspace:
      host: https://<workspace-dev>.cloud.databricks.com
  prod:
    mode: production
    workspace:
      host: https://<workspace-prod>.cloud.databricks.com

resources:
  schemas:
    sales:
      catalog_name: ${bundle.target}
      name: sales
      comment: "Data domain sales"
      grants:
        - principal: data-analysts
          privileges: [USE_SCHEMA, SELECT]

  volumes:
    raw_files:
      catalog_name: ${bundle.target}
      schema_name: ${resources.schemas.sales.name}
      name: raw_files
      comment: "Landing zone cho file thô"

Lưu ý: ở mode: development, bundle tự thêm prefix (dạng dev_<user>_) vào tên các resource không phải file/notebook như job, schema, volume. Vì vậy đừng hard-code đường dẫn /Volumes/dev/sales/... trong job, hãy tham chiếu ${resources.schemas.sales.name} như ví dụ bên dưới. Catalog dev/prod ở đây giả định đã tồn tại sẵn.

Cách làm này giúp tên catalog tự đổi theo target (dev, prod) và quyền truy cập được version control cùng với code.

Làm việc với Unity Catalog bằng SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import VolumeType

w = WorkspaceClient()

# Liệt kê catalog và schema
for c in w.catalogs.list():
    print(c.name)

for s in w.schemas.list(catalog_name="dev"):
    print(s.full_name)

# Tạo schema và managed volume
w.schemas.create(name="sales", catalog_name="dev", comment="Data domain sales")
w.volumes.create(
    catalog_name="dev",
    schema_name="sales",
    name="raw_files",
    volume_type=VolumeType.MANAGED,
)

# Upload file vào volume
with open("orders.csv", "rb") as f:
    w.files.upload("/Volumes/dev/sales/raw_files/orders/orders.csv", f, overwrite=True)

Cấu trúc của một Job

Job và Task

Nói cách khác: job quyết định khi nào và với cấu hình chung nào workflow chạy, còn task quyết định làm gì.

Các loại task được hỗ trợ

Một task có thể là:

Hai loại phổ biến nhất khi mới bắt đầu là notebook task và SQL task:

  Notebook task SQL task
Nguồn code Workspace hoặc Git SQL file, saved query, alert, dashboard
Compute Job cluster, serverless, all-purpose SQL warehouse
Option chính notebook_path, source, base_parameters warehouse_id, file/query, parameters

Các ngôn ngữ được hỗ trợ

Databricks hỗ trợ Python, SQL, Scala và R trong notebook, Java qua JAR task. Trong thực tế data engineer dùng Python và SQL nhiều nhất.

Ví dụ: job có notebook task và SQL task (bundle)

resources:
  jobs:
    daily_sales:
      name: daily_sales   # mode development tự thêm prefix [dev <user>]

      parameters:
        - name: catalog
          default: ${bundle.target}

      tasks:
        - task_key: ingest
          notebook_task:
            notebook_path: ../src/ingest.py
            base_parameters:
              source_path: /Volumes/${bundle.target}/${resources.schemas.sales.name}/${resources.volumes.raw_files.name}/orders/

        - task_key: aggregate
          depends_on:
            - task_key: ingest
          sql_task:
            warehouse_id: ${var.warehouse_id}
            file:
              path: ../src/aggregate_daily.sql
            parameters:
              catalog: ""

Deploy và chạy:

databricks bundle validate
databricks bundle deploy -t dev
databricks bundle run daily_sales -t dev

Ví dụ: tạo job tương tự bằng SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service import jobs

w = WorkspaceClient()

created = w.jobs.create(
    name="daily_sales",
    parameters=[jobs.JobParameterDefinition(name="catalog", default="dev")],
    tasks=[
        jobs.Task(
            task_key="ingest",
            notebook_task=jobs.NotebookTask(
                notebook_path="/Workspace/Users/me/ingest",
                base_parameters={"source_path": "/Volumes/dev/sales/raw_files/orders/"},
            ),
        ),
        jobs.Task(
            task_key="aggregate",
            depends_on=[jobs.TaskDependency(task_key="ingest")],
            sql_task=jobs.SqlTask(
                warehouse_id="<warehouse-id>",
                file=jobs.SqlTaskFile(path="/Workspace/Users/me/aggregate_daily.sql"),
            ),
        ),
    ],
)

run = w.jobs.run_now(job_id=created.job_id).result()  # chờ run kết thúc
print(run.state.result_state)

Compute cho Job

Có 4 loại compute chính:

Với serverless job còn có hai performance mode:

Hai mode này chỉ áp dụng cho task chạy trên serverless, không áp dụng cho classic compute hay SQL warehouse. Trong bundle, khai báo bằng performance_target: STANDARD hoặc PERFORMANCE_OPTIMIZED ngay trên job.

Chọn compute cho từng task

Mỗi task có thể gán compute riêng; các task trong cùng job có thể dùng chung compute hoặc dùng compute khác nhau.

flowchart LR
    A[ingest<br/>job cluster A] --> B[transform<br/>job cluster A]
    B --> C[aggregate<br/>SQL warehouse]
    B --> D[ml_features<br/>serverless]

Ví dụ bundle với job cluster dùng chung và task serverless:

resources:
  jobs:
    mixed_compute:
      name: mixed_compute

      job_clusters:
        - job_cluster_key: shared_etl
          new_cluster:
            spark_version: 16.4.x-scala2.13
            node_type_id: i3.xlarge
            runtime_engine: PHOTON
            autoscale:
              min_workers: 2
              max_workers: 8

      tasks:
        - task_key: ingest
          job_cluster_key: shared_etl
          notebook_task:
            notebook_path: ../src/ingest.py

        - task_key: transform
          depends_on: [{ task_key: ingest }]
          job_cluster_key: shared_etl          # dùng lại cluster, không phải start lại
          notebook_task:
            notebook_path: ../src/transform.py

        - task_key: ml_features               # không khai báo cluster => chạy serverless
          depends_on: [{ task_key: transform }]
          notebook_task:
            notebook_path: ../src/ml_features.py

        - task_key: aggregate
          depends_on: [{ task_key: transform }]
          sql_task:                             # chạy trên SQL warehouse
            warehouse_id: ${var.warehouse_id}
            file:
              path: ../src/aggregate.sql

Lưu ý: tuỳ cấu hình workspace, task không chỉ định cluster sẽ chạy serverless. Tên spark_version và node_type_id ở trên chỉ là ví dụ, cần đổi theo cloud và runtime bạn đang dùng.

Task orchestration

DAG là khái niệm chung để biểu diễn một chuỗi hoạt động xử lý data gồm nhiều task: mỗi node là một task, mỗi cạnh là một dependency. Databricks dùng DAG để quyết định task nào chạy tuần tự, task nào chạy song song.

Có thể orchestrate bằng nhiều cách: UI, REST API, SQL, bundles và SDK. Dưới đây là cùng một workflow nhỏ ở mỗi cách.

1. Declarative Automation Bundles (khuyến nghị cho production): xem các ví dụ YAML phía trên, kết hợp CI/CD.

2. Databricks SDK:

w.jobs.run_now(job_id=123, job_parameters={"catalog": "prod"})

3. CLI/REST API:

databricks jobs run-now 123 --json '{"job_parameters": {"catalog": "prod"}}'

4. SQL: khi cần chạy một pipeline được khai báo sẵn bằng SQL, ví dụ refresh materialized view hoặc streaming table, hoặc dùng SQL task như một bước trong job như ví dụ trên.

5. UI: phù hợp để thử nhanh, kéo thả task, xem DAG và debug.

Các pattern workflow phổ biến

flowchart LR
    subgraph Sequence
      b1[bronze] --> s1[silver] --> g1[gold]
    end
    subgraph Funnel
      a[source A] --> m[merge]
      b[source B] --> m
      c[source C] --> m
    end
    subgraph Fan-out
      i[ingest] --> d1[downstream 1]
      i --> d2[downstream 2]
      i --> d3[downstream 3]
    end

Ví dụ funnel pattern trong bundle: ba task ingest chạy song song (không có depends_on), task merge chờ cả ba:

tasks:
  - task_key: ingest_a
    notebook_task: { notebook_path: ../src/ingest_a.py }
  - task_key: ingest_b
    notebook_task: { notebook_path: ../src/ingest_b.py }
  - task_key: ingest_c
    notebook_task: { notebook_path: ../src/ingest_c.py }
  - task_key: merge
    depends_on:
      - task_key: ingest_a
      - task_key: ingest_b
      - task_key: ingest_c
    notebook_task: { notebook_path: ../src/merge.py }

Tạo và schedule Job

Các option cấu hình chung của task

Parameters

Task parameters (key-value) hỗ trợ các kịch bản nâng cao:

Job parameters áp dụng tự động cho mọi task trong job, ghi đè task parameter cùng tên và có thể override lúc trigger run.

Các dynamic value reference thường dùng: ,, ,.

Truy cập parameter trong task: với notebook dùng dbutils.widgets.get, cách đọc khác nhau tuỳ loại task (notebook, SQL, Python wheel, …).

# notebook task
catalog = dbutils.widgets.get("catalog")

Task values: truyền kết quả giữa các task

Task values được tạo trong lúc chạy nên rất phù hợp với quyết định phụ thuộc kết quả xử lý: số record để kiểm tra data quality, đường dẫn file sinh động, thống kê để monitor, hoặc tiêu chí cho conditional logic.

# Task "ingest": set giá trị
dbutils.jobs.taskValues.set(key="row_count", value=df.count())
# Task khác: đọc giá trị
row_count = dbutils.jobs.taskValues.get(
    taskKey="ingest",
    key="row_count",
    default=0,
    debugValue=0,   # dùng khi chạy notebook ngoài job
)

Hoặc tham chiếu trực tiếp trong cấu hình bundle:

- task_key: report
  depends_on: [{ task_key: ingest }]
  notebook_task:
    notebook_path: ../src/report.py
    base_parameters:
      rows: ""

Retries và timeout

- task_key: ingest
  max_retries: 3
  min_retry_interval_millis: 60000    # chờ 1 phút giữa các lần retry
  retry_on_timeout: true
  timeout_seconds: 3600
  notebook_task:
    notebook_path: ../src/ingest.py

Notification alerts

resources:
  jobs:
    daily_sales:
      email_notifications:
        on_failure: [data-team@example.com]
        on_duration_warning_threshold_exceeded: [data-team@example.com]

      webhook_notifications:
        on_failure:
          - id: <notification-destination-id>   # Slack/PagerDuty... đã tạo trong workspace

      health:
        rules:
          - metric: RUN_DURATION_SECONDS
            op: GREATER_THAN
            value: 3600                          # cảnh báo nếu chạy quá 1 giờ

Triggers

Trigger là rule tự động khởi động một run dựa trên điều kiện hoặc lịch.

Trigger giúp job chạy mà không cần can thiệp thủ công.

Ví dụ bundle:

# Scheduled
schedule:
  quartz_cron_expression: "0 0 6 * * ?"   # 6:00 mỗi ngày
  timezone_id: Asia/Ho_Chi_Minh
  pause_status: UNPAUSED
# File arrival
trigger:
  pause_status: UNPAUSED
  file_arrival:
    url: /Volumes/prod/sales/raw_files/orders/
    min_time_between_triggers_seconds: 300
# Table update
trigger:
  pause_status: UNPAUSED
  table_update:
    table_names:
      - prod.sales.orders_bronze
    condition: ANY_UPDATED
# Continuous
continuous:
  pause_status: UNPAUSED

Một job chỉ dùng một trong các kiểu schedule, trigger hoặc continuous.

Tương tự bằng SDK:

from databricks.sdk.service import jobs

w.jobs.update(
    job_id=123,
    new_settings=jobs.JobSettings(
        trigger=jobs.TriggerSettings(
            pause_status=jobs.PauseStatus.UNPAUSED,
            file_arrival=jobs.FileArrivalTriggerConfiguration(
                url="/Volumes/prod/sales/raw_files/orders/",
                min_time_between_triggers_seconds=300,
            ),
        )
    ),
)

Conditional và iterative task

tasks:
  - task_key: ingest
    notebook_task:
      notebook_path: ../src/ingest.py     # set task value row_count

  # If/else: chỉ xử lý tiếp khi có data
  - task_key: has_data
    depends_on: [{ task_key: ingest }]
    condition_task:
      op: GREATER_THAN
      left: ""
      right: "0"

  - task_key: transform
    depends_on:
      - task_key: has_data
        outcome: "true"
    notebook_task:
      notebook_path: ../src/transform.py

  # For each: xử lý song song nhiều region
  - task_key: export_by_region
    depends_on: [{ task_key: transform }]
    for_each_task:
      inputs: '["apac", "emea", "amer"]'
      concurrency: 3
      task:
        task_key: export_region
        notebook_task:
          notebook_path: ../src/export.py
          base_parameters:
            region: ""

  # Run if: luôn chạy để gửi thông báo, kể cả khi task phía trước fail
  - task_key: cleanup
    depends_on: [{ task_key: export_by_region }]
    run_if: ALL_DONE
    notebook_task:
      notebook_path: ../src/cleanup.py
flowchart LR
    ingest --> has_data{row_count > 0?}
    has_data -- true --> transform --> export_by_region[for each region] --> cleanup
    has_data -- false --> cleanup

Xử lý lỗi và monitoring

Xử lý lỗi không chỉ là chạy lại task, mà là xây dựng hệ thống có khả năng phục hồi hiệu quả và giữ data nhất quán khi một thành phần bị lỗi.

Repair run

Repair run cho phép chạy lại chỉ những task bị fail (và các task phụ thuộc chúng), thay vì chạy lại cả job. Ta có thể sửa task hoặc override parameter rồi chạy lại, giúp giảm thời gian và chi phí phục hồi.

Trên UI: click vào task bị fail rồi chọn Repair run. Bằng SDK:

run = w.jobs.get_run(run_id=456)

if run.state.result_state == jobs.RunResultState.FAILED:
    w.jobs.repair_run(
        run_id=456,
        rerun_all_failed_tasks=True,
        job_parameters={"catalog": "prod"},   # có thể override parameter khi repair
    ).result()

Monitoring hiệu năng job

-- Các run thất bại trong 7 ngày gần nhất
SELECT job_id, run_id, result_state, period_start_time
FROM system.lakeflow.job_run_timeline
WHERE result_state IN ('FAILED', 'ERROR', 'TIMED_OUT')
  AND period_start_time >= current_date() - INTERVAL 7 DAYS
ORDER BY period_start_time DESC;

Best practices

Ba nguyên tắc chính: chọn compute đúng để tối ưu performance/cost theo yêu cầu vận hành, thiết kế modular để dễ maintain và tái sử dụng, và dùng Git + CI/CD để triển khai nhất quán.

Compute và pricing

Với classic compute, chi phí gồm:

Serverless gộp phần lớn các khoản trên vào một đơn giá DBU, giảm đáng kể operational cost.

Modular design

Chọn kiến trúc phù hợp để deploy: một job lớn nên chia thành các DAG nhỏ hơn bằng run job task, để dễ quản lý và tái sử dụng.

- task_key: run_silver_layer
  depends_on: [{ task_key: run_bronze_layer }]
  run_job_task:
    job_id: ${resources.jobs.silver_layer.id}

Jobs và Git

Job hỗ trợ chạy notebook trực tiếp từ Git, giúp:

Cách cấu hình: tạo task với Git provider là source, sau đó chỉ định đường dẫn tới notebook chính tính từ root của repository.

resources:
  jobs:
    daily_sales:
      name: daily_sales
      git_source:
        git_url: https://github.com/my-org/sales-pipeline
        git_provider: gitHub
        git_branch: main
      tasks:
        - task_key: ingest
          notebook_task:
            notebook_path: src/ingest      # đường dẫn từ root repo
            source: GIT

Với bundle, bản thân databricks.yml đã nằm trong repo, nên workflow CI/CD điển hình là: merge vào main → databricks bundle validate → databricks bundle deploy -t prod.

Tổng hợp

Compute và cost optimization

Vận hành và thiết kế workflow

Monitoring và governance

Dev Diary

Dev Diary

Software & Data Engineer. Ghi lại những gì mình học được.

comments powered by Disqus
rss facebook twitter github gitlab youtube mail spotify lastfm instagram linkedin google google-plus pinterest medium vimeo stackoverflow reddit quora quora