รวม Azure API Management (APIM) เข้ากับ Fabric API สําหรับ GraphQL

การรวม Azure API Management (APIM) กับ API ของ Microsoft Fabric สําหรับ GraphQL ช่วยเพิ่มความสามารถของ API ของคุณอย่างมากโดยให้คุณสมบัติการปรับขนาดและความปลอดภัยที่มีประสิทธิภาพ APIM ทําหน้าที่เป็นเกตเวย์ระดับองค์กรที่เพิ่มความสามารถขั้นสูง รวมถึงการจัดการข้อมูลประจําตัว การจํากัดอัตรา การแคชการตอบสนอง การป้องกันภัยคุกคาม และการตรวจสอบแบบรวมศูนย์ ทั้งหมดนี้โดยไม่ต้องแก้ไขการกําหนดค่า Fabric API ของคุณ

ด้วยการกําหนดเส้นทางคําขอ GraphQL ของคุณผ่าน API คุณสามารถปรับขนาดเพื่อจัดการกับการรับส่งข้อมูลที่เพิ่มขึ้น

บทความนี้จะแนะนําคุณเกี่ยวกับการผสานรวม APIM กับ Fabric API สําหรับ GraphQL การกําหนดค่าการรับรองความถูกต้องของข้อมูลประจําตัวที่มีการจัดการ และการใช้นโยบายการแคชและการจํากัดอัตรา

ใครใช้ Azure API Management กับ GraphQL

การผสานรวม APIM มีค่าสําหรับ:

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

ใช้การผสานรวม API เมื่อคุณต้องการคุณสมบัติการจัดการ API ระดับองค์กร เช่น การจํากัดอัตรา การแคช นโยบายความปลอดภัย และการกํากับดูแลแบบรวมศูนย์สําหรับ Fabric GraphQL API ของคุณ

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

ก่อนที่คุณจะเริ่มต้น ให้แน่ใจว่าคุณมี:

• สร้าง Fabric API สําหรับ GraphQL แล้ว หากไม่เป็นเช่นนั้น โปรดดู สร้าง API สําหรับ GraphQL หรือใช้เริ่มต้น ด้วยฐานข้อมูล SQL ตัวอย่าง ในพอร์ทัล API สําหรับ GraphQL
• อินสแตนซ์ Azure API Management สําหรับคําแนะนําในการตั้งค่า โปรดดู สร้างอินสแตนซ์การจัดการ API
• สิทธิ์ในการสร้างข้อมูลประจําตัวที่มีการจัดการและกําหนดค่านโยบาย APIM

เพิ่ม Fabric GraphQL API ไปยังการจัดการ Azure API

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

กระบวนการนําเข้าต้องใช้ข้อมูลสองส่วนจาก Fabric GraphQL API ของคุณ: URL ปลายทาง (ที่ APIM ส่งคําขอ) และไฟล์ Schema (ซึ่งกําหนดโครงสร้าง API และการดําเนินการที่พร้อมใช้งาน)

ส่งออกรายละเอียด GraphQL API ของคุณ

ขั้นแรก ให้รวบรวมข้อมูลที่จําเป็นจาก Fabric GraphQL API ของคุณ:

1. เปิด GraphQL API ของคุณในพอร์ทัล Fabric

2. ใน Ribbon ให้เลือก คัดลอกปลายทาง เพื่อรับ URL ของ API ของคุณ

3. เลือก ส่งออกสคีมา เพื่อดาวน์โหลดไฟล์สคีมา GraphQL ไปยังอุปกรณ์ภายในเครื่องของคุณ

   

นําเข้า API ไปยัง APIM

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

1. นําทางไปยังอินสแตนซ์การจัดการ API ของคุณในพอร์ทัล Azure

2. เลือก API>+ เพิ่ม API

3. เลือกไอคอน GraphQL

4. ในหน้าจอ สร้างจาก GraphQL Schema ให้ระบุ:

   • ชื่อที่แสดง: ชื่อที่จําง่ายสําหรับ API
   • ชื่อ: ตัวระบุ API
   • ตําแหน่งข้อมูล GraphQL API: URL ปลายทางที่คุณคัดลอกจาก Fabric

5. เลือกอัปโหลด สคีมา แล้วเลือกไฟล์สคีมาที่ดาวน์โหลดมา

   

กําหนดค่าการรับรองความถูกต้องของข้อมูลประจําตัวที่มีการจัดการ

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

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

สร้างและกําหนดข้อมูลประจําตัวที่มีการจัดการ

