Traiter des données lakehouse avec des tables synchronisées

Les tables synchronisées vous permettent de servir des données de qualité analytique provenant de Unity Catalog via Lakebase Postgres. Les tables du catalogue Unity se synchronisent avec Postgres afin que les applications puissent interroger les données lakehouse directement avec une faible latence. L’ensemble de ce processus est généralement connu sous le nom d'extraction, transformation et chargement (ETL) inversé. Le lakehouse est optimisé pour l’analytique et l’enrichissement, tandis que Lakebase est conçu pour des charges de travail opérationnelles nécessitant des requêtes rapides de type recherche et des transactions ACID complètes. Les tables synchronisées comblent le fossé entre le stockage analytique et les systèmes opérationnels en gardant vos données prêtes à être utilisées dans des applications en temps réel.

Exemples de cas d’usage

Vous pouvez utiliser des tables synchronisées pour des cas d’utilisation liés au service de données tels que :

• Moteurs de personnalisation qui fournissent de nouveaux profils utilisateur aux Applications Databricks
• Applications qui traitent les prédictions de modèle ou les valeurs de fonctionnalités calculées dans le lakehouse
• Tableaux de bord destinés aux clients qui fournissent des indicateurs de performance clés en temps réel
• Services de détection des fraudes qui fournissent des scores de risque pour agir immédiatement
• Outils de support qui traitent les enregistrements client enrichis des données lakehoude

Sources prises en charge

Les tables synchronisées prennent en charge les types de sources de catalogue Unity suivants :

• Tables Delta managées et externes
• Tables Iceberg managées et externes
• Vues et vues matérialisées

Fonctionnement

Les tables synchronisées Databricks créent une copie managée de vos données Unity Catalog dans Lakebase. Lorsque vous créez une table synchronisée, vous obtenez :

1. Table synchronisée dans le catalogue Unity qui fait référence au pipeline de synchronisation
2. Une table Postgres dans Lakebase (en lecture seule, interrogeable par vos applications)

Par exemple, vous pouvez synchroniser des tables d'or, des fonctions conçues ou des sorties ML depuis analytics.gold.user_profiles vers une nouvelle table analytics.gold.user_profiles_synced synchronisée. Dans Postgres, le nom du schéma du catalogue Unity devient le nom du schéma Postgres. Cela s’affiche donc comme gold.user_profiles_syncedsuit :

SELECT * FROM gold.user_profiles_synced WHERE user_id = 12345;

Les applications se connectent aux pilotes Postgres standards et interrogent les données synchronisées en même temps que leur propre état opérationnel, en gérant les insertions, mises à jour et suppressions sur leurs propres tables dans la même base de données.

Les pipelines de synchronisation utilisent des pipelines Lakeflow managés pour mettre à jour en continu la table de catalogue Unity et la table Postgres avec des modifications de la table source. Chaque synchronisation peut utiliser jusqu’à 16 connexions à votre base de données Lakebase. Les limites de connexion dépendent de la taille de calcul/compute. Consultez Spécifications de calcul

Synchronisation accélérée avec LTAP Direct Writes

LTAP Direct Writes est un réglage optionnel de table synchronisée qui accélère les chargements volumineux. Cela fait partie de l’architecture LTAP. Elle est désactivée par défaut. Vous pouvez l’activer pour chaque table synchronisée en sélectionnant LTAP Direct Writes sous les paramètres de synchronisation dans la boîte de dialogue Créer une table synchronisée. Lorsqu’elle est activée, cette option écrit les données directement dans la couche de stockage sous-jacente à votre branche Lakebase, au lieu de faire transiter l’écriture en bloc via le point de terminaison de calcul actif, afin que les opérations de chargement se terminent plus rapidement et n’ajoutent pas de charge de requêtes au point de terminaison pendant leur exécution.

Ce que LTAP Direct Writes accélère dépend du mode de synchronisation :

• Tous les modes : Le chargement initial. Chaque table synchronisée commence par charger une copie complète de la source, et ce premier chargement utilise des écritures directes LTAP.
• Snapshot : chaque synchronisation suivante, car le mode Snapshot effectue une actualisation complète à chaque synchronisation.
• Déclenché et Continu : Uniquement lors du chargement initial. Les mises à jour ultérieures sont appliquées de manière incrémentale via Change Data Feed, et non sous forme de charges en masse.

Modes de synchronisation

Choisissez le mode de synchronisation approprié en fonction des besoins de votre application :

