Lakehouse-gegevens met gesynchroniseerde tabellen gebruiken

Met gesynchroniseerde tabellen kunt u lakehouse-gegevens bedienen via Lakebase Postgres. Unity Catalog-tabellen worden gesynchroniseerd met Postgres, zodat toepassingen rechtstreeks met lage latentie query's kunnen uitvoeren op Lakehouse-gegevens. Dit proces wordt vaak omgekeerde ETL genoemd. Lakehouse is geoptimaliseerd voor analyses en verrijking, terwijl Lakebase is ontworpen voor operationele workloads die snelle query's in opzoekstijl en transactionele consistentie vereisen.

Wat zijn gesynchroniseerde tabellen?

Met gesynchroniseerde tabellen kunt u gegevens van Unity Catalog op analyseniveau leveren via Lakebase Postgres, zodat deze beschikbaar zijn voor toepassingen die query's met lage latentie en volledige ACID-transacties nodig hebben. Ze overbruggen de kloof tussen analytische opslag en operationele systemen door uw gegevens gereed te houden voor realtime toepassingen.

Ondersteunde bronnen

Gesynchroniseerde tabellen ondersteunen de volgende Unity Catalog-brontypen:

• Beheerde en externe Delta-tabellen
• Beheerde en externe Iceberg-tabellen
• Weergaven en gematerialiseerde weergaven

Hoe werkt het?

Met Databricks gesynchroniseerde tabellen maakt u een beheerde kopie van uw Unity Catalog-gegevens in Lakebase. Wanneer u een gesynchroniseerde tabel maakt, krijgt u het volgende:

1. Een gesynchroniseerde tabel in Unity Catalog die verwijst naar de synchronisatiepijplijn
2. Een Postgres-tabel in Lakebase (alleen-lezen, doorzoekbaar door uw toepassingen)

U kunt bijvoorbeeld gouden tabellen, ontworpen functies of ML-uitvoer synchroniseren van analytics.gold.user_profiles naar een nieuwe gesynchroniseerde tabel analytics.gold.user_profiles_synced. In Postgres wordt de naam van het Unity Catalog-schema de Postgres-schemanaam, dus dit wordt weergegeven als gold.user_profiles_synced:

SELECT * FROM gold.user_profiles_synced WHERE user_id = 12345;

Toepassingen maken verbinding met standaardPostgres-stuurprogramma's en voeren een query uit op de gesynchroniseerde gegevens naast hun eigen operationele status.

Synchronisatiepijplijnen maken gebruik van beheerde Lakeflow-pijplijnen om de gesynchroniseerde tabel van Unity Catalog en de Postgres-tabel continu bij te werken met wijzigingen uit de brontabel. Elke synchronisatie kan maximaal 16 verbindingen met uw Lakebase-database gebruiken.

Lakebase Postgres ondersteunt maximaal 1.000 gelijktijdige verbindingen met transactionele garanties, zodat toepassingen verrijkte gegevens kunnen lezen terwijl ook inserts, updates en verwijderingen in dezelfde database worden verwerkt.

Versnelde initiële synchronisatie

LTAP Direct Writes is een bètafunctie van de LTAP-architectuur die de tijd voor initiële ladingen en volledige verversingen vermindert. Het laadt gegevens rechtstreeks in de opslaglaag die ten grondslag ligt aan je Lakebase-branch, in plaats van de bulkschrijfactie via het live-compute-eindpunt te routeren. Daardoor worden grote taken sneller voltooid en voegen ze tijdens het uitvoeren geen querybelasting toe aan het endpoint.

De LTAP Direct Writes-functionaliteit versnelt de initiële belasting voor elke synchronisatiemodus. Elke gesynchroniseerde tabel begint met het laden van een volledige kopie van de bron, en die eerste keer worden LTAP Direct Writes gebruikt, ongeacht of je kiest voor de modus Snapshot, Triggered of Continue. Het versnelt ook volledige verversingen, inclusief de terugkerende volledige ladingen die Snapshot-modus bij elke volgende synchronisatie uitvoert.

