Verwaltung von Lakehouse-Daten mit synchronisierten Tabellen

Mit synchronisierten Tabellen können Sie Lakehouse-Daten über Lakebase Postgres bedienen. Unity Catalog-Tabellen werden in Postgres synchronisiert, sodass Anwendungen Lakehouse-Daten direkt mit geringer Latenz abfragen können. Dieser Prozess wird häufig als Reverse ETL bezeichnet. Das Lakehouse ist für Analysen und Anreicherung optimiert, während Lakebase für operative Workloads konzipiert ist, die schnelle Suchabfragen und transaktionsbezogene Konsistenz erfordern.

Was sind synchronisierte Tabellen?

Mit synchronisierten Tabellen können Sie Analysedaten aus dem Unity-Katalog über Lakebase Postgres bereitstellen und anwendungen zur Verfügung stellen, die Abfragen mit geringer Latenz und vollständige ACID-Transaktionen benötigen. Sie überbrücken die Lücke zwischen analytischen Speicher- und operativen Systemen, indem Ihre Daten für Echtzeitanwendungen bereit gehalten werden.

Unterstützte Quellen

Synchronisierte Tabellen unterstützen die folgenden Unity Catalog-Quelltypen:

• Verwaltete und externe Delta-Tabellen
• Verwaltete und externe Iceberg-Tabellen
• Ansichten und materialisierte Ansichten

So funktioniert es

Mit synchronisierten Tabellen von Databricks wird eine verwaltete Kopie Ihrer Unity-Katalogdaten in Lakebase erstellt. Wenn Sie eine synchronisierte Tabelle erstellen, erhalten Sie Folgendes:

1. Eine synchronisierte Tabelle im Unity-Katalog, die auf die Synchronisierungspipeline verweist
2. Eine Postgres-Tabelle in Lakebase (schreibgeschützt, von Ihren Anwendungen abfragbar)

Sie können beispielsweise Goldtabellen, technische Features oder ML-Ausgaben aus analytics.gold.user_profiles in eine neue synchronisierte Tabelle analytics.gold.user_profiles_synced synchronisieren. In Postgres wird der Schemaname des Unity-Katalogs zum Namen des Postgres-Schemas, sodass dies als gold.user_profiles_synced erscheint:

SELECT * FROM gold.user_profiles_synced WHERE user_id = 12345;

Anwendungen verbinden sich mit standardmäßigen Postgres-Treibern und fragen die synchronisierten Daten zusammen mit ihrem eigenen Betriebszustand ab.

Synchronisierungspipelinen verwenden verwaltete Lakeflow-Pipelines, um sowohl die synchronisierte Tabelle Unity-Katalog als auch die Postgres-Tabelle mit Änderungen aus der Quelltabelle kontinuierlich zu aktualisieren. Jede Synchronisierung kann bis zu 16 Verbindungen mit Ihrer Lakebase-Datenbank verwenden.

Lakebase Postgres unterstützt bis zu 1.000 gleichzeitige Verbindungen mit Transaktionsgarantien, sodass Anwendungen erweiterte Daten lesen und gleichzeitig Einfügungen, Aktualisierungen und Löschungen in derselben Datenbank verarbeiten können.

Beschleunigte Anfangssynchronisation

LTAP Direct Writes ist eine Beta-Funktionalität der LTAP-Architektur , die die Zeit für Erstladevorgänge und vollständige Aktualisierungen reduziert. Es lädt Daten direkt in die Speicherschicht, die Ihrem Lakebase-Branch zugrunde liegt, anstatt den Massenschreibvorgang über den Live-Compute-Endpunkt zu leiten. Dadurch werden große Ladevorgänge schneller abgeschlossen und erzeugen während ihrer Ausführung keine Abfragelast am Endpunkt.

Die LTAP Direct Writes-Funktion beschleunigt die Anfangsbelastung für jeden Synchronisationsmodus. Jede synchronisierte Tabelle beginnt damit, eine vollständige Kopie des Quellcodes zu laden, und diese erste Ladung verwendet LTAP Direct Writes, egal ob man Snapshot, Triggered oder Continuous Mode wählt. Außerdem beschleunigt er vollständige Aktualisierungen, einschließlich der wiederkehrenden Vollladungen, die der Snapshot-Modus bei jeder weiteren Synchronisation ausführt.

