Typische configuratie van een Lakebase-project met Terraform

Op deze pagina ziet u een volledige Terraform-configuratie voor een automatisch schalend Lakebase-project met de meest gebruikte functies:

  • Beveiligde productiebranch
  • Eindpunt voor lezen en schrijven met hoge beschikbaarheid (HA) en leesbare secundaire replica’s
  • Service-principal met DATABRICKS_SUPERUSER databasebevoegdheden
  • Postgres-database die eigendom is van een app
  • Postgres-database geregistreerd in Unity Catalog voor Lakehouse Federation-query’s vanuit Databricks SQL en notebooks
  • Gesynchroniseerde tabelstreaming continu vanuit Unity Catalog
  • Databricks App verbonden met het Lakebase-project

Zie Aan de slag met Terraform voor Lakebase voor een stapsgewijze inleiding tot Terraform met Lakebase.

Prerequisites

Voordat u begint, moet u het volgende hebben:

Configuratie voltooien

Wanneer u een project maakt, maakt Azure Databricks automatisch een production vertakking, een primary eindpunt voor lezen/schrijven, een postgres-rol van eigenaar die is gekoppeld aan uw identiteit en een databricks_postgres database. Als u deze impliciet gemaakte resources wilt configureren, declareert u ze in Terraform met replace_existing = true. Zie databricks_postgres_branch, databricks_postgres_endpoint, databricks_postgres_role en databricks_postgres_database voor meer informatie.

Warning

Deze configuratie stelt is_protected = true in op de production branch en bevat een unprotect_for_destroy-variabele die is opgenomen in de branchspecificatie. Terraform kan een project met beveiligde vertakkingen niet verwijderen en de vertakking kan niet rechtstreeks worden verwijderd omdat de production levenscyclus wordt beheerd door het project. Als u resources schoon wilt verwijderen, gebruikt u een tweestapsvernietiging:

# Step 1: unprotect the branch
terraform apply -var="unprotect_for_destroy=true"

# Step 2: destroy all resources
terraform destroy -var="unprotect_for_destroy=true"

Na het uitvoeren van terraform destroy wordt het project zacht verwijderd en 7 dagen bewaard voordat het definitief wordt verwijderd. Als u het onmiddellijk definitief wilt verwijderen, stelt u purge_on_delete = true in voor de resource databricks_postgres_project voordat u destroy uitvoert.

variable "admin_sp_app_id" {
  description = "Application ID of the service principal to grant admin access"
  type        = string
}

variable "unprotect_for_destroy" {
  description = "Set to true before destroy to unprotect the production branch"
  type        = bool
  default     = false
}

# Project — top-level container for branches, endpoints, databases, and roles.
resource "databricks_postgres_project" "this" {
  project_id = "my-lakebase-project"
  # purge_on_delete = true  # Uncomment to permanently delete on destroy (default: soft delete, 7-day retention).
  spec = {
    pg_version   = 17
    display_name = "My Lakebase Project"
    default_endpoint_settings = {
      autoscaling_limit_min_cu = 0.5
      autoscaling_limit_max_cu = 4.0
      suspend_timeout_duration = "300s"
    }
  }
}

# Configure the implicitly created production branch as protected.
resource "databricks_postgres_branch" "production" {
  branch_id = "production"
  parent    = databricks_postgres_project.this.name
  spec = {
    no_expiry    = true
    is_protected = var.unprotect_for_destroy ? false : true
  }
  replace_existing = true
}

# Configure the implicitly created primary endpoint with HA.
# HA requires no_suspension = true. group.min = 2 adds a standby for automatic failover.
resource "databricks_postgres_endpoint" "primary" {
  endpoint_id = "primary"
  parent      = databricks_postgres_branch.production.name
  spec = {
    endpoint_type            = "ENDPOINT_TYPE_READ_WRITE"
    autoscaling_limit_min_cu = 0.5
    autoscaling_limit_max_cu = 4.0
    no_suspension            = true
    group = {
      min                         = 2
      max                         = 2
      enable_readable_secondaries = true
    }
  }
  replace_existing = true
}

# Grant workspace-level CAN_MANAGE on the project to the service principal.
# Use status.project_id (bare ID) not .name (full resource path) — the permissions
# API rejects the full path with a "resource type not found" error.
resource "databricks_permissions" "project" {
  database_project_name = databricks_postgres_project.this.status.project_id
  access_control {
    service_principal_name = var.admin_sp_app_id
    permission_level       = "CAN_MANAGE"
  }
}

