Använda onlinetabeller för funktionsservering i realtid

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 fungera med Mosaic AI Model Serving, Funktionsservering 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 frå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.

Krav

• 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.

   Timeserienyckel: (valfritt). Kolumn i källtabellen som ska användas som tidserienyckel. När den har angetts innehåller onlinetabellen endast raden med det senaste tidserienyckelvärdet för varje primärnyckel.

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

   Princip	beskrivning
   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.
   Utlöst	Pipelinen körs en gång för att skapa en första ögonblicksbild av källtabellen i onlinetabellen. Till skillnad från synkroniseringsläget för ögonblicksbilder, när onlinetabellen uppdateras, ändras bara sedan den senaste pipelinekörningen hämtas och tillämpas på onlinetabellen. Den inkrementella uppdateringen kan utlösas manuellt eller utlösas automatiskt enligt ett schema.
   Kontinuerligt	Pipelinen 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 Delta Live Tables som uppdaterar tabellen.

Schemalägga periodiska uppdateringar

För onlinetabeller med läget Ögonblicksbild eller Utlöst synkronisering kan du schemalägga automatiska periodiska uppdateringar. Uppdateringsschemat hanteras av Delta Live Tables-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 menyn för kebab.

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.

Krav

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

w.online_tables.create(name='main.default.my_online_table', spec=spec)

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 '
            'Delta Live Tables: '
            '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 Delta Live Tables: 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 serverdelsslutpunkten automatiskt onlinetabellen för att utföra funktionssökningar 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.

   Kommentar

   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 GET-begäran till slutpunkts-URL:en. Exemplet visar hur du gör detta med hjälp av Python-API:er. Andra språk och verktyg finns i Funktionsservering.

   # 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 på funktionsutveckling: 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 notebook-fil

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 Automatisk funktionssökning med Databricks Model Serving .

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 i 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 ha behörigheten UPPDATERA 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 huvudnamn för tjänsten skapas automatiskt för en funktionsserver eller modell som betjänar slutpunkten med begränsade behörigheter som krävs för att köra frågor mot data från onlinetabeller. Det här tjänstens huvudnamn tillåter slutpunkter att komma åt data oberoende av användaren som skapade resursen och ser till att slutpunkten kan fortsätta att fungera om skaparen lämnar arbetsytan.

Livslängden för tjänstens huvudnamn ä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 huvudnamn.

Begränsningar

• 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.
• Maximalt antal frågor per sekund (QPS) är 12 000. Kontakta ditt Databricks-kontoteam för att öka gränsen.

Felsökning

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 matcha 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 DLT-tjänsten 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. Om du kör den här frågan på ett lyckat sätt bekräftas också att serverlös beräkning kan komma åt källtabellen.

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