Teilen über

Übersicht über das Programmiermodell für Fabric-Benutzerdatenfunktionen

Das Programmiermodell für Fabric-Benutzerdatenfunktionen definiert die Muster und Konzepte für die Erstellung von Funktionen in Fabric.

Das fabric-user-data-functions SDK implementiert dieses Programmiermodell und stellt die erforderlichen Funktionen zum Erstellen und Veröffentlichen von runnablen Funktionen bereit. Mit dem SDK können Sie außerdem eine nahtlose Integration mit weiteren Elementen im Fabric-Ökosystem wie Fabric-Datenquellen durchführen. Diese Bibliothek ist in PyPI öffentlich verfügbar und in den User Data Functions-Elementen vorinstalliert.

In diesem Artikel wird erläutert, wie Sie mithilfe des SDK Funktionen erstellen, die über das Fabric-Portal, andere Fabric-Elemente oder externe Anwendungen mithilfe der REST-API aufgerufen werden können. Sie lernen das Programmiermodell und wichtige Konzepte mit praktischen Beispielen kennen.

Tipp

Ausführliche Informationen zu allen Klassen, Methoden und Parametern finden Sie in der SDK-Referenzdokumentation.

Erste Schritte mit dem SDK

In diesem Abschnitt werden die Kernkomponenten des User Data Functions SDK vorgestellt und erläutert, wie Sie Ihre Funktionen strukturieren. Sie erfahren mehr über die erforderlichen Importe, Dekoratoren und die Arten von Eingabe- und Ausgabedaten, die Ihre Funktionen verarbeiten können.

User Data Functions-SDK

Das fabric-user-data-functions SDK stellt die Kernkomponenten bereit, die Sie zum Erstellen von Benutzerdatenfunktionen in Python benötigen.

Erforderliche Importe und Initialisierung

Jede Datei mit Benutzerdatenfunktionen muss das fabric.functions Modul importieren und den Ausführungskontext initialisieren:

import datetime
import fabric.functions as fn
import logging

udf = fn.UserDataFunctions()

Der @udf.function() Dekorateur

Funktionen, die mit dem @udf.function() Decorator gekennzeichnet sind, können über das Fabric-Portal, ein anderes Fabric-Element oder eine externe Anwendung aufgerufen werden. Funktionen mit diesem Decorator müssen einen Rückgabetyp angeben.

Beispiel:

@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()}!"

Hilfsfunktionen

Python-Methoden ohne den @udf.function() Dekorateur können nicht direkt aufgerufen werden. Sie können nur aus dekorierten Funktionen aufgerufen werden und dienen als Hilfsfunktionen.

Beispiel:

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

Unterstützte Eingabetypen

Sie können für die Funktion Eingabeparameter wie die folgenden primitiven Datentypen definieren: str, int und float. Folgende Eingabedatentypen werden unterstützt:

JSON-Typ Python-Datentyp
Schnur Str
Datetime-Zeichenfolge Datum und Uhrzeit
Boolesch Boolesch
Zahlen int, float
Anordnung list[], Beispiel: list[int]
-Objekt- Wörterbuch
-Objekt- Pandas DataFrame
Objekt oder Array von Objekten Pandas Serie

Hinweis

Wenn Sie Pandas DataFrame- und Series-Typen verwenden möchten, wechseln Sie zum Fabric-Portal, suchen Sie Ihren Arbeitsbereich, und öffnen Sie das Element der Benutzerdatenfunktionen. Wählen Sie "Bibliotheksverwaltung", suchen Sie nach dem fabric-user-data-functions Paket, und aktualisieren Sie es auf Version 1.0.0 oder höher.

Beispiel für den Anforderungstext für unterstützte Eingabetypen:

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

Unterstützte Ausgabetypen

Folgende Ausgabedatentypen werden unterstützt:

Python-Datentyp
Str
Datum und Uhrzeit
Boolesch
int, float
list[Datentyp], Beispiel: list[int]
Wörterbuch
Nichts
Pandas Serie
Pandas DataFrame

Schreiben von Funktionen

Syntaxanforderungen und Einschränkungen

