Databricks online-tabeller (äldre)

En onlinetabell är en skrivskyddad kopia av en deltatabell som lagras i radorienterat format som är optimerat för onlineåtkomst. Onlinetabeller är helt serverlösa tabeller som automatiskt skalar dataflödeskapacitet med begärandebelastningen och ger låg svarstid och hög dataflödesåtkomst till data i valfri skala. Onlinetabeller är utformade för att användas med Mosaic AI Model Serving, Funktionstjänst och RAG-program (hämtningsförhöjd generation) där de används för snabba datasökningar.

Du kan också använda onlinetabeller i sökfrågor med hjälp av Lakehouse Federation. När du använder Lakehouse Federation måste du använda ett serverlöst SQL-lager för att få åtkomst till onlinetabeller. Endast läsåtgärder (SELECT) stöds. Den här funktionen är endast avsedd för interaktiva eller felsökningsändamål och bör inte användas för produktions- eller verksamhetskritiska arbetsbelastningar.

Att skapa en onlinetabell med databricks-användargränssnittet är en process i ett steg. Välj bara deltatabellen i Katalogutforskaren och välj Skapa onlinetabell. Du kan också använda REST-API:et eller Databricks SDK för att skapa och hantera onlinetabeller. Se Arbeta med onlinetabeller med API:er.

Requirements

• Arbetsytan måste vara aktiverad för Unity Catalog. Följ dokumentationen för att skapa ett Unity Catalog-metaarkiv, aktivera det på en arbetsyta och skapa en katalog.
• En modell måste vara registrerad i Unity Catalog för att få åtkomst till onlinetabeller.

Arbeta med onlinetabeller med hjälp av användargränssnittet

I det här avsnittet beskrivs hur du skapar och tar bort onlinetabeller och hur du kontrollerar status och utlöser uppdateringar av onlinetabeller.

Skapa en onlinetabell med hjälp av användargränssnittet

Du skapar en onlinetabell med Hjälp av Catalog Explorer. Information om nödvändiga behörigheter finns i Användarbehörigheter.

1. Om du vill skapa en onlinetabell måste delta-källtabellen ha en primärnyckel. Om deltatabellen som du vill använda inte har någon primärnyckel skapar du en genom att följa dessa instruktioner: Använd en befintlig Delta-tabell i Unity Catalog som en funktionstabell.

2. I Katalogutforskaren navigerar du till källtabellen som du vill synkronisera till en onlinetabell. På menyn Skapa väljer du Onlinetabell.

   

3. Använd väljarna i dialogrutan för att konfigurera onlinetabellen.

   

   Namn: Namn som ska användas för onlinetabellen i Unity Catalog.

   Primärnyckel: Kolumner i källtabellen som ska användas som primärnyckel i onlinetabellen.

   Tidsserienyckel: (valfritt). Kolumn i källtabellen som ska användas som tidsserienyckel. När den anges innehåller onlinetabellen endast raden med det senaste tidsserienyckelvärdet för varje primärnyckel.

   Synkroniseringsläge: Anger hur synkroniseringspipelinen uppdaterar onlinetabellen. Välj en av ögonblicksbilder, utlösta eller kontinuerliga.

   Policy	Description
   Snapshot	Pipelinen körs en gång för att ta en ögonblicksbild av källtabellen och kopiera den till onlinetabellen. Efterföljande ändringar i källtabellen återspeglas automatiskt i onlinetabellen genom att ta en ny ögonblicksbild av källan och skapa en ny kopia. Innehållet i onlinetabellen uppdateras atomiskt.
   Triggered	Pipelinen körs en gång för att skapa en första ögonblicksbild av källtabellen i onlinetabellen. Till skillnad från synkläget för Snapshots, när onlinetabellen uppdateras, hämtas och tillämpas endast de ändringar som skett sedan den senaste körningen av pipelinen. Den inkrementella uppdateringen kan utlösas manuellt eller utlösas automatiskt enligt ett schema.
   Continuous	Rördelen körs kontinuerligt. Efterföljande ändringar i källtabellen tillämpas stegvis på onlinetabellen i realtidsströmningsläge. Ingen manuell uppdatering krävs.

1. När du är klar klickar du på Bekräfta. Onlinetabellsidan visas.
2. Den nya onlinetabellen skapas under katalogen, schemat och namnet som anges i dialogrutan för att skapa. I Katalogutforskaren visas onlinetabellen med .