LTAP Direct Writes befindet sich in der Beta und erfordert ein Lakebase-Projekt mit Postgres 17. Um dies zu nutzen, aktiviert ein Arbeitsbereichsadministrator die Vorschau LTAP Direct Writes auf der Seite Previews in den Arbeitsbereichseinstellungen.

Auf Azure ist LTAP Direct Writes in allen Regionen außer East US, East US 2, West Europe und West US 2 verfügbar.

Synchronisierungsmodi

Wählen Sie den richtigen Synchronisierungsmodus basierend auf Ihren Anwendungsanforderungen aus:

Die Quellanforderung hängt vom Synchronisationsmodus ab:

• Snapshot kopiert alle Daten bei jeder Synchronisation, sodass die Quelle nur noch Unterstützung benötigt.SELECT *
• Triggered und Continuous wenden Änderungen auf Zeilenebene schrittweise an, daher muss die Quelle einen Änderungsdatenfeed bereitstellen. Aktivieren Sie den Change Data Feed zur Schreibzeit an der Quelle oder verwenden Sie den automatischen Change Data Feed. Wenn eine ausgelöste oder kontinuierliche Quelle keinen Change Data Feed hat, zeigt die Benutzeroberfläche eine Warnung mit dem genauen Befehl ALTER TABLE an, der ausgeführt werden soll.

Der automatische Änderungsdatenfeed (öffentliche Vorschau) berechnet Änderungen auf Zeilenebene zur Lesezeit, anstatt einen Schreibzeit-Änderungsdatenfeed auf der Quelle zu benötigen. Dies ermöglicht es mehr Quelltypen, einschließlich Apache-Eisberg-Tabellen und materialisierten Ansichten, im Triggered- oder Continued-Modus zu synchronisieren. Für die Quelltypen, die der Automatische Änderungsdatenfeed unterstützt, siehe die Dokumentation zum Automatischen Änderungsdatenfeed .

Der automatische Änderungsdatenfeed für synchronisierte Tabellen ist in der Vorschau. Während es in der Vorschau ist, erledigen Sie zwei zusätzliche Schritte:

1. Aktivieren Sie die Vorschau. Ein Arbeitsbereichsadministrator aktiviert die Vorschau des automatischen Änderungsdaten-Feeds auf der Seite Vorschauen in den Arbeitsbereichseinstellungen.

2. Legen Sie den Pipeline-Kanal auf „Vorschau“ fest. Wenn du die synchronisierte Tabelle erstellst, setze den Pipeline-Kanal auf PREVIEW. Diese Option ist derzeit nur über die API verfügbar:

   {
     "spec": {
       "new_pipeline_spec": {
         "pipeline_channel": "PREVIEW"
       }
     }
   }
   

Beispielanwendungsfälle

Sie können synchronisierte Tabellen für datenbezogene Anwendungsfälle wie:

• Personalisierungsmodule, die neue Benutzerprofile für Databricks-Apps bereitstellen
• Anwendungen, die Modellvorhersagen oder Featurewerte bereitstellen, die im Lakehouse berechnet wurden.
• Kundenorientierte Dashboards, die KPIs in Echtzeit bedienen
• Betrugserkennungsdienste, die Risikobewertungen für sofortige Maßnahmen bereitstellen
• Supporttools, die angereicherte Kundendatensätze aus Lakehouse-Daten bedienen

Erstellen einer synchronisierten Tabelle

Voraussetzungen

Sie benötigen:

• Ein Databricks-Arbeitsbereich mit aktivierter Lakebase.
• Ein Lakebase-Projekt (siehe Erstellen eines Projekts).
• Eine Unity-Katalog-Tabelle zum Synchronisieren.
• Berechtigungen zum Erstellen synchronisierter Tabellen. Sie benötigen USE_SCHEMA und CREATE_TABLE für jedes schema, das Sie verwenden.

