Webhook

Webhook ist ein Mechanismus, bei dem eine Anwendung automatisch eine andere Anwendung über ein Ereignis benachrichtigt. Statt regelmäßig nachzufragen, ob es Neuigkeiten gibt (Polling), sendet das Quellsystem aktiv eine HTTP-Anfrage an eine vordefinierte URL. Diese Art der Kommunikation wird auch als HTTP Callback oder Reverse API bezeichnet und bildet die Grundlage für moderne Event-Driven Architectures.

Wie funktionieren Webhooks?

Die Funktionsweise von Webhooks lässt sich in vier Schritte unterteilen. Im Kern geht es darum, dass ein Quellsystem bei bestimmten Ereignissen automatisch Daten an ein Zielsystem überträgt.

1. Registrierung

Zuerst registrierst du beim Anbieter (dem Quellsystem) eine URL - den sogenannten Webhook-Endpunkt. Dieser Endpunkt ist ein HTTP-Server auf deiner Seite, der eingehende Anfragen entgegennimmt. Zusätzlich legst du fest, bei welchen Ereignissen der Webhook ausgelöst werden soll. Bei GitHub könntest du beispielsweise festlegen, dass du bei jedem Push-Event benachrichtigt werden möchtest.

2. Ereignis tritt ein

Sobald das konfigurierte Ereignis im Quellsystem eintritt - etwa eine erfolgreiche Zahlung bei einem Payment-Provider oder ein neuer Commit in einem Repository - erkennt das System dies automatisch und bereitet die Benachrichtigung vor.

3. HTTP-POST-Request

Das Quellsystem sendet eine HTTP-POST-Anfrage an deine registrierte URL. Die Ereignisdaten werden als Payload im Request-Body übertragen, typischerweise im JSON-Format. Der Request enthält auch Header-Informationen wie Content-Type, Zeitstempel und oft eine kryptografische Signatur zur Verifizierung.

4. Verarbeitung und Bestätigung

Dein Webhook-Endpunkt empfängt die Anfrage, verarbeitet die Daten und antwortet mit einem HTTP-Statuscode. Ein 200 OK signalisiert dem Quellsystem, dass die Nachricht erfolgreich empfangen wurde. Die meisten Webhook-Systeme erwarten diese Bestätigung innerhalb von 5 Sekunden - längere Verarbeitungen solltest du daher asynchron ausführen.

// Beispiel: Einfacher Webhook-Endpunkt mit Express.js
const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhook', (req, res) => {
  const event = req.body;
  
  console.log('Webhook empfangen:', event.type);
  
  // Ereignis verarbeiten
  switch (event.type) {
    case 'payment.completed':
      // Bestellung als bezahlt markieren
      break;
    case 'user.created':
      // Willkommens-E-Mail senden
      break;
  }
  
  // Schnelle Bestätigung senden
  res.status(200).json({ received: true });
});

app.listen(3000);

Webhook vs. Polling vs. API

Um die Vorteile von Webhooks zu verstehen, lohnt sich ein Vergleich mit alternativen Ansätzen zur Datenübertragung zwischen Systemen. Jeder Ansatz hat seine Berechtigung - die Wahl hängt vom konkreten Anwendungsfall ab.

Webhooks eignen sich besonders, wenn Ereignisse selten auftreten, aber schnell verarbeitet werden müssen. Polling ist sinnvoll, wenn du keinen eigenen Server betreiben kannst oder die Datenquelle keine Webhooks unterstützt. Klassische API-Aufrufe sind die beste Wahl, wenn du Daten gezielt und auf Anfrage abrufen möchtest - etwa um den aktuellen Status einer Bestellung anzuzeigen.

Typische Anwendungsfälle

Webhooks sind aus modernen Softwarearchitekturen nicht mehr wegzudenken. Sie verbinden unterschiedliche Systeme und ermöglichen automatisierte Workflows ohne manuellen Eingriff.

CI/CD-Pipelines

Versionskontrollsysteme wie GitHub, GitLab oder Bitbucket nutzen Webhooks, um Build-Server über neue Commits zu informieren. Sobald du Code pushst, triggert ein Webhook automatisch die CI/CD-Pipeline - Tests laufen, Code wird kompiliert und bei Erfolg automatisch deployed.

Payment-Services

Zahlungsdienstleister wie Stripe, PayPal oder Klarna senden Webhooks bei Zahlungsereignissen. Dein Shop-System erfährt sofort, wenn eine Zahlung erfolgreich war, fehlgeschlagen ist oder zurückgebucht wurde - ohne dass du ständig den Status abfragen musst.

Chat-Bots und Messaging

Plattformen wie Slack, Discord oder Telegram nutzen Webhooks für Bot-Integrationen. Wenn jemand eine Nachricht an deinen Bot sendet, erhält dein Server einen Webhook mit dem Nachrichteninhalt und kann entsprechend reagieren.

Monitoring und Alerting

Monitoring-Tools wie Grafana, Datadog oder PagerDuty senden Webhooks, wenn bestimmte Schwellwerte überschritten werden. So kannst du bei einem Serverausfall automatisch Benachrichtigungen an Slack schicken oder Incident-Tickets erstellen.

E-Commerce und CRM

Online-Shops nutzen Webhooks, um Bestellungen an Lagersysteme weiterzuleiten, Versanddienstleister zu benachrichtigen oder CRM-Systeme mit Kundendaten zu synchronisieren. Jede neue Bestellung triggert eine Kette von automatisierten Aktionen.

Sicherheit bei Webhooks

Da Webhook-Endpunkte öffentlich erreichbar sein müssen, sind sie ein potenzielles Angriffsziel. Ein Angreifer könnte gefälschte Requests senden, um dein System zu manipulieren. Deshalb sind mehrere Sicherheitsmaßnahmen erforderlich.

HMAC-Signaturprüfung

Die wichtigste Sicherheitsmaßnahme ist die Signaturverifizierung. Der Webhook-Anbieter signiert jeden Request mit einem geheimen Schlüssel (Shared Secret) unter Verwendung von HMAC-SHA256. Du berechnest die Signatur auf deiner Seite erneut und vergleichst sie mit der im Header übermittelten Signatur. Stimmen beide überein, ist der Request authentisch.

const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  // Timing-safe Vergleich gegen Timing-Attacken
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Verwendung im Express-Handler
app.post('/webhook', (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const isValid = verifyWebhookSignature(
    JSON.stringify(req.body),
    signature,
    process.env.WEBHOOK_SECRET
  );
  
  if (!isValid) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  // Webhook verarbeiten...
});

Weitere Sicherheitsmaßnahmen

Neben der Signaturprüfung gibt es weitere Best Practices, die du beachten solltest:

• HTTPS verwenden: Webhooks sollten ausschließlich über TLS-verschlüsselte Verbindungen empfangen werden
• Zeitstempel validieren: Prüfe, ob der Request nicht älter als wenige Minuten ist (Replay-Schutz)
• IP-Whitelist: Manche Anbieter veröffentlichen ihre IP-Bereiche, die du per Firewall erlauben kannst
• Idempotenz: Stelle sicher, dass mehrfache Zustellung desselben Events keine Probleme verursacht
• Rate Limiting: Begrenze die Anzahl eingehender Requests, um DoS-Angriffe abzuwehren

Vor- und Nachteile von Webhooks

Webhooks bieten viele Vorteile, bringen aber auch Herausforderungen mit sich. Die Entscheidung für oder gegen Webhooks hängt von deinen Anforderungen und deiner Infrastruktur ab.

Vorteile

• Echtzeit-Benachrichtigungen: Ereignisse werden sofort übermittelt, ohne Verzögerung
• Ressourceneffizienz: Keine verschwendeten Anfragen bei ausbleibendem Event
• Einfache Integration: Standardisiertes HTTP-Protokoll, keine speziellen Bibliotheken nötig
• Lose Kopplung: Sender und Empfänger sind unabhängig voneinander
• Skalierbarkeit: Gut geeignet für Event-Driven Architectures und Microservices

Nachteile

• Erreichbarkeit erforderlich: Dein Endpunkt muss öffentlich erreichbar und hochverfügbar sein
• Fehlerbehandlung komplex: Bei Ausfällen musst du Retry-Logik und Dead-Letter-Queues implementieren
• Debugging schwieriger: Eingehende Requests sind schwerer nachzuvollziehen als ausgehende API-Calls
• Sicherheitsrisiko: Öffentliche Endpunkte erfordern sorgfältige Absicherung
• Keine Garantie: "At-least-once"-Semantik bedeutet, dass Events mehrfach ankommen können

Webhooks in der IT-Praxis

Webhooks begegnen dir in nahezu jeder modernen Entwicklungsumgebung. Als Fachinformatiker für Anwendungsentwicklung wirst du Webhooks implementieren, wenn du Integrationen zwischen verschiedenen Services baust - etwa um Bestellungen aus einem Shop-System an ein Lagerverwaltungssystem weiterzuleiten.

Auch als Fachinformatiker für Systemintegration sind Webhooks relevant: Du konfigurierst sie in CI/CD-Systemen, richtest Monitoring-Alerts ein oder verbindest verschiedene Cloud-Services miteinander. Das Verständnis von HTTP, JSON und grundlegenden Sicherheitskonzepten ist dabei essenziell.

Quellen und weiterführende Links

• Red Hat - What is a Webhook?
• GitHub Webhooks Dokumentation
• Stripe Webhooks Guide
• Hookdeck - What are Webhooks?
• Wikipedia - Webhook