Home / AWS / Fix AWS RDS Read Replica Lag High

AWS

Fix AWS RDS Read Replica Lag High

Resolve RDS read replica lag by optimizing replication configuration, scaling resources, and monitoring replication metrics.

Published: Apr 1, 20267 min readBy FixWikiHub Editorial Team

Abstract illustration for a troubleshooting knowledge base category.

Introduction

RDS read replicas asynchronously replicate data from the primary instance. When replication can't keep up with write traffic, the replica falls behind. Queries on the replica return stale data, and the replica may become unusable for read scaling.

Symptoms

Replication lag metrics:

```bash $ aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name ReplicaLag \ --dimensions Name=DBInstanceIdentifier,Value=my-replica \ --statistics Maximum \ --period 300

# Lag showing minutes or hours: "Datapoints": [{"Maximum": 300.0}] # 5 minutes lag ```

Application reads stale data:

sql

-- Primary: Latest transaction ID = 5000
-- Replica query shows:
SELECT MAX(transaction_id) FROM orders;  -- Returns 4800 (missing 200 transactions)

Replica status:

```bash $ aws rds describe-db-instances --db-instance-identifier my-replica \ --query 'DBInstances[*].[DBInstanceStatus,ReadReplicaSourceDBInstanceIdentifier]'

"Status": "available" "ReplicaLag": "3600" # 1 hour behind ```

Common Causes

1.High write throughput - More writes than replication can process
2.Replica undersized - Instance class can't handle replication workload
3.Long-running transactions - Large transactions block replication
4.Network latency - Cross-region or poor network connectivity
5.Binary log contention - MySQL binlog processing bottleneck
6.IOPS limit reached - Storage performance limiting replication
7.Replication thread issues - Single replication thread in MySQL

Step-by-Step Fix

1.Check logs for specific error messages
2.Verify configuration settings
3.Test network connectivity
4.Review recent changes
5.Apply corrective action
6.Verify the fix

Step 1: Monitor Replication Lag

```bash # Check current lag aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name ReplicaLag \ --dimensions Name=DBInstanceIdentifier,Value=my-replica \ --statistics Maximum \ --period 60 \ --start-time $(date -d '1 hour ago' +%s)000

# Set up lag alert aws cloudwatch put-metric-alarm \ --alarm-name rds-replica-lag-high \ --namespace AWS/RDS \ --metric-name ReplicaLag \ --dimensions Name=DBInstanceIdentifier,Value=my-replica \ --threshold 300 \ --comparison-operator GreaterThanThreshold \ --period 60 \ --evaluation-periods 3 ```

Step 2: Check Primary Instance Write Load

```bash # Check write throughput on primary aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name WriteIOPS \ --dimensions Name=DBInstanceIdentifier,Value=my-primary \ --statistics Sum \ --period 300

# Check transaction rate aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name Transactions \ --dimensions Name=DBInstanceIdentifier,Value=my-primary \ --statistics Sum \ --period 300

# If writes exceed 1000/sec, may overwhelm replica ```

Step 3: Upgrade Replica Instance Class

```bash # Compare primary and replica instance classes aws rds describe-db-instances --db-instance-identifier my-primary \ --query 'DBInstances[*].DBInstanceClass'

aws rds describe-db-instances --db-instance-identifier my-replica \ --query 'DBInstances[*].DBInstanceClass'

# Replica should match or exceed primary for compute/storage # Upgrade replica aws rds modify-db-instance \ --db-instance-identifier my-replica \ --db-instance-class db.r6g.xlarge \ --apply-immediately ```

Step 4: Increase Replica IOPS

```bash # Check replica IOPS utilization aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name ReadIOPS \ --dimensions Name=DBInstanceIdentifier,Value=my-replica \ --statistics Maximum \ --period 300

# If hitting Provisioned IOPS limit, increase aws rds modify-db-instance \ --db-instance-identifier my-replica \ --iops 10000 \ --storage-type io1 \ --apply-immediately

# Or switch to gp3 with higher baseline aws rds modify-db-instance \ --db-instance-identifier my-replica \ --storage-type gp3 \ --apply-immediately ```

Step 5: Optimize Long-Running Transactions

```sql -- On primary, check for long transactions SELECT * FROM information_schema.innodb_trx ORDER BY trx_started ASC;

-- Kill blocking transactions if needed CALL mysql.rds_kill(THREAD_ID);

-- Avoid: -- Large batch inserts without chunking -- ALTER TABLE on large tables -- Transactions holding locks for extended periods ```

Chunk large operations:

```python # Instead of single large insert cursor.execute("INSERT INTO table SELECT * FROM source") # BAD

# Chunk the operation for offset in range(0, total, batch_size): cursor.execute(f""" INSERT INTO table SELECT * FROM source LIMIT {batch_size} OFFSET {offset} """) connection.commit() # Commit each chunk ```