ขั้นแรก ให้สร้างข้อมูลประจําตัวที่มีการจัดการที่ APIM ใช้เพื่อรับรองความถูกต้อง:

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

ให้สิทธิ์ข้อมูลประจําตัวที่มีการจัดการใน Fabric

หลังจากสร้างข้อมูลประจําตัวที่มีการจัดการแล้ว คุณต้องให้สิทธิ์ในการเข้าถึงทรัพยากร Fabric ของคุณ ข้อมูลประจําตัวที่มีการจัดการจําเป็นต้องเข้าถึงทั้งรายการ GraphQL API และแหล่งข้อมูลใดๆ ที่เชื่อมต่อ (เช่น เลคเฮาส์หรือคลังสินค้า) การเพิ่มข้อมูลประจําตัวเป็นสมาชิกพื้นที่ทํางานเป็นวิธีที่ง่ายที่สุด เนื่องจากจะให้สิทธิ์การเข้าถึงรายการทั้งหมดในพื้นที่ทํางานพร้อมกัน

1. เปิดพื้นที่ทํางาน Fabric ที่มี GraphQL API ของคุณ
2. เลือก จัดการการเข้าถึง
3. เพิ่มข้อมูลประจําตัวที่มีการจัดการ (เช่น apim-id) ที่มีบทบาท ผู้สนับสนุน เป็นอย่างน้อย

กําหนดค่า APIM เพื่อใช้ข้อมูลประจําตัวที่มีการจัดการ

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

1. ในพอร์ทัล Azure ให้นําทางไปยังอินสแตนซ์ APIM ของคุณ
2. ไปที่ ความปลอดภัย>ข้อมูลประจําตัวที่มีการจัดการ
3. เพิ่มข้อมูลประจําตัวที่มีการจัดการที่ผู้ใช้กําหนดซึ่งสร้างไว้ก่อนหน้านี้

เพิ่มนโยบายการรับรองความถูกต้อง

ขั้นตอนการรับรองความถูกต้องขั้นสุดท้ายคือการเพิ่มนโยบาย APIM ที่รับโทเค็นการเข้าถึงโดยใช้ข้อมูลประจําตัวที่มีการจัดการและรวมไว้ในคําขอไปยัง Fabric นโยบายนี้ทํางานในทุกคําขอ โดยจะจัดการการรับโทเค็นและการต่ออายุโดยอัตโนมัติ นโยบายใช้องค์ประกอบเพื่อรับ authentication-managed-identity โทเค็นสําหรับทรัพยากร Fabric API จากนั้นเพิ่มลงในส่วนหัวการให้สิทธิ์

1. ใน GraphQL API ใน API ให้เลือกแท็บนโยบาย API

2. แก้ไขนโยบายการประมวลผลขาเข้า

3. เพิ่ม XML ต่อไปนี้ภายใต้ <inbound><base/>:

   <authentication-managed-identity 
       resource="https://analysis.windows.net/powerbi/api" 
       client-id="YOUR-MANAGED-IDENTITY-CLIENT-ID" 
       output-token-variable-name="token-variable" 
       ignore-error="false" />
   <set-header name="Authorization" exists-action="override">
       <value>@("Bearer " + (string)context.Variables["token-variable"])</value>
   </set-header>
   

4. แทนที่ YOUR-MANAGED-IDENTITY-CLIENT-ID ด้วยรหัสไคลเอ็นต์ของข้อมูลประจําตัวที่มีการจัดการ

5. บันทึกนโยบาย

ทดสอบการเชื่อมต่อ

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

1. ใน APIM ให้ไปที่ GraphQL API ของคุณ
2. ไปที่แท็บทดสอบ
3. ดําเนินการคิวรีตัวอย่างหรือการกลายพันธุ์เพื่อยืนยันว่าการเชื่อมต่อใช้งานได้

กําหนดค่าการแคชการตอบสนอง

การแคชการตอบสนองช่วยลดเวลาแฝงสําหรับผู้เรียก API ได้อย่างมาก และลดภาระแบ็กเอนด์บนแหล่งข้อมูล Fabric ของคุณ API รองรับการแคชในตัวหรืออินสแตนซ์ Redis ภายนอก สําหรับ GraphQL API การแคชจะใช้เนื้อหาคําขอ (คิวรี GraphQL) เป็นคีย์แคช เพื่อให้มั่นใจว่าคิวรีที่เหมือนกันจะส่งคืนการตอบสนองที่แคชไว้

ประโยชน์ของการแคชการตอบสนอง GraphQL:

• ลดเวลาแฝง: การตอบกลับที่แคชจะส่งคืนทันทีโดยไม่ต้องสืบค้น Fabric
• ลดการใช้ความจุ: คําขอ Fabric น้อยลงลดการใช้ CU (หน่วยความจุ)
• ความสามารถในการปรับขนาดที่ดีขึ้น: จัดการกับผู้ใช้พร้อมกันมากขึ้นโดยไม่ต้องเพิ่มภาระแบ็กเอนด์

เพิ่มนโยบายการแคช

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

<policies>
    <inbound>
        <base />
        <!-- Authenticate with managed identity -->
        <authentication-managed-identity 
            resource="https://analysis.windows.net/powerbi/api" 
            client-id="YOUR-MANAGED-IDENTITY-CLIENT-ID" 
            output-token-variable-name="token-variable" 
            ignore-error="false" />
        <set-header name="Authorization" exists-action="override">
            <value>@("Bearer " + (string)context.Variables["token-variable"])</value>
        </set-header>
        <!-- Check if response is cached -->
        <cache-lookup-value 
            key="@(context.Request.Body.As<String>(preserveContent: true))" 
            variable-name="cachedResponse" 
            default-value="not_exists" />
    </inbound>
    <backend>
        <!-- Only forward request if not cached -->
        <choose>
            <when condition="@(context.Variables.GetValueOrDefault<string>("cachedResponse") == "not_exists")">
                <forward-request />
            </when>
        </choose>
    </backend>
    <outbound>
        <base />
        <choose>
            <!-- Return cached response if it exists -->
            <when condition="@(context.Variables.GetValueOrDefault<string>("cachedResponse") != "not_exists")">
                <set-body>@(context.Variables.GetValueOrDefault<string>("cachedResponse"))</set-body>
            </when>
            <!-- Cache successful responses for 60 seconds -->
            <when condition="@((context.Response.StatusCode == 200) && (context.Variables.GetValueOrDefault<string>("cachedResponse") == "not_exists"))">
                <cache-store-value 
                    key="@(context.Request.Body.As<String>(preserveContent: true))" 
                    value="@(context.Response.Body.As<string>(preserveContent: true))" 
                    duration="60" />
            </when>
        </choose>
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

วิธีการทํางานของนโยบายนี้:

1. ขาเข้า: รับรองความถูกต้องด้วยข้อมูลประจําตัวที่มีการจัดการและตรวจสอบว่าการตอบสนองถูกแคชตามการสืบค้น GraphQL หรือไม่
2. แบ็กเอนด์: ข้ามการส่งต่อคําขอไปยัง Fabric หากมีการตอบสนองที่แคชไว้
3. ขาออก: ส่งคืนการตอบกลับที่แคชไว้หรือแคชการตอบกลับใหม่ที่สําเร็จเป็นเวลา 60 วินาที

ตรวจสอบว่าการแคชใช้งานได้

วิธียืนยันว่าคําขอถูกแคช

1. ใน APIM ให้ดําเนินการคิวรี GraphQL เดียวกันสองครั้ง

2. ติดตามการเรียก API เพื่อดู Hit แคช

   

ปรับระยะเวลาแคชให้เหมาะสม

ตัวอย่างนี้ใช้ระยะเวลาแคช 60 วินาที ปรับระยะเวลาตามข้อกําหนดด้านความใหม่ของข้อมูล:

• การอัปเดตความถี่สูง: ใช้ระยะเวลาที่สั้นลง (10-30 วินาที) สําหรับข้อมูลที่เปลี่ยนแปลงบ่อย
• ข้อมูลคงที่หรือข้อมูลอ้างอิง: ใช้ระยะเวลานานขึ้น (5-60 นาที) สําหรับข้อมูลที่มีการเปลี่ยนแปลงไม่บ่อยนัก
• ข้อกําหนดแบบเรียลไทม์: อย่าแคชการสืบค้นที่ต้องส่งคืนข้อมูลล่าสุดเสมอ

สําหรับสถานการณ์การแคชขั้นสูง รวมถึงการทําให้แคชเป็นโมฆะและการกําหนดค่า Redis ภายนอก โปรดดู นโยบายการแคช APIM

การจํากัดอัตรา

คุณสามารถจํากัดจํานวนการเรียกใช้ API ที่ไคลเอ็นต์สามารถทําได้ในช่วงเวลาที่กําหนด ต่อไปนี้คือรายการนโยบายการจํากัดอัตราตัวอย่างที่คุณสามารถเพิ่มได้ด้านล่าง <inbound><base/> ซึ่งจะบังคับใช้การเรียกใช้ไม่เกิน 2 ครั้งทุกๆ 60 วินาทีสําหรับผู้ใช้รายหนึ่ง

<rate-limit-by-key 
    calls="2" 
    renewal-period="60" 
    counter-key="@(context.Request.Headers.GetValueOrDefault("Authorization"))" 
    increment-condition="@(context.Response.StatusCode == 200)" 
    remaining-calls-variable-name="remainingCallsPerUser" />

หลังจากส่งการเรียก API มากกว่า 2 ครั้งในหนึ่งนาที คุณจะได้รับข้อความแสดงข้อผิดพลาดดังนี้

{
    "statusCode": 429,
    "message": "Rate limit is exceeded. Try again in 58 seconds."
}

สําหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการกําหนดค่านโยบายการจํากัดอัตราใน API โปรดดูเอกสารประกอบ

แนวทางปฏิบัติที่ดีที่สุด

เมื่อรวม APIM กับ Fabric API สําหรับ GraphQL ให้ทําตามคําแนะนําเหล่านี้:

Security

• ใช้ข้อมูลประจําตัวที่มีการจัดการ: ต้องการข้อมูลประจําตัวที่มีการจัดการมากกว่าคีย์ API หรือสตริงการเชื่อมต่อสําหรับการตรวจสอบสิทธิ์
• ใช้สิทธิ์ขั้นต่ํา: ให้สิทธิ์ขั้นต่ําที่จําเป็นสําหรับข้อมูลประจําตัวที่มีการจัดการเท่านั้น
• เปิดใช้ HTTPS เท่านั้น: กําหนดค่า APIM ให้ปฏิเสธคําขอ HTTP และบังคับใช้ HTTPS
• ตรวจสอบอินพุต: ใช้นโยบาย APIM เพื่อตรวจสอบความถูกต้องของคิวรี GraphQL ก่อนส่งต่อไปยัง Fabric

ผลการปฏิบัติงาน

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

การตรวจสอบและการกํากับดูแล

• เปิดใช้งานการวินิจฉัย: กําหนดค่าการบันทึกการวินิจฉัย APIM เพื่อติดตามการใช้งาน API
• ตั้งค่าการแจ้งเตือน: สร้างการแจ้งเตือนเมื่อมีการละเมิดและข้อผิดพลาดในการจํากัดอัตรา
• กําหนดเวอร์ชัน API: ใช้การกําหนดเวอร์ชัน APIM เพื่อจัดการการเปลี่ยนแปลงที่ผิดพลาด
• จัดทําเอกสาร API ของคุณ: ใช้พอร์ทัลนักพัฒนาของ API เพื่อจัดเตรียมเอกสาร API

การเพิ่มประสิทธิภาพต้นทุน

• ขีดจํากัดอัตราที่เหมาะสม: กําหนดขีดจํากัดที่สอดคล้องกับระดับความจุของคุณ
• ตรวจสอบการใช้ความจุ: ติดตามการใช้ความจุทั้ง APIM และ Fabric
• ใช้การแคชอย่างมีกลยุทธ์: สร้างสมดุลระหว่างข้อกําหนดด้านความสดใหม่กับการประหยัดความจุ
• ตรวจสอบรูปแบบการใช้งาน: วิเคราะห์อย่างสม่ําเสมอว่าคิวรีใดใช้ทรัพยากรมากที่สุด

Summary

การรวม Microsoft Fabric API สําหรับ GraphQL กับ Azure API Management นําความสามารถด้านข้อมูลอันทรงพลังของ Fabric มารวมกันกับคุณลักษณะเกตเวย์ API ระดับองค์กรของ API ชุดค่าผสมนี้ให้:

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

เมื่อทําตามขั้นตอนการกําหนดค่าและแนวทางปฏิบัติที่ดีที่สุดในบทความนี้ คุณจะสามารถสร้างเลเยอร์ API ที่มีประสิทธิภาพ ปลอดภัย และปรับขนาดได้ ซึ่งรองรับปริมาณงานการผลิตทั่วทั้งองค์กรของคุณ

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

• ภาพรวมของ Fabric API สําหรับ GraphQL
• Fabric API สําหรับตัวแก้ไข GraphQL
• แนวทางปฏิบัติที่ดีที่สุดด้านประสิทธิภาพ
• เอกสารการจัดการ Azure API
• การอ้างอิงนโยบาย APIM