แชร์ผ่าน

ภาพรวมโมเดลการเขียนโปรแกรมฟังก์ชันข้อมูลผู้ใช้ Fabric

ฟังก์ชันข้อมูลผู้ใช้ Fabric แบบจําลองการเขียนโปรแกรมเป็น SDK ที่มีฟังก์ชันการทํางานที่จําเป็นสําหรับการเขียนและเผยแพร่ฟังก์ชันที่สามารถเรียกใช้ได้ใน Fabric SDK ยังช่วยให้คุณสามารถรวมกับรายการอื่น ๆ ในระบบนิเวศของ Fabric ได้อย่างราบรื่น เช่น แหล่งข้อมูล Fabric ไลบรารีนี้จะพร้อมใช้งานแบบสาธารณะใน PyPI และมีการติดตั้งไว้ล่วงหน้าในรายการฟังก์ชันข้อมูลผู้ใช้ของคุณ

ฟังก์ชันข้อมูลผู้ใช้ SDK

รายการฟังก์ชันข้อมูลผู้ใช้มีหนึ่งหรือหลายฟังก์ชันที่คุณสามารถเรียกใช้ได้จากพอร์ทัล Fabric จากรายการ Fabric อื่น หรือจากแอปพลิเคชันภายนอกโดยใช้จุดสิ้นสุด REST ที่ให้มา แต่ละฟังก์ชันเป็นวิธีการในสคริปต์ Python ของคุณที่อนุญาตให้ส่งผ่านพารามิเตอร์และส่งกลับผลลัพธ์ไปยังผู้เรียกใช้ รูปแบบการเขียนโปรแกรมฟังก์ชันข้อมูลผู้ใช้ประกอบด้วยคอมโพเนนต์ต่อไปนี้:

  • ไลบรารี fabric.functions มีโค้ดที่คุณจําเป็นต้องสร้างฟังก์ชันข้อมูลผู้ใช้ใน Python คุณสามารถดูไลบรารีนี้ที่นําเข้าในเทมเพลตฟังก์ชันแรกของคุณเมื่อคุณสร้างรายการฟังก์ชันข้อมูลผู้ใช้ใหม่

  • เมธอด fn.UserDataFunctions() มีบริบทการดําเนินการที่พบที่จุดเริ่มต้นของไฟล์โค้ดในรายการฟังก์ชันข้อมูลผู้ใช้ใหม่ทั้งหมด ก่อนข้อกําหนดฟังก์ชันใด ๆ

    ตัวอย่าง:

    import datetime
import fabric.functions as fn
import logging

udf = fn.UserDataFunctions()

  • ทุกฟังก์ชันจะถูกระบุด้วย @udf.function() ตกแต่ง ผู้ตกแต่งนี้จะกําหนดว่าฟังก์ชันของคุณสามารถเรียกใช้แยกต่างหากจากพอร์ทัลหรือจากผู้เรียกใช้ภายนอกได้หรือไม่ การใช้ตัวตกแต่งนี้ยังต้องการฟังก์ชันให้มีค่าที่ส่งคืน ฟังก์ชันที่มีตัวตกแต่งนี้สามารถเข้าถึงวัตถุการเชื่อมต่อที่แสดงโดย @udf.connection ตัวตกแต่ง

    ตัวอย่างฟังก์ชันที่เรียกใช้ได้ 

    # This is a hello fabric function sample that can be invoked from the Fabric portal, another Fabric item, or an external application.

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

  • วิธี Python ใด ๆ ที่ไม่มี @udf.function() ตกแต่งไม่สามารถเรียกใช้ได้โดยตรง สามารถเรียกใช้ได้จากฟังก์ชันที่ประกอบด้วยตกแต่งเท่านั้น และสามารถใช้เป็นฟังก์ชันผู้ช่วยเหลือได้

    ตัวอย่างฟังก์ชัน ตัวช่วยเหลือ

    # This is a helper function that can be invoked from other functions, but can't be invoked or run directly because it doesn't have the @udf.function() decorator

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

ชนิดการป้อนข้อมูลที่ได้รับการสนับสนุน

คุณสามารถกําหนดพารามิเตอร์การป้อนข้อมูลสําหรับฟังก์ชัน เช่น ชนิดข้อมูลแรกเริ่ม เช่น str, int, float และอื่น ๆ ชนิดข้อมูลป้อนเข้าที่ได้รับการสนับสนุนคือ:

