Migrando Verificação de Identidade Legada com Strangler Fig e Didit (PT-BR)

Estratégia de Migração Incremental O padrão Strangler Fig permite uma migração gradual, onde a nova funcionalidade é construída ao lado do sistema antigo, substituindo progressivamente componentes legados sem reescritas disruptivas e "big-bang".

Minimizando Riscos e Tempo de Inatividade Ao isolar novas funcionalidades e rotear o tráfego seletivamente, as organizações podem reduzir o risco de falhas no sistema e manter a disponibilidade contínua do serviço durante a transição.

Aproveitando APIs Modernas A integração com a API da Didit permite o acesso a recursos de verificação de identidade nativos de IA, oferecendo detecção de fraude superior, conformidade e experiência do usuário em comparação com sistemas desatualizados.

Abordagem Modular e Developer-First da Didit A plataforma da Didit oferece uma arquitetura modular e orientada a API com KYC Core Gratuito, tornando-a ideal para adoção incremental e integração perfeita em aplicativos Spring Boot existentes.

O Desafio dos Sistemas Legados de Verificação de Identidade

Muitas organizações dependem de sistemas legados de verificação de identidade (IDV) que são difíceis de manter, caros para escalar e, muitas vezes, carecem dos recursos avançados de detecção de fraude das soluções modernas. A ideia de uma reformulação completa pode ser paralisante, levando à estagnação e ao aumento do risco. Esses sistemas mais antigos podem ter dificuldades com novos requisitos de conformidade, oferecer experiências de usuário ruins ou ser incapazes de detectar fraudes sofisticadas de deepfake e identidade sintética. A migração tradicional "big-bang", onde um sistema inteiro é substituído de uma vez, é cheia de riscos, potencial tempo de inatividade e custos de desenvolvimento significativos. É aí que uma abordagem mais estratégica e incremental se torna inestimável.

Apresentando o Padrão Strangler Fig para Migração de IDV

O padrão Strangler Fig, famoso por Martin Fowler, oferece uma solução elegante para migrar gradualmente um sistema legado, construindo novas funcionalidades em sua periferia, eventualmente "estrangulando" o sistema antigo até que ele possa ser desativado. Para a verificação de identidade, isso significa substituir funções específicas de IDV por chamadas para uma API moderna como a da Didit, enquanto o restante do aplicativo legado permanece intocado inicialmente. Este padrão é particularmente adequado para aplicativos Java/Spring Boot, permitindo que os desenvolvedores introduzam novos serviços e chamadas de API de forma incremental.

A ideia central envolve colocar uma fachada ou um gateway de API na frente do sistema legado. Novas solicitações são roteadas através deste gateway, que decide se as trata usando o novo sistema (Didit) ou as passa para o sistema legado. Com o tempo, mais e mais funcionalidades são migradas para o novo sistema, e os componentes legados são lentamente desativados. Essa abordagem minimiza o risco, permite a entrega contínua e fornece valor imediato dos recursos do novo sistema.

Implementando Strangler Fig com Spring Boot e Didit

Vamos considerar um cenário prático em um aplicativo Spring Boot. Imagine que você tem um serviço legado responsável pelo processamento de documentos de identidade e verificações de vivacidade. Você deseja substituí-lo pelos recursos avançados de Verificação de ID e Vivacidade Passiva e Ativa da Didit. Você pode introduzir um novo serviço Spring Boot, ou um componente dentro do seu serviço existente, que atua como o "estrangulador".

Etapa 1: Criar uma Camada de Proxy/Fachada

Desenvolva um novo componente Spring que intercepta chamadas destinadas à verificação de identidade. Este componente conterá a lógica para decidir se deve usar o sistema legado ou a Didit. Por exemplo, se você estiver migrando apenas novos registros de usuários, poderá roteá-los para a Didit, enquanto as reverificações de usuários existentes ainda podem passar pelo sistema legado inicialmente.

@Service
public class IdentityVerificationGateway {

    private final DiditApiClient diditApiClient;
    private final LegacyIdvService legacyIdvService;

    public IdentityVerificationGateway(DiditApiClient diditApiClient, LegacyIdvService legacyIdvService) {
        this.diditApiClient = diditApiClient;
        this.legacyIdvService = legacyIdvService;
    }

    public VerificationResult verifyIdentity(User user) {
        // Lógica para decidir se deve usar Didit ou legado
        if (user.isNewUser() || featureFlags.isDiditEnabledFor(user.getRegion())) {
            // Chamar a API Didit para Verificação de ID e Vivacidade
            return diditApiClient.performVerification(user);
        } else {
            // Retornar ao sistema legado
            return legacyIdvService.performVerification(user);
        }
    }
}

Etapa 2: Integrar a API da Didit

Dentro do seu DiditApiClient, você fará chamadas para os robustos endpoints da API da Didit. A arquitetura modular da Didit significa que você pode escolher os primitivos de identidade exatos de que precisa. Por exemplo, para realizar a Verificação de ID e Vivacidade, você normalmente iniciaria uma sessão e, em seguida, processaria os resultados. A API da Didit é verdadeiramente developer-first, oferecendo APIs limpas e um sandbox instantâneo para integração rápida.

@Service
public class DiditApiClient {

    private final RestTemplate restTemplate;
    private final String diditApiKey;
    private final String diditApiUrl;

    public DiditApiClient(@Value("${didit.api.key}") String diditApiKey,
                          @Value("${didit.api.url}") String diditApiUrl) {
        this.restTemplate = new RestTemplate();
        this.diditApiKey = diditApiKey;
        this.diditApiUrl = diditApiUrl;
    }

    public VerificationResult performVerification(User user) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("x-api-key", diditApiKey);
        headers.setContentType(MediaType.APPLICATION_JSON);

        // Exemplo: Criar uma sessão para Verificação de ID e Vivacidade
        // O workflow_id seria configurado no Console de Negócios da Didit
        // para a sequência de verificações desejada.
        String workflowId = "your-didit-workflow-id"; 
        Map<String, String> requestBody = Map.of("workflow_id", workflowId, "vendor_data", user.getUserId());

        HttpEntity<Map<String, String>> request = new HttpEntity<>(requestBody, headers);

        ResponseEntity<DiditSessionResponse> response = restTemplate.postForEntity(
            diditApiUrl + "/v3/session/", request, DiditSessionResponse.class);

        // Lidar com o URL da sessão, redirecionar o usuário e processar webhooks para resultados
        // Este exemplo simplificado assume resultados síncronos para brevidade.
        return new VerificationResult(response.getBody().getSessionId(), "PENDING");
    }
}

Lembre-se de que a Didit também oferece um Console de Negócios sem código para projetar Fluxos de Trabalho Orquestrados complexos, combinando elementos como Verificação de ID, Vivacidade Passiva e Ativa, Correspondência Facial 1:1, Triagem AML e Comprovante de Endereço. Isso permite que você defina sua jornada de verificação uma vez e, em seguida, a acione por meio de uma chamada de API simples, simplificando sua integração com o Spring Boot.

Etapa 3: Mudança Gradual de Tráfego e Monitoramento

Assim que a integração da Didit estiver em vigor, você pode mudar o tráfego gradualmente. Comece com uma pequena porcentagem de usuários, teste A/B ou habilite-o para coortes específicas. Monitore de perto o desempenho, a experiência do usuário e a precisão da verificação. As análises abrangentes e os recursos de webhook da Didit tornam esse processo de monitoramento eficiente, fornecendo atualizações em tempo real à medida que os usuários progridem na verificação. À medida que a confiança aumenta, você pode aumentar o tráfego roteado para a Didit, eventualmente desativando os componentes legados por completo.

Como a Didit Ajuda

A Didit está posicionada de forma única para facilitar migrações contínuas usando o padrão Strangler Fig. Nossa plataforma de identidade nativa de IA e developer-first oferece uma arquitetura modular que torna a integração de recursos avançados de verificação de identidade simples. Com a Didit, você obtém acesso a um conjunto de ferramentas poderosas:

• Verificação de ID (OCR, MRZ, códigos de barras): Extraia dados com precisão de documentos de identidade globalmente.
• Vivacidade Passiva e Ativa: Combata deepfakes e ataques de apresentação com detecção avançada de vivacidade biométrica.
• Correspondência Facial 1:1: Garanta que a pessoa que apresenta o ID seja seu legítimo proprietário.
• Triagem e Monitoramento AML: Mantenha a conformidade com as regulamentações globais, verificando listas de sanções e PEP.
• Comprovante de Endereço: Verifique endereços residenciais com eficiência.
• Estimativa de Idade (preservando a privacidade): Para conformidade em setores com restrição de idade sem comprometer a privacidade.
• Verificação de Telefone e E-mail: Aumente a segurança da conta e evite fraudes.

As vantagens da Didit são claras: oferecemos KYC Core Gratuito para você começar, uma arquitetura verdadeiramente modular que permite integrar apenas o que você precisa, e uma abordagem nativa de IA que oferece precisão de ponta e prevenção de fraudes. Nossa plataforma não tem taxas de configuração, e nossa ética developer-first garante APIs limpas e documentação extensa para integração rápida, alinhando-se perfeitamente com a natureza incremental do padrão Strangler Fig.

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 plano gratuito da Didit.