Leggere i dati condivisi con token di connessione

Questa pagina descrive come leggere i dati condivisi con te usando il protocollo OpenSharing open sharing con token bearer. Include istruzioni per la lettura dei dati condivisi usando gli strumenti seguenti:

• Client Iceberg
• Apache Spark
• Panda
• Power BI
• Tableau

In questo modello di condivisione si usa un file di credenziali condiviso con un membro del team dal provider di dati per ottenere l'accesso in lettura sicuro ai dati condivisi. L'accesso persiste finché la credenziale è valida e il provider continua a condividere i dati. I provider gestiscono la scadenza e la rotazione delle credenziali. Gli aggiornamenti ai dati sono disponibili quasi in tempo reale. È possibile leggere e creare copie dei dati condivisi, ma non è possibile modificare i dati di origine.

Le sezioni seguenti descrivono come usare i client Apache Spark, pandas, Power BI e Iceberg per accedere e leggere i dati condivisi usando il file di credenziali. Per un elenco completo dei connettori OpenSharing e informazioni su come usarli, vedere la documentazione di OpenSharing open source. Se si verificano problemi di accesso ai dati condivisi, contattare il provider di dati.

Prima di iniziare

Un membro del team deve scaricare il file delle credenziali condiviso dal provider di dati e usare un canale sicuro per condividere il file o il percorso del file con l'utente. Vedi Come ottenere l'accesso nel modello di condivisione Databricks-Open.

Per la documentazione specifica del connettore, vedere la pagina delle credenziali di download.

Client Iceberg: Lettura dei dati condivisi

Usare client Iceberg esterni, ad esempio Snowflake, Trino, Flink e Spark, per leggere gli asset di dati condivisi con accesso zero-copy usando l'API del catalogo REST Apache Iceberg.

Ottenere le credenziali di connessione

Prima di accedere agli asset di dati condivisi con client Iceberg esterni, raccogliere le credenziali seguenti:

• Endpoint del catalogo REST di Iceberg
• Token di connessione valido
• Nome della condivisione
• (Facoltativo) Nome dello spazio dei nomi o dello schema
• (Facoltativo) Nome della tabella

L'endpoint del catalogo REST di Iceberg (icebergEndpoint) e il token bearer si trovano nel file di credenziali condiviso con l'utente dal provider di dati. Per altre informazioni, vedere Prima di iniziare. Il nome della condivisione, lo spazio dei nomi e il nome della tabella possono essere individuati a livello di codice usando le API OpenSharing.

Negli esempi seguenti viene illustrato come ottenere le credenziali aggiuntive. Immettere l'endpoint, l'endpoint Iceberg e il token Bearer dal file delle credenziali, dove necessario:

// List shares
curl -X GET "<endpoint>/shares" \
   -H "Authorization: Bearer <bearerToken>"

// List namespaces
curl -X GET "<icebergEndpoint>/v1/shares/<share>/namespaces" \
   -H "Authorization: Bearer <bearerToken>"

// List tables
curl -X GET "<icebergEndpoint>/v1/shares/<share>/namespaces/<namespace>/tables" \
   -H "Authorization: Bearer <bearerToken>"

Configurare il catalogo Iceberg

Dopo aver ottenuto le credenziali di connessione necessarie, configurare il client in modo da usare gli endpoint del catalogo REST di Iceberg per creare ed eseguire query sulle tabelle.

1. Per ogni condivisione, creare un'integrazione del catalogo.

   USE ROLE ACCOUNTADMIN;
   
   CREATE OR REPLACE CATALOG INTEGRATION <CATALOG_PLACEHOLDER>
   CATALOG_SOURCE = ICEBERG_REST
   TABLE_FORMAT = ICEBERG
   REST_CONFIG = (
      CATALOG_URI = '<icebergEndpoint>',
      WAREHOUSE = '<share_name>',
      ACCESS_DELEGATION_MODE = VENDED_CREDENTIALS
   )
   REST_AUTHENTICATION = (
      TYPE = BEARER,
      BEARER_TOKEN = '<bearerToken>'
   )
   ENABLED = TRUE;
   