ประเภท JSON ของ ชนิดข้อมูล Python
เชือก str
สตริงวันที่เวลา วันที่เวลา
บูลีน บูล
ตัวเลข int, ลอย
อาร์เรย์ list[], ตัวอย่าง list[int]
วัตถุของ เขียนตามคําบอก
วัตถุของ DataFrame ของ pandas
วัตถุ หรือ อาร์เรย์ของวัตถุ ซีรีส์ pandas

หมายเหตุ

เพื่อใช้ประเภท DataFrame และ Series ของ pandas ให้เลือก การจัดการไลบรารี ในพอร์ทัล Fabric สําหรับฟังก์ชันข้อมูลผู้ใช้ของคุณ และอัปเดต fabric-user-data-function เวอร์ชันเป็น 1.0.0

ตัวอย่างของเนื้อความคําขอสําหรับชนิดการป้อนข้อมูลที่ได้รับการสนับสนุน:

{
  "name": "Alice",                          // String (str)
  "signup_date": "2025-07-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-07-01": {"product": "A", "units": 10},
    "2025-07-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}
  ]
}

ชนิดเอาต์พุตที่ได้รับการสนับสนุน

ชนิดข้อมูลผลลัพธ์ที่ได้รับการสนับสนุนคือ:

ชนิดข้อมูล Python
str
วันที่เวลา
บูล
int, ลอย
list[data-type] ตัวอย่างเช่น list[int]
เขียนตามคําบอก
ไม่มีใคร
ซีรีส์ pandas
DataFrame ของ pandas

วิธีการเขียนฟังก์ชัน async

เพิ่มตกแต่งแบบ async ด้วยข้อกําหนดฟังก์ชันของคุณในโค้ดของคุณ asyncด้วยฟังก์ชันคุณสามารถปรับปรุงการตอบสนองและประสิทธิภาพของแอปพลิเคชันของคุณโดยการจัดการงานหลายอย่างพร้อมกัน เหมาะอย่างยิ่งสําหรับการจัดการการดําเนินการที่ผูกกับ I/O ในปริมาณมาก ฟังก์ชันตัวอย่างนี้อ่านไฟล์ CSV จาก lakehouse โดยใช้ pandas ฟังก์ชันจะใช้ชื่อไฟล์เป็นพารามิเตอร์การป้อนข้อมูล

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

การเชื่อมต่อข้อมูลไปยังแหล่งข้อมูล Fabric

โมดูลนี้ช่วยให้คุณสามารถอ้างอิง การเชื่อมต่อข้อมูล โดยไม่จําเป็นต้องเขียนสตริงการเชื่อมต่อในโค้ดของคุณ ไลบรารี fabric.functions มีสองวิธีในการจัดการการเชื่อมต่อข้อมูล:

  • fabric.functions.FabricSqlConnection: ช่วยให้คุณสามารถทํางานกับฐานข้อมูล SQL ใน Fabric รวมถึงจุดสิ้นสุด SQL Analytics และคลังสินค้า Fabric
  • fabric.functions.FabricLakehouseClient: ช่วยให้คุณทํางานกับ Lakehouses พร้อมวิธีการเชื่อมต่อทั้งตารางของเลคเฮ้าส์และไฟล์ของเลคเฮ้าส์

เมื่อต้องการอ้างอิงการเชื่อมต่อไปยังแหล่งข้อมูล คุณจําเป็นต้องใช้ตกแต่ง @udf.connection คุณสามารถนําไปใช้ในรูปแบบใด ๆ ต่อไปนี้:

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

อาร์กิวเมนต์สําหรับ @udf.connection คือ:

  • argNameชื่อของตัวแปรที่การเชื่อมต่อใช้ในฟังก์ชันของคุณ
  • aliasนามแฝงของการเชื่อมต่อที่คุณเพิ่มด้วยเมนู จัดการการเชื่อมต่อ
  • ถ้า argName และ alias มีค่าเดียวกัน คุณสามารถใช้ @udf.connection("<alias and argName for the data connection>")ได้

ตัวอย่างเช่น

# 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:
  # Replace with the query you want to run
  query = "SELECT * FROM (VALUES ('John Smith', 31), ('Kayla Jones', 33)) AS Employee(EmpName, DepID);"

  # [...] Here is where the rest of your SqlConnection code would be.

  return results

