Tingkatkan Throughput API Didit dengan Python Asyncio (ID)

Optimalkan Konsumsi API: Python Asyncio memungkinkan operasi I/O non-blocking, secara signifikan meningkatkan efisiensi aplikasi yang melakukan banyak panggilan API ke layanan seperti Didit untuk verifikasi identitas.

Kuasai Pembatasan Tingkat: Terapkan strategi pembatasan tingkat yang canggih dengan Asyncio untuk tetap berada dalam batas API Didit, mencegah kesalahan 429 dan memastikan ketersediaan layanan yang berkelanjutan untuk skenario throughput tinggi.

Bangun Solusi Skalabel: Manfaatkan model konkurensi Asyncio untuk merancang sistem yang kuat dan skalabel yang mampu memproses ribuan permintaan verifikasi identitas per detik tanpa menimbulkan biaya infrastruktur yang tinggi.

Keunggulan API-First Didit: Pendekatan developer-first Didit, dengan API yang bersih dan sandbox instan, sangat cocok untuk integrasi dengan kerangka kerja asinkron, memungkinkan alur kerja verifikasi identitas berkinerja tinggi yang mulus mulai dari verifikasi ID hingga deteksi keaktifan.

Kebutuhan akan Kecepatan: Mengapa Asyncio untuk Konsumsi API?

Di dunia digital yang serba cepat saat ini, aplikasi sering kali perlu melakukan banyak panggilan API eksternal untuk memenuhi fungsinya. Ketika panggilan ini bersifat blocking, yang berarti aplikasi menunggu setiap respons sebelum melanjutkan ke yang berikutnya, hambatan kinerja akan cepat muncul. Ini terutama berlaku untuk layanan verifikasi identitas, di mana alur orientasi pengguna tunggal mungkin melibatkan beberapa interaksi API: Verifikasi ID, pemeriksaan Keaktifan Pasif & Aktif, Pencocokan Wajah 1:1, dan Penyaringan AML. Untuk bisnis dengan volume pengguna yang tinggi, operasi sekuensial ini dapat menyebabkan penundaan yang signifikan dan pengalaman pengguna yang buruk.

Pustaka asyncio Python menyediakan kerangka kerja yang kuat untuk menulis kode bersamaan menggunakan sintaksis async/await. Tidak seperti multithreading tradisional, yang dapat memperkenalkan kompleksitas seperti Global Interpreter Lock (GIL) untuk tugas-tugas terikat CPU, asyncio dirancang untuk operasi terikat I/O. Panggilan API secara inheren terikat I/O (menunggu respons jaringan), menjadikan asyncio kandidat ideal untuk mempercepat kemampuan aplikasi Anda dalam mengonsumsi API eksternal secara efisien. Dengan memungkinkan program Anda melakukan tugas lain sambil menunggu respons API, asyncio dapat secara dramatis meningkatkan throughput tanpa memerlukan penulisan ulang lengkap arsitektur aplikasi Anda menjadi sistem terdistribusi.

Memahami Lanskap API dan Batas Tingkat Didit

Didit, sebagai platform identitas berbasis AI, menawarkan serangkaian API yang komprehensif untuk verifikasi identitas, termasuk Verifikasi ID (OCR, MRZ, barcode), Keaktifan Pasif & Aktif, Pencocokan Wajah 1:1, Penyaringan & Pemantauan AML, dan banyak lagi. API kami dirancang untuk kinerja tinggi dan keandalan, tetapi seperti semua API yang kuat, ia menggunakan pembatasan tingkat untuk memastikan stabilitas dan penggunaan yang adil di semua klien. Memahami batasan ini sangat penting untuk setiap konsumen throughput tinggi.

Didit memberlakukan pembatasan tingkat global dan spesifik titik akhir. Misalnya, batas global biasanya 300 permintaan per menit per aplikasi untuk titik akhir GET dan Tulis/Hapus. Batasan yang lebih ketat berlaku untuk operasi berdampak tinggi, seperti 600 RPM untuk POST /v2/session/ (untuk membuat alur kerja verifikasi) dan 100 RPM untuk GET /v2/session/<id>/decision/ (untuk mengambil keputusan sesi). Ketika batasan ini terlampaui, API mengembalikan kode status 429 Too Many Requests, bersama dengan header yang membantu seperti X-RateLimit-Limit, X-RateLimit-Remaining, dan Retry-After (detik epoch) untuk memandu strategi backoff Anda.

Menerapkan asyncio memungkinkan Anda mengelola batasan tingkat ini dengan lebih efektif. Alih-alih satu utas pemblokiran yang mencapai batas, aplikasi asinkron dapat secara cerdas mengantre permintaan, menerapkan backoff eksponensial, dan mencoba kembali panggilan yang gagal tanpa memblokir seluruh alur aplikasi. Ini menghasilkan konsumsi API yang lebih lancar dan lebih sedikit gangguan, memastikan proses verifikasi identitas Anda tetap tidak terganggu bahkan selama beban puncak.

Menerapkan Asyncio untuk Panggilan API Didit Konkuren

Mengintegrasikan asyncio dengan API Didit melibatkan penggunaan klien HTTP asinkron seperti aiohttp. Berikut adalah garis besar konseptual tentang bagaimana Anda dapat menyusun panggilan API asinkron Anda:

import asyncio
import aiohttp
import time

API_KEY = "YOUR_DIDIT_API_KEY"
BASE_URL = "https://verification.didit.me/v3/"

async def call_didit_api(session, endpoint, payload=None, method='POST'):
    headers = {
        'accept': 'application/json',
        'x-api-key': API_KEY
    }
    if method == 'POST':
        headers['content-type'] = 'application/json'

    url = f"{BASE_URL}{endpoint}"
    
    async with session.request(method, url, json=payload, headers=headers) as response:
        if response.status == 429:
            retry_after = int(response.headers.get('Retry-After', '5'))
            print(f"Rate limit hit. Retrying after {retry_after} seconds...")
            await asyncio.sleep(retry_after) # Implement simple backoff
            return await call_didit_api(session, endpoint, payload, method) # Retry
        response.raise_for_status()
        return await response.json()

async def create_verification_session(session, workflow_id, user_id):
    endpoint = "session/"
    payload = {
        "workflow_id": workflow_id,
        "vendor_data": user_id,
        "callback": "https://your-app.com/didit-callback"
    }
    return await call_didit_api(session, endpoint, payload, method='POST')

async def get_session_decision(session, session_id):
    endpoint = f"session/{session_id}/decision/"
    return await call_didit_api(session, endpoint, method='GET')

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = []
        # Example: Create 10 verification sessions concurrently
        for i in range(10):
            tasks.append(create_verification_session(session, "YOUR_WORKFLOW_ID", f"user_{i}"))
        
        results = await asyncio.gather(*tasks)
        for res in results:
            print(f"Created session: {res.get('session_id')}")

        # Example: Retrieve decisions for some sessions concurrently
        decision_tasks = []
        for res in results[:5]: # Take first 5 for decision retrieval
            session_id = res.get('session_id')
            if session_id:
                decision_tasks.append(get_session_decision(session, session_id))
        
        decision_results = await asyncio.gather(*decision_tasks)
        for decision in decision_results:
            print(f"Session decision: {decision}")

if __name__ == "__main__":
    asyncio.run(main())

Contoh ini menunjukkan cara membuat beberapa sesi verifikasi dan mengambil keputusannya secara bersamaan. Fungsi call_didit_api menyertakan mekanisme coba lagi dasar untuk 429 Too Many Requests, menggunakan header Retry-After untuk mengimplementasikan backoff eksponensial. Untuk sistem produksi, pola backoff dan circuit breaker yang lebih canggih akan direkomendasikan, tetapi ini mengilustrasikan prinsip intinya.

Dengan menggunakan asyncio.gather, Anda dapat memulai beberapa permintaan API secara bersamaan, memungkinkan aplikasi Anda memproses tugas lain atau menunggu respons secara bersamaan, yang mengarah pada peningkatan kinerja yang signifikan dibandingkan dengan panggilan pemblokiran sekuensial.

Strategi untuk Verifikasi Identitas Volume Tinggi

Mencapai throughput tinggi dengan API Didit menggunakan Asyncio membutuhkan lebih dari sekadar membuat permintaan secara bersamaan. Pertimbangkan strategi berikut:

• Batching Cerdas: Meskipun verifikasi inti Didit sering kali diprakarsai pengguna, untuk operasi seperti Pemantauan AML atau pencarian data tertentu, Anda dapat merancang alur kerja yang memungkinkan pemrosesan batch jika berlaku, mengurangi jumlah total panggilan API.
• Pembatasan Tingkat Adaptif: Selain backoff eksponensial sederhana, terapkan pembatas tingkat adaptif yang memantau X-RateLimit-Remaining dan menyesuaikan tingkat konkurensi tugas asyncio Anda secara dinamis. Jika panggilan yang tersisa rendah, perlambat; jika tinggi, percepat.
• Pembaruan Berbasis Webhook: Untuk hasil sesi (misalnya, setelah Verifikasi ID atau pemeriksaan Keaktifan), andalkan webhook Didit daripada polling yang berlebihan. Ini mengurangi jumlah permintaan GET ke /v2/session/<id>/decision/, yang memiliki batas tingkat yang lebih ketat yaitu 100 RPM. Arsitektur modular Didit berarti Anda dapat mengatur notifikasi webhook untuk berbagai perubahan status, mendorong pembaruan waktu nyata ke sistem Anda tanpa kueri konstan.
• Penanganan Kesalahan dan Observabilitas: Terapkan penanganan kesalahan yang kuat untuk masalah jaringan, kesalahan API (selain 429), dan batas waktu. Catat atau beri peringatan ketika percobaan ulang dipicu atau batas tingkat secara konsisten tercapai. Ini memberikan wawasan penting untuk mengoptimalkan strategi konsumsi API Anda.
• Manajemen Sumber Daya: Kelola instans aiohttp.ClientSession Anda dengan hati-hati. Membuat sesi baru untuk setiap permintaan tidak efisien karena overhead koneksi. Menggunakan kembali satu sesi untuk beberapa permintaan umumnya merupakan praktik terbaik.

Bagaimana Didit Membantu

Didit dibangun dari awal untuk pengembang dan aplikasi berkinerja tinggi, menjadikannya mitra ideal untuk implementasi Python Asyncio. Arsitektur modular kami memungkinkan Anda untuk memasang dan memainkan pemeriksaan identitas seperti Verifikasi ID, Keaktifan Pasif & Aktif, Pencocokan Wajah 1:1, dan Penyaringan AML sesuai kebutuhan, masing-masing dapat diakses melalui API yang bersih dan terdokumentasi dengan baik. Modularitas ini berarti Anda dapat mengatur alur kerja verifikasi yang kompleks yang disesuaikan dengan kebutuhan spesifik Anda, dan kemudian mengoptimalkan konsumsinya menggunakan teknik asinkron.

Kami percaya dalam membuat verifikasi identitas dapat diakses, itulah sebabnya kami menawarkan Free Core KYC. Ini memungkinkan Anda untuk bereksperimen dan membangun integrasi asinkron Anda tanpa biaya di muka. Pendekatan berbasis AI kami memastikan bahwa layanan verifikasi kami cepat dan akurat, sangat melengkapi manfaat kecepatan Asyncio. Dengan tanpa biaya pengaturan dan model bayar-per-pemeriksaan-berhasil, Didit menyediakan solusi yang hemat biaya dan skalabel untuk bisnis yang ingin mengimplementasikan verifikasi identitas throughput tinggi. Lingkungan sandbox instan kami dan dokumentasi API yang komprehensif lebih jauh memberdayakan pengembang untuk dengan cepat mengintegrasikan dan mengoptimalkan penggunaan layanan Didit mereka, apakah Anda sedang membangun sistem baru atau meningkatkan yang sudah ada.

Siap untuk Memulai?

Siap melihat Didit beraksi? Dapatkan demo gratis hari ini.

Mulai verifikasi identitas secara gratis dengan tingkat gratis Didit.