Amazon RDS

Datafly Signal writes first-party events directly to an Amazon RDS instance over the native database protocol. Signal connects to RDS exactly as any application would — there is no Data API or special proxy involved.

Variants:

amazon_rds_postgres — RDS for PostgreSQL or Aurora PostgreSQL. Uses the PostgreSQL wire protocol.
amazon_rds_mysql — RDS for MySQL or Aurora MySQL. Uses the MySQL wire protocol.
amazon_rds_sqlserver — RDS for SQL Server. Uses the same TDS-based protocol as Azure SQL.

Why route Amazon RDS through Datafly Signal

The data lands in infrastructure you own. Signal writes to your Amazon RDS directly from your own deployment. Datafly operates no intermediary and never holds a copy of your event data.
Client IP and user agent are recorded as event context. Both come from the original visitor request rather than from your server, so geography and device analysis done in the warehouse reflects the actual visitor.
One consent decision governs every destination. Amazon RDS is gated by the same consent state as the rest of your stack, so a withdrawal applies everywhere at once.

Prerequisites

Before configuring Amazon RDS in Signal you need an AWS account with an RDS instance running, a target schema/table, a database user, and network connectivity from Signal to the instance.

Create an RDS Instance

Open the RDS console.
Click Create database.
Choose the engine: PostgreSQL, MySQL, MariaDB, SQL Server, Aurora PostgreSQL, or Aurora MySQL.
Pick a deployment option (Single-AZ for dev, Multi-AZ for production), instance class, and storage settings.
Set the Master username and Master password.
Configure VPC, subnet group, and public accessibility as needed.
Click Create database.

Note the Endpoint (e.g. datafly-db.abc123.us-east-1.rds.amazonaws.com) and Port (5432 / 3306 / 1433 depending on engine) once the instance is available.

Configure Network Access

Open the RDS instance’s VPC security group.
Add an Inbound rule allowing the relevant port from the IP addresses or CIDR range of your Signal deployment.
If Signal runs outside the VPC, enable Publicly accessible on the instance.

⚠️

Never allow 0.0.0.0/0 access to a production database. Restrict inbound rules to your Signal infrastructure’s IP addresses or use a VPC peering / PrivateLink connection.

Create a Database, Schema, and Table

Connect to the instance with psql, mysql, or sqlcmd and create the target objects. Use the table definition from the matching engine guide:

PostgreSQL: see Schema
MySQL: see Schema
SQL Server: see Schema

Create a Database User for Signal

Create a least-privilege user with INSERT on the target table only. Example for PostgreSQL:

CREATE USER datafly_signal WITH PASSWORD 'your_secure_password';
GRANT USAGE ON SCHEMA datafly TO datafly_signal;
GRANT INSERT ON TABLE datafly.events TO datafly_signal;

Configuration

The fields below apply to amazon_rds_postgres and amazon_rds_mysql:

Field	Type	Required	Description
`host`	string	Yes	The RDS endpoint hostname.
`port`	string	Yes	Database port (`5432` PG, `3306` MySQL).
`database`	string	Yes	The target database name.
`schema_name`	string	PG only	The schema to write to. PostgreSQL only.
`table_name`	string	Yes	The target table name.
`username`	string	Yes	Database username.
`password`	secret	Yes	Database password.
`ssl_mode`	select	No	PostgreSQL SSL mode (`disable`, `require`, `verify-ca`, `verify-full`).
`tls_mode`	select	No	MySQL TLS mode.

For amazon_rds_sqlserver, the fields match Azure SQL (server, port, database, schema_name, table_name, username, password, encrypt).

Signal Setup

Quick Setup

Navigate to Integrations in the sidebar.
Open the Integration Library tab.
Find Amazon RDS or filter by Database.
Click Install, select the variant matching your engine (postgres, mysql, or sqlserver), and fill in the required fields.
Click Install Integration to create the integration with a ready-to-use default blueprint.

API Setup (PostgreSQL example)

curl -X POST http://localhost:8084/v1/admin/integration-catalog/amazon_rds_postgres/install \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Amazon RDS (PostgreSQL)",
    "variant": "postgres",
    "config": {
      "host": "datafly-db.abc123.us-east-1.rds.amazonaws.com",
      "port": "5432",
      "database": "datafly_events",
      "schema_name": "datafly",
      "table_name": "events",
      "username": "datafly_signal",
      "password": "your_secure_password",
      "ssl_mode": "require"
    },
    "delivery_mode": "server_side"
  }'

Schema

Signal writes the standard event envelope. Use the same column layout as the underlying engine page:

RDS is a first-party destination in your own AWS account. The default blueprint forwards all events. Apply consent filtering via pipeline transforms or downstream views on context if your governance requires it.

Testing

Enable the integration in Signal and trigger a test event on your website.

Connect to the RDS instance and query the target table:

SELECT * FROM datafly.events ORDER BY timestamp DESC LIMIT 10;

Verify that event rows are appearing with correct data.
In Signal, check the Live Events view to confirm delivery status shows as successful.

Troubleshooting

Problem	Solution
Connection refused / timeout	Check the VPC security group allows inbound traffic on the relevant port from Signal’s IP addresses. Verify the instance is publicly accessible if Signal runs outside the VPC.
Authentication failure	Verify the database username and password. Check that the user has not been locked out.
`permission denied`	The user lacks `INSERT` on the table (or `USAGE` on the schema for PostgreSQL). Grant the required permissions.
`relation/table does not exist`	Verify the database, schema, and table names. Use fully-qualified names.
SSL connection errors	Most RDS engines require SSL. Use `ssl_mode=require` (PostgreSQL) or `tls_mode=required` (MySQL).
Slow inserts	Add indexes that match your query patterns; verify the instance class is not bottlenecked.

Visit Amazon RDS documentation for full engine-specific configuration guides.