สร้างรายการฟังก์ชันข้อมูลผู้ใช้ Fabric

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

ด้วยฟังก์ชันข้อมูลผู้ใช้ คุณสามารถ:

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

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

สิ่งที่คุณทําสําเร็จ

ในการเริ่มต้นใช้งานด่วนนี้ คุณจะทํางานต่อไปนี้ให้เสร็จสมบูรณ์:

1. สร้างรายการฟังก์ชันข้อมูลผู้ใช้ในพื้นที่ทํางานของคุณ
2. เพิ่มและกําหนดค่าไลบรารี Python ที่จําเป็น (เช่น แพนด้า)
3. แทรกฟังก์ชันจากไลบรารีตัวอย่าง
4. เขียนฟังก์ชันที่กําหนดเองด้วยไวยากรณ์และตัวตกแต่งที่เหมาะสม
5. ทดสอบและเผยแพร่ฟังก์ชันของคุณ
6. เรียกใช้ฟังก์ชันในพอร์ทัลและดูผลลัพธ์

ข้อกำหนดเบื้องต้น

• ความจุ Microsoft Fabric ในภูมิภาคที่รองรับ หากคุณไม่มีความจุ Fabric ให้เริ่มทดลองใช้ Fabric ฟรี
• พื้นที่ทํางาน Fabric ที่กําหนดให้กับความจุนั้น

สร้างรายการฟังก์ชันข้อมูลผู้ใช้ใหม่

1. ในพื้นที่ทํางานของคุณ ให้เลือก +รายการใหม่

2. ค้นหาและเลือกไทล์ ฟังก์ชันข้อมูลผู้ใช้

   

3. ป้อน ชื่อ สําหรับรายการฟังก์ชันข้อมูลผู้ใช้ แล้วเลือก สร้าง

4. เลือกไฟล์ ฟังก์ชันใหม่ เพื่อสร้างฟังก์ชันตัวอย่างใหม่ hello_fabricฟังก์ชัน Python ได้รับการเผยแพร่และโหลดในตัวแก้ไขโค้ด

5. ตัวสํารวจฟังก์ชันแสดงฟังก์ชันทั้งหมดที่เผยแพร่และพร้อมที่จะเรียกใช้ เนื่องจาก hello_fabric มีการเผยแพร่ฟังก์ชัน คุณสามารถเรียกใช้ได้จากรายการฟังก์ชันในตัวสํารวจฟังก์ชัน

   

เพิ่มฟังก์ชันใหม่จากตัวอย่าง

ตัวอย่างนี้แสดงวิธีการเพิ่มฟังก์ชันใหม่จากเมนู แทรกตัวอย่าง ในกรณีนี้ เราเพิ่มฟังก์ชันที่เรียกว่า จัดการข้อมูลด้วยไลบรารีแพนด้า ที่ใช้ pandas ไลบรารีเป็นข้อกําหนด

เพิ่มไลบรารีที่จําเป็น

1. ตรวจสอบให้แน่ใจว่าคุณอยู่ในโหมดพัฒนา

   

2. เลือก การจัดการไลบรารี เพื่อเพิ่มไลบรารีที่ฟังก์ชันของคุณจําเป็นต้องใช้

   

3. เลือก +เพิ่มจาก PyPI เพื่อเพิ่มไลบรารีใหม่จากที่เก็บ PyPI สาธารณะ

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

   

5. หรือคุณสามารถอัปเดตเวอร์ชันของ fabric_user_data_functions ไลบรารีเป็นเวอร์ชันล่าสุดที่พร้อมใช้งาน เลือกไอคอนดินสอถัดจากไลบรารีเพื่ออัปเดต

   หมายเหตุ

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

6. ปิดบานหน้าต่าง การจัดการไลบรารี เพื่อกลับไปยังโฮมเพจฟังก์ชันข้อมูลผู้ใช้

แทรกฟังก์ชันตัวอย่าง

1. เลือกแท็บ แก้ไข เพื่อเปิดตัวเลือกการแก้ไขเพิ่มเติมในเมนู Ribbon

