Pozyskiwanie danych z programu SQL Server

Dowiedz się, jak pozyskiwać dane z programu SQL Server do usługi Azure Databricks przy użyciu usługi Lakeflow Connect.

Łącznik programu SQL Server obsługuje bazy danych Azure SQL Database, Azure SQL Managed Instance i Amazon RDS SQL Database. Obejmuje to program SQL Server uruchomiony na maszynach wirtualnych platformy Azure i w usłudze Amazon EC2. Łącznik obsługuje również SQL Server w lokalnym środowisku, korzystając z sieci Azure ExpressRoute i AWS Direct Connect.

Wymagania

  • Aby utworzyć bramę wprowadzania danych i potok wprowadzania danych, należy najpierw spełnić następujące wymagania:

    • Twoje środowisko pracy ma włączoną funkcję Unity Catalog.

    • W twoim obszarze roboczym włączono bezserwerowe obliczenia. Zobacz Wymagania dotyczące obliczeń bezserwerowych.

    • Jeśli planujesz utworzyć połączenie: masz uprawnienia CREATE CONNECTION w metastore. Zobacz Zarządzanie uprawnieniami w Unity Catalog.

      Jeśli łącznik obsługuje tworzenie potoków opartych na interfejsie użytkownika, możesz utworzyć połączenie i potok w tym samym czasie, wykonując kroki na tej stronie. Jeśli jednak używasz tworzenia potoku za pomocą interfejsu API, przed wykonaniem kroków na tej stronie należy utworzyć połączenie w Eksploratorze Katalogu. Zobacz Połączenie z zarządzanymi źródłami pozyskiwania danych.

    • Jeśli planujesz użyć istniejącego połączenia, musisz mieć USE CONNECTION uprawnienia lub ALL PRIVILEGES do połączenia.

    • Masz uprawnienia USE CATALOG w katalogu docelowym.

    • Masz uprawnienia USE SCHEMA, CREATE TABLE, i CREATE VOLUME w odniesieniu do istniejącego schematu lub masz uprawnienia CREATE SCHEMA w katalogu docelowym.

    • Masz dostęp do podstawowego wystąpienia programu SQL Server. Funkcje śledzenia zmian i przechwytywania danych o zmianach nie są obsługiwane w replikach do odczytu ani w wystąpieniach pomocniczych.

    • Nieograniczone uprawnienia do tworzenia klastrów lub niestandardowa polityka (tylko interfejs API). Polityka niestandardowa dla bramy musi spełniać następujące wymagania:

      • Rodzina: Obliczenia zadań

      • Przesłonięcia zestawów polityk:

        {
          "cluster_type": {
            "type": "fixed",
            "value": "dlt"
          },
          "num_workers": {
            "type": "unlimited",
            "defaultValue": 1,
            "isOptional": true
          },
          "runtime_engine": {
            "type": "fixed",
            "value": "STANDARD",
            "hidden": true
          }
        }
        
      • Usługa Databricks zaleca określanie najmniejszych możliwych węzłów roboczych o najmniejszym rozmiarze dla bram wejściowych, ponieważ nie wpływają one na wydajność tych bram. Polityka obliczeniowa przedstawiona poniżej umożliwia usłudze Azure Databricks skalowanie bramy pobierania danych, aby spełnić wymagania Twojego obciążenia. Minimalne wymagania dla węzła sterownika to 8 rdzeni, aby umożliwić efektywną i wydajną ekstrakcję danych z bazy źródłowych.

        {
          "driver_node_type_id": {
            "type": "fixed",
            "value": "Standard_E64d_v4"
          },
          "node_type_id": {
            "type": "fixed",
            "value": "Standard_F4s"
          }
        }
        

      Aby uzyskać więcej informacji na temat zasad klastra, zobacz Wybieranie zasad obliczeniowych.

  • Aby pobrać dane z SQL Server, należy najpierw wykonać kroki opisane w temacie Konfigurowanie Microsoft SQL Server do przetwarzania danych w Azure Databricks.

Tworzenie bramy i potoku pozyskiwania

Warning

Nie zatrzymuj ręcznie bramy importu. Brama musi działać nieprzerwanie, aby przechwytywać zmiany, zanim dzienniki zmian zostaną przycięte w źródłowej bazie danych. Jeśli brama zostanie zatrzymana, zmiany można usunąć z powodu przechowywania dziennika, co wymaga pełnego odświeżenia wszystkich tabel, których dotyczy problem. Zatrzymanie i ponowne uruchomienie bramy powoduje również ponowne aprowizowanie maszyny wirtualnej, co wydłuża czas uruchomienia. Jeśli potrzebujesz rozwiązać problemy z bramą, zapoznaj się z tematem Rozwiązywanie problemów z pozyskiwaniem danych z programu SQL Server lub skontaktuj się z pomocą techniczną Databricks.

