Optimiser les performances : Python asynchrone pour l'API et les webhooks Didit (FR)

Optimiser les interactions APITirez parti de asyncio de Python pour effectuer des appels non bloquants à l'API de Didit, améliorant considérablement le débit pour la vérification d'identité et réduisant la latence pour les opérations à grand volume.

Traitement efficace des webhooksMettez en œuvre des gestionnaires de webhooks asynchrones pour traiter les événements Didit entrants sans bloquer, garantissant que votre application reste réactive et peut s'adapter à de nombreuses notifications concurrentes.

Maîtriser la gestion des limites de débitComprenez et gérez efficacement les limites de débit de l'API de Didit en utilisant des techniques asynchrones et des stratégies de repli intelligentes, prévenant les interruptions de service et assurant un échange de données fiable.

L'avantage AI-Native de DiditLa plateforme de Didit est conçue pour des performances élevées et une facilité d'utilisation pour les développeurs, offrant une inscription programmatique et des API robustes qui complètent parfaitement la programmation asynchrone pour des solutions d'identité évolutives basées sur l'IA.

Le besoin de vitesse : pourquoi la programmation asynchrone est essentielle pour l'identité

Dans le monde numérique rapide d'aujourd'hui, les applications exigent des réponses instantanées. Que vous intégriez de nouveaux utilisateurs, traitiez des transactions ou vérifiiez des identités, les retards peuvent entraîner une perte de clients et de revenus. La vérification d'identité, en particulier, implique souvent plusieurs appels API — pour vérifier des documents, effectuer une détection de vivacité ou filtrer des listes de surveillance. Les appels API synchrones, où votre programme attend que chaque requête soit terminée avant de passer à la suivante, peuvent rapidement devenir un goulot d'étranglement, surtout lorsqu'il s'agit de volumes élevés.

C'est là que la programmation asynchrone, en particulier asyncio de Python, brille. En permettant à votre application d'initier plusieurs tâches simultanément sans bloquer le thread d'exécution principal, asyncio permet un débit et une réactivité nettement supérieurs. Pour l'intégration avec des plateformes d'identité puissantes comme Didit, qui offrent des API robustes pour la vérification d'identité, la vivacité passive et active, la correspondance faciale 1:1 et le filtrage AML, l'exploitation de asyncio n'est pas seulement une optimisation — c'est une nécessité pour construire des systèmes évolutifs et performants.

Imaginez un scénario où des milliers d'utilisateurs tentent de s'inscrire simultanément. Chaque inscription nécessite plusieurs vérifications d'identité. Avec des appels synchrones, votre serveur les traiterait un par un, entraînant de longues files d'attente et des utilisateurs frustrés. Avec asyncio, votre application peut initier toutes ces vérifications presque simultanément, attendant que les résultats arrivent au fur et à mesure, améliorant considérablement l'expérience utilisateur et la capacité globale du système.

Implémentation d'appels API asynchrones vers Didit

L'intégration asynchrone avec l'API de Didit implique l'utilisation d'un client HTTP supportant asyncio, tel que httpx ou aiohttp. Ces bibliothèques vous permettent d'envoyer des requêtes sans bloquer, ce qui les rend idéales pour les scénarios à haut débit.

Prenons un cas d'utilisation courant : l'initiation de plusieurs sessions de vérification d'identité. L'API de Didit est conçue pour l'efficacité, et avec asyncio, vous pouvez la maximiser. Par exemple, la création de sessions de vérification via POST /v3/session/ peut être effectuée simultanément. Chaque session peut impliquer la vérification d'identité de Didit (OCR, MRZ, codes-barres) ou des vérifications de vivacité passive et active.

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()  # Lève une exception pour les codes d'état erronés
        return response.json()

async def main():
    didit_api_key = "VOTRE_CLE_API_DIDIT"
    user_ids = [f"user_{i}" for i in range(100)] # Simule 100 utilisateurs

    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"Erreur lors de la création de la session pour user_{user_ids[i]}: {result}")
        else:
            print(f"Session créée pour user_{user_ids[i]}: {result['session_id']}")

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

Cet exemple montre comment créer 100 sessions de vérification simultanément. Chaque appel à create_didit_session est une coroutine attendable. asyncio.gather les exécute tous en parallèle, réduisant considérablement le temps total par rapport à une exécution séquentielle.

Traitement asynchrone des webhooks Didit pour des mises à jour en temps réel

Les webhooks sont cruciaux pour les mises à jour en temps réel de Didit, informant votre système de l'achèvement de la vérification d'identité, du résultat d'un filtrage AML ou du résultat d'une vérification de preuve d'adresse. Lorsque Didit envoie une notification de webhook, votre application doit la traiter rapidement sans bloquer les webhooks entrants ultérieurs. Un gestionnaire de webhook asynchrone est essentiel pour cela.

Un framework web Python asynchrone typique comme FastAPI ou Aiohttp est parfait pour construire un récepteur de webhook asynchrone. Lorsque Didit envoie un webhook (par exemple, une notification d'achèvement de session), votre gestionnaire peut analyser la charge utile, vérifier la signature à l'aide de la secret_shared_key obtenue de la configuration du webhook de Didit, puis mettre en file d'attente le traitement de l'événement vers une tâche d'arrière-plan ou une file d'attente de messages sans retarder la réponse HTTP à Didit.

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

app = FastAPI()
WEBHOOK_SECRET = "whsec_a1b2c3d4e5f6g7h8i9j0..." # Obtenez ceci de la configuration du webhook Didit

async def process_didit_event(event_data: dict):
    # Simule un traitement asynchrone, par exemple, la mise à jour de la base de données, la notification des utilisateurs
    print(f"Traitement de l'événement Didit : {event_data['event_type']} pour la session {event_data['session_id']}")
    await asyncio.sleep(2) # Simule une tâche liée aux E/S
    print(f"Traitement de l'événement terminé pour la session {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="En-tête X-Didit-Signature manquant")

    body = await request.body()
    
    # Vérifier la signature du webhook (important pour la sécurité)
    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="Signature de webhook invalide")

    event_data = await request.json()
    
    # Traiter l'événement de manière asynchrone en arrière-plan
    asyncio.create_task(process_didit_event(event_data))
    
    return {"status": "received", "message": "Événement accepté pour traitement"}

Cet exemple FastAPI montre comment accuser réception rapidement du webhook, puis décharger le traitement réel à l'aide de asyncio.create_task. Cela garantit que votre point de terminaison de webhook reste hautement disponible et réactif, même si le traitement des événements individuels prend du temps. La configuration du webhook de Didit vous permet de spécifier une webhook_url et une webhook_version, ce qui facilite la mise en place d'une livraison d'événements sécurisée et fiable.

Naviguer les limites de débit avec des stratégies asynchrones

Les limites de débit API sont une considération critique pour toute intégration à haut débit. Didit, comme tout fournisseur d'API robuste, applique la limitation de débit pour maintenir la stabilité. Comprendre et gérer gracieusement ces limites est primordial pour éviter les erreurs 429 Too Many Requests et assurer un fonctionnement continu.

Didit fournit des en-têtes de limite de débit clairs (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After) dans ses réponses. Avec asyncio, vous pouvez implémenter des stratégies de limitation de débit sophistiquées, telles que le backoff exponentiel avec gigue et les algorithmes de seau à jetons, sans bloquer toute votre application.

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)) # Backoff exponentiel
            print(f"Limite de débit atteinte. Réessai dans {retry_after} secondes...")
            await asyncio.sleep(retry_after)
        else:
            response.raise_for_status()
            return response.json()
    raise Exception("Nombre maximal de tentatives dépassé pour la requête limitée en débit.")

async def main_rate_limited():
    didit_api_key = "VOTRE_CLE_API_DIDIT"
    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): # Simule le dépassement d'une limite de 300 rpm avec 150 tâches
            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"Requête {i} échouée : {result}")
            else:
                print(f"Requête {i} réussie : {result.get('session_id')}")

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

Cet exemple montre une stratégie de backoff exponentiel asynchrone. Lorsqu'un 429 est reçu, la coroutine attend la durée Retry-After spécifiée (ou un temps augmentant de manière exponentielle) avant de réessayer, le tout sans bloquer d'autres tâches concurrentes. Les limites globales de Didit (300 requêtes par minute et par application pour les points de terminaison GET/Write/Delete) et les limites spécifiques aux points de terminaison (par exemple, 600 rpm pour POST /v2/session/) sont clairement documentées, ce qui vous permet de concevoir vos clients asynchrones en conséquence.

Comment Didit aide à construire des solutions d'identité à haut débit

L'architecture de Didit est intrinsèquement conçue pour supporter les opérations à haut débit, ce qui en fait un partenaire idéal pour les intégrations asynchrones. Notre plateforme offre plusieurs avantages clés :

• Développeur-First & AI-Native : Didit fournit des API claires et une documentation complète, facilitant l'intégration avec asyncio de Python. Notre approche AI-native signifie que les tâches complexes de vérification d'identité, de la vérification d'identité à la vivacité passive et active, sont traitées efficacement de notre côté, permettant à votre application d'attendre simplement les résultats.
• Primitives d'identité modulaires : La conception modulaire de Didit vous permet de choisir les vérifications d'identité exactes dont vous avez besoin. Qu'il s'agisse de vérification d'identité (OCR, MRZ), de correspondance faciale 1:1, ou de preuve d'adresse, chaque primitive est accessible via une API haute performance, parfaitement adaptée aux appels concurrents.
• Enregistrement programmatique : Contrairement à de nombreuses plateformes, Didit permet un enregistrement programmatique, même pour les agents IA. Vous pouvez obtenir des informations d'identification API en seulement deux appels API, entièrement sans interface graphique, sans jamais ouvrir de navigateur. Cela minimise la friction de configuration et permet un déploiement automatisé et à grande échelle de votre infrastructure d'identité.
• Workflows orchestrés : Le moteur sans code de Didit vous permet d'orchestrer des workflows KYC complexes, réduisant le nombre d'appels API individuels que votre application doit gérer tout en bénéficiant du traitement asynchrone du résultat global de la session.
• KYC de base gratuit et tarification flexible : Didit propose un KYC de base gratuit, vous permettant de démarrer sans frais initiaux. Notre modèle de paiement par vérification réussie et l'absence de frais d'installation signifient que vous ne payez que ce que vous utilisez, ce qui correspond parfaitement aux architectures évolutives basées sur l'utilisation activées par le traitement asynchrone.

En combinant la puissance de asyncio de Python avec l'API robuste et conviviale pour les développeurs de Didit, vous pouvez construire des systèmes de vérification d'identité qui sont non seulement sécurisés et conformes, mais aussi incroyablement rapides et évolutifs, capables de répondre aux exigences des entreprises numériques modernes.

Prêt à commencer ?

Prêt à voir Didit en action ? Obtenez une démo gratuite dès aujourd'hui.

Commencez à vérifier les identités gratuitement avec le niveau gratuit de Didit.