Fabric-käyttäjädatan funktioohjelmointimallin yleiskatsaus

Fabric-käyttäjädatan funktioohjelmointimalli määrittelee Fabric-funktioiden luomisen mallit ja käsitteet.

SDK fabric-user-data-functions toteuttaa tämän ohjelmointimallin, tarjoten tarvittavan toiminnallisuuden ajettavien funktioiden luomiseen ja julkaisemiseen. SDK:n avulla voit integroida saumattomasti myös muihin Fabric-ekosysteemin kohteisiin, kuten Fabric-tietolähteisiin. Tämä kirjasto on julkisesti saatavilla PyPI ja se on esiasennettu käyttäjätietotoimintojen kohteisiin.

Tässä artikkelissa selitetään, miten SDK:ta käytetään funktioiden rakentamiseen, joita voidaan kutsua Fabric-portaalista, muista Fabric-kohteista tai ulkoisista sovelluksista REST-rajapinnan avulla. Opit ohjelmointimallin ja keskeiset käsitteet käytännön esimerkeillä.

Tippi

Täydelliset tiedot kaikista luokista, metodeista ja parametreista löydät SDK-viitedokumentaatiosta.

SDK:n aloittaminen

Tässä osiossa esitellään käyttäjätietofunktioiden SDK:n ydinkomponentit ja selitetään, miten funktiot rakennetaan. Opit vaadituista tuonti-, sisustajista sekä siitä, millaisia syöte- ja lähtödataa funktiosi pystyvät käsittelemään.

Käyttäjätietofunktiot SDK

SDK fabric-user-data-functions tarjoaa ydinkomponentit, joita tarvitset käyttäjätietofunktioiden luomiseen Pythonissa.

Vaaditut tuonnit ja alustus

Jokaisen käyttäjätietofunktiotiedoston on tuotava moduuli fabric.functions ja alustettava suorituskonteksti:

import datetime
import fabric.functions as fn
import logging

udf = fn.UserDataFunctions()

Sisustaja @udf.function()

Koristelijalla merkityt @udf.function() toiminnot voidaan kutsua Fabric-portaalista, toisesta Fabric-esineestä tai ulkoisesta sovelluksesta. Tämän koristellun funktioiden on määriteltävä palautustyyppi.

Esimerkki:

@udf.function()
def hello_fabric(name: str) -> str:
    logging.info('Python UDF trigger function processed a request.')
    logging.info('Executing hello fabric function.')
    
    return f"Welcome to Fabric Functions, {name}, at {datetime.datetime.now()}!"

Aputoiminnon toiminnot

Python-metodeja ilman @udf.function() koristelijaa ei voi kutsua suoraan. Ne voidaan kutsua vain koristelluista funktioista ja ne toimivat apufunktioina.

Esimerkki:

def uppercase_name(name: str) -> str:
    return name.upper()

Tuetut syötetyypit

Voit määrittää funktiolle syöteparametrit, kuten primitiivitietotyypit, kuten str, int, liukuluku jne. Tuetut syötetietotyypit ovat seuraavat:

JSON -tyypin	Python-tietotyyppi
Merkkijono	Str
Datetime-merkkijonon	päivämäärä/aika
Totuusarvo	Bool
Numbers -	int, kelluva
Valikoima	list[], esimerkkiluettelo[int]
Objekti	Dict
Objekti	pandas DataFrame
Objektien tai matriisi	pandas-sarja

Huomautus

Pandasin DataFrame- ja Series-tyyppejä voi käyttää menemällä Fabric-portaaliin, etsimällä työtilasi ja avaamalla käyttäjätietofunktioiden kohteen. Valitse Kirjaston hallinta, etsi fabric-user-data-functions paketti ja päivitä se versioon 1.0.0 tai uudempaan.

Esimerkki tuettujen syötetyyppien pyynnön leipätekstistä:

{
  "name": "Alice",                          // String (str)
  "signup_date": "2025-11-08T13:44:40Z",    // Datetime string (datetime)
  "is_active": true,                        // Boolean (bool)
  "age": 30,                                // Number (int)
  "height": 5.6,                            // Number (float)
  "favorite_numbers": [3, 7, 42],           // Array (list[int])
  "profile": {                              // Object (dict)
    "email": "alice@example.com",
    "location": "Sammamish"
  },
  "sales_data": {                           // Object (pandas DataFrame)
    "2025-11-01": {"product": "A", "units": 10},
    "2025-11-02": {"product": "B", "units": 15}
  },
  "weekly_scores": [                        // Object or Array of Objects (pandas Series)
    {"week": 1, "score": 88},
    {"week": 2, "score": 92},
    {"week": 3, "score": 85}
  ]
}

Tuetut tulostetyypit

Tuetut tulostetietotyypit ovat seuraavat:

Python-tietotyyppi
Str
päivämäärä/aika
Bool
int, kelluva
list[data-type], esimerkiksi list[int]
Dict
Ei mitään
pandas-sarja
pandas DataFrame

Kirjoitusfunktiot

Syntaksivaatimukset ja rajoitukset

Kun kirjoitat käyttäjädatafunktioita, noudata tarkkoja syntaksisääntöjä varmistaaksesi, että funktiot toimivat oikein.

Parametrien nimeäminen

Käytä camelCasea: Parametrien nimissä on käytettävä camelCase-nimityskäytäntöä eikä ne saa sisältää alaviivoja. Esimerkiksi käytä productName sen sijaan product_name.
Varatut avainsanat: Et voi käyttää varattuja Python-avainsanoja tai seuraavia Fabric-kohtaisia avainsanoja parametrien tai funktioiden niminä: req, context, ja reqInvocationId.

Parametrivaatimukset

Tyyppimerkinnät vaaditaan: Kaikkien parametrien tulee sisältää tyyppimerkinnät (esim. name: str).

Oletusarvot: Oletusparametriarvot ovat tuettuja. Voit määritellä oletusargumentteja Fabricin käyttäjätietofunktioissa, jotta koodisi on helpompi kutsua ja ylläpitää. Parametrit, joilla on oletusarvot, ovat valinnaisia kutsun yhteydessä; parametrit ilman oletusarvoja ovat välttämättömiä. Seuraavat tyypit ovat tuettuja oletusarvoina:

Oletustyyppi	Notes
merkkijono	Mikä tahansa JSON-sarjoitettava merkkijono.
Datetime-merkkijono	Määritä merkkijonona funktion allekirjoituksessa. Suoritusaika jäsentää merkkijonon muotoon `datetime` invocation-aikaan. Käytä ISO 8601 -muotoa (esimerkiksi, `2025-12-31T23:59:59Z`) johdonmukaiseen ja yksiselitteiseen jäsentämiseen.
totuusarvo	`True` tai `False`.
Integer	Mikä tahansa kokonaislukuarvo.
Float	Mikä tahansa liukulukuarvo.
Lista	Sen täytyy olla JSON-sarjoiteltavissa. Valitse `None` allekirjoituksessa ja aseta todellinen oletusarvo funktion sisällä välttääksesi jaetut muokattavat oletusarvot.
Sanakirja	Sen täytyy olla JSON-sarjoiteltavissa. Valitse `None` allekirjoituksessa ja aseta todellinen oletus funktion sisälle.
pandas DataFrame	Tarjotaan JSON-objektina, jonka SDK muuntaa pandas-tyypiksi. Vaatii `fabric-user-data-functions` version 1.0.0 tai uudemman.
pandas-sarja	Tarjotaan JSON-taulukkona objekteja, jotka SDK muuntaa pandas-tyypiksi. Vaatii `fabric-user-data-functions` version 1.0.0 tai uudemman.

Syntaksi

@udf.function()
def function_name(
    requiredParam: str,
    optionalStr: str = "hello",
    optionalDate: datetime.datetime = "2025-01-01T00:00:00Z",  # specify as a string; the runtime parses it to datetime at invocation time
    optionalBool: bool = True,
    optionalInt: int = 10,
    optionalFloat: float = 1.5,
    optionalList: list | None = None,   # assign real default inside the function
    optionalDict: dict | None = None,   # assign real default inside the function
) -> dict:
    optionalList = optionalList or [1, 2, 3]
    optionalDict = optionalDict or {"key": "value"}
    return {"param": requiredParam}