Hämta status- och utlösaruppdateringar med hjälp av användargränssnittet

Om du vill kontrollera onlinetabellens status klickar du på namnet på tabellen i katalogen för att öppna den. Onlinetabellsidan visas med fliken Översikt öppen. Avsnittet Data inmatning visar status för den senaste uppdateringen. Om du vill utlösa en uppdatering klickar du på Synkronisera nu. Avsnittet Datainmatning innehåller också en länk till pipelinen som uppdaterar tabellen.

Schemalägga periodiska uppdateringar

För onlinetabeller med synkläge Ögonblicksbild eller Utlöst kan du schemalägga automatiska periodiska uppdateringar. Uppdateringsschemat hanteras av pipelinen som uppdaterar tabellen.

1. I Katalogutforskaren navigerar du till onlinetabellen.
2. I avsnittet Datainmatning klickar du på länken till pipelinen.
3. I det övre högra hörnet klickar du på Schemalägg och lägger till ett nytt schema eller uppdaterar befintliga scheman.

Ta bort en onlinetabell med hjälp av användargränssnittet

På onlinetabellsidan väljer du Ta bort från kebabmeny.

Arbeta med onlinetabeller med API:er

Du kan också använda Databricks SDK eller REST API för att skapa och hantera onlinetabeller.

Referensinformation finns i referensdokumentationen för Databricks SDK för Python eller REST-API:et.

Requirements

Databricks SDK version 0.20 eller senare.

Skapa en onlinetabell med API:er

Databricks SDK – Python

from pprint import pprint
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import *

w = WorkspaceClient(host='https://xxx.databricks.com', token='xxx')

# Create an online table
spec = OnlineTableSpec(
  primary_key_columns=["pk_col"],
  source_table_full_name="main.default.source_table",
  run_triggered=OnlineTableSpecTriggeredSchedulingPolicy.from_dict({'triggered': 'true'})
)

online_table = OnlineTable(
  name="main.default.my_online_table",  # Fully qualified table name
  spec=spec  # Online table specification
)

w.online_tables.create_and_wait(table=online_table)

REST API

curl --request POST "https://xxx.databricks.com/api/2.0/online-tables" \
--header "Authorization: Bearer xxx" \
--data '{
    "name": "main.default.my_online_table",
    "spec": {
        "run_triggered": {},
        "source_table_full_name": "main.default.source_table",
        "primary_key_columns": ["a"]
    }
  }'

Onlinetabellen börjar synkroniseras automatiskt när den har skapats.

Hämta status och utlösaruppdatering med API:er

Du kan visa status och specifikationen för onlinetabellen enligt exemplet nedan. Om onlinetabellen inte är kontinuerlig och du vill utlösa en manuell uppdatering av dess data kan du använda pipeline-API:et för att göra det.

Använd pipeline-ID:t som är associerat med onlinetabellen i onlinetabellspecifikationen och starta en ny uppdatering på pipelinen för att utlösa uppdateringen. Detta motsvarar att klicka på Synkronisera nu i onlinetabellgränssnittet i Katalogutforskaren.

Databricks SDK – Python

pprint(w.online_tables.get('main.default.my_online_table'))

# Sample response
OnlineTable(name='main.default.my_online_table',
    spec=OnlineTableSpec(perform_full_copy=None,
        pipeline_id='some-pipeline-id',
        primary_key_columns=['pk_col'],
        run_continuously=None,
        run_triggered={},
        source_table_full_name='main.default.source_table',
        timeseries_key=None),
    status=OnlineTableStatus(continuous_update_status=None,
        detailed_state=OnlineTableState.PROVISIONING,
        failed_status=None,
        message='Online Table creation is '
            'pending. Check latest status in '
            'Lakeflow Declarative Pipelines: '
            'https://xxx.databricks.com/pipelines/some-pipeline-id',
        provisioning_status=None,
        triggered_update_status=None))

# Trigger an online table refresh by calling the pipeline API. To discard all existing data
# in the online table before refreshing, set "full_refresh" to "True". This is useful if your
# online table sync is stuck due to, for example, the source table being deleted and recreated
# with the same name while the sync was running.
w.pipelines.start_update(pipeline_id='some-pipeline-id', full_refresh=True)

REST API