2. Facoltativamente, aggiungere REFRESH_INTERVAL_SECONDS per mantenere aggiornati i metadati. Impostare il valore in base alla frequenza di aggiornamento del catalogo.

   REFRESH_INTERVAL_SECONDS = 30
   

3. Dopo aver configurato il catalogo, creare un database dal catalogo. In questo modo vengono creati automaticamente tutti gli schemi e le tabelle in tale catalogo.

   CREATE DATABASE <DATABASE_PLACEHOLDER>
   LINKED_CATALOG = (
      CATALOG = <CATALOG_PLACEHOLDER>
   );
   

4. Per confermare che la condivisione ha esito positivo, eseguire una query da una tabella nel database. Verranno visualizzati i dati condivisi da Azure Databricks.

Se il risultato è vuoto o si verifica un errore, seguire questa procedura comune per la risoluzione dei problemi:

• Controllare i privilegi, lo stato di generazione dello snapshot e le credenziali REST.
• Contatta il tuo provider di dati.
• Vedere la documentazione specifica per il client Iceberg.

Esempio: Accedere a tabelle condivise usando diversi client Iceberg

Gli esempi seguenti illustrano come accedere a tabelle openshared usando client Iceberg esterni, ad esempio Snowflake, Apache Spark, PyIceberg e API REST, dopo aver ottenuto le credenziali di connessione. Per altre informazioni su come ottenere le credenziali di connessione, vedere Prima di iniziare.

Snowflake

Per leggere gli asset di dati condivisi in Snowflake, caricare il file delle credenziali scaricato e generare il comando SQL necessario:

1. Dal collegamento di attivazione OpenSharing fare clic sull'icona Snowflake.

2. Nella pagina di integrazione Snowflake, caricare il file delle credenziali ricevuto dal provider di dati.

   

3. Dopo aver caricato le credenziali, scegliere la condivisione a cui si vuole accedere in Snowflake.

4. Fare clic su Genera SQL dopo aver selezionato gli asset desiderati.

   

5. Copiare e incollare il codice SQL generato nel foglio di lavoro Snowflake. Sostituire CATALOG_PLACEHOLDER con il nome del catalogo da usare e DATABASE_PLACEHOLDER con il nome del database che si desidera utilizzare.

Limitazioni

La connessione al catalogo REST Iceberg in Snowflake presenta le limitazioni seguenti:

• Il file di metadati non viene aggiornato automaticamente con lo snapshot più recente. È necessario basarsi sull'aggiornamento automatico o sugli aggiornamenti manuali.
• R2 non è supportato.
• Si applicano tutte le limitazioni del client Iceberg .

Apache Spark

Per accedere alle tabelle condivise tramite Apache Spark, configurare l'API del catalogo REST Iceberg con le impostazioni seguenti. Sostituire <spark-catalog-name> con un nome per il catalogo e specificare le credenziali di connessione:

"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",

# Configuration for accessing tables shared using Delta Sharing
"spark.sql.catalog.<spark-catalog-name>":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.<spark-catalog-name>.type": "rest",
"spark.sql.catalog.<spark-catalog-name>.uri": "<icebergEndpoint>",
"spark.sql.catalog.<spark-catalog-name>.token": "<bearerToken>",
"spark.sql.catalog.<spark-catalog-name>.warehouse":"<share_name>",
"spark.sql.catalog.<spark-catalog-name>.scope":"all-apis"

PyIceberg

PyIceberg è un'implementazione Python per accedere alle tabelle Iceberg senza usare una JVM. PyIceberg richiede pyarrow operazioni di tabella, ad esempio la lettura dei dati e l'ispezione dei metadati della tabella. Installare PyIceberg con gli elementi aggiuntivi pyarrow :

pip install "pyiceberg[pyarrow]"

Per accedere alle tabelle condivise, aggiungere la configurazione del catalogo seguente al file di configurazione pyIceberg:

catalog:
  delta_sharing:
    type: rest
    uri: <icebergEndpoint>
    warehouse: <share_name>
    token: <bearerToken>

REST API

Usare una chiamata API REST come l'esempio seguente curl per caricare una tabella e recuperarne i metadati insieme alle credenziali temporanee per l'accesso ai file di dati:

curl -X GET -H "Authorization: Bearer <bearerToken>" -H "Accept: application/json" \
<icebergEndpoint>/v1/shares/<share_name>/namespaces/<schema_name>/tables/<table_name>

La risposta include i metadati della tabella Iceberg, la posizione S3 e le credenziali AWS temporanee che consentono al client di leggere i file di dati:

{
  "metadata-location": "s3://bucket/path/to/iceberg/table/metadata/file",
  "metadata": <iceberg-table-metadata-json>,
  "config": {
    "expires-at-ms": "<epoch-ts-in-millis>",
    "s3.access-key-id": "<temporary-s3-access-key-id>",
    "s3.session-token": "<temporary-s3-session-token>",
    "s3.secret-access-key": "<temporary-secret-access-key>",
    "client.region": "<aws-bucket-region-for-metadata-location>"
  }
}

Limitazioni del client Iceberg

Quando si eseguono query sui dati OpenSharing dai client Iceberg, si applicano le limitazioni seguenti:

• Quando si elencano tabelle in uno spazio dei nomi, se lo spazio dei nomi contiene più di 100 visualizzazioni condivise, la risposta è limitata alle prime 100 visualizzazioni.

Apache Spark: leggere i dati condivisi

Seguire questa procedura per accedere ai dati condivisi usando Spark 3.x o versione successiva.

Queste istruzioni presuppongono che l'utente abbia accesso al file di credenziali condiviso dal provider di dati. Vedi Come ottenere l'accesso nel modello di condivisione Databricks-Open.

Installare i connettori OpenSharing Python e Spark

Per accedere ai metadati correlati ai dati condivisi, ad esempio l'elenco di tabelle condivise con l'utente, eseguire le operazioni seguenti. Questo esempio usa Python.

1. Installare il connettore Python delta-sharing. Per informazioni sulle limitazioni del connettore Python, vedere Limitazioni del connettore opensharing Python.

   pip install delta-sharing
   

2. Installare il connettore Apache Spark.

Elencare le tabelle condivise utilizzando Spark

Elenca le tabelle nella condivisione. Nell'esempio seguente sostituire <profile-path> con il percorso del file di credenziali.

import delta_sharing

client = delta_sharing.SharingClient(f"<profile-path>/config.share")

client.list_all_tables()

Il risultato è una matrice di tabelle, insieme ai metadati per ogni tabella. L'output seguente mostra due tabelle:

Out[10]: [Table(name='example_table', share='example_share_0', schema='default'), Table(name='other_example_table', share='example_share_0', schema='default')]

Se l'output è vuoto o non contiene le tabelle previste, contattare il provider di dati.

Accedere ai dati condivisi con Spark

Eseguire le operazioni seguenti, sostituendo queste variabili:

• <profile-path>: percorso del file delle credenziali.
• <share-name>: valore di share= per la tabella.
• <schema-name>: valore di schema= per la tabella.
• <table-name>: valore di name= per la tabella.
• <version-as-of>:opzionale. La versione della tabella da utilizzare per caricare i dati. Funziona solo se il provider di dati condivide la cronologia della tabella. Richiede delta-sharing-spark 0.5.0 o versione successiva.
• <timestamp-as-of>:opzionale. Carica i dati nella versione precedente o a quella fornita dalla marca temporale. Funziona solo se il provider di dati condivide la cronologia della tabella. Richiede delta-sharing-spark 0.6.0 o versione successiva.

Python

delta_sharing.load_as_spark(f"<profile-path>#<share-name>.<schema-name>.<table-name>", version=<version-as-of>)

spark.read.format("deltaSharing")\
.option("versionAsOf", <version-as-of>)\
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")\
.limit(10)

delta_sharing.load_as_spark(f"<profile-path>#<share-name>.<schema-name>.<table-name>", timestamp=<timestamp-as-of>)

spark.read.format("deltaSharing")\
.option("timestampAsOf", <timestamp-as-of>)\
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")\
.limit(10)

Scala

spark.read.format("deltaSharing")
.option("versionAsOf", <version-as-of>)
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")
.limit(10)

spark.read.format("deltaSharing")
.option("timestampAsOf", <version-as-of>)
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")
.limit(10)