Oletuksena on oltava JSON-sarjoiteltavia (setit ja tuplet eivät ole tuettuja). Lista- tai sanakirjaoletusten kohdalla käytä None allekirjoituksessa ja määritä todellinen oletus funktion sisällä, jotta vältetään jaetut muokattavat oletusasetukset. Käytä ISO 8601 -muotoa (esimerkiksi, 2025-12-31T23:59:59Z) päivämääräajan oletuksiin. Pandas DataFramen tai Seriesin käyttäminen oletuksena vaatii fabric-user-data-functions version 1.0.0 tai uudemman.

Toimintovaatimukset

Palautustyyppi vaaditaan: Funktioiden, joissa on koristelija @udf.function() , on määriteltävä palautustyypin annotaatio (esim. -> str).
Vaaditut tuonnit: Lause import fabric.functions as fn ja udf = fn.UserDataFunctions() alustus ovat välttämättömiä, jotta funktiot toimivat.

Esimerkki oikeasta syntaksista

@udf.function()
def process_order(orderNumber: int, customerName: str, orderDate: str) -> dict:
    return {
        "order_id": orderNumber,
        "customer": customerName,
        "date": orderDate,
        "status": "processed"
    }

Asynkronisen funktion kirjoittaminen

Lisää asynkroninen decorator funktiomäärityksen avulla koodissasi. Funktiolla async voit parantaa sovelluksesi reagointia ja tehokkuutta käsittelemällä useita tehtäviä kerralla. Ne ovat ihanteellisia suurten I/O-sidottujen toimintojen hallintaan. Tämä esimerkkifunktio lukee CSV-tiedoston lakehousesta pandas-funktion avulla. Funktio ottaa tiedoston nimen syöteparametriksi.

import pandas as pd 

# Replace the alias "<My Lakehouse alias>" with your connection alias.
@udf.connection(argName="myLakehouse", alias="<My Lakehouse alias>")
@udf.function()
async def read_csv_from_lakehouse(myLakehouse: fn.FabricLakehouseClient, csvFileName: str) -> str:

    # Connect to the Lakehouse
    connection = myLakehouse.connectToFilesAsync()   

    # Download the CSV file from the Lakehouse
    csvFile = connection.get_file_client(csvFileName)

    downloadFile = await csvFile.download_file()
    csvData = await downloadFile.readall()
    
    # Read the CSV data into a pandas DataFrame
    from io import StringIO
    df = pd.read_csv(StringIO(csvData.decode('utf-8')))

    # Display the DataFrame    
    result="" 
    for index, row in df.iterrows():
        result=result + "["+ (",".join([str(item) for item in row]))+"]"
    
    # Close the connection
    csvFile.close()
    connection.close()

    return f"CSV file read successfully.{result}"

Työskentely datan kanssa

Tietoyhteydet Fabric-tietolähteisiin

SDK mahdollistaa datayhteyksien viitamisen ilman, että koodiin tarvitsee kirjoittaa yhteysjonoja. fabric.functions kirjastossa on kaksi tapaa käsitellä tietoyhteyksiä:

fabric.functions.FabricSqlConnection: Mahdollistaa SQL-tietokantojen käytön Fabricissa, mukaan lukien SQL Analytics -päätepisteet ja Fabric-varastot.
fabric.functions.FabricLakehouseClient: Mahdollistaa Lakehousesin kanssa työskentelyn yhdessä sen kanssa, miten voit yhdistää sekä Lakehouse-taulukoihin että Lakehouse-tiedostoihin.

Jos haluat viitata yhteyteen tietolähteeseen, sinun on käytettävä @udf.connection decoratoria. Voit käyttää sitä missä tahansa seuraavista muodoista:

@udf.connection(alias="<alias for data connection>", argName="sqlDB")
@udf.connection("<alias for data connection>", "<argName>")
@udf.connection("<alias for data connection>")

@udf.connection argumentit ovat seuraavat:

argName, sen muuttujan nimi, jota yhteys käyttää funktiossasi.
alias, yhteyden alias, jonka lisäsit Yhteyksien hallinta -valikossa.
Jos argName ja alias ovat samat, voit käyttää @udf.connection("<alias and argName for the data connection>").

Esimerkki:

# Where demosqldatabase is the argument name and the alias for my data connection used for this function
@udf.connection("demosqldatabase")
@udf.function()
def read_from_sql_db(demosqldatabase: fn.FabricSqlConnection)-> list:
  # Connect to the SQL database
  connection = demosqldatabase.connect()
  cursor = connection.cursor()
  
  # Replace with the query you want to run
  query = "SELECT * FROM (VALUES ('John Smith', 31), ('Kayla Jones', 33)) AS Employee(EmpName, DepID);"
  
  # Execute the query
  cursor.execute(query)
  
  # Fetch all results
  results = cursor.fetchall()
  
  # Close the cursor and connection
  cursor.close()
  connection.close()
  
  return results

Yleiset yhteydet Fabric-kohteille tai Azure-resursseille

SDK tukee yleisiä yhteyksiä, joita voit käyttää luodaksesi yhteyksiä Fabric-kohteisiin tai Azure-resursseihin käyttämällä käyttäjätietofunktioiden omistaja-identiteettiä. Tämä ominaisuus luo Microsoft Entra ID -tokenin, jossa on kohteen omistajan identiteetti ja annettu yleisötyyppi. Käytä tätä tokenia tunnistautumiseen Fabric-kohteilla tai Azure-resursseilla, jotka tukevat kyseistä yleisötyyppiä. Tämä lähestymistapa tarjoaa samankaltaisen ohjelmointikokemuksen kuin Manage Connections -ominaisuuden hallittujen yhteyksien objektien käyttö, mutta vain kyseisen yleisötyypin kohdalla.

Tämä ominaisuus käyttää sisustajaa @udf.generic_connection() seuraavilla parametreilla:

Parametri	Kuvaus	Arvo
`argName`	Funktiolle välitettävän muuttujan nimi. Käyttäjän on määritettävä tämä muuttuja funktionsa argumenteissa ja käytettävä sille tyyppiä `fn.FabricItem`	Jos esimerkiksi `argName=CosmosDb`, funktion pitäisi sisältää tämä argumentti `cosmosDb: fn.FabricItem`
`audienceType`	Kohderyhmän tyyppi, jolle yhteys luodaan. Tämä parametri liitetään Fabric-kohteen tai Azure-palvelun tyyppiin ja määrittää, minkä asiakkaan yhteys on käytössä.	Tämän parametrin sallitut arvot ovat `CosmosDb` tai `KeyVault`.

Yhdistä Cosmos DB:hen Fabric-kontissa yleisen yhteyden avulla

Yleiset yhteydet tukevat natiiveja Cosmos DB -tietokantoja Fabric-järjestelmässä hyödyntämällä audience-tyyppiäCosmosDB. Mukana tulevat käyttäjätietofunktiot SDK tarjoaa apumenetelmän, joka get_cosmos_client hakee yksittäisen Cosmos DB -asiakasohjelman jokaiselle kutsulle.

Voit yhdistää Cosmos DB -tietokantaan Fabric-sovelluksessa yleisen yhteyden avulla seuraamalla näitä vaiheita:

Mene Fabric-portaaliin, etsi työtilasi ja avaa käyttäjätietofunktioiden kohta. Valitse Library management, etsi azure-cosmos-kirjasto ja asenna se. Lisätietoja löytyy kohdasta Hallinnoi kirjastoja.
Mene Cosmos-tietokantaasi Fabric-esineasetuksista.
Hae Cosmos-tietokantasi Fabric-päätepisteen URL-osoitteella.

Mene käyttäjätietofunktioiden kohteeseen. Käytä seuraavaa esimerkkikoodia yhdistääksesi Cosmos DB:hen Fabric-säiliössä ja suorita lukukysely Cosmos DB -näyteaineistolla. Korvaa seuraavien muuttujien arvot:

COSMOS_DB_URICosmos DB:si kanssa Fabric-päätepisteessä.
DB_NAME Cosmos DB -tietokantakohteesi nimellä.

from fabric.functions.cosmosdb import get_cosmos_client
import json

