Pular para o conteúdo principal
Última atualização em

Configuração típica de projeto do Lakebase com Pacotes de Automação Declarativa

Esta página mostra um pacote completo de Pacotes de Automação Declarativa para um projeto Lakebase Autoscale pronto para produção com os recursos mais usados:

  • Branch de produção protegida
  • Alta disponibilidade (HA) endpoint de leitura e gravação com secundários legíveis
  • Permissão em linha CAN_MANAGE em nível de workspace para uma entidade de serviço
  • Transmissão contínua de tabela sincronizada do Unity Catalog
  • Vinculação do Unity Catalog para a base de dados Lakebase
  • Databricks App conectado ao projeto Lakebase

Para uma introdução passo a passo aos Pacotes de Automação Declarativa com Lakebase, consulte Gerenciar Lakebase com Pacotes de Automação Declarativa.

Pré-requisitos​

Antes de começar, é preciso:

  • CLI do Databricks v1.0.0 ou posterior . Para verificar sua versão, execute databricks --version. Para instalar ou atualizar, consulte Instalar ou atualizar a CLI do Databricks.
  • Um workspace do Databricks com o Lakebase habilitado.
  • Uma entidade de serviço configurada para autenticação OAuth machine-to-machine (M2M). O pacote concede a este principal permissão de workspace CAN_MANAGE no projeto. Consulte Autorize acesso da entidade de serviço ao Databricks com OAuth e Gerenciar permissões de projeto.
  • Uma tabela Delta do Unity Catalog com Change Data Feed (CDF) ativado para usar como origem da sincronização. Remova os blocos postgres_synced_tables e postgres_catalogs se não precisar de sincronização de dados.

Configuração de pacote completa​

O pacote usa variáveis para todos os valores específicos do workspace. Defina-os em um arquivo .databricks/bundle/<target>/variables.json ou passe-os no momento da implantação com --var.

Ao criar um projeto, o Databricks cria automaticamente um branch production e um endpoint primary de leitura/gravação. Para configurar esses recursos criados implicitamente, adicione-os com replace_existing: true.

YAML
bundle:
  name: lakebase-typical-project

variables:
  project_id:
    description: 'Lakebase project ID (lowercase, hyphen-delimited)'
    default: 'my-lakebase-project'
  display_name:
    description: 'Human-readable project name shown in the UI'
    default: 'My Lakebase project'
  pg_version:
    description: 'Postgres major version'
    default: 17
  min_cu:
    description: 'Minimum compute units on the default endpoint'
    default: 0.5
  max_cu:
    description: 'Maximum compute units on the default endpoint'
    default: 4.0
  suspend_timeout:
    description: 'Idle time before the default endpoint suspends. Ignored when no_suspension is true.'
    default: '300s'
  admin_sp_app_id:
    description: 'Application ID of the service principal to grant CAN_MANAGE on the project'
    default: '<your-sp-application-id>'
  source_table:
    description: 'Unity Catalog three-part name of the Delta table to sync (catalog.schema.table)'
    default: '<catalog>.<schema>.<table>'
  primary_key_column:
    description: 'Primary key column of the source Delta table'
    default: '<pk>'
  storage_catalog:
    description: 'Unity Catalog catalog where the sync pipeline stores its metadata'
    default: '<catalog>'
  storage_schema:
    description: 'Unity Catalog schema where the sync pipeline stores its metadata'
    default: '<schema>'
  app_name:
    description: 'Databricks App name (must be unique in the workspace)'
    default: 'my-lakebase-app'
  uc_catalog_id:
    description: 'Name to register the Lakebase database in Unity Catalog'
    default: 'my_lakebase_uc_catalog'

targets:
  prod:
    default: true
    workspace:
      host: https://<your-workspace>.cloud.databricks.com

    resources:
      # Project — top-level container for branches, endpoints, and databases.
      # The permissions block grants workspace-level CAN_MANAGE to the service principal.
      postgres_projects:
        lakebase_project:
          project_id: ${var.project_id}
          spec:
            pg_version: ${var.pg_version}
            display_name: ${var.display_name}
            default_endpoint_settings:
              autoscaling_limit_min_cu: ${var.min_cu}
              autoscaling_limit_max_cu: ${var.max_cu}
              suspend_timeout_duration: ${var.suspend_timeout}
          permissions:
            - service_principal_name: ${var.admin_sp_app_id}
              level: CAN_MANAGE

      # Configure the implicitly created production branch as protected.
      postgres_branches:
        production:
          branch_id: production
          parent: ${resources.postgres_projects.lakebase_project.name}
          no_expiry: true
          is_protected: 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.
      postgres_endpoints:
        primary:
          endpoint_id: primary
          parent: ${resources.postgres_branches.production.name}
          endpoint_type: ENDPOINT_TYPE_READ_WRITE
          autoscaling_limit_min_cu: ${var.min_cu}
          autoscaling_limit_max_cu: ${var.max_cu}
          no_suspension: true
          group:
            min: 2
            max: 2
            enable_readable_secondaries: true
          replace_existing: true

      # Sync a Unity Catalog Delta table into the project continuously.
      postgres_synced_tables:
        orders_sync:
          synced_table_id: '${var.storage_catalog}.${var.storage_schema}.orders_synced'
          branch: ${resources.postgres_branches.production.name}
          postgres_database: databricks_postgres
          source_table_full_name: ${var.source_table}
          primary_key_columns:
            - ${var.primary_key_column}
          scheduling_policy: CONTINUOUS
          create_database_objects_if_missing: true
          new_pipeline_spec:
            storage_catalog: ${var.storage_catalog}
            storage_schema: ${var.storage_schema}

      # Bind the Lakebase database into Unity Catalog so it is queryable as UC data.
      postgres_catalogs:
        lakebase_uc_catalog:
          catalog_id: ${var.uc_catalog_id}
          postgres_database: databricks_postgres
          branch: ${resources.postgres_branches.production.name}
          create_database_if_missing: true

      # Databricks App connected to the project.
      # Update source_code_path to point to your app source directory.
      # The database value references databricks_postgres — the stable ID of the implicit
      # database that every Lakebase project creates automatically.
      apps:
        lakebase_app:
          name: ${var.app_name}
          description: 'App backed by Lakebase autoscaling'
          source_code_path: ./app_src
          config:
            command:
              - flask
              - run
              - --host=0.0.0.0
              - --port=8000
          resources:
            - name: lakebase-db
              postgres:
                branch: ${resources.postgres_branches.production.name}
                database: ${resources.postgres_branches.production.name}/databases/databricks-postgres
                permission: CAN_CONNECT_AND_CREATE

Aplicar o pacote​

Validar e implantar:

Bash
databricks bundle validate -t prod
databricks bundle deploy -t prod

Se databricks bundle deploy não for concluído na primeira execução, execute-o novamente.

O que é implantado​

O pacote cria os seguintes recursos:

  • Um projeto de autoscale do Lakebase com os defaults de compute que você especificou.
  • A branch production protegida.
  • Um endpoint primário de leitura e gravação com HA e secundários legíveis.
  • Um pipeline de sincronização contínua que transmite uma tabela Delta do Unity Catalog para o banco de dados do projeto.
  • Um catálogo do Unity Catalog apoiado pelo banco de dados Lakebase, consultável como dados UC.
  • Um aplicativo Databricks conectado ao banco de dados do projeto.
  • Permissão de CAN_MANAGE do workspace para a entidade de serviço que você especificou.

Passos seguintes​

Nesta página