Dans la boîte de dialogue Créer une table synchronisée, Instantané et Déclenché sont tous deux des modes de synchronisation à la demande, disponibles dans les paramètres avancés, tandis que Continu est un mode distinct.

L’exigence de la source dépend du mode de synchronisation :

• Snapshot copie toutes les données de chaque synchronisation, donc la source n’a besoin de supporter SELECT *que .
• Triggered et Continuous appliquent de façon incrémentielle les modifications au niveau des lignes ; la source doit donc fournir un flux de données de modification. Activez le flux de données de changement au moment d’écriture sur la source, ou utilisez le flux automatique de données de changement. Si une source déclenchée ou continue n’a pas de flux de données de changement, l’interface affiche un avertissement avec la commande exacte ALTER TABLE à exécuter.

Le flux automatique de données de changement calcule les modifications au niveau des lignes au moment de la lecture au lieu d’exiger un flux de données de modification en écriture sur la source. Cela permet à plus de types de sources, y compris les tables Apache Iceberg, de synchroniser en mode déclenché ou continu. Pour les types de sources pris en charge par le flux automatique de données de changement, consultez la documentation du flux automatique de données de changement .

Créer une table synchronisée

Prerequisites

Tu as besoin de:

• Un espace de travail Databricks avec Lakebase activé.
• Un projet Lakebase (voir Créer un projet).
• Table de catalogue Unity à synchroniser.
• Autorisations pour créer des tables synchronisées. Vous devez USE_SCHEMA et CREATE_TABLE pour tous les schémas que vous utilisez. Pour accorder ces privilèges, consultez Gérer les privilèges dans Unity Catalog.

Pour les modes déclenché ou continu , la source doit fournir un flux de données de changement. Soit activez le flux de données de changement hérité sur une table source éligible de Delta Lake, soit utilisez le flux automatique de données de changement pour des sources telles que les tables Apache Iceberg.

Pour activer le flux de données de changement lors de l'écriture sur une table source Delta, exécutez :

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

Avant de créer une table synchronisée, examinez ce qui suit :

• Source : Les types de sources pris en charge sont listés dans Sources prises en charge.
• Noms et limites : les règles de nommage, l’utilisation de la connexion et les limites par source sont listées dans Planification de capacité.
• Types de colonnes : Les mappages de types, types non pris en charge et caractères qui causent des échecs de synchronisation sont couverts dans Types de données et compatibilité.
• Identité du créateur : L’identité qui crée la table synchronisée se voit accorder l’accès à celle-ci, et vous ne pouvez pas réattribuer cet accès plus tard. Voir Accès pour l’utilisateur qui crée une table synchronisée.

IU

1. Dans Lakehouse, allez dans Catalogue dans la barre latérale de l’espace de travail, puis sélectionnez la table Unity Catalog que vous souhaitez synchroniser.

   

2. Cliquez sur Créer une>table synchronisée à partir de la vue détails de la table.

   

3. Dans la boîte de dialogue Créer une table synchronisée, configurez les sections suivantes, puis cliquez sur Créer :

   Destination

   • Nom : Sélectionnez le catalogue et le schéma de la table synchronisée, puis entrez un nom de table. Cela crée une table synchronisée de catalogue Unity et une table Postgres que vous pouvez interroger. Les listes de catalogues et de schémas incluent uniquement les schémas Unity Catalog pour lesquels vous disposez des privilèges USE_SCHEMA et CREATE_TABLE. Si vous ne voyez pas de schéma attendu, confirmez vos autorisations auprès de votre administrateur de catalogue.
   • Base de données Lakebase Postgres : Définissez le type de base de données sur Autoscaling, puis sélectionnez votre base de données Project, Branch et Postgres.

   Paramètres de synchronisation

   • Mode de synchronisation : Sélectionnez À la demande ou Continu. Pour le mode À la demande, développez les paramètres avancés et choisissez Instantané ou Déclenché. Consultez les modes de synchronisation pour obtenir des conseils.
   • LTAP Direct Writes : (Facultatif) cochez cette case pour accélérer le chargement initial. Cette option est prise en charge sur les projets Lakebase exécutant Postgres 16, 17 ou 18. Si vous ne voyez pas cette case à cocher, un administrateur de l’espace de travail doit activer l’aperçu LTAP Direct Writes depuis la page des Aperçus. Consultez Synchronisation accélérée avec LTAP Direct Writes.

   Paramètres du pipeline

   • Pipeline : Sélectionnez Créer pour créer un pipeline pour cette table synchronisée, ou Utiliser l’existant pour en réutiliser un.
   • Stratégie d’utilisation serverless : (Facultatif) sélectionnez une stratégie d’utilisation serverless pour le pipeline de synchronisation.

   Schéma

   • Clé primaire : vérifier la clé primaire (généralement détectée automatiquement). Laissez Unique sélectionné si chaque valeur de clé primaire est unique dans la source. Si les valeurs de la clé primaire peuvent se répéter, désactivez Unique et définissez une Timeseries Key. Vous ne pouvez pas changer la clé principale ou la clé de la série temporelle après avoir créé la table synchronisée.

     Important

     Les colonnes de la clé primaire ne peuvent pas être nulles dans la table synchronisée. Les lignes avec des valeurs Null dans les colonnes de clé primaire sont exclues de la synchronisation.

   • Clé de série chronologique : (Facultatif) lorsque les valeurs de clé primaire peuvent se répéter dans la source, sélectionnez une colonne pour configurer la déduplication. La table synchronisée contient alors uniquement la ligne présentant la valeur de clé de série chronologique la plus récente pour chaque clé primaire. Pour le cas d’échec sans clé de série temporelle, voir Clés dupliquées.

   • Personnaliser les types de colonnes : (Facultatif) remplacez le mappage par défaut des colonnes sources avec les types Postgres. Si vous mappez les colonnes vers vector ou halfvec, installez d’abord une extension vectorielle dans la base de données de destination. Consultez Mappages de types personnalisés.

   Si vous avez choisi Déclenché ou Continu et que vous n’avez pas encore activé Modifier le flux de données, un avertissement s’affiche avec la commande exacte à exécuter.

