Membangun Penanganan Webhook Go untuk Verifikasi Identitas Real-Time (ID)

Otomatisasi Real-timeWebhook memungkinkan respons instan berbasis peristiwa terhadap hasil verifikasi identitas, yang krusial untuk orientasi pengguna yang dinamis dan sistem pencegahan penipuan.

Penanganan Kesalahan yang TangguhMenerapkan mekanisme percobaan ulang, antrean surat mati (dead-letter queues), dan pencatatan komprehensif sangat penting untuk menjaga integritas data dan keandalan sistem saat memproses peristiwa webhook asinkron.

Keamanan adalah Prioritas UtamaSelalu validasi tanda tangan webhook, gunakan HTTPS, dan bersihkan data yang masuk untuk melindungi dari perusakan dan akses tidak sah, menjaga informasi identitas yang sensitif.

Didit Menyederhanakan IntegrasiPlatform Didit yang modular dan API-first menyediakan dukungan webhook yang komprehensif, memungkinkan pengembang untuk dengan mudah mengkonfigurasi notifikasi real-time untuk semua peristiwa verifikasi identitas, mulai dari Verifikasi ID hingga Penyaringan AML, dengan KYC Inti Gratis.

Dalam lanskap modern identitas digital, umpan balik real-time bukan hanya kemewahan; ini adalah suatu keharusan. Baik Anda sedang melakukan orientasi pengguna baru, mencegah penipuan, atau memastikan kepatuhan, mengetahui hasil pemeriksaan verifikasi identitas saat itu terjadi memungkinkan tindakan segera dan pengalaman pengguna yang lebih lancar. Di sinilah webhook bersinar. Webhook menyediakan mekanisme yang kuat bagi platform verifikasi identitas untuk memberi tahu aplikasi Anda tentang peristiwa saat terjadi, menghilangkan kebutuhan untuk polling terus-menerus.

Posting blog ini akan memandu Anda dalam membangun penanganan webhook yang tangguh dan aman di Go, yang secara khusus disesuaikan untuk memproses peristiwa verifikasi identitas. Fitur konkurensi Go yang kuat dan kinerjanya menjadikannya pilihan yang sangat baik untuk menangani sifat asinkron dari webhook.

Memahami Webhook untuk Verifikasi Identitas

Sebelum masuk ke kode, mari kita jelaskan apa itu webhook dan mengapa mereka penting untuk verifikasi identitas. Webhook pada dasarnya adalah panggilan balik HTTP yang ditentukan pengguna. Alih-alih aplikasi Anda terus-menerus meminta layanan verifikasi identitas untuk pembaruan (polling), layanan tersebut mengirimkan permintaan HTTP POST ke URL yang Anda berikan setiap kali peristiwa tertentu terjadi. Untuk verifikasi identitas, peristiwa ini dapat mencakup:

• Pemindaian dokumen ID pengguna selesai.
• Deteksi keaktifan berhasil atau gagal.
• Penyaringan AML mengembalikan kecocokan.
• Alur kerja verifikasi lengkap mencapai status akhir (misalnya, disetujui, ditolak, tinjauan manual).

Menerima peristiwa ini secara real-time memungkinkan aplikasi Anda untuk memperbarui status pengguna, memicu proses hilir, atau memberi tahu administrator tanpa penundaan. Misalnya, setelah Verifikasi ID pengguna dan pemeriksaan Keaktifan Pasif & Aktif disetujui, Anda dapat segera memberi mereka akses ke layanan Anda.

Menyiapkan Server Webhook Go Anda

Membangun penanganan webhook di Go melibatkan pengaturan server HTTP sederhana yang mendengarkan permintaan POST yang masuk. Kami akan menggunakan paket standar net/http Go untuk ini. Pertama, mari kita buat struktur server dasar.

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

// WebhookPayload mewakili struktur webhook yang masuk dari layanan verifikasi identitas.
// Ini adalah contoh yang disederhanakan; payload aktual akan bervariasi.
type WebhookPayload struct {
	Event   string `json:"event"`
	SessionID string `json:"session_id"`
	Status  string `json:"status"`
	Data    json.RawMessage `json:"data"` // Gunakan RawMessage untuk menunda unmarshaling data bersarang
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Metode tidak diizinkan", http.StatusMethodNotAllowed)
		return
	}

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "Kesalahan membaca badan permintaan", http.StatusInternalServerError)
		return
	}

	var payload WebhookPayload
	err = json.Unmarshal(body, &payload)
	if err != nil {
		http.Error(w, "Kesalahan unmarshaling payload JSON", http.StatusBadRequest)
		log.Printf("Gagal meng-unmarshal webhook: %v, Badan: %s", err, body)
		return
	}

	// Catat peristiwa yang diterima untuk saat ini. Dalam aplikasi nyata, Anda akan memproses ini.
	log.Printf("Menerima peristiwa webhook: %s untuk sesi %s dengan status %s", payload.Event, payload.SessionID, payload.Status)

	// Balas dengan 200 OK untuk mengakui penerimaan. Kebanyakan pengirim webhook mengharapkan ini.
	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, "Webhook berhasil diterima")
}

func main() {
	http.HandleFunc("/webhook", webhookHandler)

	port := ":8080"
	log.Printf("Server webhook dimulai di port %s\n", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

Contoh dasar ini menyiapkan server HTTP yang mendengarkan di port 8080 dan menangani permintaan POST ke titik akhir /webhook. Ini membaca payload JSON yang masuk, meng-unmarshal-nya ke dalam struktur WebhookPayload, dan mencatat peristiwa tersebut. Yang krusial, ia merespons dengan kode status 200 OK untuk mengonfirmasi penerimaan webhook yang berhasil. Kegagalan untuk merespons dengan 200 OK dapat menyebabkan pengirim mencoba ulang pengiriman, yang mengarah ke pemrosesan duplikat.

Memastikan Keamanan: Verifikasi Tanda Tangan dan HTTPS

Keamanan sangat penting saat berurusan dengan data verifikasi identitas yang sensitif. Anda harus memastikan bahwa webhook yang masuk sah dan belum dirusak. Dua mekanisme utama untuk ini adalah:

1. HTTPS: Selalu ekspos titik akhir webhook Anda melalui HTTPS untuk mengenkripsi data dalam perjalanan, mencegah penyadapan.
2. Verifikasi Tanda Tangan: Sebagian besar penyedia verifikasi identitas terkemuka, termasuk Didit, mengirimkan tanda tangan atau hash di header permintaan (misalnya, X-Didit-Signature). Anda harus menggunakan kunci rahasia bersama untuk menghitung hash Anda sendiri dari badan permintaan mentah dan membandingkannya dengan tanda tangan yang masuk. Jika tidak cocok, webhook kemungkinan penipuan atau telah disusupi.

Berikut adalah contoh bagaimana Anda dapat menambahkan verifikasi tanda tangan ke penanganan Anda:

// ... (impor sebelumnya dan struktur WebhookPayload)

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	// ... impor lainnya
)

const webhookSecret = "YOUR_DIDIT_WEBHOOK_SECRET" // Ganti dengan rahasia aktual Anda

func verifySignature(body []byte, signature string) bool {
	hmacHash := hmac.New(sha256.New, []byte(webhookSecret))
	hmacHash.Write(body)
	expectedMAC := hmacHash.Sum(nil)

	decodedSignature, err := hex.DecodeString(signature)
	if err != nil {
		return false
	}

	return hmac.Equal(decodedSignature, expectedMAC)
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	// ... (pemeriksaan metode dan pembacaan badan)

	signature := r.Header.Get("X-Didit-Signature") // Atau nama header serupa dari penyedia Anda
	if signature == "" {
		http.Error(w, "Header tanda tangan hilang", http.StatusUnauthorized)
		return
	}

	if !verifySignature(body, signature) {
		http.Error(w, "Tanda tangan tidak valid", http.StatusUnauthorized)
		return
	}

	// ... (unmarshaling dan pemrosesan payload)
}

Ingatlah untuk menyimpan webhookSecret Anda dengan aman, idealnya di variabel lingkungan atau sistem manajemen rahasia, tidak di-hardcode dalam aplikasi Anda.

Ketahanan: Pemrosesan Asinkron dan Percobaan Ulang

Webhook harus diproses dengan cepat untuk menghindari batas waktu dan percobaan ulang dari pengirim. Untuk tugas yang kompleks atau memakan waktu, yang terbaik adalah mengalihkan pemrosesan ke goroutine atau antrean pesan terpisah. Penanganan webhook Anda harus berfokus terutama pada penerimaan, validasi, dan pengakuan peristiwa.

// ... (kode sebelumnya)

func processWebhookAsync(payload WebhookPayload) {
	// Dalam aplikasi nyata, ini mungkin melibatkan:
	// - Menyimpan peristiwa di database
	// - Mendorong ke antrean pesan (misalnya, Kafka, RabbitMQ)
	// - Memanggil layanan internal lainnya
	log.Printf("Memproses peristiwa secara asinkron: %s untuk sesi %s", payload.Event, payload.SessionID)
	// Mensimulasikan pekerjaan
	// time.Sleep(5 * time.Second)
	log.Printf("Selesai pemrosesan asinkron untuk sesi %s", payload.SessionID)
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	// ... (verifikasi tanda tangan dan unmarshaling payload)

	// Mengakui penerimaan segera.
	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, "Webhook berhasil diterima")

	// Proses secara asinkron untuk menghindari pemblokiran respons HTTP.
	go processWebhookAsync(payload)
}

Selanjutnya, layanan eksternal terkadang dapat gagal. Terapkan mekanisme percobaan ulang untuk setiap panggilan hilir yang dilakukan selama pemrosesan asinkron. Pertimbangkan untuk menggunakan antrean surat mati (DLQ) untuk peristiwa yang berulang kali gagal, memungkinkan inspeksi manual dan pemrosesan ulang.

Bagaimana Didit Membantu

Didit, sebagai platform identitas yang berorientasi AI dan pengembang, membuat integrasi peristiwa verifikasi identitas real-time menjadi mudah dan aman. Arsitektur modular Didit dibangun untuk orkestrasi, yang berarti Anda dapat menentukan alur kerja yang kompleks yang menggabungkan Verifikasi ID (OCR, MRZ, barcode), Keaktifan Pasif & Aktif, Pencocokan Wajah 1:1, Penyaringan & Pemantauan AML, Bukti Alamat, dan bahkan Estimasi Usia yang menjaga privasi. Setiap langkah dari alur kerja ini, dan hasil akhirnya, dapat memicu peristiwa webhook langsung ke aplikasi Go Anda.

Dengan Didit, Anda mengkonfigurasi URL webhook Anda di Konsol Bisnis, dan Didit mengirimkan pembaruan otomatis ke titik akhir yang Anda konfigurasikan saat pengguna berkembang dan ketika hasil verifikasi akhir siap. Didit menyediakan payload webhook yang tangguh, seringkali menyertakan header tanda tangan agar Anda memverifikasi keaslian, memastikan keamanan integrasi Anda. Ini memungkinkan Anda untuk membangun respons otomatis yang canggih terhadap hasil verifikasi, mempercepat orientasi pengguna, meningkatkan deteksi penipuan, dan menyederhanakan proses kepatuhan tanpa intervensi manual.

Keunggulan Didit, seperti KYC Inti Gratis dan tanpa biaya pengaturan, ditambah dengan API yang bersih dan dokumentasi yang komprehensif, memberdayakan Anda untuk membangun solusi identitas berbasis peristiwa yang kuat dengan efisiensi maksimum. Baik Anda menggunakan Tautan Verifikasi untuk integrasi tanpa kode atau langsung memanfaatkan API, sistem webhook Didit memastikan Anda selalu sinkron dengan perjalanan verifikasi pengguna Anda.

Siap Memulai?

Siap melihat Didit beraksi? Dapatkan demo gratis hari ini.

Mulai verifikasi identitas secara gratis dengan tingkat gratis Didit.