Beim Schreiben von Benutzerdatenfunktionen müssen Sie bestimmte Syntaxregeln befolgen, um sicherzustellen, dass Ihre Funktionen ordnungsgemäß funktionieren.

Parameterbenennung

  • Verwenden Sie camelCase: Parameternamen müssen die CamelCase-Benennungskonvention verwenden und dürfen keine Unterstriche enthalten. Verwenden Sie z. B. productName statt product_name.
  • Reservierte Schlüsselwörter: Reservierte Python-Schlüsselwörter oder die folgenden Fabric-spezifischen Schlüsselwörter können nicht als Parameternamen oder Funktionsnamen verwendet werden: req, und contextreqInvocationId.

Parameteranforderungen

  • Keine Standardwerte: Standardwerte werden nicht unterstützt. Beim Aufrufen einer Funktion sind alle Parameter erforderlich. Die folgende Funktion löst z. B. einen Syntaxfehler aus: 
    # The default value for the argument called 'name' is not supported and treated like a syntax error.
@udf.function()
def goodbye_fabric(name: str = "N/A") -> str:
    return f"Goodbye, {name}."
  • Typanmerkungen erforderlich: Alle Parameter müssen Typanmerkungen enthalten (z. B name: str. ).

Funktionsanforderungen

  • Rückgabetyp erforderlich: Funktionen mit dem @udf.function() Decorator müssen eine Rückgabetyp-Annotation angeben (z. B. -> str).
  • Erforderliche Importe: Die import fabric.functions as fn Anweisung und udf = fn.UserDataFunctions() Initialisierung sind erforderlich, damit Ihre Funktionen funktionieren.

Beispiel für eine korrekte Syntax

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

So schreiben Sie eine asynchrone Funktion

Fügen Sie einen async-Dekorator zu Ihrer Funktionsdefinition in Ihrem Code hinzu. Mit einer async Funktion können Sie die Reaktionsfähigkeit und Effizienz Ihrer Anwendung verbessern, indem Sie mehrere Aufgaben gleichzeitig behandeln. Sie eignen sich ideal für das Verarbeiten hoher E/A-gebundener Vorgänge. Diese Beispielfunktion liest eine CSV-Datei aus einem Seehaus mithilfe von Pandas. Die Funktion verwendet den Dateinamen als Eingabeparameter.

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

Arbeiten mit Daten

Datenverbindungen mit Fabric-Datenquellen

Mit dem SDK können Sie auf Datenverbindungen verweisen, ohne dass Verbindungszeichenfolgen in Ihrem Code geschrieben werden müssen. Die fabric.functions-Bibliothek bietet zwei Möglichkeiten zum Verarbeiten von Datenverbindungen:

  • fabric.functions.FabricSqlConnection: Ermöglicht es Ihnen, in Fabric mit SQL-Datenbanken zu arbeiten, einschließlich SQL Analytics-Endpunkten und Fabric Warehouses
  • fabric.functions.FabricLakehouseClient: Ermöglicht es Ihnen, mit Lakehouses zu arbeiten und eine Verknüpfung zu Lakehouse-Tabellen und Lakehouse-Dateien zu erstellen

Um auf eine Verbindung mit einer Datenquelle zu verweisen, müssen Sie das Decorator-Element @udf.connection verwenden. Sie können dieses in einem der folgenden Formate anwenden:

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

Die Argumente für @udf.connection lauten:

  • argName, den Namen der Variablen, die die Verbindung in Ihrer Funktion verwendet.
  • alias: Alias der Verbindung, die Sie über das Menü Verbindungen verwalten hinzugefügt haben
  • Wenn argName und alias über denselben Wert verfügen, können Sie @udf.connection("<alias and argName for the data connection>") verwenden.

Beispiel

# 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

Generische Verbindungen für Fabric-Elemente oder Azure-Ressourcen