@udf.generic_connection(argName="cosmosDb", audienceType="CosmosDB")
@udf.function()
def get_product_by_category(cosmosDb: fn.FabricItem, category: str) -> list:

    COSMOS_DB_URI = "YOUR_COSMOS_DB_URL"
    DB_NAME = "YOUR_COSMOS_DB_NAME" # Note: This is the Fabric item name
    CONTAINER_NAME = "SampleData" # Note: This is your container name. In this example, we are using the SampleData container.

    cosmosClient = get_cosmos_client(cosmosDb, COSMOS_DB_URI)

    # Get the database and container
    database = cosmosClient.get_database_client(DB_NAME)
    container = database.get_container_client(CONTAINER_NAME)

    query = 'select * from c WHERE c.category=@category' #"select * from c where c.category=@category"
    parameters = [
        {
            "name": "@category", "value": category
        }
    ]
    results = container.query_items(query=query, parameters=parameters)
    items = [item for item in results]

    logging.info(f"Found {len(items)} products in {category}")

    return json.dumps(items)

Testaa tai suorita tämä funktio antamalla luokan nimi, kuten Accessory kutsuparametreissa.

Huomautus

Voit myös käyttää näitä vaiheita yhdistääksesi Azure Cosmos DB -tietokantaan käyttäen tilin URL- ja tietokantanimiä. Käyttäjätietotoimintojen omistajatilillä täytyy olla käyttöoikeudet kyseiseen Azure Cosmos DB-tiliin.

Yhdistä Azure Key Vault -sovellukseen käyttämällä yleistä yhteyttä

Yleiset yhteydet tukevat yhdistämistä Azure Key Vault käyttämällä KeyVault -yleisötyyppiä. Tämän tyyppinen yhteys edellyttää, että Fabric-käyttäjätietofunktioiden omistajalla on oikeudet yhdistää Azure Key Vault. Tämän yhteyden avulla voit noutaa avaimia, salaisuuksia tai varmenteita nimen mukaan.

Voit yhdistää Azure Key Vault hakeaksesi asiakassalaisuuden API:n kutsumista varten yleisen yhteyden avulla seuraamalla näitä vaiheita:

Mene Fabric-portaaliin, etsi työtilasi ja avaa käyttäjätietofunktioiden kohta. Valitse Library management, etsi ja asenna requests ja azure-keyvault-secrets -kirjastot. Lisätietoja löytyy kohdasta Hallinnoi kirjastoja.
Mene Azure Key Vault resourceAzure portal ja hae Vault URI sekä avaimen, salaisuuden tai sertifikaatin nimi.

Palaa Fabric-käyttäjätietofunktioiden kohteeseen ja käytä tätä näytettä. Tässä esimerkissä haet salaisuuden Azure Key Vault -sovelluksesta yhdistääksesi sen julkiseen API:hin. Korvaa seuraavien muuttujien arvo:

KEY_VAULT_URL edellisessä vaiheessa noudetulla painikkeella Vault URI .
KEY_VAULT_SECRET_NAME salaisuutesi nimellä.
API_URL -muuttuja, jossa on sen API:n URL-osoite, johon haluat muodostaa yhteyden. Tässä mallissa oletetaan, että muodostat yhteyden julkiseen ohjelmointirajapintaan, joka hyväksyy GET-pyynnöt ja ottaa seuraavat parametrit api-key ja .request-body

from azure.keyvault.secrets import SecretClient
from azure.identity import DefaultAzureCredential
import requests

@udf.generic_connection(argName="keyVaultClient", audienceType="KeyVault")
@udf.function()
def retrieveNews(keyVaultClient: fn.FabricItem, requestBody:str) -> str:
    KEY_VAULT_URL = 'YOUR_KEY_VAULT_URL'
    KEY_VAULT_SECRET_NAME= 'YOUR_SECRET'
    API_URL = 'YOUR_API_URL'

    credential = keyVaultClient.get_access_token()

    client = SecretClient(vault_url=KEY_VAULT_URL, credential=credential)

    api_key = client.get_secret(KEY_VAULT_SECRET_NAME).value

    api_url = API_URL
    params = {
        "api-key": api_key,
        "request-body": requestBody
    }

    response = requests.get(api_url, params=params)

    data = "" 

    if response.status_code == 200:
        data = response.json()
    else:
        print(f"Error {response.status_code}: {response.text}")

    return f"Response: {data}"

Testaa tai suorita tämä funktio antamalla pyynnön runko koodissasi.

Lisäominaisuudet

Ohjelmointimalli määrittelee kehittyneitä kuvioita, jotka antavat sinulle paremman hallinnan toimintoihisi. SDK toteuttaa nämä mallit luokkien ja metodien kautta, jotka mahdollistavat:

Access invocation metadata siitä, kuka kutsui funktiosi ja miten
Käsittele räätälöityjä virhetilanteita rakenteellisilla virhevastauksilla
Integroitu Fabric-muuttujakirjastoihin keskitettyyn konfiguraation hallintaan

Huomautus

Käyttäjätietofunktioilla on palvelurajoituksia pyynnön koolle, suoritusaikakatkaiselle ja vastekoolle. Lisätietoja näistä rajoituksista ja niiden valvonnasta löytyy palvelutiedoista ja rajoituksista.

Hae kutsuominaisuudet `UserDataFunctionContext` avulla

SDK sisältää objektin UserDataFunctionContext . Tämä objekti sisältää funktion kutsumetatiedot ja sitä voidaan käyttää luomaan erityistä sovelluslogiikkaa eri kutsumekanismeille (kuten portaalikutsu vs. REST API -kutsu).

Seuraavassa taulukossa näkyvät UserDataFunctionContext-objektin ominaisuudet:

Ominaisuuden nimi	Tietotyyppi	Kuvaus
invocation_id	merkkijono	Käyttäjätietofunktiokohteen kutsuun yhdistetty yksilöllinen GUID-tunnus.
executing_user	objekti	Metatiedot käyttäjän tiedoista, joita käytetään kutsun antamiseen.

executing_user-objekti sisältää seuraavat tiedot:

Ominaisuuden nimi	Tietotyyppi	Kuvaus
Oid	merkkijono (GUID)	Käyttäjän objekti-ID, joka on pyytäjälle muuttumaton tunniste. Tämä on sen käyttäjän tai palvelun päänimen todennettu käyttäjätieto, jota käytetään tämän funktion kutsumiseen kaikissa sovelluksissa.
Vuokraajan tunnus	merkkijono (GUID)	Sen vuokraajan tunnus, johon käyttäjä on kirjautunut sisään.
PreferredUsername	merkkijono	Käyttäjän määrittämä ensisijainen käyttäjänimi. Tämä arvo on muunnettavissa.

access UserDataFunctionContext-parametrin sinun täytyy käyttää seuraavaa koristelijaa funktion määritelmän yläreunassa: @udf.context(argName="<parameter name>")

Esimerkki

@udf.context(argName="myContext")
@udf.function()
def getContext(myContext: fabric.functions.UserDataFunctionContext)-> str:
    logging.info('Python UDF trigger function processed a request.')
    return f"Hello oid = {myContext.executing_user['Oid']}, TenantId = {myContext.executing_user['TenantId']}, PreferredUsername = {myContext.executing_user['PreferredUsername']}, InvocationId = {myContext.invocation_id}"

Anna käsitelty virhe `UserThrownError`

Kun kehität funktiotasi, voit antaa odotetun virhevastauksen käyttämällä SDK:ssa olevaa UserThrownError luokkaa. Yksi tämän luokan käyttötarkoitus on hallita tapauksia, joissa käyttäjän antamat syötteet eivät läpäise liiketoiminnan validointisääntöjä.

Esimerkki

import datetime

@udf.function()
def raise_userthrownerror(age: int)-> str:
    if age < 18:
        raise fn.UserThrownError("You must be 18 years or older to use this service.", {"age": age})

    return f"Welcome to Fabric Functions at {datetime.datetime.now()}!"

Luokkakonstruktori UserThrownError ottaa kaksi parametria:

Message: Tämä merkkijono palautetaan virhesanomana sovellukselle, joka käynnistää tämän funktion.
Ominaisuuksien sanasto palautetaan sovellukseen, joka kutsuu tätä funktiota.

Muuttujien hakeminen Fabric-muuttujakirjastoista

Fabric-muuttujakirjasto on keskitetty tietovarasto muuttujien hallintaan, jota voit käyttää eri kohteissa työtilassa. Sen avulla kehittäjät voivat mukauttaa ja jakaa esinemäärityksiä tehokkaasti. Jos sinulla ei vielä ole muuttujakirjastoa, katso Luo ja hallinnoi muuttujakirjastoja.