การเชื่อมต่อทั่วไปสําหรับรายการ Fabric หรือทรัพยากร Azure

การเชื่อมต่อทั่วไปช่วยให้คุณสามารถสร้างการเชื่อมต่อกับรายการ Fabric หรือทรัพยากร Azure โดยใช้ข้อมูลประจําตัวของเจ้าของรายการฟังก์ชันข้อมูลผู้ใช้ของคุณ คุณลักษณะนี้สร้างโทเค็น Microsoft Entra ID ที่มีข้อมูลประจําตัวของเจ้าของรายการและชนิดผู้ชมที่ระบุ โทเค็นนี้ใช้เพื่อรับรองความถูกต้องกับรายการ Fabric หรือทรัพยากร Azure ที่สนับสนุนชนิดผู้ชมนั้น กระบวนการนี้จะให้ประสบการณ์การเขียนโปรแกรมที่คล้ายคลึงกับการใช้ออบเจ็กต์การเชื่อมต่อที่มีการจัดการจาก คุณลักษณะ จัดการการเชื่อมต่อ แต่สําหรับชนิดผู้ชมที่ระบุในการเชื่อมต่อเท่านั้น

คุณลักษณะนี้ใช้ตัว @udf.generic_connection() ตกแต่งด้วยพารามิเตอร์ต่อไปนี้:

พารามิเตอร์ คำอธิบาย ค่า
argName ชื่อของตัวแปรที่ส่งผ่านไปยังฟังก์ชัน ผู้ใช้จําเป็นต้องระบุตัวแปรนี้ในอาร์กิวเมนต์ของฟังก์ชันและใช้ประเภทของfn.FabricItem ตัวอย่างเช่น ถ้า argName=CosmosDbฟังก์ชัน ควรมีอาร์กิวเมนต์นี้ cosmosDb: fn.FabricItem
audienceType ประเภทของกลุ่มเป้าหมายที่สร้างการเชื่อมต่อ พารามิเตอร์นี้เชื่อมโยงกับชนิดของรายการ Fabric หรือบริการ Azure และกําหนดไคลเอ็นต์ที่ใช้สําหรับการเชื่อมต่อ ค่าที่อนุญาตสําหรับพารามิเตอร์CosmosDbนี้คือ หรือKeyVault

เชื่อมต่อกับคอนเทนเนอร์ Fabric Cosmos DB โดยใช้การเชื่อมต่อทั่วไป

การเชื่อมต่อทั่วไปรองรับรายการ Fabric Cosmos DB ดั้งเดิมโดยใช้ CosmosDB ประเภทผู้ชม User Data Functions SDK ที่ให้มามีเมธอดตัวช่วยที่เรียกว่า get_cosmos_client ดึงข้อมูลไคลเอ็นต์ Cosmos DB แบบ singleton สําหรับการเรียกใช้ทุกครั้ง

คุณสามารถเชื่อมต่อกับ รายการ Fabric Cosmos DB โดยใช้การเชื่อมต่อทั่วไป โดยทําตามขั้นตอนเหล่านี้:

  1. ในรายการ Fabric User Data Functions ให้ติดตั้งazure-cosmosไลบรารีโดยใช้ประสบการณ์การจัดการไลบรารี

  2. ไปที่การตั้งค่า รายการ Fabric Cosmos DB ของคุณ

    สกรีนช็อตแสดงตําแหน่งปุ่มการตั้งค่า Fabric Cosmos DB

  3. ดึงข้อมูล URL ปลายทาง Fabric Cosmos DB ของคุณ

    สกรีนช็อตที่แสดง URL ตําแหน่งข้อมูล Fabric Cosmos DB

  4. ไปที่ รายการฟังก์ชันข้อมูลผู้ใช้ของคุณ ใช้โค้ดตัวอย่างต่อไปนี้เพื่อเชื่อมต่อกับคอนเทนเนอร์ Fabric Cosmos DB ของคุณและเรียกใช้คิวรีการอ่านโดยใช้ชุดข้อมูลตัวอย่าง Cosmos DB แทนที่ค่าของตัวแปรต่อไปนี้:

    • COSMOS_DB_URI ด้วยตําแหน่งข้อมูล Fabric Cosmos DB ของคุณ
    • DB_NAME ด้วยชื่อรายการ Fabric Cosmos DB ของคุณ
    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. ทดสอบหรือเรียกใช้ฟังก์ชันนี้ โดยระบุชื่อประเภท เช่น Accessory ในพารามิเตอร์การเรียกใช้