LTAP Direct Writes is in bèta en vereist een Lakebase-project dat Postgres 17 draait. Om het te gebruiken, schakelt een workspace-beheerder de LTAP Direct Writes-preview in vanaf de pagina Voorlezen in de werkruimte-instellingen.

Op Azure is LTAP Direct Writes beschikbaar in alle regio's behalve East US, East US 2, West Europe en West US 2.

Synchronisatiemodi

Kies de juiste synchronisatiemodus op basis van uw toepassingsbehoeften:

De bronvereiste hangt af van de synchronisatiemodus:

• Snapshot kopieert alle data bij elke synchronisatie, dus de bron hoeft alleen . te ondersteunen SELECT *.
• Getriggerd en Continu passen rijniveauwijzigingen incrementeel toe, dus de bron moet een wijzigingsdatafeed leveren. Schakel de schrijftijd-wijzigingsdatafeed in op de bron, of gebruik de automatische wijzigingsdatafeed. Als een getriggerde of continue bron geen feed voor wijzigingsgegevens heeft, toont de gebruikersinterface een waarschuwing met het exacte commando ALTER TABLE om uit te voeren.

De automatische wijzigingsdatafeed (Public Preview) berekent wijzigingen op rijniveau tijdens het lezen in plaats van een schrijftijdwijzigingsdatafeed op de bron te vereisen. Dit maakt het mogelijk dat meer brontypen, waaronder Apache Iceberg-tabellen en gematerialiseerde weergaven, synchroniseren in Triggered of Continu modus. Voor de brontypes die de automatische wijzigingsdatafeed ondersteunt, zie de documentatie voor de automatische wijzigingsdatafeed .

De automatische wijzigingsdatafeed voor gesynchroniseerde tabellen staat in preview. Terwijl het in preview is, voltooi je twee extra stappen:

1. Schakel het voorbeeld in. Een werkruimtebeheerder schakelt de previewfunctie Feed voor automatische wijzigingsgegevens in op de pagina Previews in de werkruimte-instellingen.

2. Stel het pijplijnkanaal in op preview. Wanneer je de gesynchroniseerde tabel aanmaakt, zet je het pipelinekanaal op PREVIEW. Deze optie is momenteel alleen beschikbaar via de API:

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

Voorbeelden van gebruikssituaties

U kunt gesynchroniseerde tabellen gebruiken voor gebruiksscenario's voor datatoepassingen, zoals:

• Personalisatie-engines die nieuwe gebruikersprofielen leveren aan Databricks Apps
• Toepassingen die modelvoorspellingen of functiewaarden leveren die zijn berekend in lakehouse
• Klantgerichte dashboards die prestatie-indicatoren in real time leveren
• Fraudeopsporingsdiensten die risicoscores leveren voor directe actie
• Ondersteuningstools die verrijkte klantgegevens uit lakehouse-data aanbieden

Een gesynchroniseerde tabel maken

Vereiste voorwaarden

U hebt het volgende nodig:

• Een Databricks-werkruimte waarvoor Lakebase is ingeschakeld.
• Een Lakebase-project (zie Een project maken).
• Een Unity Catalog-tabel die moet worden gesynchroniseerd.
• Machtigingen voor het maken van gesynchroniseerde tabellen. U hebt USE_SCHEMA en CREATE_TABLE nodig voor elk schema dat u gebruikt.

Voor geactiveerde of doorlopende modi moet de bron een feed voor wijzigingsgegevens leveren. Schakel ofwel de schrijftijd-wijzigingsdatafeed in op een in aanmerking komende Delta-brontabel, of gebruik de automatische wijzigingsdatafeed voor bronnen zoals Apache Iceberg-tabellen en gematerialiseerde views. De automatische wijzigingsdatafeed bevindt zich in Public Preview en vereist de extra instellingen die in Sync-modi wordt beschreven.

Om de schrijftijdwijzigingsdatafeed op een Delta-brontabel in te schakelen, voer je uit:

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

Zie Gegevenstypen en -compatibiliteit encapaciteitsplanning voor meer informatie over capaciteitsplanning en gegevenstypecompatibiliteit.

UI (Gebruikersinterface)

1. Ga naar Catalogus in de zijbalk van de werkruimte en selecteer de Unity Catalog-tabel die u wilt synchroniseren.

   

2. Klik opGesynchroniseerde tabel> vanuit de tabeldetailsweergave.

   

3. In het dialoogvenster Gesynchroniseerde tabel maken :

   De catalogus- en schemalijsten bevatten alleen Unity Catalog-schema's waarbij de huidige gebruiker USE_SCHEMA en CREATE_TABLE bevoegdheden heeft. Als u geen schema ziet dat u verwacht, bevestigt u uw machtigingen bij de catalogusbeheerder.

   1. Tabelnaam: Voer een naam in voor de gesynchroniseerde tabel (deze wordt gemaakt in dezelfde catalogus en hetzelfde schema als de brontabel). Hiermee maakt u zowel een gesynchroniseerde Unity Catalog-tabel als een Postgres-tabel die u kunt opvragen.

   2. Database-type: Kies Serverloos Lakebase (Automatisch schalen).

   3. Synchronisatiemodus: Kies Momentopname, Geactiveerd of Doorlopend op basis van uw behoeften (zie de synchronisatiemodi hierboven).

   4. Configureer je selectie van projecten, vertakkingen en databases.

   5. Controleer of de primaire sleutel juist is (meestal automatisch gedetecteerd).

      Belangrijk

      Kolommen in de primaire sleutel mogen geen null-waarden bevatten in de gesynchroniseerde tabel. Rijen met null-waarden in primaire-sleutelkolommen worden uitgesloten van de synchronisatie.

   6. (Optioneel) Als twee rijen dezelfde primaire sleutel in de brontabel kunnen delen, selecteert u een Timeseries-sleutel om ontdubbeling te configureren. Wanneer een tijdreekssleutel is opgegeven, bevat de gesynchroniseerde tabel alleen de rij met de meest recente sleutelwaarde voor tijdreeksen voor elke primaire sleutel. Zie Dubbele sleutels voor de foutmodus zonder een tijdreekssleutel.

   Als u Triggered- of Continue-modus hebt gekozen en de Change Data Feed nog niet hebt ingeschakeld, ziet u een waarschuwing met de exacte opdracht die moet worden uitgevoerd. Zie Gegevenstypen en compatibiliteit voor vragen over compatibiliteit van gegevenstypen.

   Klik op Maken om de gesynchroniseerde tabel te maken.

4. Controleer de gesynchroniseerde tabel in Catalog. Op het tabblad Overzicht ziet u de synchronisatiestatus, configuratie, pijplijnstatus en tijdstempel van laatste synchronisatie. Gebruik Nu Synchroniseren voor handmatig vernieuwen.

CLI (Command Line Interface)

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
    }
  }'

Het SYNCED_TABLE_ID positionele argument maakt gebruik van de notatie catalog.schema.table. In Postgres wordt de tabel {table} gemaakt in het schema {schema}, in de database die u hebt ingesteld ( postgres_database hier, mydb). De opdracht wacht totdat de bewerking standaard is voltooid. Zie databricks postgres create-synced-table voor alle beschikbare opties.

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}")

synced_table_id gebruikt het formaat catalog.schema.table en wordt de gesynchroniseerde tabelnaam van de Unity Catalog. In Postgres wordt de tabel {table} gemaakt in het schema {schema}, in de database die u hebt ingesteld ( postgres_database 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
    }
  }'

Hiermee wordt een langlopende bewerking geretourneerd. Poll het geretourneerde name veld totdat done: true. Zie Langlopende bewerkingen. Zie Verificatie voor het instellen van verificatie.

Volgende synchronisaties plannen of activeren

De eerste momentopname wordt automatisch uitgevoerd bij het maken. Voor momentopname- en geactiveerde modi moeten volgende synchronisaties expliciet worden geactiveerd. Continue modus is zelfbeheerd.

Pijplijntaak databasetabelsynchronisatie

De Database Table Sync pipeline-taak in Lakeflow Jobs voert de pijplijn van een gesynchroniseerde tabel uit als een werkstroomstap. Configureer de taak met een trigger voor tabelupdate of een planning.

