Het opzetten van een webhook-implementatie voor realtime feedback over de verwerkingsstatus vereist een gestructureerde aanpak. Hieronder volgt een overzicht van de belangrijkste stappen en best practices: 1. Webhook-URL en Verificatie - Webhook-URL: Gebruik https://api.mijnapp.com/webhook als endpoint. - Authenticatie: Implementeer verificatiemethoden zoals API-sleutels, tokens of handtekeningen om ongeautoriseerde toegang te voorkomen. 2. Configuratie van Statusupdates - Status-gegevens: Wanneer de verwerking van een verzoek is voltooid, stuur je een POST-verzoek naar de oorspronkelijke afzender (indien mogelijk) of naar een vooraf ingestelde callback-URL. - Payload: Verstuur een gestructureerd bericht, bijvoorbeeld JSON, met velden zoals: - request_id: unieke identifier van het oorspronkelijke verzoek - status: "success", "failure", of "pending" - details: aanvullende informatie of foutmeldingen - timestamp: tijdstip van de statusupdate - Automatisering: Zorg dat je systeem automatisch een statusupdate stuurt zodra de verwerking compleet is. 3. Retour zenden van Statusupdates - Oorspronkelijke Afzender: Als de initiële aanvraag een callback-URL bevat, stuur de updates daar naartoe. - Alternatief: Als geen callback-URL is meegegeven, stuur de status terug via het communicatiekanaal dat is overeengekomen (bijvoorbeeld via API-response of e-mail). 4. Afhandeling van Mislukte Verwerkingen en Retries - Retry-mechanisme: Wanneer een statusupdate niet succesvol wordt afgeleverd (bijvoorbeeld door netwerkfouten), plan retries met exponentiële backoff. - Maximaal aantal retries: Stel een limiet in (bijvoorbeeld 3-5 pogingen) om onnodige belasting te voorkomen. - Dead-letter queue: Log mislukte pogingen en informeer indien nodig handmatig. - Aangepaste meldingen: Geef bij herhaalde mislukkingen duidelijke foutmeldingen en status. 5. Best Practices voor Tijdige en Nauwkeurige Updates - Asynchroon Verwerken: Verwerk verzoeken asynchroon zodat statusupdates snel kunnen worden verstuurd. - Idempotentie: Zorg dat herhaalde updates niet leiden tot inconsistenties. - Timestamps en Logboeken: Log alle verzonden updates met timestamps voor audit en troubleshooting. - Validatie: Controleer of de ontvanger de updates correct ontvangt en bevestigt. - Communicatieprotocol: Gebruik betrouwbare protocollen zoals HTTPS en onderteken payloads indien mogelijk. - Monitoring en Alerts: Zet monitoring in om te controleren of updates succesvol worden afgeleverd en stuur alerts bij problemen. Door deze stappen en best practices te volgen, kun je een robuuste webhook-implementatie realiseren die tijdige en accurate statusinformatie biedt, zelfs bij mislukte pogingen of netwerkproblemen.

Hier is een gedetailleerde beschrijving voor het implementeren van jouw webhook-systeem: ## Webhook Configuratie **Basis implementatie:** ```javascript // Voorbeeld Node.js implementatie app.post('/webhook', async (req, res) => { const { requestId, data, callbackUrl } = req.body; try { // Verwerk het verzoek const result = await processRequest(data); // Stuur succes response terug await sendStatusUpdate(callbackUrl, { requestId, status: 'success', data: result, timestamp: new Date().toISOString() }); res.status(200).json({ received: true }); } catch (error) { // Stuur fout response terug await sendStatusUpdate(callbackUrl, { requestId, status: 'failed', error: error.message, timestamp: new Date().toISOString() }); res.status(200).json({ received: true }); } }); ``` ## Status Update Structuur **Success response:** ```json { "requestId": "12345", "status": "success", "data": { "processedAt": "2024-01-15T10:30:00Z", "result": "Verwerking voltooid" }, "timestamp": "2024-01-15T10:30:00Z" } ``` **Failure response:** ```json { "requestId": "12345", "status": "failed", "error": { "code": "VALIDATION_ERROR", "message": "Ongeldige invoer data", "details": "Email formaat is ongeldig" }, "timestamp": "2024-01-15T10:30:00Z" } ``` ## Retry Mechanisme **Implementatie met exponential backoff:** ```javascript async function sendStatusUpdateWithRetry(callbackUrl, payload, maxRetries = 3) { let retryCount = 0; while (retryCount <= maxRetries) { try { const response = await fetch(callbackUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) }); if (response.ok) return; throw new Error(`HTTP ${response.status}`); } catch (error) { retryCount++; if (retryCount > maxRetries) { // Log de permanente fout await logFailedDelivery(payload.requestId, error.message); return; } // Wacht exponentieel langer bij elke retry const delay = Math.pow(2, retryCount) * 1000; await new Promise(resolve => setTimeout(resolve, delay)); } } } ``` ## Best Practices ### 1. **Betrouwbaarheid** - **Idempotentie**: Zorg dat duplicate statusupdates geen problemen veroorzaken - **Queue systeem**: Gebruik een message queue (Redis, RabbitMQ) voor betrouwbare verwerking - **Database logging**: Sla alle webhook pogingen op voor auditing ### 2. **Beveiliging** ```javascript // Verificatie middleware const verifyWebhook = (req, res, next) => { const signature = req.headers['x-signature']; const expected = crypto .createHmac('sha256', process.env.WEBHOOK_SECRET) .update(JSON.stringify(req.body)) .digest('hex'); if (signature !== expected) { return res.status(401).json({ error: 'Ongeldige signature' }); } next(); }; ``` ### 3. **Performance** - **Asynchrone verwerking**: Verwerk requests async om timeouts te voorkomen - **Rate limiting**: Implementeer rate limiting voor de callback URL - **Connection pooling**: Hergebruik HTTP connections ### 4. **Monitoring** - **Health checks**: Monitor webhook endpoint beschikbaarheid - **Metrics tracking**: Houd succes/failure rates bij - **Alerting**: Stel alerts in voor hoge failure rates ### 5. **Timeout Handling** ```javascript // Timeout configuratie const axiosInstance = axios.create({ timeout: 10000, // 10 seconden timeoutErrorMessage: 'Callback timeout' }); // Circuit breaker pattern class CircuitBreaker { constructor(failureThreshold = 5, resetTimeout = 60000) { this.failureThreshold = failureThreshold; this.resetTimeout = resetTimeout; this.failureCount = 0; this.lastFailureTime = null; this.state = 'CLOSED'; } async execute(callback) { if (this.state === 'OPEN') { if (Date.now() - this.lastFailureTime > this.resetTimeout) { this.state = 'HALF_OPEN'; } else { throw new Error('Circuit breaker is OPEN'); } } try { const result = await callback(); this.onSuccess(); return result; } catch (error) { this.onFailure(); throw error; } } onSuccess() { this.failureCount = 0; this.state = 'CLOSED'; } onFailure() { this.failureCount++; this.lastFailureTime = Date.now(); if (this.failureCount >= this.failureThreshold) { this.state = 'OPEN'; } } } ``` ### 6. **Compleet Voorbeeld** ```javascript const webhookProcessor = { async processIncoming(request) { const { requestId, data, callbackUrl } = request; // Valideer input if (!this.validateRequest(request)) { await this.sendStatus(callbackUrl, { requestId, status: 'failed', error: 'Ongeldig request formaat' }); return; } // Verwerk asynchroon this.processAsync(requestId, data, callbackUrl); return { accepted: true, requestId }; }, async processAsync(requestId, data, callbackUrl) { try { // Simuleer verwerking const result = await this.executeBusinessLogic(data); // Stuur succes await this.sendStatusWithRetry(callbackUrl, { requestId, status: 'success', data: result }); } catch (error) { // Stuur fout await this.sendStatusWithRetry(callbackUrl, { requestId, status: 'failed', error: this.sanitizeError(error) }); } } }; ``` Deze implementatie zorgt voor betrouwbare, schaalbare en veilige webhook-verwerking met automatische retries en uitgebreide monitoring mogelijkheden.