หมายเหตุ

คุณยังสามารถใช้ขั้นตอนเหล่านี้เพื่อเชื่อมต่อกับฐานข้อมูล Azure Cosmos DB โดยใช้ URL บัญชีและชื่อฐานข้อมูล บัญชีเจ้าของฟังก์ชันข้อมูลผู้ใช้จะต้องมีสิทธิ์การเข้าถึงบัญชี Azure Cosmos DB นั้น

เชื่อมต่อกับ Azure Key Vault โดยใช้การเชื่อมต่อทั่วไป

การเชื่อมต่อทั่วไปรองรับการเชื่อมต่อกับ Azure Key Vault โดยใช้ KeyVault ชนิดผู้ชม การเชื่อมต่อชนิดนี้ต้องการให้เจ้าของ Fabric User Data Functions มีสิทธิ์ในการเชื่อมต่อกับ Azure Key Vault คุณสามารถใช้การเชื่อมต่อนี้เพื่อดึงคีย์ ข้อมูลลับ หรือใบรับรองตามชื่อ

คุณสามารถเชื่อมต่อกับ Azure Key Vault เพื่อดึงข้อมูลลับของไคลเอ็นต์เพื่อเรียกใช้ API โดยใช้การเชื่อมต่อทั่วไปโดยทําตามขั้นตอนเหล่านี้:

  1. ในรายการ Fabric User Data Functions ของคุณ ให้ติดตั้งไลบรารีและrequestsazure-keyvault-secretsไลบรารีโดยใช้ประสบการณ์การจัดการไลบรารี

  2. ไปที่ ทรัพยากร Azure Key Vault ของคุณและดึงข้อมูล Vault URI และชื่อของคีย์ ข้อมูลลับ หรือใบรับรองของคุณ

    สกรีนช็อตแสดง URL และค่าปลายทาง Azure Key Vault

  3. กลับไปที่ รายการ Fabric User Data Functions และใช้ตัวอย่างนี้ ในตัวอย่างนี้ เราดึงข้อมูลลับจาก Azure Key Vault เพื่อเชื่อมต่อกับ API สาธารณะ แทนที่ค่าของตัวแปรต่อไปนี้:

    • KEY_VAULT_URL ด้วยข้อมูลที่คุณ Vault URI ดึงมาในขั้นตอนก่อนหน้า
    • KEY_VAULT_SECRET_NAME ด้วยชื่อความลับของคุณ
    • API_URL ที่มี URL ของ API ที่คุณต้องการเชื่อมต่อ ตัวอย่างนี้ถือว่าคุณกําลังเชื่อมต่อกับ API สาธารณะที่ยอมรับคําขอ GET และใช้พารามิเตอร์api-keyต่อไปนี้และ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. ทดสอบหรือเรียกใช้ฟังก์ชันนี้ โดยระบุเนื้อหาคําขอในโค้ดของคุณ

รับคุณสมบัติการเรียกโดยใช้ UserDataFunctionContext

แบบจําลองการเขียนโปรแกรมยังรวมถึงวัตถุ UserDataFunctionContext ด้วย วัตถุนี้ประกอบด้วยเมตาดาต้าการเรียกใช้ฟังก์ชัน และสามารถใช้เพื่อสร้างตรรกะของแอปเฉพาะสําหรับกลไกการเรียกใช้บางอย่าง

ตารางต่อไปนี้แสดงคุณสมบัติสําหรับวัตถุ UserDataFunctionContext:

ชื่อคุณสมบัติ ชนิดข้อมูล คำอธิบาย
รหัสการเรียกใช้ สตริง GUID ที่ไม่ซ้ํากันที่เชื่อมโยงกับการเรียกใช้รายการฟังก์ชันข้อมูลผู้ใช้
ExecutingUser ออบเจ็กต์ เมตาดาต้าของข้อมูลของผู้ใช้ที่ใช้ในการอนุญาตการเรียก

วัตถุ ExecutingUser ประกอบด้วยข้อมูลต่อไปนี้:

ชื่อคุณสมบัติ ชนิดข้อมูล คำอธิบาย
Oid สตริง (GUID) ID ออบเจ็กต์ของผู้ใช้ ซึ่งเป็นตัวระบุที่ไม่เหมาะสมสําหรับผู้ร้องขอ นี่คือข้อมูลประจําตัวที่ผ่านการตรวจสอบของผู้ใช้หรือบริการหลักที่ใช้ในการเรียกใช้ฟังก์ชันนี้ในแอปพลิเคชันทั้งหมด
รหัสผู้เช่า สตริง (GUID) ID ของผู้เช่าที่ผู้ใช้ลงชื่อเข้าใช้
PreferredUsername สตริง ชื่อผู้ใช้ที่ต้องการของผู้ใช้ที่เรียก ตามที่กําหนดโดยผู้ใช้ ค่านี้มีความเสถียร

เมื่อต้องการเข้าถึงพารามิเตอร์ UserDataFunctionContext คุณต้องใช้มัณฑะต่อไปนี้ที่ด้านบนของข้อกําหนดฟังก์ชัน: @udf.context(argName="<parameter name>")

ตัวอย่าง

@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 = {context.executing_user['Oid']}, TenantId = {context.executing_user['TenantId']}, PreferredUsername = {context.executing_user['PreferredUsername']}, InvocationId = {context.invocation_id}"

โยนข้อผิดพลาดที่มีการจัดการ UserThrownError

เมื่อพัฒนาฟังก์ชันของคุณ คุณสามารถโยนการตอบสนองข้อผิดพลาดที่คาดไว้ได้โดยใช้วิธี UserThrownError ที่พร้อมใช้งานในแบบจําลองการเขียนโปรแกรม Python การใช้หนึ่งในวิธีนี้คือการจัดการกรณีที่อินพุตที่ผู้ใช้ระบุล้มเหลวในการส่งผ่านกฎการตรวจสอบทางธุรกิจ

ตัวอย่าง

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

วิธีการ UserThrownError นี้ใช้พารามิเตอร์สองตัว:

  • Message: สตริงนี้จะถูกส่งกลับเป็นข้อความแสดงข้อผิดพลาดไปยังแอปพลิเคชันที่เรียกใช้ฟังก์ชันนี้
  • พจนานุกรมของคุณสมบัติจะถูกส่งกลับไปยังโปรแกรมประยุกต์ที่เรียกใช้ฟังก์ชันนี้

รับตัวแปรจากไลบรารีตัวแปร Fabric

ไลบรารีตัวแปร Fabric ใน Microsoft Fabric เป็นที่เก็บส่วนกลางสําหรับจัดการตัวแปรที่สามารถใช้กับรายการต่างๆ ภายในพื้นที่ทํางาน ช่วยให้นักพัฒนาสามารถปรับแต่งและแชร์การกําหนดค่ารายการได้อย่างมีประสิทธิภาพ

  1. เพิ่มการเชื่อมต่อกับไลบรารีตัวแปรโดยใช้จัดการการเชื่อมต่อและรับนามแฝงสําหรับรายการไลบรารีตัวแปร
  2. เพิ่มตัว @udf.connection(argName="varLib", alias="<My Variable Library Alias>") ตกแต่งการเชื่อมต่อ เพื่ออ้างอิงนามแฝงของรายการไลบรารีตัวแปร
  3. ในคําจํากัดความของฟังก์ชัน ให้รวมอาร์กิวเมนต์ที่มีชนิดfn.FabricVariablesClient ไคลเอ็นต์นี้มีวิธีการที่คุณต้องการในการทํางานกับรายการไลบรารีตัวแปร ตัวอย่างเช่น def standardize_date(rawDate: str, varLib: fn.FabricVariablesClient) -> str:
  4. ใช้ getVariables() เมธอดเพื่อรับตัวแปรทั้งหมดจากไลบรารีตัวแปร
    # Get all variables from the variable library item
    variables = varLib.getVariables()

1 ในการอ่านค่าของตัวแปรให้ใช้อย่างใดอย่างหนึ่ง ["variable-name"] หรือ .get("variable-name").

  # Get desired format from environment or use default
  date_format = variables["DATE_FORMAT"]
  # Another way to get the variable
  # date_format= variables.get("DATE_FORMAT")

เนื้อหาที่เกี่ยวข้อง

  • เอกสารอ้างอิง API
  • รายการฟังก์ชันการสร้างผู้ใช้งาน Fabric
  • ตัวอย่างฟังก์ชันข้อมูลผู้ใช้
  • Last updated on