Das SDK unterstützt generische Verbindungen, mit denen Sie Verbindungen mit Fabric-Elementen oder Azure-Ressourcen mithilfe ihrer Besitzeridentität für Benutzerdatenfunktionen erstellen können. Dieses Feature generiert ein Microsoft Entra-ID-Token mit der Identität des Elementbesitzers und einem bereitgestellten Zielgruppentyp. Dieses Token wird verwendet, um sich bei Fabric-Elementen oder Azure-Ressourcen zu authentifizieren, die diesen Zielgruppentyp unterstützen. Dieser Ansatz bietet eine ähnliche Programmiererfahrung wie die Verwendung von verwalteten Verbindungsobjekten über das Feature "Verbindungen verwalten" , jedoch nur für den bereitgestellten Zielgruppentyp in der Verbindung.

Dieses Feature verwendet den @udf.generic_connection() Dekorierer mit den folgenden Parametern:

Parameter BESCHREIBUNG Wert
argName Der Name der Variablen, die an die Funktion übergeben wird. Der Benutzer muss diese Variable in den Argumenten ihrer Funktion angeben und den Typ fn.FabricItem dafür verwenden. Wenn die argName=CosmosDbFunktion beispielsweise dieses Argument enthalten soll, sollte die Funktion dieses Argument enthalten. cosmosDb: fn.FabricItem
audienceType Der Typ der Zielgruppe, für die die Verbindung erstellt wird. Dieser Parameter ist dem Typ des Fabric-Elements oder Azure-Diensts zugeordnet und bestimmt den client, der für die Verbindung verwendet wird. Die zulässigen Werte für diesen Parameter sind CosmosDb oder KeyVault.

Herstellen einer Verbindung mit einem Fabric Cosmos DB-Container mithilfe einer generischen Verbindung

Generische Verbindungen unterstützen systemeigene Fabric Cosmos DB-Elemente mithilfe des CosmosDB Zielgruppentyps. Das im User Data Functions SDK enthaltene SDK bietet eine Hilfsmethode namens get_cosmos_client an, die bei jedem Aufruf einen Singleton Cosmos DB-Client abruft.

Sie können eine Verbindung mit einem Fabric Cosmos DB-Element mithilfe einer generischen Verbindung herstellen, indem Sie die folgenden Schritte ausführen:

  1. Wechseln Sie zum Fabric-Portal, suchen Sie Ihren Arbeitsbereich, und öffnen Sie das Element der Benutzerdatenfunktionen. Wählen Sie "Bibliotheksverwaltung", suchen Sie nach der azure-cosmos Bibliothek, und installieren Sie sie. Weitere Informationen finden Sie unter Verwalten von Bibliotheken.

  2. Wechseln Sie zu ihren Fabric Cosmos DB-Elementeinstellungen .

    Screenshot der Position der Fabric Cosmos DB-Einstellungsschaltfläche.

  3. Rufen Sie Ihre Fabric Cosmos DB-Endpunkt-URL ab.

    Screenshot der Fabric Cosmos DB-Endpunkt-URL.

  4. Wechseln Sie zum Element "Benutzerdatenfunktionen". Verwenden Sie den folgenden Beispielcode, um eine Verbindung mit Ihrem Fabric Cosmos DB-Container herzustellen und eine Leseabfrage mithilfe des Cosmos DB-Beispieldatensatzes auszuführen. Ersetzen Sie die Werte der folgenden Variablen:

    • COSMOS_DB_URI mit Ihrem Fabric Cosmos DB-Endpunkt.
    • DB_NAME mit dem Namen Ihres Fabric Cosmos DB-Elements.
    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)

  5. Testen oder ausführen Sie diese Funktion , indem Sie einen Kategorienamen angeben, z Accessory . B. in den Aufrufparametern.

Hinweis

Sie können diese Schritte auch verwenden, um eine Verbindung mit einer Azure Cosmos DB-Datenbank mithilfe der Konto-URL und datenbanknamen herzustellen. Das Besitzerkonto der Benutzerdatenfunktionen benötigt Zugriffsberechtigungen für dieses Azure Cosmos DB-Konto.

Herstellen einer Verbindung mit Azure Key Vault mithilfe einer generischen Verbindung

Generische Verbindungen unterstützen die Verbindung mit einem Azure Key Vault mithilfe des KeyVault Zielgruppentyps. Diese Art von Verbindung erfordert, dass der Besitzer der Fabric-Benutzerdatenfunktionen über Berechtigungen zum Herstellen einer Verbindung mit dem Azure Key Vault verfügt. Sie können diese Verbindung verwenden, um Schlüssel, geheime Schlüssel oder Zertifikate anhand des Namens abzurufen.

