Vérifications d'identité extensibles en Go avec les primitives de Didit (FR)

Conception modulaire pour l'agilitéLa construction d'une architecture de plugin extensible en Go permet aux entreprises de s'adapter rapidement aux réglementations de conformité en évolution et aux nouveaux vecteurs de fraude sans remanier l'intégralité de leur système de vérification d'identité.

Exploitez les atouts de GoLa forte typification, les performances et les fonctionnalités de concurrence de Go en font un langage idéal pour développer des services de vérification d'identité robustes et évolutifs, capables de gérer un débit élevé.

Composabilité avec les primitives DiditL'intégration des primitives d'identité natives de l'IA de Didit, telles que la vérification d'identité, la détection de vivacité passive et active, et le filtrage AML, fournit des composants puissants et pré-construits qui peuvent être orchestrés au sein de plugins Go personnalisés.

L'approche développeur-first de DiditLes API épurées, le sandbox instantané et l'architecture modulaire de Didit sont parfaitement adaptés aux développeurs qui construisent des systèmes extensibles, offrant un KYC Core gratuit et aucune frais d'installation pour accélérer le développement.

La nécessité d'une vérification d'identité extensible

Dans le paysage numérique en évolution rapide d'aujourd'hui, la vérification d'identité (IDV) n'est plus un processus statique. Les réglementations évoluent, de nouvelles techniques de fraude apparaissent et les besoins commerciaux changent. Un système IDV rigide et monolithique devient rapidement un goulot d'étranglement, entravant l'innovation et augmentant les risques de conformité. C'est pourquoi une architecture de plugin extensible n'est pas seulement un luxe mais une nécessité, en particulier pour les développeurs travaillant avec des langages performants comme Go.

Une architecture extensible permet aux entreprises d'ajouter, de supprimer ou de modifier des vérifications d'identité dynamiquement sans redéployer l'ensemble du service. Cette agilité est cruciale pour s'adapter aux exigences KYC (Know Your Customer) spécifiques à chaque région, intégrer des mécanismes de détection de fraude de pointe ou expérimenter de nouveaux flux d'intégration d'utilisateurs. Par exemple, une entreprise pourrait initialement nécessiter une vérification d'identité de base et une détection de vivacité. Plus tard, elle pourrait avoir besoin d'ajouter une estimation de l'âge pour des produits spécifiques ou d'incorporer un filtrage AML pour les transactions financières. Un système basé sur des plugins gère ces ajouts de manière transparente.

Concevoir une architecture de plugin en Go

La conception axée sur les interfaces et la forte typification de Go en font un excellent choix pour la construction de systèmes de plugins robustes. L'idée principale est de définir une interface commune que tous les « plugins » de vérification d'identité doivent implémenter. Cette interface agit comme un contrat, garantissant que toute nouvelle vérification peut être intégrée de manière transparente dans le flux de travail existant.

Définir l'interface de vérification d'identité

Considérons une interface simple pour une vérification d'identité :

package main

type IdentityCheckResult struct {
    Passed  bool
    Details string
}

type IdentityChecker interface {
    Name() string
    Execute(data map[string]interface{}) (IdentityCheckResult, error)
}

Ici, IdentityChecker définit deux méthodes : Name() pour identifier le plugin et Execute() pour effectuer la vérification réelle, en prenant des données d'entrée génériques et en renvoyant un résultat. Cette abstraction permet des vérifications diverses, de la vérification de documents à l'analyse biométrique.

Implémenter des vérifications personnalisées avec les primitives de Didit

Voyons maintenant comment nous pouvons implémenter des vérifications d'identité spécifiques en utilisant les puissantes primitives de Didit au sein de ce framework de plugins. L'architecture modulaire de Didit, ses API épurées et ses capacités natives de l'IA facilitent l'intégration de ces services avancés.

Exemple : Plugin de vérification d'identité Didit

Pour la vérification d'identité basée sur des documents, nous pouvons créer un plugin qui exploite le produit de vérification d'identité de Didit, qui comprend l'OCR, le MRZ et la lecture de codes-barres dans plus de 220 pays. Ce plugin enverrait des images de documents et des données à l'API de Didit et traiterait la réponse.

package main

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