2. เลือก แทรกการจัดการข้อมูล>ตัวอย่าง>จัดการข้อมูลด้วยไลบรารีแพนด้า การดําเนินการนี้จะเพิ่มฟังก์ชันใหม่ที่ใช้ pandas ไลบรารีเพื่อจัดการข้อมูล

   

3. หลังจากแทรกตัวอย่างลงในตัวแก้ไขแล้ว คุณจะเห็นฟังก์ชันใหม่ปรากฏในตัว สํารวจฟังก์ชัน ที่มีไอคอนวงกลมอยู่ข้างๆ ไอคอนนี้บ่งชี้ว่าฟังก์ชันมีการเปลี่ยนแปลงตั้งแต่เผยแพร่ครั้งล่าสุด ซึ่งหมายความว่ามีการอัปเดตที่ต้องเผยแพร่

   

เขียนฟังก์ชันแบบกําหนดเอง

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

ทุกฟังก์ชันที่เรียกใช้ได้ต้องการ @udf.function() ตัวตกแต่งก่อนคําจํากัดความของฟังก์ชัน ตัวตกแต่งนี้ทําเครื่องหมายฟังก์ชัน Python ของคุณว่าปฏิบัติการได้ภายในเฟรมเวิร์กฟังก์ชันข้อมูลผู้ใช้ ไวยากรณ์พื้นฐานคือ:

@udf.function()
def your_function_name(parameter: type) -> return_type:
    # Your function logic here
    return result

นี่คือตัวอย่างที่สมบูรณ์ซึ่งกําหนดมาตรฐานหมวดหมู่สินค้าจากข้อมูลยอดขายดิบ:

# This function standardizes inconsistent product category names from different data sources

@udf.function()
def standardize_category(productName: str, rawCategory: str) -> dict:
    # Define category mappings for common variations
    category_mapping = {
        "electronics": ["electronic", "electronics", "tech", "devices"],
        "clothing": ["clothes", "clothing", "apparel", "fashion"],
        "home_goods": ["home", "household", "home goods", "furniture"],
        "food": ["food", "grocery", "groceries", "snacks"],
        "books": ["book", "books", "reading", "literature"]
    }
    
    # Normalize the input
    raw_lower = rawCategory.lower().strip()
    
    # Find the standardized category
    standardized = "other"
    for standard_name, variations in category_mapping.items():
        if raw_lower in variations:
            standardized = standard_name
            break
    
    return {
        "product_name": productName,
        "original_category": rawCategory,
        "standardized_category": standardized,
        "needs_review": standardized == "other"
    }

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

แนวคิดหลักของแบบจําลองการเขียนโปรแกรม

ฟังก์ชันข้อมูลผู้ใช้ของคุณใช้ โมเดลการเขียนโปรแกรม Python ของฟังก์ชันข้อมูลผู้ใช้ เพื่อสร้าง เรียกใช้ แก้ไขข้อบกพร่อง และแก้ไขฟังก์ชันแต่ละฟังก์ชัน รูปแบบการเขียนโปรแกรมมีให้โดย fabric-user-data-functions แพ็คเกจ ซึ่ง พร้อมใช้งานต่อสาธารณะบน PyPI และติดตั้งไว้ล่วงหน้าในรายการฟังก์ชันข้อมูลผู้ใช้ของคุณ

เมื่อคุณสร้างฟังก์ชันแรก ไฟล์โค้ดจะมีคําสั่งนําเข้าที่จําเป็น:

import datetime
import fabric.functions as fn
import logging

udf = fn.UserDataFunctions()

ประเด็นสําคัญเกี่ยวกับรูปแบบการเขียนโปรแกรม:

• fabric-user-data-functionsแพคเกจมีfabric.functionsโมดูล ซึ่งคุณนําเข้าตามfnในโค้ดของคุณ
• fn.UserDataFunctions()การเรียกจะสร้างบริบทการดําเนินการที่จําเป็นสําหรับการกําหนดและเรียกใช้ฟังก์ชันภายในรายการฟังก์ชันข้อมูลผู้ใช้
• ไลบรารีอื่น ๆ เช่น logging ช่วยให้คุณสามารถเขียนบันทึกที่กําหนดเองสําหรับการดีบักและการตรวจสอบ