Accedere al feed di dati delle modifiche condiviso con Spark

Se la cronologia delle tabelle è stata condivisa con l'utente e il feed di dati delle modifiche (CDF) è abilitato nella tabella di origine, accedere al feed di dati delle modifiche eseguendo quanto segue, sostituendo queste variabili. Richiede delta-sharing-spark 0.5.0 o versione successiva.

È necessario specificare un parametro start.

• <profile-path>: percorso del file delle credenziali.
• <share-name>: valore di share= per la tabella.
• <schema-name>: valore di schema= per la tabella.
• <table-name>: valore di name= per la tabella.
• <starting-version>:opzionale. Versione iniziale della query, compresa. Specificare come valore Long.
• <ending-version>:opzionale. Versione finale della query, compresa. Se la versione finale non viene specificata, l'API usa la versione più recente della tabella.
• <starting-timestamp>:opzionale. Il timestamp iniziale della query, che viene convertito in una versione creata in data uguale o successiva a questo timestamp. Specificare come stringa nel formato yyyy-mm-dd hh:mm:ss[.fffffffff].
• <ending-timestamp>:opzionale. Il timestamp finale della query viene convertito in una versione creata in precedenza o uguale a questo timestamp. Specifica come stringa nel formato yyyy-mm-dd hh:mm:ss[.fffffffff]

Python

delta_sharing.load_table_changes_as_spark(f"<profile-path>#<share-name>.<schema-name>.<table-name>",
  starting_version=<starting-version>,
  ending_version=<ending-version>)

delta_sharing.load_table_changes_as_spark(f"<profile-path>#<share-name>.<schema-name>.<table-name>",
  starting_timestamp=<starting-timestamp>,
  ending_timestamp=<ending-timestamp>)

spark.read.format("deltaSharing").option("readChangeFeed", "true")\
.option("startingVersion", <starting-version>)\
.option("endingVersion", <ending-version>)\
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")

spark.read.format("deltaSharing").option("readChangeFeed", "true")\
.option("startingTimestamp", <starting-timestamp>)\
.option("endingTimestamp", <ending-timestamp>)\
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")

Scala

spark.read.format("deltaSharing").option("readChangeFeed", "true")
.option("startingVersion", <starting-version>)
.option("endingVersion", <ending-version>)
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")

spark.read.format("deltaSharing").option("readChangeFeed", "true")
.option("startingTimestamp", <starting-timestamp>)
.option("endingTimestamp", <ending-timestamp>)
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")

Se l'output è vuoto o non contiene i dati previsti, contattare il provider di dati.

Accedere a una tabella condivisa usando Spark Structured Streaming

Se la cronologia delle tabelle viene condivisa con l'utente, è possibile trasmettere in streaming i dati condivisi. Richiede delta-sharing-spark 0.6.0 o versione successiva.

Opzioni supportate:

• ignoreDeletes: ignora le transazioni che eliminano i dati.
• ignoreChanges: consente di rielaborare gli aggiornamenti se i file sono stati riscritti nella tabella di origine a causa di un'operazione di modifica dei dati, ad esempio UPDATE, MERGE INTO, DELETE (all'interno di partizioni) o OVERWRITE. Le righe non modificate possono comunque essere emesse. Pertanto, i consumatori downstream dovrebbero essere in grado di gestire i duplicati. Le operazioni di eliminazione non vengono propagate a valle. ignoreChanges comprende ignoreDeletes. Pertanto, se si usa ignoreChanges, il flusso non viene interrotto dalle eliminazioni o dagli aggiornamenti alla tabella di origine.
• startingVersion: versione della tabella condivisa da cui iniziare. Tutte le modifiche alla tabella a partire da questa versione (inclusa) vengono lette dall'origine di streaming.
• startingTimestamp: timestamp da cui iniziare. Tutte le modifiche alla tabella che sono state confermate a partire dal timestamp (incluso) vengono lette dalla sorgente di streaming. Esempio: "2023-01-01 00:00:00.0".
• maxFilesPerTrigger: numero di nuovi file da considerare in ogni micro batch.
• maxBytesPerTrigger: quantità di dati elaborati in ogni micro batch. Questa opzione imposta un valore "soft max", ovvero un batch elabora approssimativamente questa quantità di dati e può elaborare più del limite per far avanzare la query di streaming nei casi in cui l'unità di input più piccola è maggiore di questo limite.
• readChangeFeed: Stream legge il feed di dati delle modifiche della tabella condivisa.

