Aumente o Desempenho da API Didit com Python Asyncio (PT-PT-1)

Otimize o Consumo da API: O Python Asyncio permite operações de E/S não bloqueadoras, melhorando significativamente a eficiência das aplicações que fazem inúmeras chamadas de API para serviços como o Didit para verificação de identidade.

Controle o Rate Limiting: Implemente estratégias sofisticadas de controlo de taxa com Asyncio para se manter dentro dos limites da API da Didit, prevenindo erros 429 e garantindo a disponibilidade contínua do serviço para cenários de alto rendimento.

Construa Soluções Escaláveis: Aproveite o modelo de concorrência do Asyncio para projetar sistemas robustos e escaláveis, capazes de processar milhares de pedidos de verificação de identidade por segundo sem incorrer em altos custos de infraestrutura.

Vantagem API-First da Didit: A abordagem de desenvolvedor-primeiro da Didit, com APIs limpas e um ambiente de testes instantâneo, é ideal para integração com frameworks assíncronos, permitindo fluxos de trabalho de verificação de identidade contínuos e de alto desempenho, desde a verificação de ID até à deteção de vivacidade.

A Necessidade de Velocidade: Porquê Asyncio para Consumo de API?

No mundo digital acelerado de hoje, as aplicações muitas vezes precisam de realizar inúmeras chamadas de API externas para cumprir as suas funções. Quando estas chamadas são bloqueadoras, o que significa que a aplicação espera por cada resposta antes de prosseguir para a próxima, surgem rapidamente gargalos de desempenho. Isto é especialmente verdade para serviços de verificação de identidade, onde um único fluxo de integração do utilizador pode envolver múltiplas interações de API: verificação de ID, verificações de vivacidade passivas e ativas, correspondência facial 1:1 e triagem AML. Para empresas com altos volumes de utilizadores, estas operações sequenciais podem levar a atrasos significativos e a experiências de utilizador insatisfatórias.

A biblioteca asyncio do Python fornece um framework robusto para escrever código concorrente usando a sintaxe async/await. Ao contrário da multithreading tradicional, que pode introduzir complexidades como o Global Interpreter Lock (GIL) para tarefas de uso intensivo de CPU, o asyncio é projetado para operações ligadas a E/S. As chamadas de API são inerentemente ligadas a E/S (à espera de respostas de rede), tornando o asyncio um candidato ideal para sobrecarregar a capacidade da sua aplicação de consumir APIs externas de forma eficiente. Ao permitir que o seu programa execute outras tarefas enquanto espera pelas respostas da API, o asyncio pode aumentar drasticamente o rendimento sem exigir uma reescrita completa da arquitetura da sua aplicação num sistema distribuído.

Compreender o Cenário da API Didit e os Limites de Taxa

A Didit, como plataforma de identidade nativa de IA, oferece um conjunto abrangente de APIs para verificação de identidade, incluindo verificação de ID (OCR, MRZ, códigos de barras), vivacidade passiva e ativa, correspondência facial 1:1, triagem e monitorização AML, e muito mais. A nossa API é projetada para alto desempenho e fiabilidade, mas como todas as APIs robustas, emprega limitações de taxa para garantir estabilidade e uso justo em todos os clientes. Compreender estes limites é crucial para qualquer consumidor de alto rendimento.

A Didit impõe limites de taxa tanto globais como específicos para cada endpoint. Por exemplo, os limites globais são tipicamente de 300 pedidos por minuto por aplicação, tanto para endpoints GET como para Write/Delete. Limites mais restritivos aplicam-se a operações de alto impacto, como 600 RPM para POST /v2/session/ (para criar fluxos de trabalho de verificação) e 100 RPM para GET /v2/session/<id>/decision/ (para recuperar decisões de sessão). Quando estes limites são excedidos, a API retorna um código de estado 429 Too Many Requests, juntamente com cabeçalhos úteis como X-RateLimit-Limit, X-RateLimit-Remaining e Retry-After (segundos de época) para guiar a sua estratégia de recuo.

A implementação do asyncio permite gerir estes limites de taxa de forma muito mais eficaz. Em vez de um único thread bloqueador a atingir o limite, uma aplicação assíncrona pode inteligentemente enfileirar pedidos, implementar recuo exponencial e repetir chamadas falhadas sem bloquear o fluxo de toda a aplicação. Isto resulta num consumo de API mais suave e menos interrupções, garantindo que os seus processos de verificação de identidade permanecem ininterruptos mesmo durante picos de carga.

Implementar Asyncio para Chamadas Concorrentes à API Didit

A integração do asyncio com as APIs da Didit envolve o uso de um cliente HTTP assíncrono como o aiohttp. Aqui está um esquema conceptual de como pode estruturar as suas chamadas de API assíncronas:

import asyncio
import aiohttp
import time

API_KEY = "YOUR_DIDIT_API_KEY"
BASE_URL = "https://verification.didit.me/v3/"

async def call_didit_api(session, endpoint, payload=None, method='POST'):
    headers = {
        'accept': 'application/json',
        'x-api-key': API_KEY
    }
    if method == 'POST':
        headers['content-type'] = 'application/json'

    url = f"{BASE_URL}{endpoint}"
    
    async with session.request(method, url, json=payload, headers=headers) as response:
        if response.status == 429:
            retry_after = int(response.headers.get('Retry-After', '5'))
            print(f"Limite de taxa atingido. A tentar novamente após {retry_after} segundos...")
            await asyncio.sleep(retry_after) # Implementar um recuo simples
            return await call_didit_api(session, endpoint, payload, method) # Tentar novamente
        response.raise_for_status()
        return await response.json()

async def create_verification_session(session, workflow_id, user_id):
    endpoint = "session/"
    payload = {
        "workflow_id": workflow_id,
        "vendor_data": user_id,
        "callback": "https://your-app.com/didit-callback"
    }
    return await call_didit_api(session, endpoint, payload, method='POST')

async def get_session_decision(session, session_id):
    endpoint = f"session/{session_id}/decision/"
    return await call_didit_api(session, endpoint, method='GET')

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = []
        # Exemplo: Criar 10 sessões de verificação concorrentemente
        for i in range(10):
            tasks.append(create_verification_session(session, "YOUR_WORKFLOW_ID", f"user_{i}"))
        
        results = await asyncio.gather(*tasks)
        for res in results:
            print(f"Sessão criada: {res.get('session_id')}")

        # Exemplo: Recuperar decisões para algumas sessões concorrentemente
        decision_tasks = []
        for res in results[:5]: # Pegar as primeiras 5 para recuperação de decisão
            session_id = res.get('session_id')
            if session_id:
                decision_tasks.append(get_session_decision(session, session_id))
        
        decision_results = await asyncio.gather(*decision_tasks)
        for decision in decision_results:
            print(f"Decisão da sessão: {decision}")

if __name__ == "__main__":
    asyncio.run(main())

Este exemplo demonstra como criar múltiplas sessões de verificação e recuperar as suas decisões concorrentemente. A função call_didit_api inclui um mecanismo básico de repetição para 429 Too Many Requests, usando o cabeçalho Retry-After para implementar um recuo exponencial. Para sistemas de produção, seria recomendado um padrão de recuo e disjuntor mais sofisticado, mas isto ilustra o princípio central.

Ao usar asyncio.gather, pode iniciar múltiplos pedidos de API simultaneamente, permitindo que a sua aplicação processe outras tarefas ou espere por respostas concorrentemente, levando a ganhos significativos de desempenho em comparação com chamadas bloqueadoras sequenciais.

Estratégias para Verificação de Identidade de Alto Volume

Alcançar alto rendimento com as APIs Didit usando Asyncio requer mais do que apenas fazer pedidos concorrentemente. Considere estas estratégias:

• Agrupamento Inteligente: Embora a verificação principal da Didit seja frequentemente iniciada pelo utilizador, para operações como Monitorização AML ou certas pesquisas de dados, pode projetar fluxos de trabalho que permitam o processamento em lote quando aplicável, reduzindo o número total de chamadas de API.
• Limitação de Taxa Adaptativa: Para além do simples recuo exponencial, implemente um limitador de taxa adaptativo que monitorize X-RateLimit-Remaining e ajuste o nível de concorrência das suas tarefas asyncio dinamicamente. Se as chamadas restantes forem baixas, abrande; se forem altas, acelere.
• Atualizações por Webhook: Para resultados de sessão (por exemplo, após verificação de ID ou verificações de vivacidade), confie nos webhooks da Didit em vez de sondagens excessivas. Isto reduz o número de pedidos GET para /v2/session/<id>/decision/, que tem um limite de taxa mais rigoroso de 100 RPM. A arquitetura modular da Didit significa que pode configurar notificações de webhook para várias alterações de estado, enviando atualizações em tempo real para o seu sistema sem consultas constantes.
• Tratamento de Erros e Observabilidade: Implemente um tratamento de erros robusto para problemas de rede, erros de API (além de 429s) e tempos limite. Registe ou alerte quando as repetições são acionadas ou os limites de taxa são consistentemente atingidos. Isto fornece informações cruciais para otimizar a sua estratégia de consumo de API.
• Gestão de Recursos: Gerencie cuidadosamente as suas instâncias de aiohttp.ClientSession. Criar uma nova sessão para cada pedido é ineficiente devido à sobrecarga de conexão. Reutilizar uma única sessão para múltiplos pedidos é geralmente a melhor prática.

Como a Didit Ajuda

A Didit é construída de raiz para desenvolvedores e aplicações de alto desempenho, tornando-a um parceiro ideal para implementações Python Asyncio. A nossa arquitetura modular permite-lhe "plug-and-play" verificações de identidade como verificação de ID, vivacidade passiva e ativa, correspondência facial 1:1 e triagem AML conforme necessário, cada uma acessível através de APIs limpas e bem documentadas. Esta modularidade significa que pode orquestrar fluxos de trabalho de verificação complexos adaptados às suas necessidades específicas e, em seguida, otimizar o seu consumo usando técnicas assíncronas.

Acreditamos em tornar a verificação de identidade acessível, razão pela qual oferecemos Free Core KYC. Isto permite-lhe experimentar e construir as suas integrações assíncronas sem custos iniciais. A nossa abordagem nativa de IA garante que os nossos serviços de verificação são rápidos e precisos, complementando perfeitamente os benefícios de velocidade do Asyncio. Sem taxas de configuração e um modelo de pagamento por verificação bem-sucedida, a Didit fornece uma solução económica e escalável para empresas que procuram implementar verificação de identidade de alto rendimento. O nosso ambiente de testes instantâneo e a documentação abrangente da API capacitam ainda mais os desenvolvedores a integrar e otimizar rapidamente o uso dos serviços da Didit, quer esteja a construir um novo sistema ou a melhorar um existente.

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.