Penanganan Kesalahan Tingkat Lanjut dalam Alur Kerja Verifikasi Identitas Asinkron (ID)

Percobaan Ulang yang KuatTerapkan exponential backoff dan jitter untuk kesalahan sementara dalam panggilan API ke layanan verifikasi identitas eksternal, mencegah kelebihan beban sistem dan meningkatkan tingkat keberhasilan.

Pola Pemutus SirkuitLindungi sistem Anda dari kegagalan beruntun dengan menghentikan sementara permintaan ke layanan yang gagal, memungkinkan layanan tersebut pulih dan menjaga stabilitas aplikasi secara keseluruhan.

Pencatatan & Pemantauan KomprehensifManfaatkan pencatatan terstruktur, ID korelasi, dan pemantauan waktu nyata untuk dengan cepat mengidentifikasi, mendiagnosis, dan menyelesaikan masalah dalam alur verifikasi identitas asinkron terdistribusi.

Ketahanan Bawaan DiditPlatform modular dan asli AI Didit menawarkan alur kerja terorkestrasi dan desain API yang kuat, mengabstraksi penanganan kesalahan yang kompleks untuk pemeriksaan KYC, kelangsungan hidup, dan AML inti, meningkatkan keandalan dan pengalaman pengembang.

Dalam dunia verifikasi identitas, kecepatan dan keandalan adalah yang terpenting. Seiring pertumbuhan bisnis, alur kerja asinkron menjadi penting untuk menangani volume permintaan yang tinggi tanpa memblokir utas aplikasi utama. Namun, sifat terdistribusi dan non-pemblokiran ini menimbulkan kompleksitas yang signifikan, terutama dalam hal penanganan kesalahan. Masalah jaringan, pemadaman layanan, inkonsistensi data, dan respons API yang tidak terduga semuanya dapat menggagalkan proses verifikasi identitas, menyebabkan pengalaman pengguna yang buruk, risiko kepatuhan, dan inefisiensi operasional.

Tulisan blog ini membahas strategi penanganan kesalahan tingkat lanjut untuk alur kerja verifikasi identitas asinkron, khususnya berfokus pada implementasi Python. Kami akan mengeksplorasi cara membangun sistem yang lebih tangguh dan toleran terhadap kesalahan, memastikan bahwa bahkan ketika ada masalah, proses verifikasi Anda tetap kuat.

Tantangan Kesalahan Asinkron dalam Verifikasi Identitas

Verifikasi identitas asinkron sering melibatkan beberapa layanan eksternal: penyedia Verifikasi ID seperti Didit untuk pemeriksaan OCR dan kelangsungan hidup, layanan penyaringan AML, database bukti alamat, dan mungkin sumber data lainnya. Setiap interaksi ini adalah titik potensial kegagalan. Penanganan kesalahan sinkron tradisional (misalnya, blok try-except sederhana) tidak cukup ketika operasi mungkin selesai jauh kemudian, dalam proses yang berbeda, atau bahkan gagal secara diam-diam tanpa umpan balik segera.

Pertimbangkan alur kerja KYC yang khas: pengguna mengunggah ID mereka, pemeriksaan kelangsungan hidup dilakukan, dan kemudian penyaringan AML dimulai. Jika layanan pemeriksaan kelangsungan hidup mengalami masalah jaringan sementara, mencoba lagi segera mungkin memperburuk masalah. Jika layanan AML benar-benar mati, upaya berulang hanya akan membuang-buang sumber daya dan menunda onboarding pengguna.

Menerapkan Percobaan Ulang yang Kuat dengan Exponential Backoff dan Jitter

Salah satu jenis kesalahan yang paling umum dalam sistem terdistribusi adalah kegagalan sementara. Ini adalah masalah sementara seperti gangguan jaringan, kesalahan layanan sibuk, atau perebutan database yang menyelesaikan sendiri setelah periode singkat. Mencoba lagi secara membabi buta segera setelah kegagalan dapat membebani layanan yang sedang kesulitan, menyebabkan kegagalan beruntun. Solusinya adalah percobaan ulang cerdas menggunakan exponential backoff dan jitter.

Exponential backoff melibatkan peningkatan waktu tunggu antara percobaan ulang secara eksponensial. Misalnya, tunggu 1 detik, lalu 2, lalu 4, lalu 8, dan seterusnya. Ini memberi waktu layanan untuk pulih. Jitter menambahkan penundaan acak kecil ke waktu backoff, mencegah semua klien mencoba lagi pada saat yang bersamaan, yang dapat menciptakan masalah thundering herd.

import asyncio
import random

async def call_didit_api(data, attempt=0):
    max_retries = 5
    base_delay = 1  # seconds

    try:
        # Simulate an API call to Didit's ID Verification or Liveness service
        if random.random() < 0.6 and attempt < 3: # Simulate transient failure
            raise ConnectionError(f"Simulated API error on attempt {attempt+1}")

        print(f"Successfully called Didit API on attempt {attempt+1} with data: {data}")
        return {"status": "success", "result": "verification_data"}

    except (ConnectionError, asyncio.TimeoutError) as e:
        if attempt < max_retries - 1:
            delay = base_delay * (2 ** attempt) + random.uniform(0, 0.5) # Exponential backoff + jitter
            print(f"Attempt {attempt+1} failed: {e}. Retrying in {delay:.2f} seconds...")
            await asyncio.sleep(delay)
            return await call_didit_api(data, attempt + 1)
        else:
            print(f"All {max_retries} attempts failed for data: {data}")
            raise # Re-raise the last exception if all retries fail

async def main():
    try:
        # Example usage for Didit's ID Verification
        result = await call_didit_api({"document_image": "base64_id_scan"})
        print(f"Final result: {result}")

        # Example usage for Didit's Liveness
        result_liveness = await call_didit_api({"liveness_video": "base64_video"})
        print(f"Final liveness result: {result_liveness}")

    except Exception as e:
        print(f"Workflow failed after retries: {e}")

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

Pola ini sangat berharga saat berintegrasi dengan layanan eksternal, termasuk Verifikasi ID Didit, Liveness Pasif & Aktif, atau API Penyaringan AML, yang semuanya mendapat manfaat dari komunikasi yang tangguh.

Menerapkan Pola Pemutus Sirkuit

Meskipun percobaan ulang membantu mengatasi kesalahan sementara, hal itu dapat memperburuk situasi jika layanan mengalami pemadaman yang berkepanjangan. Pola pemutus sirkuit mencegah aplikasi Anda berulang kali memanggil layanan yang kemungkinan akan gagal. Ini bekerja dengan memantau kegagalan, dan jika melebihi ambang batas tertentu dalam waktu tertentu, ia "memutus" sirkuit, membukanya untuk mencegah panggilan lebih lanjut ke layanan yang gagal. Setelah waktu habis yang dapat dikonfigurasi, ia memasuki status "setengah terbuka", memungkinkan beberapa permintaan pengujian untuk melihat apakah layanan telah pulih.

import asyncio
import time
from collections import deque

class CircuitBreaker:
    def __init__(self, failure_threshold=3, recovery_timeout=10, half_open_attempts=1):
        self.state = "CLOSED"
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.half_open_attempts = half_open_attempts
        self.failures = 0
        self.last_failure_time = None
        self.successes_in_half_open = 0

    async def __call__(self, func, *args, **kwargs):
        if self.state == "OPEN":
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.state = "HALF_OPEN"
                self.successes_in_half_open = 0
                print("Circuit Breaker: Moving to HALF_OPEN state.")
            else:
                raise CircuitBreakerOpenError("Circuit is OPEN. Service is likely down.")

        try:
            result = await func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure(e)
            raise

    def _on_success(self):
        if self.state == "HALF_OPEN":
            self.successes_in_half_open += 1
            if self.successes_in_half_open >= self.half_open_attempts:
                self.state = "CLOSED"
                self.failures = 0
                print("Circuit Breaker: Service recovered. Moving to CLOSED state.")
        elif self.state == "CLOSED":
            self.failures = 0 # Reset failures on success in closed state

    def _on_failure(self, error):
        if self.state == "HALF_OPEN":
            self.state = "OPEN"
            self.last_failure_time = time.time()
            print(f"Circuit Breaker: Failure in HALF_OPEN. Moving to OPEN state. Error: {error}")
        elif self.state == "CLOSED":
            self.failures += 1
            if self.failures >= self.failure_threshold:
                self.state = "OPEN"
                self.last_failure_time = time.time()
                print(f"Circuit Breaker: Failures exceeded threshold. Moving to OPEN state. Error: {error}")

class CircuitBreakerOpenError(Exception):
    pass

# Example usage with a simulated Didit AML Screening call
async def simulate_aml_screening():
    if random.random() < 0.7: # Simulate frequent failures
        raise ConnectionError("AML service unavailable")
    await asyncio.sleep(0.1)
    return {"aml_status": "clear"}

async def main():
    cb = CircuitBreaker()
    for i in range(20):
        try:
            print(f"--- Attempt {i+1} ---")
            result = await cb(simulate_aml_screening)
            print(f"AML Screening Success: {result}")
        except CircuitBreakerOpenError as e:
            print(f"Caught: {e}")
            await asyncio.sleep(1) # Wait a bit before next attempt if circuit is open
        except ConnectionError as e:
            print(f"Caught: {e}")
        await asyncio.sleep(0.5)

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

Pola ini sangat berguna untuk layanan penting seperti Penyaringan AML Didit atau operasi Pencarian Wajah skala besar, di mana dependensi yang gagal dapat memengaruhi banyak pengguna.

Pencatatan, Pemantauan, dan Peringatan Komprehensif

Bahkan dengan percobaan ulang dan pemutus sirkuit yang kuat, kesalahan akan terjadi. Kuncinya adalah mengetahui kapan itu terjadi, memahami alasannya, dan bereaksi dengan cepat. Pencatatan komprehensif, pemantauan waktu nyata, dan peringatan proaktif tidak dapat dinegosiasikan untuk alur kerja asinkron.

• Pencatatan Terstruktur: Pesan log harus dalam format yang dapat dibaca mesin (misalnya, JSON) dan menyertakan konteks seperti session_id, workflow_id, nama layanan, stempel waktu, dan jenis kesalahan. Ini memungkinkan agregasi dan analisis yang mudah.
• ID Korelasi: Tetapkan ID korelasi unik untuk setiap permintaan verifikasi identitas pada titik masuknya dan teruskan melalui semua panggilan layanan berikutnya. Ini memungkinkan Anda untuk melacak perjalanan satu pengguna melalui sistem terdistribusi yang kompleks, bahkan saat menggunakan layanan modular seperti Verifikasi ID dan Estimasi Usia Didit.
• Dasbor Pemantauan: Visualisasikan metrik utama seperti tingkat keberhasilan API, latensi, tingkat kesalahan, dan panjang antrean untuk setiap komponen alur kerja Anda. Alat seperti Prometheus, Grafana, atau layanan pemantauan cloud-native sangat berharga.
• Peringatan: Siapkan peringatan untuk ambang batas kritis (misalnya, tingkat kesalahan melebihi 5% selama 5 menit, atau layanan tertentu tidak dapat dijangkau). Peringatan harus dikirim ke tim yang tepat melalui PagerDuty, Slack, atau email, memungkinkan tindakan segera.

Misalnya, saat pengguna memulai sesi verifikasi menggunakan Alur Kerja Terorkestrasi Didit, session_id dibuat. ID ini harus ditangkap dalam log Anda untuk setiap langkah, mulai dari panggilan API awal ke Didit hingga panggilan balik webhook terakhir dengan hasil verifikasi. Jika masalah muncul, Anda dapat dengan cepat memfilter log berdasarkan session_id ini untuk menunjukkan titik kegagalan yang tepat.

Bagaimana Didit Membantu

Didit, sebagai platform identitas asli AI yang mengutamakan pengembang, dirancang untuk menyederhanakan alur kerja verifikasi identitas yang kompleks, termasuk tantangan penanganan kesalahan yang melekat. Arsitektur modular kami berarti bahwa meskipun Anda dapat membangun solusi yang sangat disesuaikan, sebagian besar ketahanan yang mendasarinya ditangani untuk Anda.

• Alur Kerja Terorkestrasi: Mesin alur kerja tanpa kode Didit memungkinkan Anda menentukan urutan verifikasi yang kompleks (misalnya, Verifikasi ID + Liveness + Penyaringan AML) tanpa menulis kode ekstensif untuk orkestrasi atau manajemen status. Didit menangani percobaan ulang internal dan transisi status, secara signifikan mengurangi beban penanganan kesalahan di pihak Anda.
• API dan Webhook yang Kuat: API kami yang bersih dibangun untuk keandalan, dan sistem webhook kami menyediakan pembaruan waktu nyata tentang status verifikasi. Didit mengelola pengiriman webhook ini dengan mekanisme percobaan ulang bawaan, memastikan Anda menerima pembaruan penting bahkan jika titik akhir Anda sementara tidak tersedia.
• KYC Inti Gratis: Mulai dengan verifikasi identitas penting, termasuk Verifikasi ID (OCR, MRZ, kode batang) dan Liveness Pasif & Aktif, tanpa biaya di muka. Ini memungkinkan Anda untuk menerapkan verifikasi yang kuat tanpa khawatir tentang ketahanan infrastruktur yang mendasarinya.
• Keandalan Asli AI: Sistem berbasis AI kami secara inheren dirancang untuk ketersediaan dan kinerja tinggi, meminimalkan kesalahan internal dan memberikan hasil yang konsisten untuk produk seperti Pencocokan Wajah 1:1 dan Estimasi Usia.
• Data Identitas Terstruktur: Semua hasil verifikasi disediakan sebagai data terstruktur, membuatnya lebih mudah bagi sistem Anda untuk memproses hasil dan menangani pengecualian secara terprogram.

Dengan memanfaatkan platform Didit, Anda dapat menyerahkan sebagian besar kompleksitas penanganan kesalahan asinkron, berfokus pada logika bisnis inti Anda sambil memastikan pengalaman verifikasi identitas yang andal dan aman bagi pengguna Anda.

Siap Memulai?

Siap melihat Didit beraksi? Dapatkan demo gratis hari ini.

Mulai memverifikasi identitas secara gratis dengan tingkat gratis Didit.