Trigger supportati:

• Trigger.ProcessingTime: trigger predefinito, usato quando non viene specificato alcun trigger esplicito. I dati vengono elaborati in micro batch continui.
• Trigger.AvailableNow: La query acquisisce all'avvio la versione sul lato server della tabella condivisa, elabora il backlog come più micro-batch che rispettano maxFilesPerTrigger e maxVersionsPerRpc, e termina fino a esaurimento della versione acquisita. Richiede delta-sharing-spark la versione 1.4.0 o successiva. Le versioni precedenti ripiegano su un wrapper Trigger.AvailableNow che non rispetta maxVersionsPerRpc.
• Trigger.Once:Deprecato; usare Trigger.AvailableNow invece . Nelle versioni di delta-sharing-spark precedenti alla 1.4.0, Trigger.AvailableNow ripiega su un wrapper che non rispetta maxVersionsPerRpc.

Esempi di query di streaming strutturato

Python

spark.readStream.format("deltaSharing")\
.option("startingVersion", 0)\
.option("ignoreDeletes", true)\
.option("maxBytesPerTrigger", 10000)\
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")

Scala

spark.readStream.format("deltaSharing")
.option("startingVersion", 0)
.option("ignoreChanges", true)
.option("maxFilesPerTrigger", 10)
.load("<profile-path>#<share-name>.<schema-name>.<table-name>")

Vedere anche Concetti di Structured Streaming.

Leggere tabelle con vettori di eliminazione o mappatura delle colonne abilitati

I vettori di eliminazione sono una funzione di ottimizzazione dell'archiviazione che il provider può abilitare sulle tabelle Delta condivise. Vedere Vettori di eliminazione in Databricks.

Azure Databricks supporta anche il mapping delle colonne per le tabelle Delta. Vedi Rinominare ed eliminare colonne con la mappatura delle colonne di Delta Lake.

Se il provider ha condiviso una tabella con vettori di eliminazione o mapping di colonne abilitati, è possibile leggere la tabella utilizzando un sistema di calcolo in esecuzione su delta-sharing-spark 3.1 o una versione successiva. Se si usano cluster Databricks, è possibile eseguire operazioni di lettura batch usando un cluster che esegue Databricks Runtime 14.1 o versione successiva. Le query CDF e le query di streaming richiedono Databricks Runtime 14.2 o superiore.

È possibile eseguire le query batch così come sono, perché possono risolvere automaticamente responseFormat in base alle caratteristiche della tabella condivisa.

Per leggere un feed di dati delle modifiche (CDF) o per eseguire query di streaming su tabelle condivise con vettori di eliminazione o mapping di colonne abilitati, è necessario impostare l'opzione responseFormat=delta aggiuntiva.

I seguenti esempi illustrano le query batch, CDF e streaming:

import org.apache.spark.sql.SparkSession

val spark = SparkSession
        .builder()
        .appName("...")
        .master("...")
        .config("spark.sql.extensions", "io.delta.sql.DeltaSparkSessionExtension")
        .config("spark.sql.catalog.spark_catalog", "org.apache.spark.sql.delta.catalog.DeltaCatalog")
        .getOrCreate()

val tablePath = "<profile-file-path>#<share-name>.<schema-name>.<table-name>"

// Batch query
spark.read.format("deltaSharing").load(tablePath)

// CDF query
spark.read.format("deltaSharing")
  .option("readChangeFeed", "true")
  .option("responseFormat", "delta")
  .option("startingVersion", 1)
  .load(tablePath)

// Streaming query
spark.readStream.format("deltaSharing").option("responseFormat", "delta").load(tablePath)

Leggere le colonne di rilevamento delle righe nelle tabelle condivise

Se il provider di dati ha abilitato il rilevamento delle righe in una tabella condivisa, è possibile eseguire query sulle colonne dei metadati di rilevamento delle righe usando Scala Spark. Per un elenco delle colonne disponibili, vedere Tracciamento delle righe in Azure Databricks.