Für getriggerte oder kontinuierliche Modi muss die Quelle einen Wechseldatenfeed bereitstellen. Entweder aktivieren Sie den Schreibzeit-Änderungsdatenfeed in einer geeigneten Delta-Quelltabelle, oder verwenden Sie automatischen Änderungsdatenfeed für Quellen wie Apache Iceberg-Tabellen und materialisierte Ansichten. Der automatische Änderungsdatenfeed befindet sich in der öffentlichen Vorschau und erfordert die zusätzliche Konfiguration, die in Sync modes beschrieben wird.

Um den Änderungsdaten-Feed zur Schreibzeit für eine Delta-Quelltabelle zu aktivieren, führen Sie Folgendes aus:

ALTER TABLE your_catalog.your_schema.your_table
SET TBLPROPERTIES (delta.enableChangeDataFeed = true)

Informationen zur Kapazitätsplanung und Datentypkompatibilität finden Sie unter Datentypen und Kompatibilität und Kapazitätsplanung.

Benutzeroberfläche

1. Wechseln Sie in der Arbeitsbereichs-Randleiste zu "Katalog ", und wählen Sie die Unity-Katalogtabelle aus, die Sie synchronisieren möchten.

   

2. Klicken Sie in der Tabellendetailseite auf ">Synchronisierte Tabelle erstellen".

   

3. Im Dialogfeld "Synchronisierte Tabelle erstellen ":

   Die Katalog- und Schemalisten enthalten nur Unity-Katalogschemas, bei denen der aktuelle Benutzer über USE_SCHEMA und CREATE_TABLE Berechtigungen verfügt. Wenn kein von Ihnen erwartetes Schema angezeigt wird, bestätigen Sie Ihre Berechtigungen mit Ihrem Katalogadministrator.

   1. Tabellenname: Geben Sie einen Namen für Ihre synchronisierte Tabelle ein (sie wird im selben Katalog und Schema wie die Quelltabelle erstellt). Dadurch wird sowohl eine synchronisierte Unity-Katalogtabelle als auch eine Postgres-Tabelle erstellt, die Sie abfragen können.

   2. Datenbanktyp: Wählen Sie Lakebase Serverless (Autoscaling) aus.

   3. Synchronisierungsmodus: Wählen Sie "Momentaufnahme", " Ausgelöst" oder " Fortlaufend" basierend auf Ihren Anforderungen aus (siehe Synchronisierungsmodi oben).

   4. Konfigurieren Sie Ihre Projekt-, Verzweigungs- und Datenbankoptionen.

   5. Überprüfen Sie, ob der Primärschlüssel korrekt ist (in der Regel automatisch erkannt).

      Von Bedeutung

      Spalten im Primärschlüssel dürfen in der synchronisierten Tabelle nicht null sein. Zeilen mit Nullen in Primärschlüsselspalten werden von der Synchronisierung ausgeschlossen.

   6. (Optional) Wenn zwei Zeilen denselben Primärschlüssel in der Quelltabelle gemeinsam nutzen können, wählen Sie einen Timeseries-Schlüssel aus, um die Deduplizierung zu konfigurieren. Wenn ein Zeitserienschlüssel angegeben wird, enthält die synchronisierte Tabelle nur die Zeile mit dem neuesten Zeitserienschlüsselwert für jeden Primärschlüssel. Informationen zum Fehlermodus ohne Zeitserienschlüssel finden Sie unter "Doppelte Schlüssel".

   Wenn Sie den Modus "Ausgelöst" oder "Fortlaufend" ausgewählt haben und den Change Data Feed noch nicht aktiviert haben, wird eine Warnung mit dem genauen auszuführenden Befehl angezeigt. Informationen zur Kompatibilität von Datentypen finden Sie unter Datentypen und Kompatibilität.

   Klicken Sie auf "Erstellen ", um die synchronisierte Tabelle zu erstellen.

4. Überwachen Sie die synchronisierte Tabelle im Katalog. Auf der Registerkarte " Übersicht " werden der Synchronisierungsstatus, die Konfiguration, der Pipelinestatus und der Zeitstempel der letzten Synchronisierung angezeigt. Verwenden Sie "Jetzt synchronisieren " für die manuelle Aktualisierung.