Käyttääksesi muuttujakirjastoa funktioissasi, lisäät siihen yhteyden käyttäjätietofunktioiden kohteesta. Muuttujakirjastot löytyvät OneLake-katalogista yhdessä tietolähteiden, kuten SQL-tietokantojen ja järvitalojen, kanssa.

Seuraa näitä ohjeita käyttääksesi muuttujakirjastoja funktioissasi:

Lisää käyttäjätietofunktioiden kohteessa yhteys muuttujakirjastoon. OneLake-katalogista etsi ja valitse muuttujakirjasto, sitten valitse Yhdistä. Huomaa alias , jonka Fabric luo yhteydelle.
Lisää muuttujakirjaston alkiolle yhteyden koristelija. Voit esimerkiksi @udf.connection(argName="varLib", alias="<My Variable Library Alias>") korvata aliaksen muuttujan kirjastokohteen juuri lisätylle yhteydelle.
Sisällytä funktion määritykseen argumentti, jonka tyyppi fn.FabricVariablesClienton . Tämä asiakasohjelma tarjoaa menetelmiä, joita tarvitset muuttujien kirjastokohteen käsittelyyn.
Käytä getVariables() metodia saadaksesi kaikki muuttujat muuttujakirjastosta.
Voit lukea muuttujien arvot käyttämällä joko ["variable-name"] tai ..get("variable-name")

Esimerkki:

Tässä esimerkissä simuloidaan konfiguraatioskenaario tuotanto- ja kehitysympäristölle. Tämä funktio asettaa tallennuspolun valitun ympäristön mukaan käyttämällä muuttujakirjastosta haettua arvoa. Muuttujakirjastossa on muuttuja nimeltä ENV , jossa käyttäjät voivat asettaa arvon dev tai prod.

@udf.connection(argName="varLib", alias="<My Variable Library Alias>")
@udf.function()
def get_storage_path(dataset: str, varLib: fn.FabricVariablesClient) -> str:
    """
    Description: Determine storage path for a dataset based on environment configuration from Variable Library.
    
    Args:
        dataset_name (str): Name of the dataset to store.
        varLib (fn.FabricVariablesClient): Fabric Variable Library connection.
    
    Returns:
        str: Full storage path for the dataset.
    """
    # Retrieve variables from Variable Library
    variables = varLib.getVariables()
    
    # Get environment and base paths
    env = variables.get("ENV")    
    dev_path = variables.get("DEV_FILE_PATH")
    prod_path = variables.get("PROD_FILE_PATH")
    
    # Apply environment-specific logic
    if env.lower() == "dev":
        return f"{dev_path}{dataset}/"
    elif env.lower() == "prod":
        return f"{prod_path}{dataset}/"
    else:
        return f"incorrect settings define for ENV variable"

Palaute

Onko tästä sivusta apua?

Last updated on 2026-08-05

Fabric-käyttäjädatan funktioohjelmointimallin yleiskatsaus

SDK:n aloittaminen

Käyttäjätietofunktiot SDK

Vaaditut tuonnit ja alustus

Sisustaja @udf.function()

Aputoiminnon toiminnot

Tuetut syötetyypit

Tuetut tulostetyypit

Kirjoitusfunktiot

Syntaksivaatimukset ja rajoitukset

Parametrien nimeäminen

Parametrivaatimukset

Toimintovaatimukset

Esimerkki oikeasta syntaksista

Asynkronisen funktion kirjoittaminen

Työskentely datan kanssa

Tietoyhteydet Fabric-tietolähteisiin

Esimerkki:

Yleiset yhteydet Fabric-kohteille tai Azure-resursseille

Yhdistä Cosmos DB:hen Fabric-kontissa yleisen yhteyden avulla

Yhdistä Azure Key Vault -sovellukseen käyttämällä yleistä yhteyttä

Lisäominaisuudet

Hae kutsuominaisuudet UserDataFunctionContext avulla

Anna käsitelty virhe UserThrownError

Muuttujien hakeminen Fabric-muuttujakirjastoista

Esimerkki:

Liittyvä sisältö

Palaute

Lisäresursseja

Hae kutsuominaisuudet `UserDataFunctionContext` avulla

Anna käsitelty virhe `UserThrownError`