Ongeza Utendaji: Python Async kwa API ya Didit na Webhooks (SW)

Boresha Mwingiliano wa APITumia asyncio ya Python kufanya simu zisizozuia kwenye API ya Didit, kuboresha pakubwa utendaji wa uthibitishaji wa utambulisho na kupunguza ucheleweshaji kwa shughuli za kiasi kikubwa.

Usindikaji Bora wa WebhookTekeleza viendesha webhook visivyo vya kusubiri ili kuchakata matukio ya Didit yanayoingia bila kuzuia, kuhakikisha programu yako inabaki msikivu na inaweza kupanuka kushughulikia arifa nyingi zinazotokea kwa wakati mmoja.

Dhibiti Usimamizi wa Vikomo vya KasiElewa na udhibiti kwa ufanisi vikomo vya kasi vya API ya Didit kwa kutumia mbinu zisizo za kusubiri na mikakati mahiri ya kurudi nyuma, kuzuia kukatizwa kwa huduma na kuhakikisha ubadilishanaji wa data wa kuaminika.

Faida ya Didit ya AI-NativeJukwaa la Didit limeundwa kwa utendaji wa hali ya juu na urafiki kwa msanidi, likitoa usajili wa programu na API dhabiti zinazosaidia kikamilifu programu isiyo ya kusubiri kwa suluhisho za utambulisho zinazoweza kupanuka, zinazoendeshwa na AI.

Uhitaji wa Kasi: Kwa Nini Programu Isiyo ya Kusubiri Ni Muhimu kwa Utambulisho

Katika ulimwengu wa kidijitali wa leo unaoenda kasi, programu zinahitaji majibu ya papo hapo. Iwe unaingiza watumiaji wapya, unachakata miamala, au unathibitisha vitambulisho, ucheleweshaji unaweza kusababisha kupoteza wateja na mapato. Uthibitishaji wa utambulisho, hasa, mara nyingi unahusisha simu nyingi za API—kuangalia nyaraka, kufanya ugunduzi wa uhai, au kuchunguza dhidi ya orodha za uangalizi. Simu za API za kusubiri, ambapo programu yako inasubiri kila ombi kukamilika kabla ya kuendelea na linalofuata, zinaweza haraka kuwa kikwazo, hasa unaposhughulika na kiasi kikubwa.

Hapa ndipo programu isiyo ya kusubiri, hasa asyncio ya Python, inang'aa. Kwa kuruhusu programu yako kuanzisha kazi nyingi kwa wakati mmoja bila kuzuia mfuatano mkuu wa utekelezaji, asyncio huwezesha utendaji wa juu zaidi na usikivu. Kwa kuunganisha na majukwaa yenye nguvu ya utambulisho kama Didit, ambayo hutoa API dhabiti za Uthibitishaji wa Kitambulisho, Uhai Hasi na Amilifu, Ulinganifu wa Uso wa 1:1, na Uchunguzi wa AML, kutumia asyncio si tu uboreshaji—ni hitaji la kujenga mifumo inayoweza kupanuka, yenye utendaji wa hali ya juu.

Fikiria hali ambapo maelfu ya watumiaji wanajaribu kujisajili kwa wakati mmoja. Kila usajili unahitaji ukaguzi kadhaa wa utambulisho. Kwa simu za kusubiri, seva yako ingechakata hizi moja baada ya nyingine, na kusababisha foleni ndefu na watumiaji wenye kukata tamaa. Kwa asyncio, programu yako inaweza kuanzisha ukaguzi huu wote karibu kwa wakati mmoja, ikisubiri matokeo kurudi yakiwa tayari, ikiboresha sana uzoefu wa mtumiaji na uwezo wa jumla wa mfumo.

Kutekeleza Simu za Async API kwa Didit

Kuunganisha na API ya Didit bila kusubiri kunahusisha kutumia mteja wa HTTP anayeunga mkono asyncio, kama vile httpx au aiohttp. Maktaba hizi hukuruhusu kutuma maombi bila kuzuia, na kuzifanya ziwe bora kwa hali zenye utendaji wa juu.

Hebu tuchunguze kesi ya matumizi ya kawaida: kuanzisha vikao vingi vya uthibitishaji wa utambulisho. API ya Didit imeundwa kwa ufanisi, na kwa asyncio, unaweza kuongeza hili. Kwa mfano, kuunda vikao vya uthibitishaji kupitia POST /v3/session/ kunaweza kufanywa kwa wakati mmoja. Kila kikao kinaweza kuhusisha Uthibitishaji wa Kitambulisho wa Didit (OCR, MRZ, misimbo pau) au ukaguzi wa Uhai Hasi na Amilifu.

import asyncio
import httpx

async def create_didit_session(api_key: str, user_id: str):
    url = "https://apx.didit.me/v3/sessions/"
    headers = {"x-api-key": api_key, "Content-Type": "application/json"}
    payload = {"external_id": user_id, "flow_id": "your_flow_id"}
    
    async with httpx.AsyncClient() as client:
        response = await client.post(url, headers=headers, json=payload)
        response.raise_for_status()  # Inua ubaguzi kwa misimbo mibaya ya hali
        return response.json()

async def main():
    didit_api_key = "YOUR_DIDIT_API_KEY"
    user_ids = [f"user_{i}" for i in range(100)] # Simamia watumiaji 100

    tasks = [create_didit_session(didit_api_key, user_id) for user_id in user_ids]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Hitilafu wakati wa kuunda kikao kwa user_{user_ids[i]}: {result}")
        else:
            print(f"Kikao kimeundwa kwa user_{user_ids[i]}: {result['session_id']}")

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

Mfano huu unaonyesha jinsi ya kuunda vikao 100 vya uthibitishaji kwa wakati mmoja. Kila simu kwa create_didit_session ni coroutine inayoweza kusubiri. asyncio.gather huviendesha vyote sambamba, ikipunguza sana muda wote ikilinganishwa na utekelezaji wa mfuatano.

Kushughulikia Webhooks za Didit bila Kusubiri kwa Sasisho za Wakati Halisi

Webhooks ni muhimu kwa sasisho za wakati halisi kutoka Didit, zikiarifu mfumo wako kuhusu kukamilika kwa Uthibitishaji wa Kitambulisho, matokeo ya Uchunguzi wa AML, au matokeo ya ukaguzi wa Uthibitisho wa Anwani. Wakati Didit inapotuma arifa ya webhook, programu yako inahitaji kuichakata haraka bila kuzuia webhooks zinazofuata zinazoingia. Kidhibiti cha webhook kisicho cha kusubiri ni muhimu kwa hili.

Mfumo wa wavuti wa Python usio wa kusubiri kama FastAPI au Aiohttp ni kamili kwa kujenga kipokeaji cha webhook kisicho cha kusubiri. Wakati Didit inapotuma webhook (k.m., arifa ya kukamilika kwa kikao), kidhibiti chako kinaweza kuchanganua mzigo, kuthibitisha saini kwa kutumia secret_shared_key iliyopatikana kutoka kwa usanidi wa webhook wa Didit, na kisha kuweka foleni usindikaji wa tukio kwa kazi ya nyuma au foleni ya ujumbe bila kuchelewesha jibu la HTTP kurudi Didit.

from fastapi import FastAPI, Request, HTTPException
import hmac
import hashlib
import asyncio

app = FastAPI()
WEBHOOK_SECRET = "whsec_a1b2c3d4e5f6g7h8i9j0..." # Pata hii kutoka kwa usanidi wa webhook wa Didit

async def process_didit_event(event_data: dict):
    # Simamia usindikaji usio wa kusubiri, k.m., kusasisha hifadhidata, kuwaarifu watumiaji
    print(f"Inachakata tukio la Didit: {event_data['event_type']} kwa kikao {event_data['session_id']}")
    await asyncio.sleep(2) # Simamia kazi inayotegemea I/O
    print(f"Imemaliza kuchakata tukio kwa kikao {event_data['session_id']}")

@app.post("/didit-webhook")
async def didit_webhook(request: Request):
    signature = request.headers.get("X-Didit-Signature")
    if not signature:
        raise HTTPException(status_code=400, detail="Kichwa cha X-Didit-Signature kinakosekana")

    body = await request.body()
    
    # Thibitisha saini ya webhook (muhimu kwa usalama)
    expected_signature = hmac.new(WEBHOOK_SECRET.encode('utf-8'), body, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(signature, expected_signature):
        raise HTTPException(status_code=403, detail="Saini batili ya webhook")

    event_data = await request.json()
    
    # Chakata tukio bila kusubiri kwa nyuma
    asyncio.create_task(process_didit_event(event_data))
    
    return {"status": "received", "message": "Tukio limekubaliwa kwa usindikaji"}

Mfano huu wa FastAPI unaonyesha jinsi ya kukiri haraka webhook na kisha kuhamisha usindikaji halisi kwa kutumia asyncio.create_task. Hii inahakikisha kuwa kituo chako cha webhook kinabaki kinapatikana kwa urahisi na msikivu, hata kama usindikaji wa matukio binafsi unachukua muda. Usanidi wa webhook wa Didit hukuruhusu kubainisha webhook_url na webhook_version, na kuifanya iwe rahisi kusanidi uwasilishaji wa matukio salama na wa kuaminika.

Kuelekeza Vikomo vya Kasi kwa Mikakati ya Async

Vikomo vya kasi vya API ni jambo muhimu la kuzingatia kwa muunganisho wowote wa utendaji wa juu. Didit, kama mtoa huduma yeyote wa API dhabiti, huweka vikomo vya kasi ili kudumisha utulivu. Kuelewa na kushughulikia vikomo hivi kwa hekima ni muhimu ili kuepusha makosa ya 429 Too Many Requests na kuhakikisha operesheni inayoendelea.

Didit hutoa vichwa wazi vya kikomo cha kasi (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After) katika majibu yake. Kwa asyncio, unaweza kutekeleza mikakati ya kisasa ya kuweka vikomo vya kasi, kama vile kurudi nyuma kwa exponential na jitter na algoriti za ndoo ya tokeni, bila kuzuia programu yako yote.

import asyncio
import httpx
import time

async def make_rate_limited_request(client: httpx.AsyncClient, url: str, headers: dict, payload: dict, retries: int = 5):
    for attempt in range(retries):
        response = await client.post(url, headers=headers, json=payload)
        if response.status_code == 429:
            retry_after = int(response.headers.get("Retry-After", 2 ** attempt)) # Kurudi nyuma kwa exponential
            print(f"Kikomo cha kasi kimefikiwa. Inajaribu tena baada ya {retry_after} sekunde...")
            await asyncio.sleep(retry_after)
        else:
            response.raise_for_status()
            return response.json()
    raise Exception("Jaribio la juu limezidi kwa ombi la kikomo cha kasi.")

async def main_rate_limited():
    didit_api_key = "YOUR_DIDIT_API_KEY"
    url = "https://apx.didit.me/v3/sessions/"
    headers = {"x-api-key": didit_api_key, "Content-Type": "application/json"}
    
    async with httpx.AsyncClient() as client:
        tasks = []
        for i in range(150): # Simamia kuzidi kikomo cha 300 rpm na kazi 150
            payload = {"external_id": f"user_{i}", "flow_id": "your_flow_id"}
            tasks.append(make_rate_limited_request(client, url, headers, payload))
        
        results = await asyncio.gather(*tasks, return_exceptions=True)
        for i, result in enumerate(results):
            if isinstance(result, Exception):
                print(f"Ombi {i} limeshindwa: {result}")
            else:
                print(f"Ombi {i} limefanikiwa: {result.get('session_id')}")

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

Mfano huu unaonyesha mkakati wa kurudi nyuma kwa exponential usio wa kusubiri. Wakati 429 inapopokelewa, coroutine inasubiri kwa muda uliowekwa wa Retry-After (au muda unaoongezeka kwa exponential) kabla ya kujaribu tena, yote bila kuzuia kazi zingine zinazotokea kwa wakati mmoja. Vikomo vya Didit vya kimataifa (maombi 300 kwa dakika kwa kila programu kwa vituo vya GET/Write/Delete) na vikomo maalum vya kituo (k.m., 600 rpm kwa POST /v2/session/) vimeandikwa wazi, kukuruhusu kubuni wateja wako wa async ipasavyo.

Jinsi Didit Inasaidia Kujenga Suluhisho za Utambulisho Zenye Utendaji wa Juu

Usanifu wa Didit kiasili umeundwa kusaidia shughuli za utendaji wa juu, na kuifanya kuwa mshirika bora kwa muunganisho usio wa kusubiri. Jukwaa letu linatoa faida kadhaa muhimu:

• Msanidi Kwanza & AI-Native: Didit hutoa API safi na nyaraka kamili, na kuifanya iwe rahisi kuunganisha na asyncio ya Python. Mbinu yetu ya AI-native inamaanisha kuwa kazi ngumu za uthibitishaji wa utambulisho, kutoka Uthibitishaji wa Kitambulisho hadi Uhai Hasi na Amilifu, zinachakatwa kwa ufanisi upande wetu, kuruhusu programu yako kusubiri tu matokeo.
• Vipengele vya Msingi vya Utambulisho vya Kimoduli: Usanifu wa kimoduli wa Didit hukuruhusu kuchagua na kuchagua ukaguzi halisi wa utambulisho unaohitaji. Iwe ni Uthibitishaji wa Kitambulisho (OCR, MRZ), Ulinganifu wa Uso wa 1:1, au Uthibitisho wa Anwani, kila kipengele kinapatikana kupitia API yenye utendaji wa hali ya juu, inayofaa kabisa kwa simu za wakati mmoja.
• Usajili wa Programu: Tofauti na majukwaa mengi, Didit inaruhusu usajili wa programu, hata kwa mawakala wa AI. Unaweza kupata sifa za API kwa simu mbili tu za API, bila kichwa kabisa, bila kufungua kivinjari. Hii inapunguza msuguano wa usanidi na kuwezesha uwekaji wa miundombinu yako ya utambulisho kiotomatiki, kwa kiwango kikubwa.
• Mifumo ya Kazi Iliyoratibiwa: Injini ya Didit isiyo na msimbo hukuruhusu kuratibu mifumo tata ya kazi ya KYC, kupunguza idadi ya simu za API za kibinafsi ambazo programu yako inahitaji kudhibiti huku bado ikinufaika na usindikaji usio wa kusubiri wa matokeo ya kikao cha jumla.
• KYC ya Msingi Bure & Bei Inayobadilika: Didit inatoa KYC ya Msingi Bure, kukuruhusu kuanza bila gharama za awali. Mfumo wetu wa kulipa-kwa-ukaguzi-uliofanikiwa na hakuna ada za kuanzisha unamaanisha unalipa kile unachotumia tu, ukilingana kikamilifu na usanifu unaoweza kupanuka, unaotegemea matumizi unaowezeshwa na usindikaji usio wa kusubiri.

Kwa kuchanganya nguvu ya Python asyncio na API dhabiti na rafiki kwa msanidi ya Didit, unaweza kujenga mifumo ya uthibitishaji wa utambulisho ambayo sio tu salama na inayolingana bali pia ni ya haraka sana na inayoweza kupanuka, yenye uwezo wa kushughulikia mahitaji ya biashara za kisasa za kidijitali.

Uko Tayari Kuanza?

Uko tayari kuona Didit ikifanya kazi? Pata onyesho la bure leo.

Anza kuthibitisha vitambulisho bila malipo na kiwango cha bure cha Didit.