CLI

databricks postgres create-synced-table my-catalog.sales.orders \
  --json '{
    "spec": {
      "source_table_full_name": "main.sales.orders",
      "branch": "projects/my-project/branches/production",
      "primary_key_columns": ["order_id"],
      "scheduling_policy": "SNAPSHOT",
      "postgres_database": "mydb",
      "create_database_objects_if_missing": true
    }
  }'

Das SYNCED_TABLE_ID Positionsargument verwendet das Format catalog.schema.table. In Postgres wird die Tabelle {table} im Schema {schema} erstellt, in der Datenbank, die Sie mit postgres_database festgelegt haben (hier, mydb). Der Befehl wartet standardmäßig auf den Abschluss des Vorgangs. Alle verfügbaren Optionen finden Sie unter databricks postgres create-synced-table.

Python SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import (
    SyncedTable,
    SyncedTableSyncedTableSpec,
    SyncedTableSyncedTableSpecSyncedTableSchedulingPolicy,
)

w = WorkspaceClient()

synced_table = w.postgres.create_synced_table(
    synced_table=SyncedTable(spec=SyncedTableSyncedTableSpec(
        source_table_full_name="main.sales.orders",
        branch="projects/my-project/branches/production",
        primary_key_columns=["order_id"],
        scheduling_policy=SyncedTableSyncedTableSpecSyncedTableSchedulingPolicy.SNAPSHOT,
        postgres_database="mydb",
        create_database_objects_if_missing=True,
    )),
    synced_table_id="my-catalog.sales.orders",
).wait()

print(f"Synced table created: {synced_table.name}")

Das synced_table_id nutzt das Format catalog.schema.table und wird zum synchronisierten Tabellennamen des Unity Catalog. In Postgres wird die Tabelle {table} im Schema {schema} erstellt, in der Datenbank, die Sie mit postgres_database festgelegt haben (hier, mydb).

Java SDK

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import java.util.List;

WorkspaceClient w = new WorkspaceClient();

SyncedTable syncedTable = w.postgres().createSyncedTable(
    new CreateSyncedTableRequest()
        .setSyncedTableId("my-catalog.sales.orders")
        .setSyncedTable(new SyncedTable()
            .setSpec(new SyncedTableSyncedTableSpec()
                .setSourceTableFullName("main.sales.orders")
                .setBranch("projects/my-project/branches/production")
                .setPrimaryKeyColumns(List.of("order_id"))
                .setSchedulingPolicy(SyncedTableSyncedTableSpecSyncedTableSchedulingPolicy.SNAPSHOT)
                .setPostgresDatabase("mydb")
                .setCreateDatabaseObjectsIfMissing(true))))
    .waitForCompletion();

System.out.println("Synced table created: " + syncedTable.getName());

cURL

curl -X POST "https://your-workspace.cloud.databricks.com/api/2.0/postgres/synced_tables?synced_table_id=my-catalog.sales.orders" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_table_full_name": "main.sales.orders",
      "branch": "projects/my-project/branches/production",
      "primary_key_columns": ["order_id"],
      "scheduling_policy": "SNAPSHOT",
      "postgres_database": "mydb",
      "create_database_objects_if_missing": true
    }
  }'

Dies gibt einen lang laufenden Vorgang zurück. Abrufen des zurückgegebenen Felds name bis done: true. Siehe Lang andauernde Vorgänge. Informationen zum Einrichten der Authentifizierung finden Sie unter "Authentifizierung".

Planen oder Auslösen von nachfolgenden Synchronisierungen

Die erste Momentaufnahme wird beim Erstellen automatisch ausgeführt. Für Snapshot und Trigger-Modus müssen nachfolgende Synchronisierungen explizit ausgelöst werden. Kontinuierlicher Modus ist selbstverwaltend.

Pipeline-Aufgabe zur Synchronisierung von Datenbanktabellen

