Verificações de Identidade Extensíveis em Go com Primitivos Didit (PT-PT)

Design Modular para AgilidadeConstruir uma arquitetura de plugin extensível em Go permite que as empresas se adaptem rapidamente às regulamentações de conformidade em evolução e a novos vetores de fraude, sem ter de reformular todo o seu sistema de verificação de identidade.

Aproveite os Pontos Fortes do GoA tipagem forte, o desempenho e as funcionalidades de concorrência do Go tornam-no uma linguagem ideal para desenvolver serviços de verificação de identidade robustos e escaláveis, capazes de lidar com alto débito.

Composição com Primitivos DiditA integração dos primitivos de identidade nativos de IA da Didit, como Verificação de Documento, Liveness Passiva & Ativa e Análise AML, fornece componentes poderosos e pré-construídos que podem ser orquestrados dentro de plugins Go personalizados.

Abordagem Developer-First da DiditAs APIs limpas da Didit, o sandbox instantâneo e a arquitetura modular são perfeitamente adequados para programadores que criam sistemas extensíveis, oferecendo KYC Essencial Gratuito e sem taxas de configuração para acelerar o desenvolvimento.

A Necessidade de Verificação de Identidade Extensível

No panorama digital em rápida mudança de hoje, a verificação de identidade (IDV) já não é um processo estático. As regulamentações evoluem, novas técnicas de fraude surgem e as necessidades de negócio mudam. Um sistema IDV rígido e monolítico rapidamente se torna um gargalo, dificultando a inovação e aumentando os riscos de conformidade. É por isso que uma arquitetura de plugin extensível não é apenas um luxo, mas uma necessidade, especialmente para programadores que trabalham com linguagens de alto desempenho como o Go.

Uma arquitetura extensível permite que as empresas adicionem, removam ou modifiquem verificações de identidade dinamicamente sem reimplantar todo o serviço. Esta agilidade é crucial para se adaptar aos requisitos de KYC (Know Your Customer) específicos da região, integrar mecanismos de deteção de fraude de ponta ou experimentar novos fluxos de integração de utilizadores. Por exemplo, uma empresa pode inicialmente exigir Verificação de Documento básica e Deteção de Liveness. Mais tarde, poderá precisar de adicionar Estimativa de Idade para produtos específicos ou incorporar Análise AML para transações financeiras. Um sistema baseado em plugins lida com estas adições de forma integrada.

Conceber uma Arquitetura de Plugin em Go

O design impulsionado por interfaces e a tipagem forte do Go tornam-no uma excelente escolha para construir sistemas de plugins robustos. A ideia central é definir uma interface comum que todos os "plugins" de verificação de identidade devem implementar. Esta interface atua como um contrato, garantindo que qualquer nova verificação possa ser integrada de forma transparente no fluxo de trabalho existente.

Definir a Interface de Verificação de Identidade

Consideremos uma interface simples para uma verificação de identidade:

package main

type IdentityCheckResult struct {
    Passed  bool
    Details string
}

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

Aqui, IdentityChecker define dois métodos: Name() para identificar o plugin e Execute() para realizar a verificação real, recebendo dados de entrada genéricos e retornando um resultado. Esta abstração permite diversas verificações, desde a verificação de documentos até à análise biométrica.

Implementar Verificações Personalizadas com os Primitivos da Didit

Agora, vejamos como podemos implementar verificações de identidade específicas usando os poderosos primitivos da Didit dentro desta estrutura de plugin. A arquitetura modular, as APIs limpas e as capacidades nativas de IA da Didit tornam a integração destes serviços avançados simples.

Exemplo: Plugin de Verificação de Documento Didit

Para a verificação de identidade baseada em documentos, podemos criar um plugin que aproveita o produto de Verificação de Documento da Didit, que inclui OCR, MRZ e leitura de código de barras em mais de 220 países. Este plugin enviaria imagens e dados de documentos para a API da Didit e processaria a 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
    }

    // Numa aplicação real, enviaria a imagem para a API de Verificação de Documento da Didit.
    // Para este exemplo, simularemos uma chamada.
    // Documentação: https://docs.didit.me/core-technology/id-verification

    // Simular chamada de API para a Verificação de Documento da Didit
    // Substituir por chamada de API real e tratamento de erros
    fmt.Printf("A chamar a Verificação de Documento da Didit para a imagem: %s...\n", documentImage[:20]) // Truncar para exibição
    
    // Assumir uma resposta bem-sucedida para demonstração
    if documentImage != "invalid_id_image" {
        return IdentityCheckResult{Passed: true, Details: "Documento de identidade verificado pela Didit."}, nil
    } else {
        return IdentityCheckResult{Passed: false, Details: "A verificação do documento de identidade falhou pela Didit." + " Imagem inválida fornecida."}, 
            fmt.Errorf("A verificação de documento de identidade da Didit falhou")
    }
}

Exemplo: Plugin de Verificação de Liveness Didit

Para combater deepfakes e ataques de apresentação, uma verificação de liveness é essencial. A Didit oferece deteção de Liveness Passiva & Ativa. Um plugin poderia integrar isto, processando um pequeno vídeo ou uma série de imagens.

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
    }

    // Simular chamada de API para a Deteção de Liveness da Didit
    // Substituir por chamada de API real e tratamento de erros
    fmt.Printf("A chamar a Deteção de Liveness da Didit para o vídeo: %s...\n", livenessVideo[:20])

    if livenessVideo != "deepfake_video" {
        return IdentityCheckResult{Passed: true, Details: "Liveness detetada pela Didit."}, nil
    } else {
        return IdentityCheckResult{Passed: false, Details: "A deteção de liveness falhou pela Didit." + " Deepfake detetado."}, 
            fmt.Errorf("A deteção de Liveness da Didit falhou")
    }
}

Orquestrar Fluxos de Trabalho com Plugins

Depois de ter os seus plugins, precisa de um mecanismo para os orquestrar num fluxo de trabalho coerente. Os Fluxos de Trabalho Orquestrados da Didit fornecem um construtor visual sem código para isso, mas se estiver a construir um serviço Go personalizado, pode gerir esta lógica programaticamente.

package main

import "fmt"

// Um orquestrador simples
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("\nA executar a verificação %s...\n", check.Name())
        res, err := check.Execute(userData)
        results = append(results, res)
        if err != nil || !res.Passed {
            fmt.Printf("A verificação %s falhou: %s\n", check.Name(), res.Details)
            return results, fmt.Errorf("O fluxo de trabalho falhou em %s: %w", check.Name(), err)
        }
        fmt.Printf("A verificação %s passou: %s\n", check.Name(), res.Details)
    }
    return results, nil
}

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

    // Exemplo de dados de utilizador
    userData := map[string]interface{}{
        "documentImage": "valid_passport_image_base64",
        "livenessVideo": "valid_liveness_video_base64",
        "name":          "Jane Doe",
    }

    fmt.Println("--- A executar fluxo de trabalho bem-sucedido ---")
    results, err := workflow.Run(userData)
    if err != nil {
        fmt.Printf("O fluxo de trabalho foi concluído com erros: %v\n", err)
    } else {
        fmt.Println("O fluxo de trabalho foi concluído com sucesso!")
    }
    for _, r := range results {
        fmt.Printf("- %s: Passou = %t, Detalhes = %s\n", r.Name, r.Passed, r.Details)
    }

    // Exemplo de um fluxo de trabalho com falha
    fmt.Println("\n--- A executar fluxo de trabalho com falha (ID inválido) ---")
    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("O fluxo de trabalho foi concluído com erros: %v\n", err)
    } else {
        fmt.Println("O fluxo de trabalho foi concluído com sucesso!")
    }
    for _, r := range failingResults {
        fmt.Printf("- %s: Passou = %t, Detalhes = %s\n", r.Name, r.Passed, r.Details)
    }
}

Este orquestrador simples executa verificações sequencialmente. Num cenário do mundo real, poderá adicionar lógica condicional, execução paralela ou retentativas, espelhando as capacidades do construtor de fluxo de trabalho sem código da Didit.

Considerações Avançadas para Arquiteturas de Plugin Go

Ao construir uma arquitetura de plugin pronta para produção em Go, considere estes aspetos:

• Tratamento de Erros: Implemente tratamento de erros robusto e registo para cada plugin.
• Configuração: Permita que os plugins sejam configurados dinamicamente (por exemplo, chaves de API, limiares).
• Carregamento de Plugins: Para uma verdadeira extensibilidade sem recompilação, explore o pacote plugin do Go (embora tenha limitações de plataforma) ou processos externos/gRPC para comunicação interprocessos.
• Segurança: Garanta que os plugins são isolados ou devidamente verificados para evitar a execução de código malicioso.
• Fluxo de Dados: Defina contratos de dados claros para entradas e saídas de cada plugin.
• White-Labeling: Se estiver a construir um fluxo direcionado ao utilizador, lembre-se de que a Didit oferece extensas opções de white-labeling, permitindo-lhe personalizar cores, tipos de letra, logótipos e até usar um domínio personalizado, garantindo uma experiência de marca perfeita. Isto é crucial para manter a confiança do utilizador e reduzir as taxas de abandono durante o processo de verificação.

Como a Didit Ajuda

A Didit foi concebida de raiz para este tipo de integração modular e extensível. Como plataforma de identidade nativa de IA e focada no programador, a Didit fornece os blocos de construção – ou "primitivos" – que podem ser perfeitamente integrados na sua arquitetura de plugin Go. A nossa arquitetura modular significa que pode escolher os componentes de verificação exatos de que necessita, seja Verificação de Documento, Liveness Passiva & Ativa, Correspondência Facial 1:1, Análise e Monitorização AML, Comprovativo de Morada ou Estimativa de Idade. Cada um destes pode ser um plugin distinto no seu sistema.

A Didit destaca-se por oferecer KYC Essencial Gratuito, permitindo-lhe começar com verificações de identidade essenciais sem custos iniciais. As nossas APIs limpas e documentação abrangente, juntamente com um sandbox instantâneo, tornam a integração intuitiva e rápida. Ao aproveitar a Didit, você descarrega a complexidade de manter modelos de IA sofisticados, bases de dados globais de documentos e atualizações de conformidade, permitindo que o seu serviço Go se concentre na orquestração e na lógica de negócio. O modelo de pagamento por verificação bem-sucedida da Didit e a ausência de taxas de configuração alinham-se ainda mais com uma arquitetura flexível e escalável, garantindo que paga apenas pelo que usa.

Pronto para Começar?

Pronto para ver a Didit em ação? Obtenha uma demonstração gratuita hoje.

Comece a verificar identidades gratuitamente com o nível gratuito da Didit.