type DiditIDVCheck struct{}

func (d *DiditIDVCheck) Name() string {
    return "DiditIDVerification"
}

func (d *DiditIDVCheck) Execute(data map[string]interface{}) (IdentityCheckResult, error) {
    documentImage, ok := data["documentImage"].(string)
    if !ok {
        return IdentityCheckResult{Passed: false, Details: "Missing document image"}, nil
    }

    // Dans une application réelle, vous enverriez l'image à l'API de vérification d'identité de Didit.
    // Pour cet exemple, nous allons simuler un appel.
    // Documentation: https://docs.didit.me/core-technology/id-verification

    // Simuler l'appel API à la vérification d'identité de Didit
    // Remplacer par un appel API réel et une gestion d'erreurs
    fmt.Printf("Appel de la vérification d'identité Didit pour l'image : %s...\n", documentImage[:20]) // Tronquer pour l'affichage
    
    // Supposons une réponse réussie pour la démonstration
    if documentImage != "invalid_id_image" {
        return IdentityCheckResult{Passed: true, Details: "Document d'identité vérifié par Didit."}, nil
    } else {
        return IdentityCheckResult{Passed: false, Details: "La vérification du document d'identité a échoué par Didit." + " Image invalide fournie."}, 
            fmt.Errorf("La vérification d'identité Didit a échoué")
    }
}

Exemple : Plugin de vérification de vivacité Didit

Pour lutter contre les deepfakes et les attaques de présentation, une vérification de vivacité est essentielle. Didit propose une détection de vivacité passive et active. Un plugin pourrait l'intégrer, traitant une courte vidéo ou une série d'images.

package main

type DiditLivenessCheck struct{}

func (d *DiditLivenessCheck) Name() string {
    return "DiditLivenessDetection"
}

func (d *DiditLivenessCheck) Execute(data map[string]interface{}) (IdentityCheckResult, error) {
    livenessVideo, ok := data["livenessVideo"].(string)
    if !ok {
        return IdentityCheckResult{Passed: false, Details: "Missing liveness video"}, nil
    }

    // Simuler l'appel API à la détection de vivacité de Didit
    // Remplacer par un appel API réel et une gestion d'erreurs
    fmt.Printf("Appel de la détection de vivacité Didit pour la vidéo : %s...\n", livenessVideo[:20])

    if livenessVideo != "deepfake_video" {
        return IdentityCheckResult{Passed: true, Details: "Vivacité détectée par Didit."}, nil
    } else {
        return IdentityCheckResult{Passed: false, Details: "La détection de vivacité a échoué par Didit." + " Deepfake détecté."}, 
            fmt.Errorf("La détection de vivacité Didit a échoué")
    }
}

Orchestrer les flux de travail avec des plugins

Une fois que vous avez vos plugins, vous avez besoin d'un mécanisme pour les orchestrer dans un flux de travail cohérent. Les flux de travail orchestrés de Didit fournissent un constructeur visuel sans code pour cela, mais si vous construisez un service Go personnalisé, vous pouvez gérer cette logique par programme.

package main

import "fmt"

// Un simple orchestrateur
type Workflow struct {
    Checks []IdentityChecker
}

func (w *Workflow) AddCheck(checker IdentityChecker) {
    w.Checks = append(w.Checks, checker)
}

func (w *Workflow) Run(userData map[string]interface{}) ([]IdentityCheckResult, error) {
    var results []IdentityCheckResult
    for _, check := range w.Checks {
        fmt.Printf("\nExécution de la vérification %s...\n", check.Name())
        res, err := check.Execute(userData)
        results = append(results, res)
        if err != nil || !res.Passed {
            fmt.Printf("La vérification %s a échoué : %s\n", check.Name(), res.Details)
            return results, fmt.Errorf("Le flux de travail a échoué à %s : %w", check.Name(), err)
        }
        fmt.Printf("La vérification %s a réussi : %s\n", check.Name(), res.Details)
    }
    return results, nil
}

func main() {
    workflow := &Workflow{}
    workflow.AddCheck(&DiditIDVCheck{})
    workflow.AddCheck(&DiditLivenessCheck{})

    // Exemple de données utilisateur
    userData := map[string]interface{}{
        "documentImage": "valid_passport_image_base64",
        "livenessVideo": "valid_liveness_video_base64",
        "name":          "Jane Doe",
    }

    fmt.Println("--- Exécution du flux de travail réussi ---")
    results, err := workflow.Run(userData)
    if err != nil {
        fmt.Printf("Le flux de travail s'est terminé avec des erreurs : %v\n", err)
    } else {
        fmt.Println("Le flux de travail s'est terminé avec succès !")
    }
    for _, r := range results {
        fmt.Printf("- %s: Réussi = %t, Détails = %s\n", r.Name, r.Passed, r.Details)
    }

    // Exemple d'un flux de travail échoué
    fmt.Println("\n--- Exécution du flux de travail échoué (ID invalide) ---")
    failingUserData := map[string]interface{}{
        "documentImage": "invalid_id_image",
        "livenessVideo": "valid_liveness_video_base64",
        "name":          "John Smith",
    }
    failingResults, err := workflow.Run(failingUserData)
    if err != nil {
        fmt.Printf("Le flux de travail s'est terminé avec des erreurs : %v\n", err)
    } else {
        fmt.Println("Le flux de travail s'est terminé avec succès !")
    }
    for _, r := range failingResults {
        fmt.Printf("- %s: Réussi = %t, Détails = %s\n", r.Name, r.Passed, r.Details)
    }
}

Cet orchestrateur simple exécute les vérifications séquentiellement. Dans un scénario réel, vous pourriez ajouter une logique conditionnelle, une exécution parallèle ou des tentatives, reflétant les capacités du constructeur de flux de travail sans code de Didit.

Considérations avancées pour les architectures de plugins Go

Lors de la construction d'une architecture de plugin prête pour la production en Go, tenez compte de ces aspects :

• Gestion des erreurs : Implémentez une gestion des erreurs et une journalisation robustes pour chaque plugin.
• Configuration : Permettez aux plugins d'être configurés dynamiquement (par exemple, clés API, seuils).
• Chargement des plugins : Pour une véritable extensibilité sans recompilation, explorez le package plugin de Go (bien qu'il ait des limitations de plateforme) ou des processus externes/gRPC pour la communication inter-processus.
• Sécurité : Assurez-vous que les plugins sont isolés ou correctement vérifiés pour empêcher l'exécution de code malveillant.
• Flux de données : Définissez des contrats de données clairs pour les entrées et les sorties de chaque plugin.
• Marque blanche : Si vous construisez un flux destiné aux utilisateurs, n'oubliez pas que Didit offre de nombreuses options de personnalisation, vous permettant de personnaliser les couleurs, les polices, les logos et même d'utiliser un domaine personnalisé, garantissant une expérience de marque transparente. Cela est crucial pour maintenir la confiance des utilisateurs et réduire les taux d'abandon pendant le processus de vérification.

Comment Didit aide

Didit est conçu dès le départ pour ce type d'intégration modulaire et extensible. En tant que plateforme d'identité native de l'IA et axée sur les développeurs, Didit fournit les blocs de construction – ou « primitives » – qui peuvent être intégrés de manière transparente dans votre architecture de plugin Go. Notre architecture modulaire signifie que vous pouvez choisir les composants de vérification exacts dont vous avez besoin, qu'il s'agisse de la vérification d'identité, de la vivacité passive et active, de la correspondance faciale 1:1, du filtrage et de la surveillance AML, de la preuve d'adresse ou de l'estimation de l'âge. Chacun de ceux-ci peut être un plugin distinct dans votre système.

Didit se distingue en offrant un KYC Core gratuit, vous permettant de commencer avec les vérifications d'identité essentielles sans frais initiaux. Nos API épurées et notre documentation complète, ainsi qu'un sandbox instantané, rendent l'intégration intuitive et rapide. En tirant parti de Didit, vous déchargez la complexité de la maintenance de modèles d'IA sophistiqués, de bases de données de documents mondiales et de mises à jour de conformité, permettant à votre service Go de se concentrer sur l'orchestration et la logique métier. Le modèle de paiement par vérification réussie de Didit et l'absence de frais d'installation s'alignent également sur une architecture flexible et évolutive, garantissant que vous ne payez que ce que vous utilisez.

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.