Trigger voor updates van de brontabel

De taak wordt geactiveerd wanneer de bron-Unity Catalog-tabel wordt bijgewerkt. Met Triggered modus worden alleen nieuwe wijzigingen incrementeel toegepast, waardoor bijna real-time actualisering mogelijk is zonder de altijd-aan kosten van de continue modus.

1. Klik in de zijbalk op Werkstromen.
2. Klik op Taak maken of open een bestaande taak.
3. Klik op het tabblad Taken op + Een ander taaktype toevoegen.
4. Selecteer onder Opname en transformatie de pijplijn voor databasetabelsynchronisatie.
5. Selecteer in het veld Pijplijn de pijplijn die is gekoppeld aan de gesynchroniseerde tabel.
6. Klik onder Planningen en triggers op Trigger toevoegen.
7. Selecteer Tabelupdate als triggertype.
8. Selecteer onder Tabellen de bron Unity Catalog-tabel die u wilt bewaken.
9. Klik op Opslaan.

Triggeren volgens een schema

Hiermee wordt de synchronisatie uitgevoerd met een vaste frequentie. Geschikt voor de momentopnamemodus , waarbij een nachtelijke of wekelijkse volledige vernieuwing doorgaans het meest efficiënte patroon is.

1. Volg stap 1 tot en met 5 hierboven om een databasetabelsynchronisatiepijplijntaak toe te voegen aan een taak.
2. Klik onder Planningen en triggers op Trigger toevoegen.
3. Selecteer Gepland als het triggertype.
4. Stel uw cron-planning en -tijdzone in en klik vervolgens op Opslaan.

Synchronisatiestatus controleren

De huidige status en laatste synchronisatietijd van een gesynchroniseerde tabel controleren:

UI (Gebruikersinterface)

Navigeer in Catalog naar de gesynchroniseerde tabel en selecteer het tabblad Overzicht . Hier ziet u de huidige synchronisatiestatus, de pijplijnstatus en de laatste tijdstempel van de synchronisatie.

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}"

Gegevenstypen en compatibiliteit

Unity Catalog-gegevenstypen worden toegewezen aan Postgres-typen bij het maken van gesynchroniseerde tabellen. Complexe typen (ARRAY, MAP, STRUCT) worden opgeslagen als JSONB in Postgres.

Aangepaste typetoewijzingen

Wanneer je een gesynchroniseerde tabel maakt, kun je de standaard Delta-naar-Postgres type-mapping voor specifieke kolommen overschrijven met type_overrides.

CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;

Aangepaste type-mappings zijn configureerbaar via de API, CLI en Databricks SDK's wanneer je een gesynchroniseerde tabel maakt.

Voor een brontabel main.docs.chunks(id BIGINT, title STRING, embedding ARRAY<FLOAT>) koppelt het volgende title aan varchar(256) en embedding aan vector(1024) in Postgres:

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 }
      ]
    }
  }'

Zonder de override, title zou TEXT en embedding zou zijn JSONB.

Ongeldige tekens verwerken

Bepaalde tekens, zoals null-bytes (0x00), zijn toegestaan in kolommen van Unity Catalog STRING, ARRAY, MAP of STRUCT, maar worden niet ondersteund in Postgres TEXT- of JSONB-kolommen. Dit kan synchronisatiefouten veroorzaken met fouten zoals:

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

• De eerste fout treedt op wanneer een null-byte wordt weergegeven in een tekenreekskolom op het hoogste niveau, die rechtstreeks wordt toegewezen aan Postgres TEXT.
• De tweede fout treedt op wanneer een null-byte wordt weergegeven in een tekenreeks die is genest binnen een complex type (STRUCT, ARRAYof MAP), dat wordt geserialiseerd als JSONB. Tijdens de serialisatie worden alle tekenreeksen naar Postgres TEXTgecast, waar \u0000 niet is toegestaan.

Oplossingen:

• Tekenreeksvelden opschonen: verwijder niet-ondersteunde tekens voordat u synchroniseert. Voor null-bytes in tekenreekskolommen:

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