# Create a Postgres role backed by the service principal with full database privileges.
# depends_on serializes creation — Lakebase processes one branch operation at a time.
resource "databricks_postgres_role" "admin_sp" {
  role_id = "admin-sp"
  parent  = databricks_postgres_branch.production.name
  spec = {
    identity_type    = "SERVICE_PRINCIPAL"
    postgres_role    = var.admin_sp_app_id
    auth_method      = "LAKEBASE_OAUTH_V1"
    membership_roles = ["DATABRICKS_SUPERUSER"]
    attributes = {
      createdb   = true
      createrole = true
      bypassrls  = true
    }
  }
  depends_on = [databricks_postgres_endpoint.primary]
}

# Create a Postgres database owned by the admin SP role.
resource "databricks_postgres_database" "app" {
  database_id = "app"
  parent      = databricks_postgres_branch.production.name
  spec = {
    postgres_database = "app"
    role              = databricks_postgres_role.admin_sp.name
  }
}

# Register the Postgres database in Unity Catalog. This makes the database queryable
# from Databricks SQL and notebooks through Lakehouse Federation, and serves as the
# parent namespace for synced tables that live inside the Lakebase Catalog.
# create_database_if_missing is set explicitly because the database is managed by
# the databricks_postgres_database resource above.
resource "databricks_postgres_catalog" "app_catalog" {
  catalog_id = "app_catalog"
  spec = {
    postgres_database          = databricks_postgres_database.app.status.postgres_database
    branch                     = databricks_postgres_branch.production.name
    create_database_if_missing = false
  }
}

# Sync a Unity Catalog Delta table into the Lakebase database continuously.
# Prefixing synced_table_id with the Lakebase Catalog name places the synced table
# inside the catalog so it's discoverable alongside the rest of the catalog's contents.
# postgres_database references the catalog's status, which implicitly orders this
# resource after the catalog without an explicit depends_on.
resource "databricks_postgres_synced_table" "orders" {
  synced_table_id = "app_catalog.default.orders_synced"
  spec = {
    branch                             = databricks_postgres_branch.production.name
    postgres_database                  = databricks_postgres_catalog.app_catalog.status.postgres_database
    source_table_full_name             = "my_catalog.default.orders"
    primary_key_columns                = ["order_id"]
    scheduling_policy                  = "CONTINUOUS"
    create_database_objects_if_missing = true
    new_pipeline_spec = {
      storage_catalog = "my_catalog"
      storage_schema  = "default"
    }
  }
}

# Databricks App connected to the Lakebase project.
# database must be the full resource name (databricks_postgres_database.app.name),
# not the Postgres database name. permission must be "CAN_CONNECT_AND_CREATE".
resource "databricks_app" "this" {
  name        = "my-lakebase-app"
  description = "App backed by Lakebase autoscaling project"
  depends_on  = [databricks_postgres_database.app]
  resources = [{
    name = "lakebase-db"
    postgres = {
      branch     = databricks_postgres_branch.production.name
      database   = databricks_postgres_database.app.name
      permission = "CAN_CONNECT_AND_CREATE"
    }
  }]
}

Note

Met deze configuratie maakt u een afzonderlijke rol () en database (admin_spapp) in plaats van de impliciete eigenaarsrol en databricks_postgres -database te beheren. Als u deze impliciete resources onder Terraform-beheer wilt brengen, declareert u ze met replace_existing = true behulp van hun bestaande id's. De database-id is altijd databricks-postgres. De rol-id wordt afgeleid van de identiteit die de branch heeft aangemaakt: het deel van het e-mailadres vóór @ (omgezet naar kleine letters, waarbij niet-alfanumerieke tekens worden vervangen door koppeltekens) voor een gebruiker, of sp-<application-id> voor een service-principal. Als u niet zeker weet wat de exacte waarde is, leest u deze uit de Gebruikersinterface van Lakebase of de Postgres-API in plaats van deze handmatig af te leiden.

spec.membership_roles overschrijft de lidmaatschappen van de rol bij elke toepassing in plaats van deze samen te voegen. Laat DATABRICKS_SUPERUSER in de lijst staan; als u dit weglaat, worden alle lidmaatschappen van de rol verwijderd.

resource "databricks_postgres_role" "owner" {
  role_id = "jane-doe" # normalized login of the creating identity
  parent  = databricks_postgres_branch.production.name
  spec = {
    postgres_role    = "jane.doe@databricks.com" # the raw login
    membership_roles = ["DATABRICKS_SUPERUSER"]
    attributes = {
      createdb   = true
      createrole = true
      bypassrls  = true
    }
  }
  replace_existing = true
}

resource "databricks_postgres_database" "databricks_postgres" {
  database_id = "databricks-postgres"
  parent      = databricks_postgres_branch.production.name
  spec = {
    postgres_database = "databricks_postgres"
    # spec.role is omitted, so the database keeps its existing owner.
  }
  replace_existing = true
}

Aanvullende informatiebronnen

  • Last updated on