ทดสอบและเผยแพร่ฟังก์ชันของคุณ

เมื่อคุณสร้างฟังก์ชันหลายฟังก์ชัน (ฟังก์ชันตัวอย่าง manipulate_data และฟังก์ชันที่กําหนดเอง standardize_category ของคุณ) คุณสามารถทดสอบและเผยแพร่พร้อมกันได้

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

2. เมื่อคุณพร้อมที่จะทําให้ฟังก์ชันของคุณพร้อมใช้งาน ให้เลือก เผยแพร่ เพื่อบันทึกการเปลี่ยนแปลงและอัปเดตฟังก์ชันทั้งหมดของคุณ การประกาศอาจใช้เวลาสักครู่

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

   • เรียกใช้จากพอร์ทัลในโหมดเรียกใช้อย่างเดียว
   • เรียกใช้จากรายการ Fabric อื่น เช่น ไปป์ไลน์ สมุดบันทึก หรือกฎ Activator
   • เรียกใช้จากแอปพลิเคชันภายนอกผ่านปลายทาง REST

เรียกใช้ฟังก์ชันของคุณ

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

1. เลือก โหมดเรียกใช้อย่างเดียว จากตัวเลือกโหมดที่มุมบนขวาของพอร์ทัล

   

2. เลือกไอคอน เรียกใช้ ที่แสดงขึ้นเมื่อคุณวางเมาส์เหนือฟังก์ชันในรายการ Functions explorer

   

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

1. ในตัวสํารวจฟังก์ชัน ให้วางเมาส์เหนือฟังก์ชันmanipulate_data

2. เลือกปุ่ม เรียกใช้ ที่ปรากฏขึ้นเมื่อคุณวางเมาส์เหนือฟังก์ชัน

3. บานหน้าต่างเรียกใช้จะเปิดขึ้นทางด้านขวาของหน้าจอ

4. ในบานหน้าต่างเรียกใช้ คุณจะเห็นข้อมูลชื่อพารามิเตอร์ที่มีชนิดlist ป้อนค่า JSON ต่อไปนี้ในกล่องข้อความ:

   [
    {
     "Name": "John",
     "Age": 22,
     "Gender": "male"
    }
   ]
   

5. เลือกปุ่ม เรียกใช้ ในบานหน้าต่างเรียกใช้ (อยู่ถัดจากตําแหน่งที่คุณป้อนข้อมูล JSON) เพื่อเรียกใช้ฟังก์ชัน

   

6. ดูผลลัพธ์และบันทึกภายใต้ ผลลัพธ์ (รายการ) ในบานหน้าต่างเรียกใช้ ผลลัพธ์แสดงข้อมูลที่จัดการเป็นแพนด้า DataFrame ในรูปแบบ JSON

เรียกใช้ฟังก์ชันแบบกําหนดเอง

ตอนนี้ลองเรียกใช้ฟังก์ชันที่กําหนดเอง standardize_category ของคุณ

1. ในตัวสํารวจฟังก์ชัน ให้วางเมาส์เหนือฟังก์ชันstandardize_category

2. เลือกปุ่ม เรียกใช้ ที่ปรากฏขึ้นเมื่อคุณวางเมาส์เหนือฟังก์ชัน

3. บานหน้าต่างเรียกใช้จะเปิดขึ้นทางด้านขวาของหน้าจอ

4. ระบุพารามิเตอร์การทดสอบ:

   • ชื่อผลิตภัณฑ์: Laptop Computer
   • raw หมวดหมู่: tech

5. เลือก เรียกใช้ และสังเกตผลลัพธ์ ซึ่งควรแสดงหมวดหมู่มาตรฐานเป็น "อิเล็กทรอนิกส์" และรวมข้อมูลเมตาเกี่ยวกับการจัดหมวดหมู่

จัดการฟังก์ชัน

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