Die Aufgabe Synchronisierungspipeline der Datenbanktabelle in Lakeflow-Einzelvorgängen führt die Pipeline einer synchronisierten Tabelle als Workflowschritt aus. Konfigurieren Sie den Auftrag mit einem Tabellenaktualisierungstrigger oder einem Zeitplan.

Trigger für Quelltabellenaktualisierungen

Löst den Einzelvorgang aus, wenn die Unity-Katalogtabelle aktualisiert wird. Im Modus Getriggert werden nur neue Änderungen inkrementell übernommen, sodass die Daten in Quasi-Echtzeit aktualisiert werden können, ohne die Always-on-Kosten des kontinuierlichen Modus.

1. Klicken Sie in der Randleiste auf "Workflows".
2. Klicken Sie auf " Auftrag erstellen ", oder öffnen Sie einen vorhandenen Auftrag.
3. Klicken Sie auf der Registerkarte "Aufgaben " auf +Einen anderen Vorgangstyp hinzufügen.
4. Wählen Sie unter "Aufnahme" und "Transformation" die Pipeline "Datenbanktabellensynchronisierung" aus.
5. Wählen Sie im Feld "Pipeline " die Pipeline aus, die Ihrer synchronisierten Tabelle zugeordnet ist.
6. Klicken Sie unter "Zeitpläne und Trigger" auf "Trigger hinzufügen".
7. Wählen Sie "Tabelle aktualisieren" als Triggertyp aus.
8. Wählen Sie unter "Tabellen" die zu überwachende Quelltabelle des Unity-Katalogs aus.
9. Klicke auf Speichern.

Auslösen nach Zeitplan

Führt die Synchronisierung in einem festen Rhythmus aus. Gut geeignet für den Snapshot-Modus , bei dem eine nächtliche oder wöchentliche vollständige Aktualisierung in der Regel das effizienteste Muster ist.

1. Führen Sie die oben beschriebenen Schritte 1 bis 5 aus, um einem Auftrag eine Pipelineaufgabe für die Datenbanktabellensynchronisierung hinzuzufügen.
2. Klicken Sie unter "Zeitpläne und Trigger" auf "Trigger hinzufügen".
3. Wählen Sie "Geplant" als Triggertyp aus.
4. Legen Sie Ihren Cron-Zeitplan und die Zeitzone fest, und klicken Sie dann auf "Speichern".

Überprüfen des Synchronisierungsstatus

So überprüfen Sie den aktuellen Zustand und die uhrzeit der letzten Synchronisierung einer synchronisierten Tabelle:

Benutzeroberfläche

Navigieren Sie im Katalog zu Ihrer synchronisierten Tabelle, und wählen Sie die Registerkarte "Übersicht " aus. Er zeigt den aktuellen Synchronisierungsstatus, den Pipelinestatus und den zeitstempel der letzten Synchronisierung an.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

table = w.postgres.get_synced_table("synced_tables/my-catalog.sales.orders")
print(f"State: {table.status.detailed_state}")
print(f"Last sync: {table.status.last_sync_time}")
print(f"Message: {table.status.message}")

Java SDK

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.SyncedTable;

WorkspaceClient w = new WorkspaceClient();

SyncedTable table = w.postgres().getSyncedTable("synced_tables/my-catalog.sales.orders");
System.out.println("State: " + table.getStatus().getDetailedState());
System.out.println("Last sync: " + table.getStatus().getLastSyncTime());
System.out.println("Message: " + table.getStatus().getMessage());

cURL

curl "https://your-workspace.cloud.databricks.com/api/2.0/postgres/synced_tables/my-catalog.sales.orders" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}"

Datentypen und Kompatibilität

Unity Catalog-Datentypen werden beim Erstellen synchronisierter Tabellen den Postgres-Typen zugeordnet. Komplexe Typen (ARRAY, MAP, STRUCT) werden als JSONB in Postgres gespeichert.

Benutzerdefinierte Typabbildungen

Wenn du eine synchronisierte Tabelle erstellst, kannst du die Standard-Delta-zu-Postgres-Typzuordnung für bestimmte Spalten mit type_overridesüberschreiben.

CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;