È necessario impostare l'opzione responseFormat su delta.

spark.read.format("deltaSharing")
  .option("responseFormat", "delta")
  .load("<profile-path>#<share-name>.<schema-name>.<table-name>")
  .select("_metadata.row_id")
  .show()

Pandas: legge i dati condivisi

Seguire questa procedura per accedere ai dati condivisi nella pandas versione 0.25.3 o successiva.

Queste istruzioni presuppongono che l'utente abbia accesso al file di credenziali condiviso dal provider di dati. Vedi Come ottenere l'accesso nel modello di condivisione Databricks-Open.

Installare il connettore Python OpenSharing

Per accedere ai metadati correlati ai dati condivisi, ad esempio l'elenco di tabelle condivise con l'utente, è necessario installare il delta-sharing Python connector. Per informazioni sulle limitazioni del connettore Python, vedere Limitazioni del connettore opensharing Python.

pip install delta-sharing

Elencare le tabelle condivise con pandas

Per elencare le tabelle nella condivisione, eseguire le operazioni seguenti, sostituendo <profile-path>/config.share con il percorso del file delle credenziali.

import delta_sharing

client = delta_sharing.SharingClient(f"<profile-path>/config.share")

client.list_all_tables()

Se l'output è vuoto o non contiene le tabelle previste, contattare il provider di dati.

Accedere ai dati condivisi con pandas

Per accedere ai dati condivisi in pandas con Python, eseguire le operazioni seguenti, sostituendo le variabili come indicato di seguito:

• <profile-path>: percorso del file delle credenziali.
• <share-name>: valore di share= per la tabella.
• <schema-name>: valore di schema= per la tabella.
• <table-name>: valore di name= per la tabella.

import delta_sharing
delta_sharing.load_as_pandas(f"<profile-path>#<share-name>.<schema-name>.<table-name>")

Accedere a un feed di dati delle modifiche condiviso usando pandas

Per accedere al feed di dati delle modifiche per una tabella condivisa in pandas usando Python, eseguire le operazioni seguenti, sostituendo le variabili come indicato di seguito. Un feed di dati delle modifiche potrebbe non essere disponibile, a seconda che il provider di dati abbia condiviso o meno il feed di dati delle modifiche per la tabella.

• <starting-version>:opzionale. Versione iniziale della query, compresa.
• <ending-version>:opzionale. Versione finale della query, compresa.
• <starting-timestamp>:opzionale. L'indicatore di tempo iniziale della query Questo viene convertito in una versione creata successivamente o uguale a questo timestamp.
• <ending-timestamp>:opzionale. Timestamp finale della query. Questa conversione viene effettuata in una versione creata in precedenza o uguale a questo indicatore temporale.

import delta_sharing
delta_sharing.load_table_changes_as_pandas(
  f"<profile-path>#<share-name>.<schema-name>.<table-name>",
  starting_version=<starting-version>,
  ending_version=<ending-version>)

delta_sharing.load_table_changes_as_pandas(
  f"<profile-path>#<share-name>.<schema-name>.<table-name>",
  starting_timestamp=<starting-timestamp>,
  ending_timestamp=<ending-timestamp>)

Se l'output è vuoto o non contiene i dati previsti, contattare il provider di dati.

Power BI: Leggere i dati condivisi

Il connettore Power BI OpenSharing consente di individuare, analizzare e visualizzare i set di dati condivisi con l'utente tramite il protocollo openSharing open.

Requisiti

• Power BI Desktop 2.99.621.0 o versione successiva.
• Accesso al file di credenziali condiviso dal provider di dati. Vedi Come ottenere l'accesso nel modello di condivisione Databricks-Open.

Connettersi a Databricks

Per connettersi a Azure Databricks usando il connettore OpenSharing, eseguire le operazioni seguenti:

1. Aprire il file delle credenziali condivise con un editor di testo per recuperare l'URL dell'endpoint e il token.
2. Apri Power BI Desktop.
3. Nel menu Recupera dati cercare OpenSharing.
4. Selezionare il connettore e fare clic su Connetti.
5. Immettere l'URL dell'endpoint copiato dal file delle credenziali nel campo URL del server OpenSharing .
6. Facoltativamente, nella scheda Opzioni avanzate impostare un limite di righe per il numero massimo di righe che è possibile scaricare. Questa opzione è impostata su 1 milione di righe per impostazione predefinita.
7. Fare clic su OK.
8. Per Autenticazione copiare il token recuperato dal file delle credenziali in Bearer Token.
9. Fare clic su Connetti.

Limitazioni del connettore Power BI OpenSharing

Il connettore Power BI OpenSharing presenta le limitazioni seguenti:

• I dati caricati dal connettore devono rientrare nella memoria del computer. Per gestire questo requisito, il connettore limita il numero di righe importate al limite Row Limit impostato nella scheda Opzioni avanzate in Power BI Desktop.

Tableau: Leggi i dati condivisi

Il connettore Tableau OpenSharing consente di individuare, analizzare e visualizzare i set di dati condivisi con l'utente tramite il protocollo aperto OpenSharing.

Requisiti

• Tableau Desktop e Tableau Server 2024.1 o versione successiva
• Accesso al file di credenziali condiviso dal provider di dati. Vedi Come ottenere l'accesso nel modello di condivisione Databricks-Open.

Connettersi ad Azure Databricks

Per connettersi a Azure Databricks usando il connettore OpenSharing, eseguire le operazioni seguenti:

1. Passare a Tableau Exchange, seguire le istruzioni per scaricare OpenSharing Connector e inserirlo in una cartella desktop appropriata.
2. Aprire Tableau Desktop.
3. Nella pagina Connettori cercare "OpenSharing by Databricks".
4. Selezionare Carica file di condivisione e scegliere il file delle credenziali condiviso dal provider.
5. Fare clic su Recupera dati.
6. Nella Esplora dati selezionare la tabella.
7. Facoltativamente, aggiungere filtri SQL o limiti di riga.
8. Fare clic su Ottieni dati tabella.

Limitazioni

Il connettore Tableau OpenSharing presenta le limitazioni seguenti:

• I dati caricati dal connettore devono rientrare nella memoria del computer. Per gestire questo requisito, il connettore limita il numero di righe importate al limite di riga impostato in Tableau.
• Tutte le colonne vengono restituite come tipo String.
• Il filtro SQL funziona solo se il server OpenSharing supporta predicateHint.
• I vettori di eliminazione non sono supportati.
• Il mapping delle colonne non è supportato.

Limitazioni del connettore openSharing Python

Queste limitazioni sono specifiche del connettore OpenSharing Python:

• Il connettore Python OpenSharing 1.1.0+ supporta le query snapshot su tabelle con mapping di colonne, ma le query CDF su tabelle con mapping di colonne non sono supportate.
• Il connettore OpenSharing Python non riesce a eseguire query CDF con use_delta_format=True se lo schema è stato modificato durante l'intervallo di versioni sottoposto a query.

Limitazioni delle tabelle di streaming

È possibile leggere solo lo snapshot corrente di una tabella di streaming condivisa. Le funzionalità seguenti non sono supportate per le tabelle di streaming nella condivisione da Databricks a Open:

• Esecuzione di query sui dati della cronologia della tabella
• Esecuzione di query sul feed di dati delle modifiche della tabella (CDF)
• Uso della tabella come origine per Spark Structured Streaming

Limitazioni delle visualizzazioni materializzate

È possibile leggere solo lo snapshot corrente di una vista materializzata condivisa. L'uso di una vista materializzata come origine per Spark Structured Streaming non è supportato nella condivisione da Databricks a Open.

Richiedere una nuova credenziale

Se l'URL di attivazione delle credenziali o le credenziali scaricate vengono perse, danneggiate o compromesse oppure le credenziali scadono senza che il provider invii una nuova credenziale, contattare il provider per richiedere una nuova credenziale.

Se si è un destinatario Azure Databricks che ha importato le credenziali come oggetto provider in Unity Catalog, applicare le nuove credenziali usando l'API REST di Databricks. Vedere Ruotare le credenziali per i destinatari aperti.