Tutoriel : Création d'un point de terminaison Webhook à l'aide de l'URL d'une fonction Lambda

Ouvrez la page Functions (Fonctions) de la console Lambda.

Créez une fonction de base « Hello world » en procédant comme suit :

1. Sélectionnez Create function (Créer une fonction).

2. Sélectionnez Créer à partir de zéro.

3. Sous Nom de la fonction, saisissez myLambdaWebhook.

4. Pour Runtime, sélectionnez python3.13.

5. Sélectionnez Create function (Créer une fonction).

Dans le volet Source du code, remplacez le code existant en copiant et en collant ce qui suit :

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

Dans la section DÉPLOYER, choisissez Déployer pour mettre à jour le code de votre fonction.

Ouvrez la page Functions (Fonctions) de la console Lambda.

Créez une fonction de base « Hello world » en procédant comme suit :

1. Sélectionnez Create function (Créer une fonction).

2. Sélectionnez Créer à partir de zéro.

3. Sous Nom de la fonction, saisissez myLambdaWebhook.

4. Pour Runtime, sélectionnez nodejs22.x.

5. Sélectionnez Create function (Créer une fonction).

Dans le volet Source du code, remplacez le code existant en copiant et en collant ce qui suit :

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;
    }
  };

Dans la section DÉPLOYER, choisissez Déployer pour mettre à jour le code de votre fonction.

Enregistrez le code suivant sous forme de fichier nommécalculate_signature.py. Remplacez le secret du webhook dans le code par votre propre valeur.

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)

Calculez la signature en exécutant la commande suivante depuis le répertoire dans lequel vous avez enregistré le code. Copiez la signature émise par le code.

python calculate_signature.py

Enregistrez le code suivant sous forme de fichier nommécalculate_signature.mjs. Remplacez le secret du webhook dans le code par votre propre valeur.

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);

Calculez la signature en exécutant la commande suivante depuis le répertoire dans lequel vous avez enregistré le code. Copiez la signature émise par le code.

node calculate_signature.mjs