Verificacions d'Identitat Extensibles a Go amb les Primitives de Didit (CA)

Disseny Modular per a l'AgilitatConstruir una arquitectura de connectors extensible a Go permet a les empreses adaptar-se ràpidament a les regulacions de compliment en evolució i als nous vectors de frau sense haver de revisar tot el seu sistema de verificació d'identitat.

Aprofita els Punts Forts de GoLa forta tipificació, el rendiment i les característiques de concurrència de Go el converteixen en un llenguatge ideal per desenvolupar serveis de verificació d'identitat robustos i escalables capaços de gestionar un alt rendiment.

Composabilitat amb les Primitives de DiditLa integració de les primitives d'identitat natives d'IA de Didit, com la verificació d'identitat, la vivacitat passiva i activa, i el cribratge AML, proporciona components potents i preconstruïts que es poden orquestrar dins de connectors Go personalitzats.

L'Enfocament Developer-First de DiditLes API netes de Didit, el sandbox instantani i l'arquitectura modular són perfectament adequats per a desenvolupadors que construeixen sistemes extensibles, oferint KYC Core gratuït i sense tarifes de configuració per accelerar el desenvolupament.

La Necessitat de la Verificació d'Identitat Extensible

En el panorama digital actual en ràpida evolució, la verificació d'identitat (IDV) ja no és un procés estàtic. Les regulacions evolucionen, sorgeixen noves tècniques de frau i les necessitats empresarials canvien. Un sistema IDV rígid i monolític es converteix ràpidament en un coll d'ampolla, dificultant la innovació i augmentant els riscos de compliment. Per això, una arquitectura de connectors extensible no és només un luxe, sinó una necessitat, especialment per als desenvolupadors que treballen amb llenguatges d'alt rendiment com Go.

Una arquitectura extensible permet a les empreses afegir, eliminar o modificar les comprovacions d'identitat de manera dinàmica sense tornar a desplegar tot el servei. Aquesta agilitat és crucial per adaptar-se als requisits KYC (Know Your Customer) específics de la regió, integrar mecanismes de detecció de frau d'avantguarda o experimentar amb nous fluxos d'incorporació d'usuaris. Per exemple, una empresa podria requerir inicialment una verificació d'identitat bàsica i detecció de vivacitat. Més tard, podria necessitar afegir una estimació d'edat per a productes específics o incorporar cribratge AML per a transaccions financeres. Un sistema basat en connectors gestiona aquestes addicions sense problemes.

Dissenyant una Arquitectura de Connectors a Go

El disseny basat en interfícies i la forta tipificació de Go el converteixen en una excel·lent opció per construir sistemes de connectors robustos. La idea principal és definir una interfície comuna que tots els "connectors" de comprovació d'identitat han d'implementar. Aquesta interfície actua com un contracte, assegurant que qualsevol nova comprovació es pugui integrar perfectament en el flux de treball existent.

Definint la Interfície de Comprovació d'Identitat

Considerem una interfície senzilla per a una comprovació d'identitat:

package main

type IdentityCheckResult struct {
    Passed  bool
    Details string
}

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

Aquí, IdentityChecker defineix dos mètodes: Name() per identificar el connector i Execute() per realitzar la comprovació real, prenent dades d'entrada genèriques i retornant un resultat. Aquesta abstracció permet comprovacions diverses, des de la verificació de documents fins a l'anàlisi biomètrica.

Implementant Comprovacions Personalitzades amb les Primitives de Didit

Ara, vegem com podem implementar comprovacions d'identitat específiques utilitzant les potents primitives de Didit dins d'aquest marc de connectors. L'arquitectura modular de Didit, les API netes i les capacitats natives d'IA faciliten la integració d'aquests serveis avançats.

Exemple: Connector de Verificació d'Identitat de Didit

Per a la verificació d'identitat basada en documents, podem crear un connector que aprofiti el producte de verificació d'identitat de Didit, que inclou OCR, MRZ i escaneig de codi de barres en més de 220 països. Aquest connector enviaria imatges de documents i dades a l'API de Didit i processaria la resposta.

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
    }

    // En una aplicació real, enviaríeu la imatge a l'API de verificació d'identitat de Didit.
    // Per a aquest exemple, simularem una crida.
    // Documentació: https://docs.didit.me/core-technology/id-verification

    // Simula la crida a l'API de verificació d'identitat de Didit
    // Substitueix per la crida a l'API real i la gestió d'errors
    fmt.Printf("S'està cridant la verificació d'identitat de Didit per a la imatge: %s...\n", documentImage[:20]) // Trunca per a la visualització
    
    // Assumeix una resposta exitosa per a la demostració
    if documentImage != "invalid_id_image" {
        return IdentityCheckResult{Passed: true, Details: "Document d'identitat verificat per Didit."}, nil
    } else {
        return IdentityCheckResult{Passed: false, Details: "La verificació del document d'identitat ha fallat per Didit." + " S'ha proporcionat una imatge no vàlida."}, 
            fmt.Errorf("La verificació d'identitat de Didit ha fallat")
    }
}

Exemple: Connector de Comprovació de Vivacitat de Didit

Per combatre els deepfakes i els atacs de presentació, una comprovació de vivacitat és essencial. Didit ofereix detecció de vivacitat passiva i activa. Un connector podria integrar-ho, processant un vídeo curt o una sèrie d'imatges.

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
    }

    // Simula la crida a l'API de detecció de vivacitat de Didit
    // Substitueix per la crida a l'API real i la gestió d'errors
    fmt.Printf("S'està cridant la detecció de vivacitat de Didit per al vídeo: %s...\n", livenessVideo[:20])

    if livenessVideo != "deepfake_video" {
        return IdentityCheckResult{Passed: true, Details: "Vivacitat detectada per Didit."}, nil
    } else {
        return IdentityCheckResult{Passed: false, Details: "La detecció de vivacitat ha fallat per Didit." + " Deepfake detectat."}, 
            fmt.Errorf("La detecció de vivacitat de Didit ha fallat")
    }
}

Orquestrant Fluxos de Treball amb Connectors

Un cop tinguis els teus connectors, necessites un mecanisme per orquestrar-los en un flux de treball coherent. Els fluxos de treball orquestrats de Didit proporcionen un constructor visual sense codi per a això, però si estàs construint un servei Go personalitzat, pots gestionar aquesta lògica programàticament.

package main

import "fmt"

// Un orquestrador senzill
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("\nExecutant la comprovació %s...\n", check.Name())
        res, err := check.Execute(userData)
        results = append(results, res)
        if err != nil || !res.Passed {
            fmt.Printf("La comprovació %s ha fallat: %s\n", check.Name(), res.Details)
            return results, fmt.Errorf("el flux de treball ha fallat a %s: %w", check.Name(), err)
        }
        fmt.Printf("La comprovació %s ha passat: %s\n", check.Name(), res.Details)
    }
    return results, nil
}

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

    // Dades d'usuari d'exemple
    userData := map[string]interface{}{
        "documentImage": "valid_passport_image_base64",
        "livenessVideo": "valid_liveness_video_base64",
        "name":          "Jane Doe",
    }

    fmt.Println("--- Executant flux de treball exitós ---")
    results, err := workflow.Run(userData)
    if err != nil {
        fmt.Printf("El flux de treball ha finalitzat amb errors: %v\n", err)
    } else {
        fmt.Println("El flux de treball ha finalitzat amb èxit!")
    }
    for _, r := range results {
        fmt.Printf("- %s: Passat = %t, Detalls = %s\n", r.Name, r.Passed, r.Details)
    }

    // Exemple d'un flux de treball que falla
    fmt.Println("\n--- Executant flux de treball que falla (ID no vàlida) ---")
    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("El flux de treball ha finalitzat amb errors: %v\n", err)
    } else {
        fmt.Println("El flux de treball ha finalitzat amb èxit!")
    }
    for _, r := range failingResults {
        fmt.Printf("- %s: Passat = %t, Detalls = %s\n", r.Name, r.Passed, r.Details)
    }
}

Aquest orquestrador senzill executa comprovacions seqüencialment. En un escenari del món real, podríeu afegir lògica condicional, execució paral·lela o reintents, reflectint les capacitats del constructor de fluxos de treball sense codi de Didit.

Consideracions Avançades per a Arquitectures de Connectors Go

Quan construeixis una arquitectura de connectors preparada per a la producció a Go, considera aquests aspectes:

• Gestió d'Errors: Implementa una gestió d'errors i un registre robustos per a cada connector.
• Configuració: Permet que els connectors es configurin dinàmicament (per exemple, claus API, llindars).
• Càrrega de Connectors: Per a una veritable extensibilitat sense recompilació, explora el paquet plugin de Go (tot i que té limitacions de plataforma) o processos externs/gRPC per a la comunicació entre processos.
• Seguretat: Assegura que els connectors estiguin en un sandbox o degudament verificats per evitar l'execució de codi maliciós.
• Flux de Dades: Defineix contractes de dades clars per a les entrades i sortides de cada connector.
• Etiquetatge Blanc (White-Labeling): Si estàs construint un flux de cara a l'usuari, recorda que Didit ofereix àmplies opcions d'etiquetatge blanc, que et permeten personalitzar colors, tipus de lletra, logotips i fins i tot utilitzar un domini personalitzat, assegurant una experiència de marca perfecta. Això és crucial per mantenir la confiança de l'usuari i reduir les taxes d'abandonament durant el procés de verificació.

Com Ajuda Didit

Didit està dissenyat des de zero precisament per a aquest tipus d'integració modular i extensible. Com a plataforma d'identitat nativa d'IA i orientada al desenvolupador, Didit proporciona els blocs de construcció —o "primitives"— que es poden integrar perfectament en la teva arquitectura de connectors Go. La nostra arquitectura modular significa que pots triar els components de verificació exactes que necessites, ja sigui la verificació d'identitat, la vivacitat passiva i activa, la concordança facial 1:1, el cribratge i monitorització AML, la prova d'adreça o l'estimació d'edat. Cadascun d'aquests pot ser un connector diferent al teu sistema.

Didit destaca per oferir KYC Core gratuït, el que et permet començar amb comprovacions d'identitat essencials sense costos inicials. Les nostres API netes i la documentació completa, juntament amb un sandbox instantani, fan que la integració sigui intuïtiva i ràpida. Aprofitant Didit, descàrregues la complexitat de mantenir models d'IA sofisticats, bases de dades de documents globals i actualitzacions de compliment, permetent al teu servei Go centrar-se en l'orquestració i la lògica de negoci. El model de pagament per comprovació exitosa de Didit i l'absència de tarifes de configuració s'alineen encara més amb una arquitectura flexible i escalable, assegurant que només pagues pel que utilitzes.

A punt per començar?

A punt per veure Didit en acció? Obté una demostració gratuïta avui.

Comença a verificar identitats gratuïtament amb el nivell gratuït de Didit.