Interfejs użytkownika usługi Databricks

  1. Na pasku bocznym obszaru roboczego usługi Azure Databricks kliknij pozycję Pozyskiwanie danych.

  2. Na stronie Dodawanie danych w obszarze Łączniki usługi Databricks kliknij pozycję SQL Server.

  3. Na stronie Connection w kreatorze importu wybierz połączenie, które przechowuje poświadczenia dostępu do programu SQL Server. Jeśli masz CREATE CONNECTION uprawnienia w magazynie metadanych, możesz kliknąć ikonę plusa. Utwórz połączenie, aby utworzyć nowe połączenie, korzystając ze szczegółów uwierzytelniania opisanych w Tworzenie połączenia z serwerem SQL Server.

  4. Kliknij przycisk Dalej.

  5. Na stronie Konfiguracja pozyskiwania wprowadź unikatową nazwę potoku pozyskiwania. Ten pipeline przenosi dane z lokalizacji tymczasowej do miejsca docelowego.

  6. Wybierz wykaz i schemat, do których mają być zapisywane dzienniki zdarzeń. Dziennik zdarzeń zawiera dzienniki audytu, kontrole jakości danych, postęp przetwarzania danych i błędy. Jeśli masz USE CATALOG i CREATE SCHEMA uprawnienia do katalogu, możesz kliknąć w ikonę Plus. Utwórz schemat w menu rozwijanym, aby utworzyć nowy schemat.

  7. (Opcjonalnie) Ustaw opcję Automatyczne odświeżanie pełne dla wszystkich tabel na wartość Włączone. Gdy automatyczne odświeżanie jest włączone, potok automatycznie próbuje rozwiązać problemy, takie jak zdarzenia związane z czyszczeniem logów i niektóre typy ewolucji schematu, w pełni odświeżając tabelę, której dotyczy dany problem. Jeśli śledzenie historii jest włączone, pełne odświeżanie spowoduje usunięcie tej historii.

  8. Wprowadź unikatową nazwę bramy przyjęcia danych. Brama to rura, która wyodrębnia zmiany ze źródła i przygotowuje je do załadowania strumienia pozyskiwania.

  9. Wybierz katalog i schemat lokalizacji przejściowej. Wolumen jest tworzony w tej lokalizacji w celu tymczasowego przechowywania wyodrębnionych danych. Jeśli masz USE CATALOG i CREATE SCHEMA uprawnienia do katalogu, możesz kliknąć w ikonę Plus. Utwórz schemat w menu rozwijanym, aby utworzyć nowy schemat.

  10. Kliknij Utwórz kanał i kontynuuj.

  11. Na stronie Źródło wybierz tabele do importowania. Jeśli wybierzesz określone tabele, możesz skonfigurować ustawienia tabeli:

    a. (Opcjonalnie) Na karcie Ustawienia określ nazwę docelową dla każdej importowanej tabeli. Jest to przydatne do odróżnienia tabel docelowych podczas wielokrotnego pozyskiwania obiektu do tego samego schematu. Zobacz Nazwa tabeli docelowej.

    a. (Opcjonalnie) Zmień domyślne ustawienie śledzenia historii . Zobacz Włączanie śledzenia historii (typ SCD 2).

  12. Kliknij przycisk Dalej, a następnie kliknij przycisk Zapisz i kontynuuj.

  13. Na stronie Miejsce docelowe wybierz wykaz i schemat, do którego mają być ładowane dane. Jeśli masz USE CATALOG i CREATE SCHEMA uprawnienia do katalogu, możesz kliknąć w ikonę Plus. Utwórz schemat w menu rozwijanym, aby utworzyć nowy schemat.

  14. Kliknij przycisk Zapisz i kontynuuj.

  15. Na stronie Konfiguracja bazy danych kliknij pozycję Weryfikuj , aby potwierdzić, że źródło jest prawidłowo skonfigurowane do pozyskiwania danych usługi Azure Databricks. Zwracane są wszystkie brakujące konfiguracje. Aby uzyskać instrukcje do rozwiązania, kliknij pozycję Ukończ konfigurację. Następnie kliknij Dalej. Alternatywnie kliknij pozycję Pomiń walidację.

  16. (Opcjonalnie) Na stronie Harmonogramy i powiadomienia kliknij ikonę Plus. Utwórz harmonogram. Ustaw częstotliwość odświeżania tabel docelowych.

  17. (Opcjonalnie) Kliknij ikonę Plus Dodaj powiadomienie aby ustawić powiadomienia e-mail dotyczące powodzenia lub niepowodzenia operacji potoku, a następnie kliknij pozycję Zapisz i uruchom potok.

