Mengintegrasikan Azure API Management (APIM) dengan Fabric API untuk GraphQL

Mengintegrasikan Azure API Management (APIM) dengan API Microsoft Fabric untuk GraphQL secara signifikan meningkatkan kemampuan API Anda dengan menyediakan fitur skalabilitas dan keamanan yang kuat. APIM bertindak sebagai gateway tingkat perusahaan yang menambahkan kemampuan tingkat lanjut termasuk manajemen identitas, pembatasan laju, penembolokan respons, perlindungan ancaman, dan pemantauan terpusat—semuanya tanpa memodifikasi konfigurasi Fabric API Anda.

Dengan merutekan permintaan GraphQL melalui APIM, Anda dapat menskalakan untuk menangani peningkatan lalu lintas, menerapkan kebijakan keamanan canggih, dan mendapatkan visibilitas ke dalam pola penggunaan API di seluruh organisasi Anda.

Artikel ini memandu Anda dalam mengintegrasikan APIM dengan Fabric API untuk GraphQL, mengonfigurasi autentikasi identitas terkelola, dan menerapkan kebijakan cache dan pembatasan laju.

Siapa yang menggunakan Azure API Management dengan GraphQL

Integrasi APIM sangat berharga untuk:

Arsitek perusahaan mengekspos data Fabric melalui gateway API terpusat dan diatur untuk akses di seluruh organisasi
Administrator Fabric menerapkan pembatasan kecepatan data, pengelolaan cache, dan kebijakan keamanan untuk melindungi kapasitas dan data Fabric.
Tim keamanan TI yang memerlukan autentikasi, otorisasi, dan perlindungan ancaman tingkat lanjut untuk akses data Fabric
Tim platform yang mengelola dan mengatur beberapa FABRIC GraphQL API di seluruh departemen dan unit bisnis

Gunakan integrasi APIM saat Anda memerlukan fitur manajemen API tingkat perusahaan seperti pembatasan tingkat, penembolokan, kebijakan keamanan, dan tata kelola terpusat untuk API GraphQL Fabric Anda.

Prasyarat

Sebelum memulai, pastikan Anda memiliki:

API Fabric untuk GraphQL sudah dibuat. Jika tidak, lihat Membuat API untuk GraphQL atau menggunakan Mulai dengan contoh database SQL di api untuk portal GraphQL
Instans Azure API Management. Untuk instruksi penyiapan, lihat Membuat instans API Management
Izin untuk membuat identitas terkelola dan mengonfigurasi kebijakan APIM

Menambahkan Fabric GraphQL API ke Azure API Management

Langkah pertama dalam mengintegrasikan APIM dengan Fabric adalah mengimpor API GraphQL Anda ke Azure API Management. Proses ini membuat proksi yang merutekan permintaan melalui APIM sambil mempertahankan koneksi ke sumber data Fabric Anda. Dengan mengimpor API, Anda menetapkan fondasi untuk menambahkan fitur tingkat perusahaan seperti kebijakan autentikasi, penyimpanan sementara, dan pembatasan laju.

Proses impor memerlukan dua informasi dari Fabric GraphQL API Anda: URL titik akhir (di mana APIM mengirim permintaan) dan file skema (yang menentukan struktur API dan operasi yang tersedia).

Mengekspor detail API GraphQL Anda

Pertama, kumpulkan informasi yang diperlukan dari Fabric GraphQL API Anda:

Buka API GraphQL Anda di portal Fabric
Di pita, pilih Salin titik akhir untuk mendapatkan URL API Anda
Pilih Ekspor skema untuk mengunduh file skema GraphQL ke perangkat lokal Anda

Mengimpor API ke APIM

Dengan URL titik akhir dan file skema Anda siap, Anda sekarang dapat mendaftarkan API GraphQL di APIM. Ini membuat definisi API yang digunakan APIM untuk memvalidasi permintaan, menghasilkan dokumentasi, dan menerapkan kebijakan. Skema yang Anda unggah menentukan kueri dan mutasi apa yang dapat dijalankan klien.

Navigasi ke instans API Management Anda di portal Microsoft Azure
Pilih API>+ Tambahkan API
Pilih ikon GraphQL
Di layar Buat dari skema GraphQL , sediakan:
- Nama tampilan: Nama yang mudah diingat untuk API
- Nama: Pengidentifikasi API
- Titik akhir API GraphQL: URL titik akhir yang Anda salin dari Fabric
Pilih Unggah skema dan pilih file skema yang Anda unduh

Mengonfigurasi autentikasi identitas terkelola

Sekarang setelah API GraphQL Anda terdaftar di APIM, Anda perlu mengonfigurasi cara APIM mengautentikasi dengan Fabric. Identitas terkelola menyediakan metode autentikasi bebas kata sandi yang aman yang menghilangkan kebutuhan untuk menyimpan kredensial dalam konfigurasi APIM Anda. Azure secara otomatis mengelola siklus hidup identitas dan menangani akuisisi token, membuat pendekatan ini lebih aman dan lebih mudah dipertahankan daripada metode autentikasi tradisional.

Penyiapan autentikasi melibatkan tiga langkah utama: membuat identitas terkelola di Azure, memberinya izin untuk mengakses ruang kerja Fabric dan sumber data Anda, dan mengonfigurasi APIM untuk menggunakan identitas ini saat membuat permintaan ke Fabric.

Membuat dan menetapkan identitas terkelola

Pertama, buat identitas terkelola yang digunakan APIM untuk mengautentikasi:

Buat identitas terkelola yang ditetapkan pengguna di portal Microsoft Azure.
Perhatikan ID Klien identitas terkelola—Anda memerlukan ID klien untuk konfigurasi kebijakan.

Memberikan izin identitas terkelola di Fabric

Setelah membuat identitas terkelola, Anda harus memberinya izin untuk mengakses sumber daya Fabric Anda. Identitas terkelola memerlukan akses ke item API GraphQL itu sendiri dan sumber data apa pun yang terhubung dengannya (seperti lakehouse atau gudang). Menambahkan identitas sebagai anggota ruang kerja adalah pendekatan paling sederhana karena memberikan akses ke semua item di ruang kerja sekaligus.

Buka ruang kerja Fabric yang berisi API GraphQL Anda
Pilih Kelola akses
Menambahkan identitas terkelola (misalnya, apim-id) dengan setidaknya peran Kontributor

Tip

Untuk kontrol yang lebih terperinci, Anda dapat memberikan izin langsung ke item Fabric individual (API dan sumber datanya) alih-alih akses tingkat ruang kerja. Kontrol granular sangat penting jika API Anda menggunakan autentikasi akses menyeluruh (SSO). Untuk informasi selengkapnya, lihat Ringkasan autentikasi dan izin.

Mengonfigurasi APIM untuk menggunakan identitas terkelola

Dengan izin yang diberikan dalam Fabric, Anda perlu memberi tahu APIM identitas terkelola mana yang akan digunakan. Asosiasi ini memungkinkan APIM untuk mengautentikasi sebagai identitas tersebut saat membuat permintaan ke Fabric GraphQL API Anda.

Di portal Microsoft Azure, navigasikan ke instans APIM Anda
Pergi ke Keamanan>Identitas Terkelola
Menambahkan identitas terkelola yang ditetapkan pengguna yang Anda buat sebelumnya

Menambahkan kebijakan autentikasi

Langkah autentikasi akhir adalah menambahkan kebijakan APIM yang mendapatkan token akses menggunakan identitas terkelola dan menyertakannya dalam permintaan ke Fabric. Kebijakan ini berjalan pada setiap permintaan, secara otomatis menangani akuisisi dan perpanjangan token. Kebijakan ini menggunakan authentication-managed-identity elemen untuk mendapatkan token untuk sumber daya Fabric API, lalu menambahkannya ke header Otorisasi.

Di API GraphQL Anda di APIM, pilih tab Kebijakan API
Mengedit kebijakan pemrosesan masuk

Tambahkan XML berikut di bawah <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>

Gantilah YOUR-MANAGED-IDENTITY-CLIENT-ID dengan Client ID identitas terkelola Anda
Simpan kebijakan

Menguji koneksi

Sebelum melanjutkan untuk menambahkan caching dan pembatasan laju permintaan, verifikasi bahwa penyiapan autentikasi berfungsi dengan benar. Pengujian sekarang memastikan bahwa masalah apa pun yang Anda temui nanti tidak terkait dengan konfigurasi autentikasi.

Di APIM, navigasikan ke API GraphQL Anda
Masuk ke tab Uji
Jalankan kueri sampel atau mutasi untuk mengonfirmasi bahwa koneksi berfungsi

Mengonfigurasi penembolokan respons

Penembolokan respons secara signifikan mengurangi latensi untuk pemanggil API dan mengurangi beban backend pada sumber data Fabric Anda. APIM mendukung caching bawaan atau instans Redis eksternal. Untuk API GraphQL, cache menggunakan isi permintaan (kueri GraphQL) sebagai kunci cache, memastikan bahwa kueri yang identik mengembalikan respons cache.

Manfaat penembolokan respons GraphQL:

Latensi yang berkurang: Respons cache ditampilkan secara instan tanpa mengkueri Fabric
Konsumsi kapasitas yang lebih rendah: Permintaan ke Fabric yang lebih sedikit mengurangi penggunaan unit kapasitas (CU)
Skalabilitas yang lebih baik: Menangani pengguna yang lebih bersamaan tanpa meningkatkan beban backend

Tambahkan kebijakan cache

Untuk menerapkan caching, Anda mengubah kebijakan autentikasi yang ada untuk menambahkan pencarian dan logika cache. Kebijakan memeriksa respons cache sebelum meneruskan permintaan ke Fabric dan menyimpan respons yang berhasil untuk digunakan di masa mendatang. Contoh kebijakan lengkap ini menunjukkan bagaimana autentikasi dan penyimpanan sementara bekerja sama.

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

Cara kerja kebijakan ini:

Inbound: Mengautentikasi menggunakan identitas terkelola dan memeriksa apakah respons telah di-cache berdasarkan kueri GraphQL
Backend: Lompati penerusan permintaan ke Fabric jika ada respons cache
Keluar: Mengembalikan respons yang di-cache atau menyimpan respons baru yang berhasil selama 60 detik

Pastikan cache berfungsi

Untuk mengonfirmasi bahwa permintaan sedang di-cache:

Di APIM, jalankan kueri GraphQL yang sama dua kali
Melacak panggilan API untuk melihat temuan cache

Mengoptimalkan durasi cache

Contohnya menggunakan durasi cache 60 detik. Sesuaikan durasi berdasarkan persyaratan kesegaran data Anda:

Pembaruan frekuensi tinggi: Gunakan durasi yang lebih pendek (10-30 detik) untuk data yang sering berubah
Data statis atau referensi: Gunakan durasi yang lebih lama (5-60 menit) untuk data yang jarang berubah
Persyaratan real time: Jangan cache kueri yang harus selalu mengembalikan data terbaru

Untuk skenario penembolokan tingkat lanjut, termasuk pembatalan cache dan konfigurasi Redis eksternal, lihat kebijakan penembolokan APIM.

Pembatasan kecepatan

Anda dapat membatasi jumlah panggilan API yang dapat dilakukan klien dalam periode waktu tertentu. Berikut adalah contoh entri kebijakan pembatasan tarif yang dapat Anda tambahkan di bawah ini <inbound><base/> yang memberlakukan tidak lebih dari dua panggilan setiap 60 detik untuk pengguna tertentu:

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

Setelah mengirim lebih dari dua panggilan API dalam satu menit, Anda akan menerima pesan kesalahan:

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

Untuk informasi selengkapnya tentang cara mengonfigurasi kebijakan pembatasan tarif di APIM, lihat dokumentasi.

Praktik terbaik

Saat mengintegrasikan APIM dengan Fabric API untuk GraphQL, ikuti rekomendasi berikut:

Keamanan

Menggunakan identitas terkelola: Lebih memilih identitas terkelola daripada kunci API atau string koneksi untuk autentikasi
Menerapkan hak istimewa paling sedikit: Hanya berikan izin minimum yang diperlukan untuk identitas terkelola
Aktifkan HTTPS saja: Mengonfigurasi APIM untuk menolak permintaan HTTP dan menerapkan HTTPS
Memvalidasi input: Gunakan kebijakan APIM untuk memvalidasi kueri GraphQL sebelum meneruskan ke Fabric

Performance

Cache data yang sering diakses: Mengidentifikasi kueri umum dan mengatur durasi cache yang sesuai
Memantau tingkat hit cache: Menggunakan analitik APIM untuk melacak efektivitas cache
Mengoptimalkan batas laju: Menyeimbangkan pengalaman pengguna dengan perlindungan kapasitas
Menggunakan penyebaran regional: Menyebarkan APIM di wilayah yang sama dengan kapasitas Fabric Anda

Pemantauan dan tata kelola

Mengaktifkan diagnostik: Mengonfigurasi pembuatan log diagnostik APIM untuk melacak penggunaan API
Menyiapkan pemberitahuan: Membuat pemberitahuan untuk pelanggaran dan kesalahan batas tarif
Versikan API Anda: Gunakan versioning APIM untuk mengelola perubahan yang signifikan
Dokumentasikan API Anda: Gunakan portal pengembang APIM untuk menyediakan dokumentasi API

Pengoptimalan biaya

Batas laju ukuran yang tepat: Tetapkan batas yang selaras dengan tingkat kapasitas Anda
Memantau konsumsi kapasitas: Melacak penggunaan kapasitas APIM dan Fabric
Gunakan penembolokan secara strategis: Menyeimbangkan kebutuhan kesegaran dengan efisiensi kapasitas
Meninjau pola penggunaan: Menganalisis kueri mana yang mengonsumsi sumber daya terbanyak secara teratur

Ringkasan

Mengintegrasikan Fabric API untuk GraphQL dengan Azure API Management menggabungkan kemampuan data Fabric yang kuat dengan fitur gateway API kelas perusahaan APIM. Kombinasi ini menyediakan:

Keamanan yang ditingkatkan: Autentikasi identitas terkelola, perlindungan ancaman, dan kontrol akses berbasis kebijakan
Skalabilitas yang ditingkatkan: Caching respons, pembatasan kecepatan, dan distribusi beban di beberapa backend
Performa yang lebih baik: Mengurangi latensi melalui cache dan routing permintaan yang sudah dioptimalkan
Tata kelola terpusat: Pemantauan, penerapan versi, dan manajemen terpadu di beberapa API
Kontrol biaya: Pembatasan tingkat dan caching mengurangi konsumsi kapasitas Fabric

Dengan mengikuti langkah-langkah konfigurasi dan praktik terbaik dalam artikel ini, Anda dapat membangun lapisan API yang kuat, aman, dan dapat diskalakan yang mendukung beban kerja produksi di seluruh organisasi Anda.

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-01-21