• Converteren naar BINAIR: Voor STRING-kolommen waarbij onbewerkte bytes nodig zijn, moet u naar BINAIR type converteren.

Capaciteitsplanning

Houd rekening met de volgende resourcevereisten bij het plannen van de implementatie van gesynchroniseerde tabellen:

• Verbindingsgebruik: Elke gesynchroniseerde tabel gebruikt tot 16 verbindingen met je Lakebase-database, die meetellen voor de limiet van het project.
• Quotum voor grootte: Totaal aantal logische gegevens voor alle gesynchroniseerde tabellen heeft een quotum van 16 TB. Neem contact op met databricks-ondersteuning als u een groter quotum nodig hebt. Afzonderlijke tabellen hebben geen quotum, maar Databricks raadt aan maximaal 1 TB te gebruiken voor tabellen waarvoor vernieuwingen zijn vereist.
• Grootte voor volledig vernieuwen: bij het activeren van een volledige vernieuwing wordt de oude versie in Postgres pas verwijderd als de nieuwe synchronisatie is voltooid. Beide versies tellen tijdens het vernieuwingsproces tijdelijk mee voor het groottequotum van de logische database.
• Tabellen per bron: Één brontabel kan maximaal 20 gesynchroniseerde tabellen bevatten.
• Naamgevingsvereisten: database-, schema- en tabelnamen mogen alleen alfanumerieke tekens en onderstrepingstekens ([A-Za-z0-9_]+) bevatten.
• Richtlijnen voor bron-id: Vermijd het gebruik van hoofdletters of speciale tekens in kolom- of tabelnamen in de bron-Unity Catalog-tabel. Als u ze bewaart, moet u deze id's citeren wanneer u ernaar verwijst in Postgres.
• Schemaontwikkeling: Alleen wijzigingen in additief schema (zoals het toevoegen van kolommen) worden ondersteund voor geactiveerde en continue modi.
• Wijziging van de tabeldefinitie: Het bijwerken van de definitie van een gesynchroniseerde tabel wordt niet ondersteund via een interface (UI, SDK's, CLI, REST API, Terraform of DAB's). Om de primaire sleutel of tijdreekssleutel te wijzigen, of om een niet-additieve schemawijziging door te voeren, verwijder je de gesynchroniseerde tabel en maak je een nieuwe aan.
• Dubbele sleutels: als twee rijen dezelfde primaire sleutel in de brontabel hebben, mislukt de synchronisatiepijplijn tenzij u ontdubbeling configureert met behulp van een tijdreekssleutel.
• API-idempotentie: Gesynchroniseerde tabel-API's zijn idempotent, dus probeer het opnieuw op tijdelijke fouten om te zorgen voor tijdige bewerkingen.
• Updatesnelheid: Voor Lakebase ondersteunt de synchronisatiepijplijn continue en getriggerde schrijfacties met ongeveer 150 rijen per seconde per capaciteitseenheid (CU) en snapshot-schrijfacties met maximaal 2.000 rijen per seconde per CU.

Bewerkingen die zijn toegestaan voor gesynchroniseerde tabellen in Postgres

Azure Databricks raadt u aan alleen de volgende bewerkingen uit te voeren in Postgres voor gesynchroniseerde tabellen om onbedoelde overschrijven of inconsistenties van gegevens te voorkomen:

• Query's met het kenmerk Alleen-lezen
• Indexen maken
• De tabel verwijderen (om ruimte vrij te maken na het verwijderen van de gesynchroniseerde tabel uit Unity Catalog)

Hoewel het mogelijk is om gesynchroniseerde tabellen in Postgres op andere manieren te wijzigen, wordt de synchronisatiepijplijn beïnvloed.

Eigendom en machtigingen

Een gesynchroniseerde tabel is eigendom van de interne databricks_writer_<dbid> rol, niet van de gebruiker die deze heeft gemaakt, omdat de synchronisatiepijplijn deze beheert (zie Postgres-rollen). Alleen-eigenaarsopdrachten, zoals het configureren van beveiliging op rijniveau, kunnen niet rechtstreeks worden uitgevoerd in een gesynchroniseerde tabel.