4. Surveillez la table synchronisée dans le catalogue. L’onglet Vue d’ensemble affiche l’état de synchronisation, la configuration, l’état du pipeline et le dernier horodatage de synchronisation. Utilisez La synchronisation maintenant pour l’actualisation manuelle.

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

L’argument SYNCED_TABLE_ID positionnel utilise le format catalog.schema.table. Dans Postgres, la table {table} est créée dans le schéma {schema}, à l’intérieur de la base de données avec laquelle postgres_database vous avez défini (ici, mydb). La commande attend que l’opération se termine par défaut. Pour toutes les options disponibles, consultez databricks postgres create-synced-table.

Pour redéfinir les correspondances de type de colonne par défaut, ajoutez type_overrides à spec. Consultez Mappages de types personnalisés.

Kit de développement logiciel (SDK) Python

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

Le synced_table_id utilise le format catalog.schema.table qui devient le nom de table synchronisée du catalogue Unity. Dans Postgres, la table {table} est créée dans le schéma {schema}, à l’intérieur de la base de données avec laquelle postgres_database vous avez défini (ici, mydb).

Kit de développement logiciel (SDK) Java

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

Ceci renvoie une opération longue. Interrogez le champ name renvoyé jusqu’à done: true. Consultez les opérations de longue durée. Pour la configuration de l’authentification, consultez Authentification.

Planifier ou déclencher des synchronisations ultérieures

Le chargement initial s’exécute automatiquement lorsque vous créez une table synchronisée. Ensuite, la façon dont les synchronisations s’exécutent dépend du mode de synchronisation :

• Le mode Continu diffuse les modifications au fur et à mesure. Tu n’as pas besoin de déclencher des synchronisations.
• Les modes Instantané et Déclenché se synchronisent uniquement lors du déclenchement. Pour exécuter une synchronisation manuellement, ouvrez la table synchronisée dans Catalogue et cliquez sur Synchroniser maintenant dans l’onglet Vue d’ensemble. Pour exécuter automatiquement les synchronisations, ajoutez le pipeline de la table synchronisée à un travail dans Lakeflow Jobs en tant que tâche Database Table Sync pipeline, puis configurez le travail avec l’un des déclencheurs suivants :
  • Déclencher lors des mises à jour de la table source : Idéal pour le mode Déclenché.
  • Déclenchement selon un planning : Idéal pour le mode Snapshot .

Déclencheur pour les mises à jour de la table source

Déclenche le travail lorsque la table de catalogue Unity source est mise à jour. Avec le mode déclenché , seules les nouvelles modifications sont appliquées de manière incrémentielle, ce qui donne une actualisation quasi en temps réel sans le coût permanent du mode continu.

1. Dans votre espace de travail, cliquez sur Travaux & Pipelines dans la barre latérale.
2. Cliquez sur Créer un travail ou ouvrez un travail existant.
3. Sous l’onglet Tâches , cliquez sur + Ajouter un autre type de tâche.
4. Sous Ingestion et Transformation, sélectionnez pipeline de synchronisation de table de base de données.
5. Dans le champ Pipeline , sélectionnez le pipeline associé à votre table synchronisée.
6. Sous Planifications et déclencheurs, cliquez sur Ajouter un déclencheur.
7. Sélectionnez Mise à jour de table comme type de déclencheur.
8. Sous Tables, sélectionnez la table de catalogue Unity source à surveiller.
9. Cliquez sur Enregistrer.

Déclencher selon une planification

Exécute la synchronisation à une cadence fixe. Adaptée au mode Instantané, où une actualisation complète nocturne ou hebdomadaire constitue généralement le modèle le plus efficace.

1. Dans votre espace de travail, cliquez sur Travaux & Pipelines dans la barre latérale.
2. Cliquez sur Créer un travail ou ouvrez un travail existant.
3. Sous l’onglet Tâches , cliquez sur + Ajouter un autre type de tâche.
4. Sous Ingestion et Transformation, sélectionnez pipeline de synchronisation de table de base de données.
5. Dans le champ Pipeline , sélectionnez le pipeline associé à votre table synchronisée.
6. Sous Planifications et déclencheurs, cliquez sur Ajouter un déclencheur.
7. Sélectionnez Scheduled comme type de déclencheur.
8. Définissez votre planification cron et votre fuseau horaire, puis cliquez sur Enregistrer.

Vérifier l’état de synchronisation

Pour vérifier l’état actuel et l’heure de la dernière synchronisation d’une table synchronisée :

IU

Dans Catalogue, accédez à votre table synchronisée et sélectionnez l’onglet Vue d’ensemble . Il affiche l’état de synchronisation actuel, l’état du pipeline et le dernier horodatage de synchronisation.

Kit de développement logiciel (SDK) Python

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

Kit de développement logiciel (SDK) Java

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

Types de données et compatibilité

Les types de données du catalogue Unity sont mappés aux types Postgres lors de la création de tables synchronisées. Les types complexes (ARRAY, MAP, STRUCT) et VARIANT sont stockés sous forme JSONB dans Postgres.

Mappages de types personnalisés

Lorsque vous créez une table synchronisée, vous pouvez remplacer la correspondance par défaut Delta-à-Postgres pour des colonnes spécifiques avec type_overrides.

CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;

Les mappages personnalisés de types sont configurables lorsque vous créez une table synchronisée. Dans l’interface, utilisez Personnaliser les types de colonnes sous Schéma dans la boîte de dialogue Créer une table synchronisée . Dans les SDK API, CLI et Databricks, utilisez type_overrides.

Pour une table source main.docs.chunks(id BIGINT, title STRING, embedding ARRAY<FLOAT>), les correspondances suivantes associent title à varchar(256) et embedding à vector(1024) dans 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 }
      ]
    }
  }'

Sans la dérogation, title serait TEXT et embedding serait JSONB.

Gérer les caractères non valides

Certains caractères tels que les octets Null (0x00) sont autorisés dans les colonnes STRING, ARRAY, MAP ou STRUCT du catalogue Unity, mais pas prises en charge dans les colonnes TEXT ou JSONB Postgres. Cela peut entraîner des échecs de synchronisation avec des erreurs telles que :

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

• La première erreur se produit lorsqu’un octet Null apparaît dans une colonne de chaîne de niveau supérieur, qui est mappée directement à Postgres TEXT.
• La deuxième erreur se produit lorsqu’un octet Null apparaît dans une chaîne imbriquée à l’intérieur d’un type complexe (STRUCT, ARRAYou MAP), qui est sérialisé en tant que JSONB. Pendant la sérialisation, toutes les chaînes sont converties en Postgres TEXT, où \u0000 est interdit.

Solutions :

• Nettoyer les champs de chaîne : supprimez les caractères non pris en charge avant la synchronisation. Pour les octets null dans les colonnes STRING :

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

• Convertir en BINARY : pour les colonnes STRING où la conservation des octets bruts est nécessaire, convertissez en type BINARY.

Planification de la capacité

Lors de la planification de l’implémentation de vos tables synchronisées, tenez compte des besoins en ressources suivants :

