Tutorial: Erstellen eines Webhook-Endpunkts mithilfe einer Lambda-Funktions-URL - AWS Lambda
VoraussetzungenSo erstellen Sie die Lambda-Funktion:Erstellen Sie den geheimen SchlüsselErstellen Sie den URL-Endpunkt der FunktionTesten Sie die Funktion in der KonsoleTesten Sie die Funktion mit einer HTTP-AnfrageBereinigen Ihrer Ressourcen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Tutorial: Erstellen eines Webhook-Endpunkts mithilfe einer Lambda-Funktions-URL

In diesem Tutorial erstellen Sie eine Lambda-Funktions-URL, um einen Webhook-Endpunkt zu implementieren. Ein Webhook ist eine einfache, ereignisgesteuerte Kommunikation, die automatisch Daten zwischen Anwendungen über HTTP sendet. Sie können einen Webhook verwenden, um sofort über Ereignisse in einem anderen System informiert zu werden, z. B. wenn sich ein neuer Kunde auf einer Website anmeldet, eine Zahlung bearbeitet oder eine Datei hochgeladen wird.

Mit Lambda können Webhooks entweder mithilfe der Lambda-Funktion URLs oder des API Gateway implementiert werden. Function ist eine gute Wahl für einfache Webhooks, für die keine Funktionen wie erweiterte Autorisierung oder Anforderungsvalidierung erforderlich URLs sind.

Tipp

Wenn Sie sich nicht sicher sind, welche Lösung für Ihren speziellen Anwendungsfall am besten geeignet ist, finden Sie weitere Informationen unterWählen Sie eine Methode, um Ihre Lambda-Funktion über eine HTTP-Anfrage aufzurufen.

Voraussetzungen

Um dieses Tutorial abzuschließen, müssen Sie entweder Python (Version 3.8 oder höher) oder Node.js (Version 18 oder höher) auf Ihrem lokalen Computer installiert haben.

Um den Endpunkt mithilfe einer HTTP-Anfrage zu testen, verwendet das Tutorial curl, ein Befehlszeilentool, mit dem Sie Daten mithilfe verschiedener Netzwerkprotokolle übertragen können. In der curl-Dokumentation erfahren Sie, wie Sie das Tool installieren, falls Sie es noch nicht haben.

So erstellen Sie die Lambda-Funktion:

Erstellen Sie zunächst die Lambda-Funktion, die ausgeführt wird, wenn eine HTTP-Anfrage an Ihren Webhook-Endpunkt gesendet wird. In diesem Beispiel sendet die sendende Anwendung jedes Mal eine Aktualisierung, wenn eine Zahlung eingereicht wird, und gibt im Hauptteil der HTTP-Anfrage an, ob die Zahlung erfolgreich war. Die Lambda-Funktion analysiert die Anfrage und ergreift entsprechend dem Status der Zahlung Maßnahmen. In diesem Beispiel druckt der Code lediglich die Bestellnummer für die Zahlung, aber in einer echten Anwendung könnten Sie die Bestellung zu einer Datenbank hinzufügen oder eine Benachrichtigung senden.

Die Funktion implementiert auch die am häufigsten verwendete Authentifizierungsmethode für Webhooks, die Hash-basierte Nachrichtenauthentifizierung (HMAC). Bei dieser Methode teilen sich sowohl die sendende als auch die empfangende Anwendung einen geheimen Schlüssel. Die sendende Anwendung verwendet einen Hashing-Algorithmus, um mithilfe dieses Schlüssels zusammen mit dem Nachrichteninhalt eine eindeutige Signatur zu generieren, und fügt die Signatur als HTTP-Header in die Webhook-Anforderung ein. Die empfangende Anwendung wiederholt dann diesen Schritt, generiert die Signatur mithilfe des geheimen Schlüssels und vergleicht den resultierenden Wert mit der Signatur, die im Anforderungsheader gesendet wurde. Wenn das Ergebnis übereinstimmt, wird die Anfrage als legitim angesehen.

Erstellen Sie die Funktion mithilfe der Lambda-Konsole mit der Python- oder Node.js Runtime.

Python
So erstellen Sie die Lambda-Funktion:

  1. Öffnen Sie die Seite Funktionen der Lambda-Konsole.

  2. Erstellen Sie eine grundlegende „Hello World“ -Funktion, indem Sie wie folgt vorgehen:

    1. Wählen Sie Funktion erstellen aus.

    2. Wählen Sie Verfassen von Grund auf aus.

    3. Geben Sie für Function name (Funktionsname) myLambdaWebhook ein.

    4. Wählen Sie für Runtime python3.13 aus.

    5. Wählen Sie Funktion erstellen aus.

  3. Ersetzen Sie im Bereich Codequelle den vorhandenen Code, indem Sie Folgendes kopieren und einfügen:

    import json
import hmac
import hashlib
import os

def lambda_handler(event, context):
    
    # Get the webhook secret from environment variables
    webhook_secret = os.environ['WEBHOOK_SECRET']
    
    # Verify the webhook signature
    if not verify_signature(event, webhook_secret):
        return {
            'statusCode': 401,
            'body': json.dumps({'error': 'Invalid signature'})
        }
    
    try:
        # Parse the webhook payload
        payload = json.loads(event['body'])
        
        # Handle different event types
        event_type = payload.get('type')
        
        if event_type == 'payment.success':
            # Handle successful payment
            order_id = payload.get('orderId')
            print(f"Processing successful payment for order {order_id}")
            
            # Add your business logic here
            # For example, update database, send notifications, etc.
            
        elif event_type == 'payment.failed':
            # Handle failed payment
            order_id = payload.get('orderId')
            print(f"Processing failed payment for order {order_id}")
            
            # Add your business logic here
            
        else:
            print(f"Received unhandled event type: {event_type}")
        
        # Return success response
        return {
            'statusCode': 200,
            'body': json.dumps({'received': True})
        }
        
    except json.JSONDecodeError:
        return {
            'statusCode': 400,
            'body': json.dumps({'error': 'Invalid JSON payload'})
        }
    except Exception as e:
        print(f"Error processing webhook: {e}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': 'Internal server error'})
        }

def verify_signature(event, webhook_secret):
    """
    Verify the webhook signature using HMAC
    """
    try:
        # Get the signature from headers
        signature = event['headers'].get('x-webhook-signature')

        if not signature:
            print("Error: Missing webhook signature in headers")
            return False
        
        # Get the raw body (return an empty string if the body key doesn't exist)
        body = event.get('body', '')
        
        # Create HMAC using the secret key
        expected_signature = hmac.new(
            webhook_secret.encode('utf-8'),
            body.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        
        # Compare the expected signature with the received signature to authenticate the message
        is_valid = hmac.compare_digest(signature, expected_signature)
        if not is_valid:
            print(f"Error: Invalid signature. Received: {signature}, Expected: {expected_signature}")
            return False
            
        return True
    except Exception as e:
        print(f"Error verifying signature: {e}")
        return False

  4. Wählen Sie im Abschnitt BEREITSTELLEN die Option Bereitstellen aus, um den Code Ihrer Funktion zu aktualisieren.

Node.js
So erstellen Sie die Lambda-Funktion:

  1. Öffnen Sie die Seite Funktionen der Lambda-Konsole.

  2. Erstellen Sie eine grundlegende „Hallo Welt“ -Funktion, indem Sie wie folgt vorgehen:

    1. Wählen Sie Funktion erstellen aus.

    2. Wählen Sie Verfassen von Grund auf aus.

    3. Geben Sie für Function name (Funktionsname) myLambdaWebhook ein.

    4. Wählen Sie für Runtime nodejs22.x aus.

    5. Wählen Sie Funktion erstellen aus.

  3. Ersetzen Sie im Bereich Codequelle den vorhandenen Code, indem Sie Folgendes kopieren und einfügen:

    import crypto from 'crypto';

export const handler = async (event, context) => {
    // Get the webhook secret from environment variables
    const webhookSecret = process.env.WEBHOOK_SECRET;

    // Verify the webhook signature
    if (!verifySignature(event, webhookSecret)) {
        return {
            statusCode: 401,
            body: JSON.stringify({ error: 'Invalid signature' })
        };
    }

    try {
        // Parse the webhook payload
        const payload = JSON.parse(event.body);

        // Handle different event types
        const eventType = payload.type;

        switch (eventType) {
            case 'payment.success': {
                // Handle successful payment
                const orderId = payload.orderId;
                console.log(`Processing successful payment for order ${orderId}`);

                // Add your business logic here
                // For example, update database, send notifications, etc.
                break;
            }

            case 'payment.failed': {
                // Handle failed payment
                const orderId = payload.orderId;
                console.log(`Processing failed payment for order ${orderId}`);

                // Add your business logic here
                break;
            }

            default:
                console.log(`Received unhandled event type: ${eventType}`);
        }

        // Return success response
        return {
            statusCode: 200,
            body: JSON.stringify({ received: true })
        };

    } catch (error) {
        if (error instanceof SyntaxError) {
            // Handle JSON parsing errors
            return {
                statusCode: 400,
                body: JSON.stringify({ error: 'Invalid JSON payload' })
            };
        }

        // Handle all other errors
        console.error('Error processing webhook:', error);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: 'Internal server error' })
        };
    }
};

// Verify the webhook signature using HMAC

const verifySignature = (event, webhookSecret) => {
    try {
        // Get the signature from headers
        const signature = event.headers['x-webhook-signature'];
  
        if (!signature) {
            console.log('No signature found in headers:', event.headers);
            return false;
        }
  
        // Get the raw body (return an empty string if the body key doesn't exist)
        const body = event.body || '';
  
        // Create HMAC using the secret key
        const hmac = crypto.createHmac('sha256', webhookSecret);
        const expectedSignature = hmac.update(body).digest('hex');
  
        // Compare expected and received signatures
        const isValid = signature === expectedSignature;
        if (!isValid) {
            console.log(`Invalid signature. Received: ${signature}, Expected: ${expectedSignature}`);
            return false;
        }
        
        return true;
    } catch (error) {
        console.error('Error during signature verification:', error);
        return false;
    }
  };

  4. Wählen Sie im Abschnitt BEREITSTELLEN die Option Bereitstellen aus, um den Code Ihrer Funktion zu aktualisieren.

Erstellen Sie den geheimen Schlüssel

Damit die Lambda-Funktion die Webhook-Anfrage authentifiziert, verwendet sie einen geheimen Schlüssel, den sie mit der aufrufenden Anwendung teilt. In diesem Beispiel wird der Schlüssel in einer Umgebungsvariablen gespeichert. In einer Produktionsanwendung empfehlen wir die Verwendung AWS Secrets Manager als sicherere Option. Weitere Informationen zur Verwendung von Secrets Manager zum Speichern geheimer Schlüssel finden Sie unter Create an AWS Secrets Manager Secret und Get Secrets from AWS Secrets Manager im AWS Secrets Manager Benutzerhandbuch.

Erstellen und speichern Sie den geheimen Webhook-Schlüssel

  1. Generieren Sie eine lange, zufällige Zeichenfolge mit einem kryptografisch sicheren Zufallszahlengenerator. Sie können die folgenden Codefragmente in Python oder Node.js verwenden, um ein 32-stelliges Geheimnis zu generieren und auszudrucken, oder Sie können Ihre eigene bevorzugte Methode verwenden.

    Python
    Beispiel Code zum Generieren eines Geheimnisses
    import secrets
webhook_secret = secrets.token_urlsafe(32)
print(webhook_secret)
    Node.js
    Beispiel Code zur Generierung eines Geheimnisses (ES-Modulformat)
    import crypto from 'crypto';
let webhookSecret = crypto.randomBytes(32).toString('base64');
console.log(webhookSecret)

  2. Speichern Sie Ihre generierte Zeichenfolge als Umgebungsvariable für Ihre Funktion, indem Sie wie folgt vorgehen:

    1. Wählen Sie auf der Registerkarte Konfiguration für Ihre Funktion die Option Umgebungsvariablen aus.

    2. Wählen Sie Edit (Bearbeiten) aus.

    3. Wählen Sie Umgebungsvariablen hinzufügen aus.

    4. Geben Sie für Schlüssel WEBHOOK_SECRET und dann für Wert das Geheimnis ein, das Sie im vorherigen Schritt generiert haben.

    5. Wählen Sie Save (Speichern) aus.

Sie müssen dieses Geheimnis später im Tutorial erneut verwenden, um Ihre Funktion zu testen. Notieren Sie es sich also jetzt.

Erstellen Sie den URL-Endpunkt der Funktion

Erstellen Sie mithilfe einer Lambda-Funktions-URL einen Endpunkt für Ihren Webhook. Da Sie den Authentifizierungstyp von verwenden, NONE um einen Endpunkt mit öffentlichem Zugriff zu erstellen, kann jeder, der die URL hat, Ihre Funktion aufrufen. Weitere Informationen zur Steuerung des Zugriffs auf Funktionen URLs finden Sie unter. Kontrolle des Zugriffs auf Lambda-Funktions-URLs Wenn Sie erweiterte Authentifizierungsoptionen für Ihren Webhook benötigen, sollten Sie API Gateway verwenden.

Erstellen Sie den URL-Endpunkt der Funktion

  1. Wählen Sie auf der Registerkarte Konfiguration für Ihre Funktion die Option Funktions-URL aus.

  2. Wählen Sie Funktions-URL erstellen.

  3. Wählen Sie als Authentifizierungstyp die Option NONE aus.

  4. Wählen Sie Save (Speichern) aus.

Der Endpunkt für die Funktions-URL, die Sie gerade erstellt haben, wird im Bereich Funktions-URL angezeigt. Kopieren Sie den Endpunkt, um ihn später im Tutorial zu verwenden.

Testen Sie die Funktion in der Konsole

Bevor Sie eine HTTP-Anfrage verwenden, um Ihre Funktion über den URL-Endpunkt aufzurufen, testen Sie sie in der Konsole, um sicherzustellen, dass Ihr Code wie erwartet funktioniert.

Um die Funktion in der Konsole zu überprüfen, berechnen Sie zunächst eine Webhook-Signatur anhand des Geheimnisses, das Sie zuvor im Tutorial generiert haben, mit der folgenden Test-JSON-Payload:

{
    "type": "payment.success", 
    "orderId": "1234",
    "amount": "99.99"
}

Verwenden Sie eines der folgenden Python- oder Node.js- Codebeispiele, um die Webhook-Signatur unter Verwendung Ihres eigenen Geheimnisses zu berechnen.

Python
Berechnen Sie die Webhook-Signatur

  1. Speichern Sie den folgenden Code als Datei mit dem Namencalculate_signature.py. Ersetzen Sie das Webhook-Geheimnis im Code durch Ihren eigenen Wert.

    import secrets
import hmac
import json
import hashlib

webhook_secret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M"

body = json.dumps({"type": "payment.success", "orderId": "1234", "amount": "99.99"})

signature = hmac.new(
            webhook_secret.encode('utf-8'),
            body.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()

print(signature)

  2. Berechnen Sie die Signatur, indem Sie den folgenden Befehl aus demselben Verzeichnis ausführen, in dem Sie den Code gespeichert haben. Kopieren Sie die Signatur, die der Code ausgibt.

    python calculate_signature.py
Node.js
Berechne die Webhook-Signatur

  1. Speichern Sie den folgenden Code als Datei mit dem Namencalculate_signature.mjs. Ersetzen Sie das Webhook-Geheimnis im Code durch Ihren eigenen Wert.

    import crypto from 'crypto';

const webhookSecret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M"
const body = "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}";

let hmac = crypto.createHmac('sha256', webhookSecret);
let signature = hmac.update(body).digest('hex');

console.log(signature);

  2. Berechnen Sie die Signatur, indem Sie den folgenden Befehl aus demselben Verzeichnis ausführen, in dem Sie den Code gespeichert haben. Kopieren Sie die Signatur, die der Code ausgibt.

    node calculate_signature.mjs

Sie können Ihren Funktionscode jetzt mit einer Test-HTTP-Anfrage in der Konsole testen.

Testen Sie die Funktion in der Konsole

  1. Wählen Sie die Registerkarte Code für Ihre Funktion aus.

  2. Wählen Sie im Abschnitt TESTEREIGNISSE die Option Neues Testereignis erstellen

  3. Geben Sie als Event name (Ereignisname) die Zeichenfolge myEvent ein.

  4. Ersetzen Sie das vorhandene JSON, indem Sie Folgendes kopieren und in den Bereich Event-JSON einfügen. Ersetzen Sie die Webhook-Signatur durch den Wert, den Sie im vorherigen Schritt berechnet haben.

    {
  "headers": {
    "Content-Type": "application/json",
    "x-webhook-signature": "2d672e7a0423fab740fbc040e801d1241f2df32d2ffd8989617a599486553e2a"
  },
  "body": "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}"
}

  5. Wählen Sie Save (Speichern) aus.

  6. Wählen Sie  aufrufen aus.

    Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:

    Python
    Status: Succeeded
Test Event Name: myEvent

Response:
{
  "statusCode": 200,
  "body": "{\"received\": true}"
}

Function Logs:
START RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Version: $LATEST
Processing successful payment for order 1234
END RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6
REPORT RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6	Duration: 1.55 ms	Billed Duration: 2 ms	Memory Size: 128 MB	Max Memory Used: 36 MB	Init Duration: 136.32 ms
    Node.js
    Status: Succeeded
Test Event Name: myEvent

Response:
{
  "statusCode": 200,
  "body": "{\"received\":true}"
}

Function Logs:
START RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Version: $LATEST
2025-01-10T18:05:42.062Z	e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4	INFO	Processing successful payment for order 1234
END RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4
REPORT RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4	Duration: 60.10 ms	Billed Duration: 61 ms	Memory Size: 128 MB	Max Memory Used: 72 MB	Init Duration: 174.46 ms

Request ID: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4

Testen Sie die Funktion mit einer HTTP-Anfrage

Verwenden Sie das Befehlszeilentool curl, um Ihren Webhook-Endpunkt zu testen.

Testen Sie die Funktion mithilfe von HTTP-Anfragen

  1. Führen Sie in einem Terminal- oder Shell-Programm den folgenden curl-Befehl aus. Ersetzen Sie die URL durch den Wert für Ihren eigenen Funktions-URL-Endpunkt und ersetzen Sie die Webhook-Signatur durch die Signatur, die Sie mit Ihrem eigenen geheimen Schlüssel berechnet haben.

    curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \
-H "Content-Type: application/json" \
-H "x-webhook-signature: d5f52b76ffba65ff60ea73da67bdf1fc5825d4db56b5d3ffa0b64b7cb85ef48b" \
-d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}'

    Die Ausgabe sollte folgendermaßen aussehen:

    {"received": true}

  2. Prüfen Sie die CloudWatch Protokolle Ihrer Funktion, um sicherzustellen, dass sie die Nutzlast korrekt analysiert hat. Gehen Sie dazu wie folgt vor:

    1. Öffnen Sie die Gruppenseite Logs in der CloudWatch Amazon-Konsole.

    2. Wählen Sie die Protokollgruppe Ihrer Funktion aus (/aws/lambda/myLambdaWebhook).

    3. Wählen Sie den neuesten Protokoll-Stream.

      In den Protokollen Ihrer Funktion sollten Sie eine Ausgabe sehen, die der folgenden ähnelt:

      Python
      Processing successful payment for order 1234
      Node.js
      2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234

  3. Vergewissern Sie sich, dass Ihr Code eine ungültige Signatur erkennt, indem Sie den folgenden curl-Befehl ausführen. Ersetzen Sie die URL durch Ihren eigenen Funktions-URL-Endpunkt.

    curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \
-H "Content-Type: application/json" \
-H "x-webhook-signature: abcdefg" \
-d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}'

    Die Ausgabe sollte folgendermaßen aussehen:

    {"error": "Invalid signature"}

Bereinigen Ihrer Ressourcen

Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS Ressourcen, die Sie nicht mehr verwenden, vermeiden Sie unnötige Kosten für Ihre AWS-Konto.

So löschen Sie die Lambda-Funktion:

  1. Öffnen Sie die Seite Funktionen der Lambda-Konsole.

  2. Wählen Sie die Funktion aus, die Sie erstellt haben.

  3. Wählen Sie Aktionen, Löschen aus.

  4. Geben Sie confirm in das Texteingabefeld ein und wählen Sie Delete (Löschen) aus.

Als Sie die Lambda-Funktion in der Konsole erstellt haben, hat Lambda auch eine Ausführungsrolle für Ihre Funktion erstellt.

So löschen Sie die Ausführungsrolle

  1. Öffnen Sie die Seite Roles (Rollen) in der IAM-Konsole.

  2. Wählen Sie die Ausführungsrolle aus, die Lambda erstellt hat. Die Rolle hat das NamensformatmyLambdaWebhook-role-<random string>.

  3. Wählen Sie Löschen.

  4. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie Delete (Löschen) aus.