Benutzerdefinierte Typzuordnungen sind über API, CLI und Databricks-SDKs konfigurierbar, wenn du eine synchronisierte Tabelle erstellst.

Für eine Quelltabelle main.docs.chunks(id BIGINT, title STRING, embedding ARRAY<FLOAT>) wird in Postgres die folgende Zuordnung von title auf varchar(256) und von embedding auf vector(1024) vorgenommen:

databricks postgres create-synced-table main.docs.chunks_pg \
  --json '{
    "spec": {
      "source_table_full_name": "main.docs.chunks",
      "branch": "projects/my-project/branches/production",
      "primary_key_columns": ["id"],
      "scheduling_policy": "SNAPSHOT",
      "postgres_database": "mydb",
      "create_database_objects_if_missing": true,
      "type_overrides": [
        { "column_name": "title", "pg_type": "PG_SPECIFIC_TYPE_VARCHAR", "size": 256 },
        { "column_name": "embedding", "pg_type": "PG_SPECIFIC_TYPE_VECTOR", "size": 1024 }
      ]
    }
  }'

Ohne die Überschreibung wäre title gleich TEXT und embedding gleich JSONB.

Behandeln ungültiger Zeichen

Bestimmte Zeichen wie Nullbytes (0x00) sind in Unity Catalog STRING-, ARRAY-, MAP- oder STRUCT-Spalten zulässig, werden jedoch in Postgres TEXT- oder JSONB-Spalten nicht unterstützt. Dies kann zu Synchronisierungsfehlern wie folgenden führen:

ERROR: invalid byte sequence for encoding "UTF8": 0x00
ERROR: unsupported Unicode escape sequence DETAIL: \u0000 cannot be converted to text

• Der erste Fehler tritt auf, wenn ein NULL-Byte in einer Top-Level-Zeichenfolgenspalte angezeigt wird, die direkt Postgres TEXT zugeordnet ist.
• Der zweite Fehler tritt auf, wenn in einer Zeichenfolge, die in einen komplexen Typ (STRUCT, ARRAY oder MAP) eingebettet ist, ein Null-Byte vorkommt, der als JSONB serialisiert wird. Während der Serialisierung werden alle Zeichenfolgen in Postgres TEXTumgewandelt, wo \u0000 nicht zulässig ist.

Lösungen :

• Löschen sie Zeichenfolgenfelder: Entfernen Sie nicht unterstützte Zeichen vor der Synchronisierung. Für Nullbytes in STRING-Spalten:

  SELECT REPLACE(column_name, CAST(CHAR(0) AS STRING), '') AS cleaned_column FROM your_table
  

• In BINÄR konvertieren: Für STRING-Spalten, bei denen die Beibehaltung von unformatierten Bytes erforderlich ist, konvertieren Sie in DEN BINÄR-Typ.

Kapazitätsplanung

Berücksichtigen Sie bei der Planung der Implementierung synchronisierter Tabellen die folgenden Ressourcenanforderungen:

• Verbindungsauslastung: Jede synchronisierte Tabelle verwendet bis zu 16 Verbindungen zu Ihrer Lakebase-Datenbank, die zum Verbindungslimit des Projekts zählen.
• Größenkontingent: Logische Gesamtdaten in allen synchronisierten Tabellen weisen ein Kontingent von 16 TB auf. Wenden Sie sich an den Databricks-Support, wenn Sie ein größeres Kontingent benötigen. Einzelne Tabellen verfügen nicht über ein Kontingent, aber Databricks empfiehlt, für Tabellen, die Aktualisierungen erfordern, nicht mehr als 1 TB zu überschreiten.
• Full-Refresh-Größe: Beim Auslösen einer vollständigen Aktualisierung wird die alte Version in Postgres erst gelöscht, wenn die neue Synchronisierung abgeschlossen ist. Beide Versionen werden während der Aktualisierung vorübergehend auf das Kontingent der logischen Datenbankgröße angerechnet.
• Tabellen pro Quelle: Eine einzelne Quelltabelle kann bis zu 20 synchronisierte Tabellen aufweisen.
• Benennungsanforderungen: Datenbank-, Schema- und Tabellennamen dürfen nur alphanumerische Zeichen und Unterstriche ([A-Za-z0-9_]+) enthalten.
• Quellbezeichnerleitfaden: Vermeiden Sie die Verwendung von Großbuchstaben oder Sonderzeichen in Spalten- oder Tabellennamen in der Unity-Quelltabelle. Wenn Sie sie beibehalten, müssen Sie diese Bezeichner zitieren, wenn Sie sie in Postgres referenzieren.
• Schemaentwicklung: Nur additive Schemaänderungen (z. B. das Hinzufügen von Spalten) werden für triggered- und Continuous-Modi unterstützt.
• Änderung der Tabellendefinition: Das Aktualisieren der Definition einer synchronisierten Tabelle wird über keine Schnittstelle (UI, SDKs, CLI, REST API, Terraform oder DABs) unterstützt. Um den Primärschlüssel oder Zeitreihenschlüssel zu ändern oder eine nicht-additive Schemaänderung vorzunehmen, löschen Sie die synchronisierte Tabelle und erstellen Sie eine neue.
• Doppelte Schlüssel: Wenn zwei Zeilen denselben Primärschlüssel in der Quelltabelle aufweisen, schlägt die Synchronisierungspipeline fehl, es sei denn, Sie konfigurieren die Deduplizierung mithilfe eines Zeitserienschlüssels.
• API-Idempotenz: APIs für synchronisierte Tabellen sind idempotent. Versuchen Sie es daher bei vorübergehenden Fehlern erneut, um eine rechtzeitige Ausführung sicherzustellen.
• Update-Rate: Für Lakebase unterstützt die Synchronisationspipeline kontinuierliche und getriggerte Schreibvorgänge mit etwa 150 Zeilen pro Sekunde pro Capacity Unit (CU) und Snapshot-Schreiben mit bis zu 2.000 Zeilen pro Sekunde und CU.

Vorgänge, die für synchronisierte Tabellen in Postgres zulässig sind

Azure Databricks empfiehlt, nur die folgenden Vorgänge in Postgres für synchronisierte Tabellen auszuführen, um versehentliche Überschreibungen oder Dateninkonsistenzen zu verhindern:

• Schreibgeschützte Abfragen
• Erstellen von Indizes
• Ablegen der Tabelle (zum Freigeben von Speicherplatz nach dem Entfernen der synchronisierten Tabelle aus dem Unity-Katalog)

Während es möglich ist, synchronisierte Tabellen in Postgres auf andere Weise zu ändern, stört es die Synchronisierungspipeline.

Besitz und Berechtigungen

Eine synchronisierte Tabelle gehört der internen databricks_writer_<dbid> Rolle, nicht dem Benutzer, der sie erstellt hat, da die Synchronisierungspipeline sie verwaltet (siehe Postgres-Rollen). Befehle, die nur dem Besitzer vorbehalten sind, wie z. B. das Konfigurieren der Sicherheit auf Zeilenebene, können nicht direkt auf einer synchronisierten Tabelle ausgeführt werden.

Zugriff für den Benutzer, der eine synchronisierte Tabelle erstellt

Wenn Sie eine synchronisierte Tabelle erstellen, wird Ihrer Azure-Databricks-Identität automatisch die Berechtigung erteilt, sie zu verwenden. Es ist keine databricks_superuser Aktion erforderlich. Ihre Identität erhält die folgenden Berechtigungen für die synchronisierte Tabelle:

Ihnen wird INSERT oder UPDATE nicht gewährt. Die Pipeline besitzt die Daten der Tabelle, sodass direkte Schreibvorgänge bei der nächsten Aktualisierung überschrieben werden. DELETE und TRUNCATE leeren nur die Tabelle. Die nächste Aktualisierung füllt die Tabelle aus der Quelle erneut auf.

Dieser Zugriff wird von Ihren Unity-Katalogberechtigungen für die synchronisierte Tabelle abgeleitet und im Unity-Katalog verwaltet. Um dies zu ändern, aktualisieren Sie die Unity-Katalogberechtigungen des Benutzers. Sie können kein REVOKE direkt aus einer Azure Databricks-Identität in Postgres ausführen.

