Trigger AWS Lambdas from database changes

1. Open the AWS Lambda console and click “Create function”.
2. Choose “Author from scratch”.
3. Give your function a name (e.g., “newUserHandler”).
4. Select a runtime (e.g., “Node.js 20.x”) and which ever architecture you want to support (e.g., “arm64”).
5. Click “Create function”:

Replace the default code in the Lambda function. Here’s an example:

export const handler = async (event) => {
  // Verify the Sequin webhook secret
  const authHeader = event.headers.authorization;
  if (!authHeader || authHeader !== `Bearer ${process.env.SEQUIN_WEBHOOK_SECRET}`) {
    return {
      statusCode: 401,
      body: JSON.stringify('Unauthorized'),
    };
  }

  try {
    const payload = JSON.parse(event.body);
    const { record } = payload;

    if (record && record.name) {
      console.log(`Hello ${record.name}`);
    } else {
      console.log('No name found in the payload.');
    }

    return {
      statusCode: 200,
      body: JSON.stringify('Success'),
    };
  } catch (error) {
    console.error('Error processing request:', error);
    return {
      statusCode: 500,
      body: JSON.stringify('Internal Server Error'),
    };
  }
};

This function first checks the authorization header to make sure the request is coming from Sequin. Then it processes the payload and logs the name from the payload to the console.

Click “Deploy” to save the function.

1. In the Lambda function “Configuration” tab, scroll down to the “Environment variables” section.
2. Click “Edit” and then “Add environment variable”.
3. Set the key as SEQUIN_WEBHOOK_SECRET and the value to a secure secret of your choice.
4. Click “Save”.

You will need to use this secret value in the Sequin dashboard when you create the push consumer.

To make your Lambda function accessible via HTTP, you need to create a Function URL:

1. Go to your Lambda function in the AWS Console.
2. In the “Configuration” tab, click on “Function URL” in the left sidebar.
3. Click “Create function URL”.
4. For “Auth type”, select “NONE”.
5. Under “Configure cross-origin resource sharing (CORS)”, check “Configure CORS”.
6. In the “Allowed origins” field, enter ”*” (without quotes) to allow all origins for now. You can restrict this later.
7. Click “Save”.

After saving, you’ll see a Function URL. This is the URL you’ll use to configure your Sequin consumer in the next section.

Navigate to the “Sinks” tab, click the “Create Sink” button, and select “Webhook Sink”.

Select the table you want to capture changes from (i.e public.users).

Specify whether you want to receive changes or rows from the table.

If you selected changes, in “Records to process”, you can indicate whether you want to receive insert, update, and/or delete changes. Select all three for now. No need to add a filter.

You can optionally indicate if you want your webhook endpoint to receive a backfill of all or a portion of the table’s existing data. For now, leave “Backfill” toggled off.

Under “Message grouping”, leave the default option selected to ensure events for the same row are sent to your webhook endpoint in order.

Under “Delivery configuration”, choose a conservative value for “Request timeout” and set “Batch size” to 1 since we’re just logging messages.

Under “HTTP Endpoint”, enter the Lambda Function URL you obtained earlier. Then click to “Add Encrypted Header” with the key Authorization and the value Bearer SEQUIN_WEBHOOK_SECRET, using the secret value you set in your Lambda function’s environment variables.

Give your sink a name (i.e. users_webhook_sink) and click “Create Webhook Sink”.

Insert a row into your table. For example:

insert into
users (name)
values
  (
    'John Doe'
  );

In the Sequin console, open the Messages tab on your webhook sink and confirm that a message was delivered:

1. Open the AWS Lambda console and navigate to your function.
2. Click on the “Monitor” tab and then “View CloudWatch logs”.
3. In the most recent log stream, you should see a log entry: Hello John Doe: