Comprehensive Guide to MySQL to Amazon Redshift Data Replication Using Tungsten Replicator

Introduction

In today’s data-driven landscape, organizations frequently need to replicate data from operational MySQL databases to analytical platforms like Amazon Redshift for business intelligence and reporting purposes. This process presents unique challenges, particularly when dealing with heterogeneous database systems that have different architectures and data formats.

Amazon Redshift, as a fully managed data warehouse service, requires specialized approaches for data ingestion from traditional RDBMS systems like MySQL. This comprehensive guide explores how to implement real-time data replication from MySQL to Amazon Redshift using Tungsten Replicator, an enterprise-grade open-source solution that simplifies cross-platform data synchronization.

Understanding Tungsten Replicator

Core Architecture Overview

Tungsten Replicator is a robust, open-source replication engine designed to extract data from various MySQL variants (including Amazon RDS, Percona Server, and MariaDB) and Oracle databases, then apply this data to diverse target systems such as Vertica, Cassandra, and Amazon Redshift. The solution supports advanced replication topologies including parallel replication, fan-in configurations, and multi-master setups, making it ideal for complex enterprise environments.

Three-Component Architecture

The Tungsten Replicator architecture consists of three fundamental components:

1. Extractor (Master Service)

The extractor component continuously monitors MySQL’s binary log (binlog) and captures all data changes in real-time. It then writes this transactional information into the Transaction History Log for further processing.

2. Transaction History Log (THL)

The THL serves as an intelligent intermediary that stores transactional data from source databases in a universal format. This component acts as a translator between different database systems, ensuring data consistency and enabling seamless cross-platform replication.

3. Applier (Slave Service)

The applier component processes raw row-data from the THL and transforms it into appropriate formats (JSON, BSON, or CSV) for bulk loading into target systems. This component is crucial for heterogeneous deployments and requires MySQL binary log format to be set to ROW.

Prerequisites and System Requirements

Server Environment Setup

Before implementing Tungsten Replicator, ensure your environment meets the following requirements:

Software Dependencies:

• Java Development Kit (JDK) 7 or higher
• Apache Ant 1.8 or higher
• Ruby runtime environment
• Net-SSH library

MySQL Configuration Requirements

Your MySQL source database must be configured with the following parameters:

-- Essential MySQL configuration
binlog-format = row
binlog-row-image = full
collation-server = utf8_general_ci
character-set-server = utf8

Critical Requirements:

• All tables designated for replication must have primary keys
• Binary logging must be enabled with ROW format
• Sufficient disk space for binary log retention

Amazon Redshift Prerequisites

Database Structure:

• Target database and schema names must match the source MySQL database names
• Appropriate user permissions for data loading operations
• Network connectivity between replication server and Redshift cluster

AWS S3 Configuration:

• Dedicated S3 bucket with read/write permissions
• Valid AWS access key and secret key credentials
• Proper IAM roles for Redshift to access S3 resources

Implementation Guide

Environment Setup Example

For this implementation, we’ll use the following infrastructure:

• MySQL Source Server: 10.0.1.100 (EC2 instance)
• Amazon Redshift Cluster: analytics-cluster.abc123.us-east-1.redshift.amazonaws.com
• S3 Staging Bucket: s3://minervadb-replication-staging
• Target Tables: customer_profiles, transaction_history from ecommerce_analyticsdatabase

Step 1: Tungsten Replicator Installation

Clone and build Tungsten Replicator from the official repository:

# Clone the repository
git clone https://github.com/continuent/tungsten-replicator.git

# Build the package
cd tungsten-replicator
sh builder/build.sh

# Create installation directory
mkdir -p /opt/tungsten-replicator

# Extract built package
tar --strip-components 1 -zxvf builder/build/tungsten-replicator-5.2.1.tar.gz -C /opt/tungsten-replicator/

# Clean up source files
cd .. && rm -rf tungsten-replicator

Step 2: Redshift Schema Preparation

Create the target database and tables in Amazon Redshift:

-- Connect to Redshift and create database
CREATE DATABASE ecommerce_analytics;

-- Switch to the new database
\c ecommerce_analytics

-- Create target tables with appropriate data types
CREATE TABLE ecommerce_analytics.customer_profiles (
    customer_id INT PRIMARY KEY,
    email_address VARCHAR(255),
    registration_date DATE,
    customer_tier VARCHAR(50)
);

CREATE TABLE ecommerce_analytics.transaction_history (
    transaction_id BIGINT PRIMARY KEY,
    customer_id INT,
    transaction_amount DECIMAL(10,2),
    transaction_timestamp TIMESTAMP,
    product_category VARCHAR(100)
);

Step 3: Master Service Configuration

Create a dedicated replication user in MySQL:

-- Create replication user with appropriate privileges
GRANT REPLICATION SLAVE ON *.* TO 'tungsten_replicator'@'localhost' 
IDENTIFIED BY 'SecureReplicationPassword2024';

FLUSH PRIVILEGES;

Configure the Tungsten master service:

cd /opt/tungsten-replicator

# Reset configuration defaults
./tools/tpm configure defaults --reset

# Configure master service
./tools/tpm configure master \
--install-directory=/opt/tungsten-master \
--enable-heterogeneous-service=true \
--members=mysql-source-server \
--master=mysql-source-server

# Set connection parameters
./tools/tpm configure master --hosts=mysql-source-server \
--replication-user=tungsten_replicator \
--replication-password=SecureReplicationPassword2024 \
--skip-validation-check=MySQLUnsupportedDataTypesCheck \
--property=replicator.filter.pkey.addColumnsToDeletes=true \
--property=replicator.filter.pkey.addPkeyToInserts=true

# Install master configuration
./tools/tpm install

Step 4: Slave Service Configuration

Create the S3 configuration file:

{
    "awsS3Path": "s3://minervadb-replication-staging",
    "awsAccessKey": "AKIAIOSFODNN7EXAMPLE",
    "awsSecretKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "gzipS3Files": "false",
    "cleanUpS3Files": "true"
}

Configure the slave service for Redshift:

# Reset configuration
./tools/tpm configure defaults --reset

# Configure slave service
./tools/tpm configure slave \
--install-directory=/opt/tungsten-slave \
--enable-heterogeneous-service=true \
--members=mysql-source-server

# Set Redshift connection and replication filters
./tools/tpm configure slave --hosts=mysql-source-server \
--replication-host=analytics-cluster.abc123.us-east-1.redshift.amazonaws.com \
--replication-user=redshift_admin \
--replication-password=RedshiftAdminPassword2024 \
--datasource-type=redshift \
--batch-enabled=true \
--batch-load-template=redshift \
--redshift-dbname=ecommerce_analytics \
--svc-applier-filters=dropstatementdata,replicate \
--property=replicator.filter.replicate.do=ecommerce_analytics.customer_profiles,ecommerce_analytics.transaction_history \
--svc-applier-block-commit-interval=30s \
--svc-applier-block-commit-size=10 \
--rmi-port=10002 \
--thl-port=2113 \
--master-thl-port=2112 \
--master-thl-host=mysql-source-server

# Install slave configuration
./tools/tpm install

# Copy S3 configuration file
cp s3-config.json /opt/tungsten-slave/share/

Step 5: Worker Table Generation

Generate and create staging tables in Redshift:

# Generate staging table DDL
/opt/tungsten-slave/tungsten/tungsten-replicator/bin/ddlscan \
-db ecommerce_analytics \
-template ddl-mysql-redshift-staging.vm > redshift_staging_tables.sql

# Apply staging tables to Redshift
psql -h analytics-cluster.abc123.us-east-1.redshift.amazonaws.com \
-U redshift_admin -d ecommerce_analytics -f redshift_staging_tables.sql

Step 6: Replication Startup and Verification

Start the master service:

/opt/tungsten-master/tungsten/cluster-home/bin/startall

# Verify master status
/opt/tungsten-master/tungsten/tungsten-replicator/bin/trepctl services

/opt/tungsten-slave/tungsten/cluster-home/bin/startall

# Verify slave status
/opt/tungsten-slave/tungsten/tungsten-replicator/bin/trepctl services

-- Insert test data into MySQL
INSERT INTO customer_profiles VALUES 
(1001, 'john.doe@email.com', '2024-01-15', 'Premium'),
(1002, 'jane.smith@email.com', '2024-01-16', 'Standard'),
(1003, 'mike.johnson@email.com', '2024-01-17', 'Premium');

INSERT INTO transaction_history VALUES 
(50001, 1001, 299.99, '2024-01-20 14:30:00', 'Electronics'),
(50002, 1002, 149.50, '2024-01-20 15:45:00', 'Clothing'),
(50003, 1003, 89.99, '2024-01-20 16:20:00', 'Books');

-- Check replicated customer data
SELECT * FROM ecommerce_analytics.customer_profiles;

-- Check replicated transaction data
SELECT * FROM ecommerce_analytics.transaction_history;

-- Verify data consistency
SELECT 
    cp.customer_id,
    cp.email_address,
    COUNT(th.transaction_id) as transaction_count,
    SUM(th.transaction_amount) as total_spent
FROM ecommerce_analytics.customer_profiles cp
LEFT JOIN ecommerce_analytics.transaction_history th 
    ON cp.customer_id = th.customer_id
GROUP BY cp.customer_id, cp.email_address;

pendingError: Stage task failed: stage=q-to-dbms seqno=125 fragno=0
pendingErrorCode: NONE
pendingErrorEventId: mysql-bin.000015:0000000000089234;-1
pendingExceptionMessage: CSV loading failed: schema=ecommerce_analytics table=customer_profiles 
message=Value too long for character type

-- Add new column with larger capacity
ALTER TABLE ecommerce_analytics.customer_profiles 
ADD COLUMN email_address_new VARCHAR(500);

-- Copy existing data
UPDATE ecommerce_analytics.customer_profiles 
SET email_address_new = email_address;

-- Drop old column and rename new one
ALTER TABLE ecommerce_analytics.customer_profiles 
DROP COLUMN email_address;

ALTER TABLE ecommerce_analytics.customer_profiles 
RENAME COLUMN email_address_new TO email_address;

# Check replication lag
/opt/tungsten-slave/tungsten/tungsten-replicator/bin/trepctl status | grep appliedLatency

# Monitor error logs
tail -f /opt/tungsten-slave/service_logs/trepsvc.log

# Verify sequence numbers are advancing
/opt/tungsten-slave/tungsten/tungsten-replicator/bin/trepctl status | grep appliedLastSeqno

# For high-volume environments
--svc-applier-block-commit-interval=60s
--svc-applier-block-commit-size=50

# For low-latency requirements
--svc-applier-block-commit-interval=10s
--svc-applier-block-commit-size=5

# Configure parallel processing
./tools/tpm configure slave \
--svc-parallelization-type=disk \
--channels=4 \
--svc-parallelization-store-class=com.continuent.tungsten.replicator.storage.parallel.ParallelQueueStore

// Example transformation filter
function filter(event) {
    // Transform customer tier values
    if (event.data.customer_tier === 'VIP') {
        event.data.customer_tier = 'Premium Plus';
    }

    // Format email addresses to lowercase
    if (event.data.email_address) {
        event.data.email_address = event.data.email_address.toLowerCase();
    }

    return event;
}

# Enable DDL replication
./tools/tpm configure slave \
--property=replicator.applier.ddl.enabled=true \
--property=replicator.applier.ddl.createTablesEnabled=true

# Configure SSL for MySQL connection
./tools/tpm configure master \
--property=replicator.datasource.mysql.connectionSpec.useSSL=true \
--property=replicator.datasource.mysql.connectionSpec.requireSSL=true

# Configure SSL for Redshift connection
./tools/tpm configure slave \
--property=replicator.datasource.redshift.connectionSpec.ssl=true

-- Create dedicated replication user with minimal privileges
CREATE USER 'tungsten_readonly'@'%' IDENTIFIED BY 'ComplexPassword2024!';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'tungsten_readonly'@'%';

-- Enable audit logging for replication activities
SET GLOBAL general_log = 'ON';
SET GLOBAL log_output = 'TABLE';

#!/bin/bash
# replication_monitor.sh

TUNGSTEN_HOME="/opt/tungsten-slave"
LOG_FILE="/var/log/tungsten-monitor.log"
ALERT_THRESHOLD=300  # 5 minutes in seconds

# Check replication lag
LAG=$($TUNGSTEN_HOME/tungsten/tungsten-replicator/bin/trepctl status | grep appliedLatency | awk '{print $2}')

if [ "$LAG" -gt "$ALERT_THRESHOLD" ]; then
    echo "$(date): ALERT - Replication lag is ${LAG} seconds" >> $LOG_FILE
    # Send alert notification
    curl -X POST "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK" \
         -H 'Content-type: application/json' \
         --data '{"text":"Tungsten Replicator lag alert: '$LAG' seconds"}'
fi

# Create monitoring cron job
echo "*/5 * * * * /opt/scripts/replication_monitor.sh" | crontab -

# Log key metrics every 5 minutes
echo "*/5 * * * * /opt/tungsten-slave/tungsten/tungsten-replicator/bin/trepctl status >> /var/log/tungsten-metrics.log" | crontab -

# Backup THL data
tar -czf /backup/thl-backup-$(date +%Y%m%d).tar.gz /opt/tungsten-slave/tungsten/tungsten-replicator/log/

# Backup configuration files
tar -czf /backup/config-backup-$(date +%Y%m%d).tar.gz /opt/tungsten-slave/tungsten/cluster-home/conf/

# Configure multiple master sources
./tools/tpm configure slave \
--master-thl-host=mysql-primary,mysql-secondary \
--property=replicator.service.autoFailover=true