Créer un gestionnaire de webhook Go pour les événements de vérification d'identité (FR)

Automatisation en temps réelLes webhooks permettent des réponses instantanées et basées sur des événements aux résultats de vérification d'identité, cruciaux pour l'intégration dynamique des utilisateurs et les systèmes de prévention de la fraude.

Gestion robuste des erreursLa mise en œuvre de mécanismes de réessai, de files d'attente de lettres mortes et d'une journalisation complète est essentielle pour maintenir l'intégrité des données et la fiabilité du système lors du traitement des événements webhook asynchrones.

La sécurité est primordialeValidez toujours les signatures de webhook, utilisez HTTPS et nettoyez les données entrantes pour vous protéger contre la falsification et les accès non autorisés, protégeant ainsi les informations d'identité sensibles.

Didit simplifie l'intégrationLa plateforme modulaire et API-first de Didit offre un support webhook complet, permettant aux développeurs de configurer facilement des notifications en temps réel pour tous les événements de vérification d'identité, de la vérification d'identité au contrôle AML, avec un KYC de base gratuit.

Dans le paysage moderne de l'identité numérique, le feedback en temps réel n'est pas un luxe ; c'est une nécessité. Que vous intégriez de nouveaux utilisateurs, préveniez la fraude ou assuriez la conformité, connaître le résultat d'une vérification d'identité au moment où elle se produit permet une action immédiate et une expérience utilisateur plus fluide. C'est là que les webhooks brillent. Les webhooks offrent un mécanisme puissant permettant aux plateformes de vérification d'identité de notifier votre application des événements au fur et à mesure qu'ils se produisent, éliminant le besoin d'un sondage constant.

Cet article de blog vous guidera dans la construction d'un gestionnaire de webhook robuste et sécurisé en Go, spécifiquement adapté au traitement des événements de vérification d'identité. Les puissantes fonctionnalités de concurrence et les performances de Go en font un excellent choix pour gérer la nature asynchrone des webhooks.

Comprendre les webhooks pour la vérification d'identité

Avant de plonger dans le code, clarifions ce que sont les webhooks et pourquoi ils sont essentiels pour la vérification d'identité. Un webhook est essentiellement un rappel HTTP défini par l'utilisateur. Au lieu que votre application demande continuellement des mises à jour à un service de vérification d'identité (polling), le service envoie une requête HTTP POST à une URL que vous fournissez chaque fois qu'un événement spécifique se produit. Pour la vérification d'identité, ces événements pourraient inclure :

• La numérisation du document d'identité d'un utilisateur est terminée.
• La détection de vivacité réussit ou échoue.
• Le contrôle AML renvoie une correspondance.
• Un flux de travail de vérification complet atteint un statut final (par exemple, approuvé, rejeté, examen manuel).

Recevoir ces événements en temps réel permet à votre application de mettre à jour les statuts des utilisateurs, de déclencher des processus en aval ou de notifier les administrateurs sans délai. Par exemple, une fois que la vérification d'identité et les contrôles de vivacité passive et active d'un utilisateur sont approuvés, vous pouvez immédiatement lui accorder l'accès à votre service.

Configuration de votre serveur webhook Go

La construction d'un gestionnaire de webhook en Go implique la mise en place d'un simple serveur HTTP qui écoute les requêtes POST entrantes. Nous utiliserons le package standard net/http de Go pour cela. Tout d'abord, créons une structure de serveur de base.

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

// WebhookPayload représente la structure d'un webhook entrant provenant d'un service de vérification d'identité.
// Ceci est un exemple simplifié ; les charges utiles réelles varieront.
type WebhookPayload struct {
	Event   string `json:"event"`
	SessionID string `json:"session_id"`
	Status  string `json:"status"`
	Data    json.RawMessage `json:"data"` // Utiliser RawMessage pour différer le démasquage des données imbriquées
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed)
		return
	}

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "Erreur de lecture du corps de la requête", http.StatusInternalServerError)
		return
	}

	var payload WebhookPayload
	err = json.Unmarshal(body, &payload)
	if err != nil {
		http.Error(w, "Erreur de démasquage de la charge utile JSON", http.StatusBadRequest)
		log.Printf("Échec du démasquage du webhook : %v, Corps : %s", err, body)
		return
	}

	// Journaliser l'événement reçu pour l'instant. Dans une application réelle, vous le traiteriez.
	log.Printf("Événement webhook reçu : %s pour la session %s avec le statut %s", payload.Event, payload.SessionID, payload.Status)

	// Répondre avec un 200 OK pour accuser réception. La plupart des expéditeurs de webhook s'attendent à cela.
	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, "Webhook reçu avec succès")
}