Verwalten des synchronisierten Tabellenzugriffs

Nachdem eine synchronisierte Tabelle erstellt wurde, kann databricks_superuser eine synchronisierte Tabelle aus Postgres lesen. Der databricks_superuser besitzt pg_read_all_data, wodurch diese Rolle von allen Tabellen lesen kann. Außerdem verfügt sie über die pg_write_all_data Berechtigung, die es dieser Rolle erlaubt, in alle Tabellen zu schreiben. Dies bedeutet, dass ein databricks_superuser auch in eine synchronisierte Tabelle in Postgres schreiben kann. Lakebase unterstützt dieses Schreibverhalten, falls Sie dringende Änderungen an Ihrer Zieltabelle vornehmen müssen. Azure Databricks empfiehlt jedoch, stattdessen Korrekturen in der Quelltabelle vorzunehmen.

• Dies databricks_superuser kann auch anderen Benutzern berechtigungen gewähren:

  GRANT USAGE ON SCHEMA synced_table_schema TO user;
  

  GRANT SELECT ON synced_table_name TO user;
  

• databricks_superuser kann diese Berechtigungen widerrufen:

  REVOKE USAGE ON SCHEMA synced_table_schema FROM user;
  

  REVOKE {SELECT | INSERT | UPDATE | DELETE} ON synced_table_name FROM user;
  

Verwalten von synchronisierten Tabellenvorgängen

Die databricks_superuser Kann verwalten, welche Benutzer berechtigt sind, bestimmte Vorgänge für eine synchronisierte Tabelle auszuführen. Die unterstützten Vorgänge für synchronisierte Tabellen sind:

• CREATE INDEX
• ALTER INDEX
• DROP INDEX
• DROP TABLE

Alle anderen DDL-Vorgänge werden für synchronisierte Tabellen verweigert.

Um diese Berechtigungen zusätzlichen Benutzern zu gewähren, muss databricks_superuser zuerst eine Erweiterung für databricks_auth erstellen.

CREATE EXTENSION IF NOT EXISTS databricks_auth;

Anschließend kann ein databricks_superuser Benutzer zum Verwalten einer synchronisierten Tabelle hinzugefügt werden:

SELECT databricks_synced_table_add_manager('"synced_table_schema"."synced_table"'::regclass, '[user]');

Der databricks_superuser kann einen Benutzer von der Verwaltung einer synchronisierten Tabelle entfernen.

SELECT databricks_synced_table_remove_manager('[table]', '[user]');

databricks_superuser kann alle Vorgesetzten anzeigen:

SELECT * FROM databricks_synced_table_managers;

Löschen einer synchronisierten Tabelle

Durch das Löschen einer synchronisierten Tabelle aus dem Unity-Katalog wird auch die entsprechende Postgres-Tabelle gelöscht.

Benutzeroberfläche

Suchen Sie im Katalog ihre synchronisierte Tabelle, klicken Sie auf das Menü, und wählen Sie "Löschen" aus.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

w.postgres.delete_synced_table("synced_tables/my-catalog.sales.orders").wait()

Java SDK

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

w.postgres().deleteSyncedTable("synced_tables/my-catalog.sales.orders").waitForCompletion();

cURL

curl -X DELETE "https://your-workspace.cloud.databricks.com/api/2.0/postgres/synced_tables/my-catalog.sales.orders" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}"

Weitere Informationen

Katalogintegration

• Katalogduplizierung: Das Erstellen einer synchronisierten Tabelle in einem Standardkatalog für eine Postgres-Datenbank, die auch als separater Datenbankkatalog registriert ist, bewirkt, dass die synchronisierte Tabelle im Unity-Katalog sowohl im Standard- als auch im Datenbankkatalog angezeigt wird.

Weitere Optionen

Informationen zu Möglichkeiten, Daten in Nicht-Databricks-Systeme zu synchronisieren, finden Sie unter Partner Connect ETL-Lösungen umkehren wie Census oder Hightouch.