• Utilisation des connexions : chaque table synchronisée utilise jusqu’à 16 connexions à votre base de données Lakebase, qui comptent dans la limite de connexion du projet.
• Quota de taille : Le total des données logiques sur toutes les tables synchronisées compte dans le quota de stockage de la base de données de la branche. Contactez le support Databricks si vous avez besoin d’un quota plus important. Les tables individuelles n’ont pas de quota, mais Databricks recommande de ne pas dépasser 1 To pour les tables nécessitant des actualisations.
• Taille d’actualisation complète : lors du déclenchement d’une actualisation complète, l’ancienne version dans Postgres n’est pas supprimée tant que la nouvelle synchronisation n’est pas terminée. Les deux versions sont temporairement prises en compte dans le quota de taille logique de la base de données pendant l’opération d’actualisation.
• Tables par source : une table source unique peut avoir jusqu’à 20 tables synchronisées.
• Exigences de nommage : Les noms de base de données, de schéma et de table peuvent contenir uniquement des caractères alphanumériques et des traits de soulignement ([A-Za-z0-9_]+).
• Conseils relatifs à l’identificateur de source : évitez d’utiliser des lettres majuscules ou des caractères spéciaux dans les noms de colonnes ou de tables de la table catalogue Unity source. Si vous les conservez, vous devez citer ces identificateurs lors de leur référencement dans Postgres.
• Évolution du schéma : seules les modifications de schéma additifs (comme l’ajout de colonnes) sont prises en charge pour les modes déclenchés et continus.
• Modification de la définition de la table : La mise à jour de la définition d’une table synchronisée en place n’est prise en charge via aucune interface (UI, SDK, CLI, REST API, Terraform ou DAB). Pour modifier la clé primaire ou la clé de la série temporelle, ou pour effectuer un changement de schéma non additif, supprimez la table synchronisée et créez-en une nouvelle.
• Clés en double : si deux lignes ont la même clé primaire dans la table source, le pipeline de synchronisation échoue, sauf si vous configurez la déduplication à l’aide d’une clé timeseries.
• Idempotence des API : les API des tables synchronisées sont idempotentes ; réessayez en cas d’erreurs transitoires afin de garantir l’exécution des opérations dans les délais.
• Taux de mise à jour : Pour Lakebase, le pipeline de synchronisation prend en charge les écritures continues et déclenchées à environ 150 lignes par seconde par unité de capacité (CU) et les écritures instantanées jusqu’à 2 000 lignes par seconde par CU.

Opérations autorisées sur des tables synchronisées dans Postgres

Azure Databricks recommande d’effectuer uniquement les opérations suivantes dans Postgres pour les tables synchronisées afin d’éviter les remplacements accidentels ou les incohérences de données :

• Requêtes en lecture seule
• Création d’index (voir Ajouter des indices à une table synchronisée)
• Suppression de la table (pour libérer de l’espace après avoir supprimé la table synchronisée du catalogue Unity)

Bien qu’il soit possible de modifier des tables synchronisées dans Postgres d’une autre manière, elle interfère avec le pipeline de synchronisation.

Ajouter des index à une table synchronisée

Une table synchronisée est créée avec un index de clé primaire. Pour ajouter d’autres index, créez-les dans Postgres une fois la table créée. Par exemple, pour prendre en charge les requêtes d’inclusion sur une colonne JSONB, comme une colonne synchronisée à partir d’une colonne source VARIANT, créez un indice GIN :

CREATE INDEX orders_payload_gin ON sales.orders USING GIN (payload);

Les index que vous créez sur une table synchronisée persistent à travers les synchronisations. Chaque charge complète, y compris chaque synchronisation Snapshot et tout rafraîchissement complet, reconstruit vos index, donc chaque index supplémentaire ajoute du temps à ces synchronisations. En modes déclenché et continu, chaque index ralentit aussi les mises à jour incrémentales.

Pour créer des index, vous devez être le propriétaire ou créateur de la table synchronisée, le databricks_superuser, ou un utilisateur ajouté comme gestionnaire de la table synchronisée. Voir Gérer les opérations de table synchronisées.

Gardez à l’esprit ce qui suit lorsque vous créez des indices :

• Les tables synchronisées sont des tables partitionnées. Postgres ne prend pas en charge CREATE INDEX CONCURRENTLY sur une table partitionnée, donc utilisez CREATE INDEX à la place. CREATE INDEX bloque les écritures sur la table, y compris celles du pipeline de synchronisation, jusqu’à la fin de la création de l’index. Si la configuration prend plus de 20 minutes pendant qu’une synchronisation est en attente, la synchronisation échoue et n’est pas réessayée automatiquement. Les requêtes peuvent toujours lire la table, sauf si un chargement complet est en attente de basculer vers les données actualisées. Sur les grandes tables, créez des index lorsqu’aucune synchronisation n’est en cours.
• Exécutez des créations longues d’index depuis un client Postgres. Construire un index sur une grande table peut prendre beaucoup de temps. Exécutez le build depuis un client tel que psql au lieu de l’éditeur SQL.