Toegang voor de gebruiker die een gesynchroniseerde tabel maakt

Wanneer u een gesynchroniseerde tabel maakt, krijgt uw Azure Databricks identiteit automatisch toegang om deze te gebruiken. Er is geen databricks_superuser actie vereist. Uw identiteit krijgt de volgende bevoegdheden voor de gesynchroniseerde tabel:

Aan u zijn INSERT of UPDATE niet toegewezen. De pijplijn is eigenaar van de gegevens in de tabel, dus rechtstreekse schrijfacties worden bij de volgende verversing overschreven. DELETE en TRUNCATE alleen de tabel wissen. Met de volgende vernieuwing wordt de tabel opnieuw ingevuld vanuit de bron.

Deze toegang is afgeleid van uw Unity Catalog-machtigingen voor de gesynchroniseerde tabel en wordt beheerd in Unity Catalog. Als u dit wilt wijzigen, werkt u de Unity Catalog-machtigingen van de gebruiker bij. U kunt het niet REVOKE rechtstreeks vanuit een Azure Databricks identiteit in Postgres.

Gesynchroniseerde tabeltoegang beheren

Nadat een gesynchroniseerde tabel is gemaakt, kan de databricks_superuser tabel een gesynchroniseerde tabel lezen uit Postgres. De databricks_superuser heeft pg_read_all_data, waarmee deze rol alle tabellen kan lezen. Het heeft ook de pg_write_all_data bevoegdheid, waarmee deze rol naar alle tabellen kan schrijven. Dit betekent dat een databricks_superuser kan ook schrijven naar een gesynchroniseerde tabel in Postgres. Lakebase ondersteunt dit schrijfgedrag voor het geval u dringende wijzigingen moet aanbrengen in uw doeltabel. Azure Databricks raadt echter aan om in plaats daarvan oplossingen te maken in uw brontabel.

• De databricks_superuser gebruiker kan deze bevoegdheden ook verlenen aan andere gebruikers:

  GRANT USAGE ON SCHEMA synced_table_schema TO user;
  

  GRANT SELECT ON synced_table_name TO user;
  

• De databricks_superuser volgende bevoegdheden kunnen worden ingetrokken:

  REVOKE USAGE ON SCHEMA synced_table_schema FROM user;
  

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

Gesynchroniseerde tabelbewerkingen beheren

Hiermee databricks_superuser kunt u beheren welke gebruikers gemachtigd zijn om specifieke bewerkingen uit te voeren op een gesynchroniseerde tabel. De ondersteunde bewerkingen voor gesynchroniseerde tabellen zijn:

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

Alle andere DDL-bewerkingen worden geweigerd voor gesynchroniseerde tabellen.

Als u deze bevoegdheden wilt verlenen aan extra gebruikers, moet u databricks_superuser eerst een extensie maken op databricks_auth:

CREATE EXTENSION IF NOT EXISTS databricks_auth;

Vervolgens kan de databricks_superuser gebruiker een gebruiker toevoegen om een gesynchroniseerde tabel te beheren:

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

Het databricks_superuser kan een gebruiker verwijderen zodat deze geen gesynchroniseerde tabel meer beheert.

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

De databricks_superuser kan alle managers bekijken.

SELECT * FROM databricks_synced_table_managers;

Een gesynchroniseerde tabel verwijderen

Als u een gesynchroniseerde tabel uit Unity Catalog verwijdert, wordt ook de bijbehorende Postgres-tabel verwijderd.

UI (Gebruikersinterface)

Zoek in Catalogus de gesynchroniseerde tabel, klik op het en selecteer Verwijderen.

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}"

Meer informatie

Catalogusintegratie

• Catalogusduplicatie: Als u een gesynchroniseerde tabel maakt in een standaardcatalogus die is gericht op een Postgres-database die ook is geregistreerd als een afzonderlijke databasecatalogus, wordt de gesynchroniseerde tabel weergegeven in Unity Catalog onder zowel de standaard- als de databasecatalogus.

Andere opties

Zie Partner Connect reverse ETL-oplossingen zoals Census of Hightouch voor het synchroniseren van gegevens in niet-Databricks-systemen.