Sie können eine Verbindung mit Azure Key Vault herstellen, um einen geheimen Clientschlüssel abzurufen, um eine API mithilfe einer generischen Verbindung aufzurufen, indem Sie die folgenden Schritte ausführen:

  1. Wechseln Sie zum Fabric-Portal, suchen Sie Ihren Arbeitsbereich, und öffnen Sie das Element der Benutzerdatenfunktionen. Wählen Sie "Bibliotheksverwaltung" aus, suchen Sie dann nach den requests und azure-keyvault-secrets Bibliotheken und installieren Sie diese. Weitere Informationen finden Sie unter Verwalten von Bibliotheken.

  2. Wechseln Sie im Azure-Portal zu Ihrer Azure Key Vault-Ressource, und rufen Sie den Vault URI Namen Ihres Schlüssels, Ihres geheimen Schlüssels oder Zertifikats ab.

    Screenshot der Azure Key Vault-Endpunkt-URL und -Werte.

  3. Wechseln Sie zurück zum Fabric User Data Functions-Element , und verwenden Sie dieses Beispiel. In diesem Beispiel rufen wir einen geheimen Schlüssel aus Azure Key Vault ab, um eine Verbindung mit einer öffentlichen API herzustellen. Ersetzen Sie den Wert der folgenden Variablen:

    • KEY_VAULT_URL mit dem Vault URI, das Sie im vorherigen Schritt abgerufen haben.
    • KEY_VAULT_SECRET_NAME mit dem Namen Ihres geheimen Schlüssels.
    • API_URL Variable mit der URL der API, mit der Sie eine Verbindung herstellen möchten. In diesem Beispiel wird davon ausgegangen, dass Sie eine Verbindung mit einer öffentlichen API herstellen, die GET-Anforderungen akzeptiert und die folgenden Parameter api-key verwendet 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}"

  4. Testen oder ausführen Sie diese Funktion , indem Sie einen Anforderungstext in Ihrem Code angeben.

Erweiterte Funktionen

Das Programmiermodell definiert erweiterte Muster, die Ihnen eine bessere Kontrolle über Ihre Funktionen bieten. Das SDK implementiert diese Muster über Klassen und Methoden, mit denen Sie folgende Aktionen ausführen können:

  • Zugreifen auf Aufrufmetadaten darüber, wer Ihre Funktion aufgerufen hat und wie
  • Behandeln von benutzerdefinierten Fehlerszenarien mit strukturierten Fehlerantworten
  • Integration in Fabric-Variablenbibliotheken für die zentrale Konfigurationsverwaltung

Hinweis

Benutzerdatenfunktionen verfügen über Dienstbeschränkungen für Anforderungsgröße, Ausführungstimeout und Antwortgröße. Ausführliche Informationen zu diesen Grenzwerten und deren Durchsetzung finden Sie unter Dienstdetails und Einschränkungen.

Abrufen von Aufrufeigenschaften mithilfe von UserDataFunctionContext

Das SDK enthält das UserDataFunctionContext Objekt. Dieses Objekt enthält die Funktionsaufrufmetadaten und kann verwendet werden, um spezifische App-Logik für verschiedene Aufrufmechanismen zu erstellen (z. B. Portalaufrufe im Vergleich zum REST-API-Aufruf).

In der folgenden Tabelle sind die Eigenschaften für das UserDataFunctionContext-Objekt aufgeführt:

Eigenschaftsname Datentyp BESCHREIBUNG
invocation_id Schnur Eindeutige GUID, die an den Aufruf des User Data Functions-Elements gebunden ist
ausführender_Benutzer Objekt Metadaten der Benutzerinformationen, die zum Autorisieren des Aufrufs verwendet werden

Das executing_user-Objekt enthält die folgenden Informationen:

Eigenschaftsname Datentyp BESCHREIBUNG
OID Zeichenfolge (GUID) Die Objekt-ID des Benutzers, bei der es sich um einen unveränderlichen Bezeichner für die anfordernde Instanz handelt. Sie stellt die überprüfte Identität des Benutzers oder Dienstprinzipals dar, der in allen Anwendungen zum Aufrufen dieser Funktion verwendet wird.
Mieter-ID Zeichenfolge (GUID) ID des Mandanten, bei dem der Benutzer angemeldet ist
BevorzugterBenutzername Schnur Bevorzugter Benutzername des aufrufenden Benutzers, wie von den Benutzenden festgelegt Dieser Wert ist veränderlich.

Um auf den Parameter UserDataFunctionContext zuzugreifen, müssen Sie oben in der Funktionsdefinition das folgende Decorator-Element verwenden: @udf.context(argName="<parameter name>").

Beispiel

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

Auslösen eines behandelten Fehlers mit UserThrownError

Beim Entwickeln Ihrer Funktion können Sie eine erwartete Fehlerantwort mithilfe der UserThrownError im SDK verfügbaren Klasse auslösen. Eine Verwendung dieser Klasse ist das Verwalten von Fällen, in denen die vom Benutzer bereitgestellten Eingaben die geschäftlichen Validierungsregeln nicht bestehen.

Beispiel

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

Der UserThrownError Klassenkonstruktor akzeptiert zwei Parameter:

  • Message: Diese Zeichenfolge wird als Fehlermeldung an die Anwendung zurückgegeben, die diese Funktion aufruft.
  • Ein Wörterbuch mit Eigenschaften wird an die Anwendung zurückgegeben, die diese Funktion aufruft.

Abrufen von Variablen aus Fabric-Variablenbibliotheken

Eine Fabric-Variablenbibliothek in Microsoft Fabric ist ein zentrales Repository zum Verwalten von Variablen, die für verschiedene Elemente innerhalb eines Arbeitsbereichs verwendet werden können. Es ermöglicht Entwicklern, Elementkonfigurationen effizient anzupassen und zu teilen. Wenn Sie noch keine Variablebibliothek haben, lesen Sie " Erstellen und Verwalten von Variablenbibliotheken".

Um eine Variable-Bibliothek in Ihren Funktionen zu verwenden, fügen Sie eine Verbindung mit ihr aus dem Element der Benutzerdatenfunktionen hinzu. Variable Bibliotheken werden im OneLake-Katalog zusammen mit Datenquellen wie SQL-Datenbanken und Lakehouses angezeigt.

Führen Sie die folgenden Schritte aus, um Variablenbibliotheken in Ihren Funktionen zu verwenden:

  1. Fügen Sie in Ihrem Benutzerdatenfunktionen-Element eine Verbindung zu Ihrer Variablenbibliothek hinzu. Suchen und wählen Sie im OneLake-Katalog Ihre Variablenbibliothek aus, und wählen Sie dann Verbinden aus. Beachten Sie den Alias , den Fabric für die Verbindung generiert.
  2. Fügen Sie einen Verbindungsdekorator für das Variablenbibliothekselement hinzu. Ersetzen Sie beispielsweise @udf.connection(argName="varLib", alias="<My Variable Library Alias>") das Alias durch die neu hinzugefügte Verbindung für das Variablenbibliothekselement.
  3. Fügen Sie in der Funktionsdefinition ein Argument mit Typ fn.FabricVariablesClientein. Dieser Client stellt Methoden bereit, die Sie für die Arbeit mit dem Variablenbibliothekselement benötigen.
  4. Verwenden Sie getVariables() die Methode, um alle Variablen aus der Variablenbibliothek abzurufen.
  5. Um die Werte der Variablen zu lesen, verwenden Sie entweder ["variable-name"] oder .get("variable-name").

Beispiel

In diesem Beispiel simulieren wir ein Konfigurationsszenario für eine Produktions- und Entwicklungsumgebung. Diese Funktion legt abhängig von der ausgewählten Umgebung einen Speicherpfad fest, indem ein wert verwendet wird, der aus der Variablenbibliothek abgerufen wird. Die Variable-Bibliothek enthält eine Variable, die ENV genannt wird, in der Benutzer einen Wert von dev oder prod festlegen können.

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

Verwandte Inhalte

  • Last updated on