Pakiety automatyzacji deklaratywnej

Przed przetwarzaniem przy użyciu pakietów automatyzacji deklaratywnej powinieneś mieć dostęp do istniejącego połączenia. Aby uzyskać instrukcje, zobacz Tworzenie połączenia SQL Server.

Katalog i schemat tymczasowy mogą być takie same jak katalog i schemat docelowy. Katalog przejściowy nie może być katalogiem obcym. Określ lokalizację ustawienia w sekcji gateway_definition pliku YAML potoku pakietu.

Brama pobierania wyodrębnia dane migawkowe i zmiany ze źródłowej bazy danych i przechowuje je w woluminie przejściowym Unity Catalog. Bramę należy uruchomić jako ciągły proces. Pomaga to uwzględnić wszelkie zasady przechowywania dzienników zmian, które masz w źródłowej bazie danych.

Potok pozyskiwania stosuje migawkę i zmienia dane z woluminu przejściowego na docelowe tabele przesyłania strumieniowego.

Pakiety mogą zawierać definicje YAML dotyczące prac i zadań, są zarządzane przy użyciu interfejsu wiersza polecenia usługi Databricks i mogą być udostępniane oraz uruchamiane w różnych docelowych obszarach roboczych (takich jak rozwój, środowisko testowe i produkcja). Aby uzyskać więcej informacji, zobacz Co to są pakiety deklaratywne automatyzacji?.

  1. Utwórz pakiet przy użyciu interfejsu wiersza polecenia usługi Databricks:

    databricks bundle init
    
  2. Dodaj konfigurację potoku i zadania do pakietu. Zobacz Przykłady , aby zapoznać się z kompletnym przykładem ze wszystkimi dostępnymi opcjami.

  3. Wdróż pipeline za pomocą CLI Databricks.

    databricks bundle deploy
    

Notatnik Databricks

Zaktualizuj komórkę Configuration w poniższym notesie, używając połączenia źródłowego, oraz katalogu docelowego, schematu docelowego i tabel do pobrania ze źródła.

Pobierz notes

Terraform

Możesz użyć narzędzia Terraform do wdrażania i zarządzania potokami do pozyskiwania danych w SQL Server. Aby uzyskać pełną przykładową strukturę, w tym konfiguracje narzędzia Terraform do tworzenia bram i potoków pozyskiwania, zobacz repozytorium przykładów narzędzia Terraform lakeflow Connect w witrynie GitHub.

Weryfikowanie pomyślnego pozyskiwania danych

Widok listy na stronie szczegółów potoku przedstawia liczbę rekordów przetworzonych podczas pozyskiwania danych. Te liczby są odświeżane automatycznie.

Weryfikowanie replikacji

Kolumny Upserted records i Deleted records nie są domyślnie wyświetlane. Możesz je włączyć, klikając przycisk Ikona konfiguracji kolumn i wybierając je.

Examples

Skorzystaj z tych przykładów, aby skonfigurować rurociąg.

Konfiguracja pipeline'u

Pakiety automatyzacji deklaratywnej

Poniższy pakiet definiuje potok bramy sieciowej, potok pozyskiwania danych oraz zaplanowane zadanie. Zakomentowane opcje pokazują wszystkie dostępne opcje konfiguracji. Zaktualizuj sekcje variables i targets, używając danych źródłowych i docelowych.

bundle:
  name: lakeflow-connect-sqlserver