Propriété et autorisations

Une table synchronisée appartient au rôle interne databricks_writer_<dbid> , et non à l’utilisateur qui l’a créée, car le pipeline de synchronisation le gère (voir rôles Postgres). Les commandes propriétaire uniquement, telles que la configuration de la sécurité au niveau des lignes, ne peuvent pas être exécutées directement sur une table synchronisée.

Accès pour l’utilisateur qui crée une table synchronisée

Lorsque vous créez une table synchronisée, votre identité de Azure Databricks est automatiquement autorisée à l’utiliser. Aucune databricks_superuser action n’est requise. Votre identité dispose des privilèges suivants sur la table synchronisée :

Vous ne disposez pas de INSERT ou de UPDATE. Le pipeline possède les données de la table, de sorte que les écritures directes sont remplacées lors de la prochaine actualisation. DELETE et TRUNCATE effacent uniquement le tableau. L’actualisation suivante remplit la table à partir de la source.

Cet accès est dérivé de vos autorisations de catalogue Unity sur la table synchronisée et est géré dans le catalogue Unity. Pour le modifier, mettez à jour les autorisations du catalogue Unity de l’utilisateur. Vous ne pouvez pas le REVOKE à partir d'une identité Azure Databricks directement dans Postgres.

Gérer l’accès aux tables synchronisées

Après la création d’une table synchronisée, le databricks_superuser peut lire une table synchronisée depuis Postgres. databricks_superuserA pg_read_all_data , qui permet à ce rôle de lire à partir de toutes les tables. Il possède également le privilège pg_write_all_data, ce qui permet à ce rôle d’écrire dans toutes les tables. Cela signifie qu’un databricks_superuser peut également écrire dans une table synchronisée dans Postgres. Lakebase prend en charge ce comportement d’écriture si vous devez apporter des modifications urgentes dans votre table cible. Toutefois, Azure Databricks recommande d’apporter des correctifs dans votre table source à la place.

• databricks_superuser peut également accorder ces privilèges à d'autres utilisateurs :

  GRANT USAGE ON SCHEMA synced_table_schema TO user;
  

  GRANT SELECT ON synced_table_name TO user;
  

• databricks_superuser peut révoquer ces privilèges :

  REVOKE USAGE ON SCHEMA synced_table_schema FROM user;
  

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

Gérer les opérations de table synchronisée

Les databricks_superuser peuvent gérer quels utilisateurs sont autorisés à effectuer des opérations spécifiques sur une table synchronisée. Les opérations prises en charge pour les tables synchronisées sont les suivantes :

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

Toutes les autres opérations DDL sont refusées pour les tables synchronisées.

Pour accorder ces privilèges à des utilisateurs supplémentaires, databricks_superuser doit d’abord créer une extension sur databricks_auth:

CREATE EXTENSION IF NOT EXISTS databricks_auth;

Ensuite, databricks_superuser peut ajouter un utilisateur pour gérer une table synchronisée :

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

Le databricks_superuser peut supprimer un utilisateur de la gestion d’une table synchronisée.

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

databricks_superuser peut afficher tous les gestionnaires :

SELECT * FROM databricks_synced_table_managers;

Supprimer une table synchronisée

La suppression d’une table synchronisée à partir du catalogue Unity supprime également la table Postgres correspondante.

IU

Dans Catalogue, recherchez votre table synchronisée, cliquez sur Menu, puis sélectionnez Supprimer.

Kit de développement logiciel (SDK) Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

Kit de développement logiciel (SDK) Java

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

Intégration du catalogue

Une table synchronisée peut apparaître dans plus d’un catalogue dans Unity Catalog. Cette duplication de catalogue est attendue lorsque vous créez une table synchronisée dans un catalogue standard et que sa base de données Postgres de destination est également enregistrée comme un catalogue de base de données. Dans ce cas, la table synchronisée apparaît dans les deux catalogues.

Synchroniser vers des systèmes en dehors d’Azure Databricks

Pour synchroniser des données dans des systèmes autres que Databricks, consultez les solutions ETL inversées Partner Connect telles que Census ou Hightouch.

Ressources additionnelles

• Apprenez à vous connecter à votre base de données
• Enregistrer une base de données Lakebase dans le catalogue Unity
• Découvrez Unity Catalog