เปลี่ยนชื่อฟังก์ชัน

1. ในโหมด พัฒนา ให้เลือกในตัวแก้ไขโค้ดและอัปเดตชื่อฟังก์ชัน ตัวอย่างเช่น เปลี่ยนชื่อ hello_fabric เป็น hello_fabric1:

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

2. หลังจากเปลี่ยนชื่อ แล้ว ให้เลือก เผยแพร่ เพื่อบันทึกการเปลี่ยนแปลงเหล่านี้

3. เมื่อเผยแพร่การเปลี่ยนแปลงแล้ว คุณจะเห็นชื่อใหม่สําหรับฟังก์ชันในตัวสํารวจฟังก์ชัน

ลบฟังก์ชัน

หากต้องการลบฟังก์ชัน ให้เลือกรหัสฟังก์ชันในตัวแก้ไขโค้ดและลบส่วนโค้ดทั้งหมด เผยแพร่การเปลี่ยนแปลงเพื่อลบทั้งหมดออกจากรายการฟังก์ชันข้อมูลผู้ใช้

ตัวอย่างเช่น เมื่อต้องลบฟังก์ชัน hello_fabric ให้ลบบล็อกโค้ดต่อไปนี้:

@udf.function()
def hello_fabric(name: str) -> str:
    logging.info('Python UDF trigger function processed a request.')

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

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

การแก้ไขปัญหา

หากคุณพบปัญหาขณะทํางานกับฟังก์ชันข้อมูลผู้ใช้:

• ฟังก์ชันจะไม่เผยแพร่ - ตรวจสอบข้อผิดพลาดทางไวยากรณ์ในโค้ดของคุณ ตรวจสอบให้แน่ใจว่ามีรายการนําเข้า (fabric.functions) และ udf = fn.UserDataFunctions() รายการที่จําเป็นทั้งหมด
• ข้อผิดพลาดในการตั้งชื่อพารามิเตอร์ - โปรดจําไว้ว่าชื่อพารามิเตอร์ต้องใช้ camelCase (ไม่มีขีดล่าง) ตรวจสอบข้อกําหนดและข้อจํากัดทางไวยากรณ์
• ข้อผิดพลาดในการนําเข้าไลบรารี - ตรวจสอบว่ามีการเพิ่มไลบรารีที่จําเป็นทั้งหมดผ่านการจัดการไลบรารี และเวอร์ชันเข้ากันได้กับ Python 3.11
• ฟังก์ชันไม่ปรากฏใน Functions explorer - ตรวจสอบให้แน่ใจว่าคุณได้เผยแพร่การเปลี่ยนแปลงของคุณหลังจากเพิ่มหรือแก้ไขฟังก์ชัน

หากต้องการความช่วยเหลือเพิ่มเติม โปรดดู ขีดจํากัดและข้อควรพิจารณาของบริการฟังก์ชันข้อมูลผู้ใช้

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

เมื่อคุณสร้างรายการฟังก์ชันข้อมูลผู้ใช้รายการแรกแล้ว ให้สํารวจแหล่งข้อมูลเหล่านี้เพื่อเพิ่มพูนทักษะของคุณ:

• สร้างรายการฟังก์ชันข้อมูลผู้ใช้ Fabric ใน Visual Studio Code - เรียนรู้การพัฒนาฟังก์ชันภายในเครื่องด้วยการสนับสนุน IDE เต็มรูปแบบ
• เรียนรู้เกี่ยวกับโมเดลการเขียนโปรแกรมฟังก์ชันข้อมูลผู้ใช้ - เจาะลึกลงไปใน Python SDK และคุณสมบัติขั้นสูง
• เรียกใช้ฟังก์ชันข้อมูลผู้ใช้จากแอปพลิเคชัน Python - เรียกใช้ฟังก์ชันของคุณจากแอปพลิเคชันภายนอกผ่าน REST API
• จัดการไลบรารีสําหรับฟังก์ชันข้อมูลผู้ใช้ - เรียนรู้เทคนิคการจัดการไลบรารีขั้นสูง