# Variables parameterize the bundle for different environments and sources.
# Set values here, override per-target, or pass with: databricks bundle deploy -var="key=value"
variables:
  # The name of the Unity Catalog connection to your SQL Server instance.
  # This connection must already exist and be of type SQLSERVER.
  connection_name:
    description: 'Unity Catalog connection name for the SQL Server source'
  # The SQL Server database name to ingest from.
  # In Lakeflow Connect, this maps to source_catalog in the table/schema spec.
  source_database:
    description: 'SQL Server database name (maps to source_catalog in table specs)'
  # The SQL Server schema to ingest from (for example, "dbo", "sales").
  source_schema:
    description: 'SQL Server schema name to ingest from'
  # The Unity Catalog catalog where ingested Delta tables are created.
  dest_catalog:
    description: 'Destination Unity Catalog catalog for ingested tables'
  # The Unity Catalog schema where ingested Delta tables are created.
  dest_schema:
    description: 'Destination Unity Catalog schema for ingested tables'
  # The Unity Catalog catalog for the gateway's internal staging volume.
  # Can be the same as dest_catalog. Must not be a foreign catalog.
  staging_catalog:
    description: 'Catalog for gateway staging volume'
  # The Unity Catalog schema for the gateway's internal staging volume.
  staging_schema:
    description: 'Schema for gateway staging volume'

resources:
  pipelines:
    # --- Gateway pipeline ---
    # Extracts change data from SQL Server and stages it in a Unity Catalog
    # volume. Must run continuously to capture changes before change logs are
    # truncated in the source database.
    gw_pipeline:
      name: 'lfc-sqlserver-gateway-${bundle.target}'
      # Gateway pipelines must be continuous.
      continuous: true
      # "CURRENT" (stable) or "PREVIEW" (early access).
      channel: 'CURRENT'
      # (Optional) Associate with a budget policy for cost tracking.
      # budget_policy_id: "<policy-uuid>"
      # The gateway runs on classic compute. Cluster settings are managed
      # automatically. You can optionally customize the cluster:
      # clusters:
      #   - label: "default"
      #     autoscale:
      #       min_workers: 1
      #       max_workers: 4
      #     # node_type_id: "i3.xlarge"
      #     # Restrict the cluster to an approved cluster policy.
      #     # policy_id: "<cluster-policy-id>"
      catalog: ${var.staging_catalog}
      schema: ${var.staging_schema}
      gateway_definition:
        # (Required) Unity Catalog connection name (type SQLSERVER).
        connection_name: ${var.connection_name}
        # (Required) Catalog and schema for the staging volume.
        gateway_storage_catalog: ${var.staging_catalog}
        gateway_storage_schema: ${var.staging_schema}
        # (Optional) Custom staging volume name. If not set, the system
        # auto-generates: __databricks_ingestion_gateway_staging_data-<pipeline_id>
        # gateway_storage_name: "my_custom_staging_volume"

    # --- Ingestion pipeline ---
    # Reads staged data from the gateway and applies it to Delta tables.
    mi_pipeline:
      name: 'lfc-sqlserver-ingestion-${bundle.target}'
      # Continuous mode is not supported for the ingestion pipeline.
      # Use a scheduled job to trigger runs.
      continuous: false
      channel: 'CURRENT'
      # (Optional) Associate with a budget policy for cost tracking.
      # budget_policy_id: "<policy-uuid>"
      # The ingestion pipeline runs on serverless compute only.
      serverless: true
      # (Optional) Development mode for faster iteration (no retries).
      # development: true
      catalog: ${var.dest_catalog}
      schema: ${var.dest_schema}
      # (Optional) Email notifications for pipeline events.
      # notifications:
      #   - email_recipients:
      #       - "team@example.com"
      #     alerts:
      #       - "on-update-failure"
      #       - "on-update-fatal-failure"
      #       - "on-flow-failure"
      # (Optional) Run as a service principal for production.
      # run_as:
      #   service_principal_name: "my-service-principal"
      ingestion_definition:
        # (Required) References the gateway pipeline. The connection is
        # inherited from the gateway. Do not specify connection_name here.
        ingestion_gateway_id: ${resources.pipelines.gw_pipeline.id}
        # Pipeline-level table configuration defaults. These apply to all
        # tables unless overridden at the schema or table level.
        table_configuration:
          # SCD Type: How changes are applied to destination tables.
          #   SCD_TYPE_1: Overwrites rows with latest values (default).
          #   SCD_TYPE_2: Preserves history with __START_AT/__END_AT columns.
          #               Requires CDC on source. CT does not support SCD_TYPE_2.
          scd_type: 'SCD_TYPE_1'
          # (Optional) Auto full refresh policy. Triggers a snapshot when the
          # pipeline detects issues resolvable by re-reading all source data
          # (for example, CT/CDC retention window expired).
          # auto_full_refresh_policy:
          #   enabled: true
          #   min_interval_hours: 24
        # (Optional) Schedule automatic full refreshes.
        # full_refresh_window:
        #   start_hour: 2
        #   days_of_week:
        #     - "SUNDAY"
        #   time_zone_id: "America/Los_Angeles"
        objects:
          # Option 1: Schema-level ingestion. Ingests all tables from a source
          # schema. New tables added to the schema are picked up automatically.
          - schema:
              source_catalog: ${var.source_database}
              source_schema: ${var.source_schema}
              destination_catalog: ${var.dest_catalog}
              destination_schema: ${var.dest_schema}
              # (Optional) Override table_configuration for this schema.
              # table_configuration:
              #   scd_type: "SCD_TYPE_2"
          # Option 2: Table-level ingestion. Provides granular control.
          # Replace or combine with the schema-level spec.
          # - table:
          #     source_catalog: ${var.source_database}
          #     source_schema: ${var.source_schema}
          #     source_table: "customers"
          #     destination_catalog: ${var.dest_catalog}
          #     destination_schema: ${var.dest_schema}
          #     # (Optional) Rename the table at the destination.
          #     # destination_table: "customers_v2"
          #     table_configuration:
          #       scd_type: "SCD_TYPE_1"
          #       # Include only specific columns (mutually exclusive with exclude_columns).
          #       # include_columns:
          #       #   - "customer_id"
          #       #   - "first_name"
          #       #   - "email"
          #       # Exclude specific columns. All other columns are included.
          #       # exclude_columns:
          #       #   - "internal_notes"
          #       # Logical ordering columns for change resolution.
          #       # sequence_by:
          #       #   - "updated_at"
          #       # Auto full refresh for this table.
          #       # auto_full_refresh_policy:
          #       #   enabled: true
          #       #   min_interval_hours: 48
      # (Optional) Grant additional users or groups access.
      # permissions:
      #   - user_name: "analyst@example.com"
      #     level: "CAN_VIEW"
      #   - group_name: "data-engineers"
      #     level: "CAN_RUN"

  # --- Scheduled job ---
  # Triggers the ingestion pipeline on a schedule.
  jobs:
    mi_schedule:
      name: 'lfc-sqlserver-ingestion-schedule-${bundle.target}'
      # Quartz cron syntax: "seconds minutes hours day month day-of-week"
      # Examples: "0 0 * * * ?" (hourly), "0 0 */4 * * ?" (every 4 hours)
      schedule:
        quartz_cron_expression: '0 */30 * * * ?'
        timezone_id: 'UTC'
      tasks:
        - task_key: 'run_ingestion'
          pipeline_task:
            pipeline_id: ${resources.pipelines.mi_pipeline.id}
      # email_notifications:
      #   on_failure:
      #     - "team@example.com"

# Deploy to different workspaces with: databricks bundle deploy -t <target>
targets:
  dev:
    default: true
    workspace:
      host: https://<workspace-url>.cloud.databricks.com
    variables:
      connection_name: '<sqlserver-connection>'
      source_database: '<database-name>'
      source_schema: 'dbo'
      dest_catalog: '<dest-catalog>'
      dest_schema: '<dest-schema>'
      staging_catalog: '<staging-catalog>'
      staging_schema: '<staging-schema>'

Notatnik Databricks

Poniżej przedstawiono przykładową Configuration sekcję specyfikacji potoku:

# The name of the UC connection with the credentials to access the source database
connection_name = "my_connection"

# The name of the UC catalog and schema to store the replicated tables
target_catalog_name = "main"
target_schema_name = "lakeflow_sqlserver_connector_cdc"

# The name of the UC catalog and schema to store the staging volume with intermediate
# CDC and snapshot data. Use the destination catalog/schema by default.
stg_catalog_name = target_catalog_name
stg_schema_name = target_schema_name

# The name of the Gateway pipeline to create
gateway_pipeline_name = "cdc_gateway"

# The name of the Ingestion pipeline to create
ingestion_pipeline_name = "cdc_ingestion"

# Construct the full list of tables to replicate.
# IMPORTANT: The letter case of catalog, schema, and table names must match exactly
# the case used in the source database system tables.
tables_to_replicate = replicate_full_db_schema("MY_DB", ["MY_DB_SCHEMA"])
# Append tables from additional schemas as needed:
#  + replicate_tables_from_db_schema("MY_DB", "MY_SCHEMA_2", ["table3", "table4"])

Często używane wzorce

Aby zapoznać się z zaawansowanymi konfiguracjami potoków, zobacz Typowe wzorce dla zarządzanych potoków pozyskiwania.

Następne kroki

Rozpocznij, zaplanuj i ustaw alerty w swoim strumieniu danych. Zobacz Typowe zadania zarządzania potokiem.

Dodatkowe zasoby