curl --request GET \
  "https://xxx.databricks.com/api/2.0/online-tables/main.default.my_online_table" \
  --header "Authorization: Bearer xxx"

# Sample response
{
  "name": "main.default.my_online_table",
  "spec": {
    "run_triggered": {},
    "source_table_full_name": "main.default.source_table",
    "primary_key_columns": ["pk_col"],
    "pipeline_id": "some-pipeline-id"
  },
  "status": {
    "detailed_state": "PROVISIONING",
    "message": "Online Table creation is pending. Check latest status in Lakeflow Declarative Pipelines: https://xxx.databricks.com#joblist/pipelines/some-pipeline-id"
  }
}

# Trigger an online table refresh by calling the pipeline API. To discard all existing data
# in the online table before refreshing, set "full_refresh" to "True". This is useful if your
# online table sync is stuck due to, for example, the source table being deleted and recreated
# with the same name while the sync was running.
curl --request POST "https://xxx.databricks.com/api/2.0/pipelines/some-pipeline-id/updates" \
  --header "Authorization: Bearer xxx" \
  --data '{
    "full_refresh": true
  }'

Ta bort en onlinetabell med API:er

Databricks SDK – Python

w.online_tables.delete('main.default.my_online_table')

REST API

curl --request DELETE \
  "https://xxx.databricks.com/api/2.0/online-tables/main.default.my_online_table" \
  --header "Authorization: Bearer xxx"

Om du tar bort onlinetabellen stoppas all pågående datasynkronisering och alla dess resurser frigörs.

Hantera tabelldata online med hjälp av en funktionsserverslutpunkt

För modeller och program som finns utanför Databricks kan du skapa en funktion som betjänar slutpunkten för att hantera funktioner från onlinetabeller. Slutpunkten gör funktioner tillgängliga med låg svarstid med hjälp av ett REST-API.

1. Skapa en funktionsspecifikation.

   När du skapar en funktionsspecifikation anger du deltatabellen för källan. På så sätt kan funktionsspecifikationen användas i både offline- och onlinescenarier. För onlinesökningar använder den servande slutpunkten automatiskt onlinetabellen för att hämta funktioner med låg latens.

   Delta-källtabellen och onlinetabellen måste använda samma primärnyckel.

   Funktionsspecifikationen kan visas på fliken Funktion i Katalogutforskaren.

   from databricks.feature_engineering import FeatureEngineeringClient, FeatureLookup
   
   fe = FeatureEngineeringClient()
   fe.create_feature_spec(
     name="catalog.default.user_preferences_spec",
     features=[
       FeatureLookup(
         table_name="user_preferences",
         lookup_key="user_id"
       )
     ]
   )
   

2. Skapa en funktion som betjänar slutpunkten.

   Det här steget förutsätter att du har skapat en onlinetabell med namnet user_preferences_online_table som synkroniserar data från Delta-tabellen user_preferences. Använd funktionsspecifikationen för att skapa en funktionsserverslutpunkt. Slutpunkten gör data tillgängliga via ett REST-API med hjälp av den associerade onlinetabellen.

   Note

   Den användare som utför den här åtgärden måste vara ägare till både offlinetabellen och onlinetabellen.

   Databricks SDK – Python

   from databricks.sdk import WorkspaceClient
   from databricks.sdk.service.serving import EndpointCoreConfigInput, ServedEntityInput
   
   workspace = WorkspaceClient()
   
   # Create endpoint
   endpoint_name = "fse-location"
   
   workspace.serving_endpoints.create_and_wait(
     name=endpoint_name,
     config=EndpointCoreConfigInput(
       served_entities=[
         ServedEntityInput(
           entity_name=feature_spec_name,
           scale_to_zero_enabled=True,
           workload_size="Small"
         )
       ]
     )
   )
   

   Python-API

   from databricks.feature_engineering.entities.feature_serving_endpoint import (
     ServedEntity,
     EndpointCoreConfig,
   )
   
   fe.create_feature_serving_endpoint(
     name="user-preferences",
     config=EndpointCoreConfig(
       served_entities=ServedEntity(
         feature_spec_name="catalog.default.user_preferences_spec",
         workload_size="Small",
         scale_to_zero_enabled=True
       )
     )
   )
   