func main() {
	http.HandleFunc("/webhook", webhookHandler)

	port := ":8080"
	log.Printf("Serveur webhook démarrant sur le port %s\n", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

Cet exemple de base configure un serveur HTTP écoutant sur le port 8080 et gérant les requêtes POST vers le point de terminaison /webhook. Il lit la charge utile JSON entrante, la démasque dans une structure WebhookPayload et journalise l'événement. De manière cruciale, il répond avec un code d'état 200 OK pour confirmer la réception réussie du webhook. Ne pas répondre avec un 200 OK peut entraîner la réémission de la livraison par l'expéditeur, ce qui conduit à un traitement en double.

Assurer la sécurité : vérification de la signature et HTTPS

La sécurité est primordiale lorsqu'il s'agit de données de vérification d'identité sensibles. Vous devez vous assurer que les webhooks entrants sont légitimes et n'ont pas été altérés. Les deux principaux mécanismes pour cela sont :

1. HTTPS : Exposez toujours votre point de terminaison webhook via HTTPS pour chiffrer les données en transit, empêchant ainsi l'écoute clandestine.
2. Vérification de la signature : La plupart des fournisseurs de vérification d'identité réputés, y compris Didit, envoient une signature ou un hachage dans les en-têtes de la requête (par exemple, X-Didit-Signature). Vous devez utiliser une clé secrète partagée pour calculer votre propre hachage du corps de la requête brute et le comparer avec la signature entrante. S'ils ne correspondent pas, le webhook est probablement frauduleux ou compromis.

Voici un exemple de la façon dont vous pourriez ajouter la vérification de la signature à votre gestionnaire :

// ... (importations précédentes et structure WebhookPayload)

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	// ... autres importations
)

const webhookSecret = "VOTRE_SECRET_WEBHOOK_DIDIT" // Remplacez par votre secret réel

func verifySignature(body []byte, signature string) bool {
	hmacHash := hmac.New(sha256.New, []byte(webhookSecret))
	hmacHash.Write(body)
	expectedMAC := hmacHash.Sum(nil)

	decodedSignature, err := hex.DecodeString(signature)
	if err != nil {
		return false
	}

	return hmac.Equal(decodedSignature, expectedMAC)
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	// ... (vérification de la méthode et lecture du corps)

	signature := r.Header.Get("X-Didit-Signature") // Ou un nom d'en-tête similaire de votre fournisseur
	if signature == "" {
		http.Error(w, "En-tête de signature manquant", http.StatusUnauthorized)
		return
	}

	if !verifySignature(body, signature) {
		http.Error(w, "Signature invalide", http.StatusUnauthorized)
		return
	}

	// ... (démasquage et traitement de la charge utile)
}

N'oubliez pas de stocker votre webhookSecret en toute sécurité, idéalement dans des variables d'environnement ou un système de gestion des secrets, et non pas codé en dur dans votre application.

Robustesse : traitement asynchrone et tentatives

Les webhooks doivent être traités rapidement pour éviter les délais d'attente et les réessais de l'expéditeur. Pour les tâches complexes ou chronophages, il est préférable de décharger le traitement vers une goroutine ou une file d'attente de messages distincte. Votre gestionnaire de webhook devrait principalement se concentrer sur la réception, la validation et l'accusé de réception de l'événement.

// ... (code précédent)

func processWebhookAsync(payload WebhookPayload) {
	// Dans une application réelle, cela pourrait impliquer :
	// - Le stockage de l'événement dans une base de données
	// - L'envoi à une file d'attente de messages (par exemple, Kafka, RabbitMQ)
	// - L'appel d'autres services internes
	log.Printf("Traitement asynchrone de l'événement : %s pour la session %s", payload.Event, payload.SessionID)
	// Simuler le travail
	// time.Sleep(5 * time.Second)
	log.Printf("Fin du traitement asynchrone pour la session %s", payload.SessionID)
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	// ... (vérification de la signature et démasquage de la charge utile)

	// Accuser réception immédiatement.
	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, "Webhook reçu avec succès")

	// Traiter de manière asynchrone pour éviter de bloquer la réponse HTTP.
	go processWebhookAsync(payload)
}

De plus, les services externes peuvent occasionnellement échouer. Implémentez des mécanismes de réessai pour tous les appels en aval effectués pendant le traitement asynchrone. Envisagez d'utiliser une file d'attente de lettres mortes (DLQ) pour les événements qui échouent à plusieurs reprises, permettant une inspection manuelle et un nouveau traitement.

Comment Didit aide

Didit, en tant que plateforme d'identité native de l'IA et axée sur les développeurs, simplifie et sécurise l'intégration des événements de vérification d'identité en temps réel. L'architecture modulaire de Didit est conçue pour l'orchestration, ce qui signifie que vous pouvez définir des flux de travail complexes combinant la vérification d'identité (OCR, MRZ, codes-barres), la vivacité passive et active, la correspondance faciale 1:1, le contrôle et le suivi AML, la preuve d'adresse et même l'estimation de l'âge respectueuse de la vie privée. Chaque étape de ces flux de travail, ainsi que le résultat final, peut déclencher des événements webhook directement vers votre application Go.

Avec Didit, vous configurez votre URL de webhook dans la console professionnelle, et Didit envoie des mises à jour automatisées à votre point de terminaison configuré au fur et à mesure que l'utilisateur progresse et lorsque le résultat final de la vérification est prêt. Didit fournit des charges utiles de webhook robustes, incluant souvent un en-tête de signature pour que vous puissiez vérifier l'authenticité, assurant la sécurité de votre intégration. Cela vous permet de créer des réponses sophistiquées et automatisées aux résultats de vérification, accélérant l'intégration des utilisateurs, améliorant la détection de la fraude et rationalisant les processus de conformité sans intervention manuelle.

Les avantages de Didit, tels que le KYC de base gratuit et l'absence de frais d'installation, associés à ses API claires et à sa documentation complète, vous permettent de créer des solutions d'identité puissantes et basées sur des événements avec une efficacité maximale. Que vous utilisiez des liens de vérification pour une intégration sans code ou que vous exploitiez directement l'API, le système de webhook de Didit garantit que vous êtes toujours en phase avec les parcours de vérification de vos utilisateurs.

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.