Step 6: Check Network Bandwidth

```bash # For cross-region replicas, network bandwidth matters # Check network throughput aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name NetworkReceiveThroughput \ --dimensions Name=DBInstanceIdentifier,Value=my-replica \ --statistics Maximum \ --period 300

# Cross-region replication limited by inter-region bandwidth # Consider same-region replica for better performance ```

Step 7: MySQL Replication Optimization

```bash # Check replica status in MySQL mysql> SHOW SLAVE STATUS;

-- Key fields: -- Seconds_Behind_Master: Lag in seconds -- Relay_Master_Log_File: Current binlog file -- Exec_Master_Log_Pos: Position in binlog

-- Increase parallel replication threads (MySQL 8.0+) aws rds modify-db-parameter-group \ --db-parameter-group-name my-mysql-params \ --parameters ParameterName=replica_parallel_workers,ParameterValue=4,ApplyMethod=immediate ```

Important MySQL parameters:

```bash # Increase binlog buffer aws rds modify-db-parameter-group \ --db-parameter-group-name mysql-params \ --parameters ParameterName=binlog_cache_size,ParameterValue=131072,ApplyMethod=pending-reboot

# Enable parallel replication aws rds modify-db-parameter-group \ --db-parameter-group-name mysql-params \ --parameters ParameterName=slave_parallel_workers,ParameterValue=4,ApplyMethod=pending-reboot

# Check sync_binlog setting # sync_binlog=0: Faster but less durable # sync_binlog=1: Slower but safe ```

Step 8: PostgreSQL Replication Optimization

```sql -- Check replication status SELECT * FROM pg_stat_replication;

-- Key fields: -- sent_lsn, write_lsn, flush_lsn, replay_lsn -- Lag = sent_lsn - replay_lsn

-- Calculate lag in bytes SELECT client_addr, state, sent_lsn - replay_lsn AS lag_bytes, pg_wal_lsn_diff(sent_lsn, replay_lsn) / 1024 / 1024 AS lag_mb FROM pg_stat_replication; ```

Optimize PostgreSQL parameters:

```bash # Increase max_wal_senders aws rds modify-db-parameter-group \ --db-parameter-group-name postgres-params \ --parameters ParameterName=max_wal_senders,ParameterValue=10,ApplyMethod=pending-reboot

# Adjust wal_keep_size aws rds modify-db-parameter-group \ --db-parameter-group-name postgres-params \ --parameters ParameterName=wal_keep_size,ParameterValue=2048,ApplyMethod=pending-reboot ```

Step 9: Restart Replication If Stalled

```bash # For MySQL - restart replication mysql> STOP SLAVE; mysql> START SLAVE;

# For PostgreSQL - reconnect replica aws rds reboot-db-instance --db-instance-identifier my-replica

# If severe lag, recreate replica aws rds delete-db-instance --db-instance-identifier my-replica --skip-final-snapshot

aws rds create-db-instance-read-replica \ --db-instance-identifier my-replica \ --source-db-instance-identifier arn:aws:rds:region:account:db:my-primary ```

Step 10: Consider Aurora for Better Replication

```bash # Aurora has near-instant replication (milliseconds) # Aurora replicas share storage with primary

aws rds create-db-cluster \ --db-cluster-identifier my-aurora-cluster \ --engine aurora-mysql \ --master-username admin \ --master-user-password password

aws rds create-db-instance \ --db-instance-identifier my-aurora-replica \ --db-cluster-identifier my-aurora-cluster \ --instance-class db.r6g.large \ --engine aurora-mysql ```

Aurora advantages: - Replicas can be promoted instantly - No replication lag for reads (shared storage) - Up to 15 replicas per cluster

Replication Lag Thresholds

Lag	Impact	Action
< 1 second	Excellent	Normal operation
1-30 seconds	Acceptable	Monitor closely
30-60 seconds	Concerning	Investigate cause
1-5 minutes	Poor	Scale resources, optimize
> 5 minutes	Critical	Restart/recreate replica

Verification

```bash # Check lag after fix aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name ReplicaLag \ --dimensions Name=DBInstanceIdentifier,Value=my-replica \ --statistics Maximum \ --period 60

# Should show lag < 30 seconds

# Query replica and verify data matches mysql> SHOW SLAVE STATUS; # Seconds_Behind_Master should be small ```

[Fix AWS RDS Connection Limit Exceeded](/articles/fix-aws-rds-connection-limit-exceeded)
[Fix AWS RDS Aurora Failover Slow](/articles/fix-aws-rds-aurora-failover-slow)
[Fix AWS RDS Parameter Group Not Applying](/articles/fix-aws-rds-parameter-group-not-applying)