3. Hämta data från funktionsserverns slutpunkt.

   Om du vill komma åt API-slutpunkten skickar du en HTTP POST-begäran till slutpunkts-URL:en. Exemplet visar hur du gör detta med hjälp av Python-API:er. För andra språk och verktyg, se Funktionstjänster.

   # Set up credentials
   export DATABRICKS_TOKEN=...
   

   url = "https://{workspace_url}/serving-endpoints/user-preferences/invocations"
   
   headers = {'Authorization': f'Bearer {DATABRICKS_TOKEN}', 'Content-Type': 'application/json'}
   
   data = {
     "dataframe_records": [{"user_id": user_id}]
   }
   data_json = json.dumps(data, allow_nan=True)
   
   response = requests.request(method='POST', headers=headers, url=url, data=data_json)
   if response.status_code != 200:
     raise Exception(f'Request failed with status {response.status_code}, {response.text}')
   
   print(response.json()['outputs'][0]['hotel_preference'])
   

Använda onlinetabeller med RAG-program

RAG-program är ett vanligt användningsfall för onlinetabeller. Du skapar en onlinetabell för de strukturerade data som RAG-programmet behöver och är värd för dem på en funktion som betjänar slutpunkten. RAG-programmet använder funktionsserverslutpunkten för att leta upp relevanta data från onlinetabellen.

De vanliga stegen är följande:

1. Skapa en funktion som betjänar slutpunkten.
2. Skapa ett verktyg med LangChain eller liknande paket som använder slutpunkten för att söka efter relevanta data.
3. Använd verktyget i en LangChain-agent eller liknande agent för att hämta relevanta data.
4. Skapa en modell som betjänar slutpunkten som värd för programmet.

Stegvisa instruktioner och en exempelanteckningsbok finns i Exempel: använda funktioner med strukturerade RAG-program.

Notebook-exempel

Följande notebook-fil visar hur du publicerar funktioner till onlinetabeller för realtidsservering och automatisk funktionssökning.

Demoanteckningsbok för onlinetabeller

Hämta anteckningsbok

Använda onlinetabeller med Mosaic AI Model Serving

Du kan använda onlinetabeller för att söka efter funktioner för Mosaic AI Model Serving. När du synkroniserar en funktionstabell till en onlinetabell letar modeller som tränats med funktioner från funktionstabellen automatiskt upp funktionsvärden från onlinetabellen under slutsatsdragningen. Ingen ytterligare konfiguration krävs.

1. Använd en FeatureLookup för att träna modellen.

   För modellträning använder du funktioner från offlinefunktionstabellen i modellträningsuppsättningen, som du ser i följande exempel:

   training_set = fe.create_training_set(
     df=id_rt_feature_labels,
     label='quality',
     feature_lookups=[
         FeatureLookup(
             table_name="user_preferences",
             lookup_key="user_id"
         )
     ],
     exclude_columns=['user_id'],
   )
   

2. Servera modellen med Mosaic AI Model Serving. Modellen söker automatiskt upp funktioner från onlinetabellen. Mer information finns i Modellservering med automatisk funktionsökning .

Användarbehörigheter

Du måste ha följande behörigheter för att skapa en onlinetabell:

• SELECT behörighet i källtabellen.
• USE CATALOG behörighet till målkatalogen.
• USE SCHEMA och CREATE TABLE behörighet för målschemat.

Om du vill hantera datasynkroniseringspipelinen för en onlinetabell måste du antingen vara ägare till onlinetabellen eller beviljas REFRESH behörighet i onlinetabellen. Användare som inte har USE CATALOG och USE SCHEMA behörigheter i katalogen ser inte onlinetabellen i Katalogutforskaren.

Unity Catalog-metaarkivet måste ha privilege model version 1.0.

Slutpunktsbehörighetsmodell

Ett unikt tjänstehuvudnamn skapas automatiskt för en slutpunkt för funktionsbetjäning eller modellbetjäning, med begränsade behörigheter som krävs för att ställa frågor till data från onlinetabeller. Tjänstens huvudprincip tillåter slutpunkter att komma åt data oberoende av den användare som skapade resursen. Det säkerställer också att slutpunkten kan fortsätta att fungera om skaparen lämnar arbetsytan.

Tjänsteprincipens livslängd är slutpunktens livslängd. Granskningsloggar kan indikera systemgenererade poster för ägaren av Unity Catalog-katalogen som beviljar nödvändiga privilegier till tjänstens huvudkonto.

Limitations

• Endast en onlinetabell stöds per källtabell.
• En onlinetabell och dess källtabell kan ha högst 1 000 kolumner.
• Kolumner med datatyperNA ARRAY, MAP eller STRUCT kan inte användas som primära nycklar i onlinetabellen.
• Om en kolumn används som primärnyckel i onlinetabellen ignoreras alla rader i källtabellen där kolumnen innehåller null-värden.
• Sekundärtabeller, systemtabeller och interna tabeller stöds inte som källtabeller.
• Källtabeller utan deltaändringsdataflöde aktiverat stöder endast synkroniseringsläget för ögonblicksbilder.
• Deltadelningstabeller stöds endast i synkroniseringsläget för ögonblicksbilder.
• Katalog-, schema- och tabellnamn för onlinetabellen får endast innehålla alfanumeriska tecken och understreck och får inte börja med tal. Bindestreck (-) tillåts inte.
• Kolumner av strängtyp är begränsade till 64 KB längd.
• Kolumnnamn är begränsade till 64 tecken långa.
• Den maximala storleken på raden är 2 MB.
• Den kombinerade storleken på alla onlinetabeller i ett Unity Catalog-metaarkiv under den offentliga förhandsversionen är 2 TB okomprimerade användardata.
• Det maximala läsdataflödet för ett metaarkiv är cirka 750 MB/s.

Troubleshooting

Jag ser inte alternativet Skapa onlinetabell

Orsaken är vanligtvis att tabellen som du försöker synkronisera från (källtabellen) inte är en typ som stöds. Kontrollera att källtabellens skyddsbara typ (visas på fliken Katalogutforskarens information ) är ett av de alternativ som stöds nedan:

• TABLE_EXTERNAL
• TABLE_DELTA
• TABLE_DELTA_EXTERNAL
• TABLE_DELTASHARING
• TABLE_DELTASHARING_MUTABLE
• TABLE_STREAMING_LIVE_TABLE
• TABLE_STANDARD
• TABLE_FEATURE_STORE
• TABLE_FEATURE_STORE_EXTERNAL
• TABLE_VIEW
• TABLE_VIEW_DELTASHARING
• TABLE_MATERIALIZED_VIEW

Jag kan inte välja antingen utlösta eller kontinuerliga synkroniseringslägen när jag skapar en onlinetabell

Detta inträffar om källtabellen inte har deltaändringsdataflöde aktiverat eller om det är en vy eller materialiserad vy. Om du vill använda inkrementell synkroniseringsläge aktiverar du antingen ändringsdataflöde i källtabellen eller använder en tabell som inte visas.

Onlinetabelluppdateringen misslyckas eller statusen visas offline

Börja felsöka det här felet genom att klicka på pipeline-ID:t som visas på fliken Översikt i onlinetabellen i Catalog Explorer.

På sidan för pipelinegränssnittet som visas klickar du på posten med texten "Det gick inte att lösa flödet '__online_table".

Ett popup-fönster visas med information i avsnittet Felinformation .

Vanliga orsaker till fel är följande:

• Källtabellen togs bort eller togs bort och återskapades med samma namn medan onlinetabellen synkroniserades. Detta är särskilt vanligt med kontinuerliga onlinetabeller eftersom de ständigt synkroniseras.

• Det går inte att komma åt källtabellen via serverlös beräkning på grund av brandväggsinställningarna. I det här fallet kan avsnittet Felinformation visa felmeddelandet "Det gick inte att starta tjänsten Lakeflow Deklarativa Pipelines i klustret xxx...".

• Den aggregerade storleken på onlinetabeller överskrider gränsen på 2 TB (okomprimerad storlek). Gränsen på 2 TB refererar till den okomprimerade storleken när deltatabellen har expanderats i radorienterat format. Tabellens storlek i radformat kan vara betydligt större än storleken på deltatabellen som visas i Katalogutforskaren, som refererar till tabellens komprimerade storlek i ett kolumnorienterat format. Skillnaden kan vara så stor som 100x, beroende på innehållet i tabellen.

  Om du vill beräkna den okomprimerade, radut utökade storleken på en Delta-tabell använder du följande fråga från ett serverlöst SQL Warehouse. Frågan returnerar den uppskattade utökade tabellstorleken i byte. Att lyckas köra denna förfrågan bekräftar också att serverlös databehandling kan komma åt källtabellen.

  SELECT sum(length(to_csv(struct(*)))) FROM `source_table`;