[AWS troubleshooting: Fix IAM Permission Denied - Complete Tro](fix-iam-permission-denied)
[AWS cloud troubleshooting: AWS ACM Certificate Pending Validation Because the](aws-acm-certificate-pending-validation-wrong-route53-zone)
[AWS cloud troubleshooting: AWS ALB Returns 502 Because the Target Closed the ](aws-alb-502-target-closed-connection-keepalive-timeout-mismatch)
[AWS cloud troubleshooting: Fix AWS ALB CreateListener TargetGroupNotFound Err](aws-alb-createlistener-targetgroupnotfound)
[AWS cloud troubleshooting: Fix Aws Alb Lambda 502 Bad Gateway Issue in AWS](aws-alb-lambda-502-bad-gateway)

Was this guide helpful?

Related search paths

People also search for

If the symptom is close but not identical, these search paths usually surface the right neighboring fixes faster than scrolling the full archive.

AWS RDS Read Replica Lag High AWS RDS Read Replica Lag High AWS AWS RDS Read Replica Lag High troubleshooting AWS RDS Read Replica Lag High fix Resolve RDS read replica lag by optimizing replication configuration, scaling resources, and monitoring replication metrics AWS Resolve RDS read replica lag by optimizing replication configuration, scaling resources, and monitoring replication metrics

Explore Related Topics

Browse Guides from Other Categories

Discover troubleshooting guides from related categories to expand your knowledge.

FAQ

AWS Troubleshooting FAQs

Common questions about troubleshooting and preventing similar issues

How do I know if this aws-errors troubleshooting guide applies to my situation?

This guide is designed for aws-errors issues. If you're experiencing similar symptoms described in the article, follow the step-by-step instructions. Start with the most common causes and work through the diagnostic process.

Is it safe to follow these aws-errors troubleshooting steps?

Yes, all steps are designed to be safe and non-destructive. We recommend creating backups before making significant changes and testing each step before proceeding to the next.

How long does it typically take to resolve this type of aws-errors issue?

Most aws-errors issues can be resolved within 30 minutes to 2 hours, depending on the complexity and root cause. Follow the troubleshooting flow to identify and fix the problem efficiently.

How can I prevent this aws-errors issue from happening again?

Regular maintenance, monitoring, and following best practices for aws-errors configuration can help prevent recurrence. Consider implementing automated checks and alerts for early detection.

Written by

FixWikiHub Editorial Team

Our editorial team consists of experienced DevOps engineers, systems administrators, and cloud architects with hands-on experience in production environments across AWS, Azure, GCP, and on-premises infrastructure.

Every guide undergoes technical review for accuracy and is updated when software versions, commands, or best practices change.

Last updated: Apr 1, 2026

About our team

Important Notice

Disclaimer & Safety Guidelines

The troubleshooting steps in this guide are provided for educational and informational purposes. Before applying any changes to production systems:

Test in a staging environment first — Always verify commands and configurations in a non-production environment before deploying to live systems.
Create backups — Ensure you have current backups of databases, configurations, and critical files before making changes.
Understand the impact — Review how each step may affect your specific environment, dependencies, and users.
Consult official documentation — This guide supplements, but does not replace, official vendor documentation and best practices.

FixWikiHub is not responsible for any damages arising from the use of this content. See our Terms of Use for more information.

Resources

Official Documentation & Further Reading

For authoritative information, consult the official documentation for the technologies discussed in this guide. Our troubleshooting content supplements, but does not replace, vendor documentation.

AWS Documentation — Official Amazon Web Services guides and API references
Kubernetes Documentation — Official Kubernetes documentation
Nginx Documentation — Official Nginx web server documentation
Apache Documentation — Official Apache HTTP Server documentation
Docker Documentation — Official Docker container documentation

Fix AWS RDS Read Replica Lag High

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Monitor Replication Lag

Step 2: Check Primary Instance Write Load

Step 3: Upgrade Replica Instance Class

Step 4: Increase Replica IOPS

Step 5: Optimize Long-Running Transactions

Step 6: Check Network Bandwidth

Step 7: MySQL Replication Optimization

Step 8: PostgreSQL Replication Optimization

Step 9: Restart Replication If Stalled

Step 10: Consider Aurora for Better Replication

Replication Lag Thresholds

Verification

People also search for

Browse Guides from Other Categories

WordPress

SSL

DNS

AWS Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading

Fix AWS RDS Read Replica Lag High

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Monitor Replication Lag

Step 2: Check Primary Instance Write Load

Step 3: Upgrade Replica Instance Class

Step 4: Increase Replica IOPS

Step 5: Optimize Long-Running Transactions

Step 6: Check Network Bandwidth

Step 7: MySQL Replication Optimization

Step 8: PostgreSQL Replication Optimization

Step 9: Restart Replication If Stalled

Step 10: Consider Aurora for Better Replication

Replication Lag Thresholds

Verification

Related Issues

Related Articles

People also search for

Share this guide

More AWS Troubleshooting Guides

Browse Guides from Other Categories

AWS Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading