DEV Community: Darshan

Zero-Downtime-Cross-Region-Database-Migration-using-AWS-DMS

Darshan — Fri, 24 Apr 2026 12:49:33 +0000

Overview
This project demonstrates how to perform a zero-downtime database migration across AWS regions using:

AWS Database Migration Service (DMS)
Amazon RDS (MySQL)
AWS CloudFormation
The system uses Change Data Capture (CDC) to continuously replicate database changes, ensuring minimal downtime and real-time synchronization.

🎯 Key Features
✅ Zero/near-zero downtime migration
🔄 Real-time data replication using CDC
🌍 Cross-region migration (e.g., Mumbai → Singapore)
⚡ Automated infrastructure setup
🔍 Data validation and consistency

🏗️ Architecture

![Uploading image](...

🔁 Workflow
Full data load from source to target
CDC captures real-time changes
DMS applies changes continuously
Target DB stays in sync
Cutover to target database
🧰 Tech Stack
AWS DMS
Amazon RDS (MySQL)
AWS CloudFormation
MySQL Workbench
⚙️ Step-by-Step Implementation
🟦 Step 1: Create Source Database (RDS - Region A)
Go to AWS Console → RDS
Click Create Database
Select:
Engine: MySQL
Instance: db.t3.micro
Set username & password
Enable public access (for testing)
or (Use cloud formation code)

download the source-db.yaml from cloudformaton/ folder

open cloudformation in aws cli

click on create stack

select - choose an existing template

select - upload a template file

create stack

🟦 Step 2: Create Target Database (RDS - Region B)
Switch AWS region
Repeat same steps as source
or (Use cloud formation code)

use target-db.yaml file from cloudformation/ folder
🟦 Step 3: Enable CDC (IMPORTANT)
Create Parameter Group
Go to RDS → Parameter Groups
Create new parameter group
Set:
binlog_format = ROW
binlog_row_image = FULL
Attach to source DB
Reboot database
Step 4: Create DMS Replication Instance
Go to DMS → Replication Instances Click Create Select: Instance: dms.t3.medium

Step 5: Create Endpoints
Source Endpoint

Enter source DB details (endpoint of source RDS)

Test connection

Target Endpoint

Enter target DB details (endpoint of destination RDS)

Test connection

Step 6: Create Migration Task
Go to DMS → Tasks → Create Task Configure: Migration Type: Full Load + CDC (change data capture) Table Mapping: Schema: demo_db Table: users

Step 7: Start Migration
Start the task Monitor: Full load CDC status

Step 8: Validate Data
connect source-db RDS database to mysql workbeanch
username admin password - Password123!
endpoint is RDS database endpoint
do the same for target RDS database

Source: INSERT INTO users VALUES (1, 'test_user');

Source database:

Step 9: Test CDC
UPDATE users SET name = 'updated' WHERE id = 1;

👉 Changes should reflect in target DB instantly Target database :

Step 10: Cutover
Stop writes to source Ensure replication lag = 0 Switch application to target DB

Key Concepts
🔹 What is CDC?

CDC captures changes (INSERT, UPDATE, DELETE) from database logs and replicates them in real time.

🔹 What is Replication Instance?

It is the compute engine that:

Reads source DB
Processes data
Writes to target DB
🔹 What is DMS Task?

Defines:

What to migrate
How to migrate
When to migrate
Common Issues & Fixes
possible errors
Error 1236 (Binlog Not Found)

Cause: Old logs deleted

Fix:

Recreate task Start from beginning

CDC Not Working Fix: binlog_format = ROW binlog_row_image = FULL

Data Not Syncing Check task status Ensure CDC enabled

Cost Estimation
Service Cost RDS (2 instances) ~$1.6 DMS ~$2.4 Data Transfer ~$0.2 Total ~$4–5

Results
✅ Zero downtime migration achieved
🔄 Real-time replication working
📈 Data consistency maintained
🏁 Conclusion
This project demonstrates how AWS DMS with CDC enables seamless and reliable database migration with minimal downtime.

References
1.AWS DMS Documentation 2.AWS RDS Documentation 3.MySQL Binlog Documentation

Author
Darshan B

Deploying First Website on AWS EC2 (step by step guide)

Darshan — Thu, 02 Apr 2026 15:30:46 +0000

In this blog, I’ll walk through how I deployed my first website on an EC2 instance using AWS.
We will cover everything from launching an instance to connecting via SSH and hosting a static HTML page using Nginx.

Step 1: Create an AWS EC2 Instance

Go to AWS Console → EC2 Dashboard
Click on Launch Instance

Configuration:
Name: any-name
AMI: Amazon Linux 2023
Instance Type: t2.micro or t3.micro (Free Tier)

Key Pair:
Create a new key pair
Name : my-key-pair

Download .pem file (very important)

Step 2: Configure Security Group

Allow the following:

SSH (Port 22) → Anywhere (0.0.0.0/0)
HTTP (Port 80) → Anywhere (0.0.0.0/0)

Copy the public Ipv4 of your ec2 instance

Step 3: Connect to EC2 via SSH (Windows)

Open Command prompt and run:

ssh -i my-key-pair.pem ec2-user@PUBLIC_IP_OF_EC2

Step 4: Update the Server
sudo yum update -y

Step 5: Install Nginx
sudo dnf install nginx -y

Start and enable Nginx:

sudo systemctl start nginx
sudo systemctl enable nginx

Check status:

sudo systemctl status nginx

Step 6: Access Default Nginx Page

Open browser and go to:

http://PUBLIC_IP_OF_EC2

You shoud see:

Step 8: Replace Default HTML Page

Navigate to Nginx folder:

cd /usr/share/nginx/html

Edit file:

sudo nano index.html

Paste:

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Hello from EC2 Website</title>
</head>
<body>
  <h1>Hello from EC2</h1>
  <p>This is my first deployed website</p>
</body>
</html>

Save and exit.

Step 9: Restart Nginx
sudo systemctl restart nginx

Step 10: View Your Website

Open:

http://PUBLIC_IP_OF_EC2

U will see Your html page

Key Learnings
EC2 is a virtual server in the cloud
SSH allows remote access
Nginx serves web content
File paths matter (/ vs ~)
Security Groups control access

Day 4: System Design Basics + AWS Storage

Darshan — Tue, 24 Mar 2026 09:41:03 +0000

Today was all about understanding how real-world systems are designed for scalability, speed, and reliability.

🔹 Username Availability Check (Backend Logic)
Ever wondered how apps instantly tell you “username already taken”?
I explored:

Using Redis HashMap for fast lookup (cache hit ⚡)
Storing key-value pairs like username → userId
Result: Super fast checks without hitting the database every time

Also learned about:

Tries (Prefix Trees) → Efficient string search
Time Complexity: O(m), where m = length of string

🔹 Data Structures for Scale

B+ Trees → Used in databases (O(log N))
Bloom Filters → Memory-efficient, fast checks (with small error probability)

🔹 System Design Components

💡 API Gateway

Handles requests
Authentication & Authorization
Rate limiting
Request/Response transformation
Monitoring & analytics

💡 Load Balancer

Distributes traffic across servers
Improves scalability & availability
Algorithms:
Round Robin
Least Connections
IP Hash
Weighted

💡 Reverse Proxy (like Nginx)

Sits in front of servers
Adds caching, security, compression
Flow: Client → Proxy → Backend → Proxy → Response

🔹 AWS Storage Deep Dive

📦 EBS (Elastic Block Storage)

Virtual hard disk for EC2
Persistent storage
Can detach & attach to other instances
Works within same Availability Zone

📦 S3 (Object Storage)

Stores files, backups
Access via API (HTTP)
Highly scalable

📦 Instance Storage

Temporary (ephemeral)
Very fast
Used for cache/temp data

🔥 Key Takeaway
Speed = Cache (Redis)
Scalability = Load Balancer + API Gateway
Efficiency = Right Data Structure (Trie, Bloom Filter)
Storage = Use the right AWS service

Day - 1

Darshan — Thu, 12 Mar 2026 19:01:41 +0000

Today marks Day 1 of my 180-day journey to becoming a Backend & Cloud Engineer.

My focus areas for this challenge are:

Data Structures & Algorithms (DSA)

Backend Development

Cloud Computing

DevOps

Here’s what I learned today.

Recursion (Basics)

I started learning the fundamentals of recursion, where a function calls itself to solve smaller instances of the same problem.

Key Ideas

Break the problem into smaller subproblems

Define a base case

The recursive call solves the rest

Example
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)

I also solved one basic recursion problem to understand how recursive calls work in the call stack.

Hashing (Basics)

Next, I explored hashing, which is used to map keys to values efficiently.

Why Hashing is Useful

Fast lookup

Efficient data retrieval

Commonly used for frequency counting problems

Example Idea

Counting the occurrences of elements using a hash map.

Example concept:

arr = [1,2,2,3,3,3]

freq = {}

for num in arr:
freq[num] = freq.get(num,0) + 1

print(freq)

I solved one hashing-based problem to practice the concept.

Understanding Live Stream Architecture

Today I explored how live streaming platforms work behind the scenes.

Reference video:
https://youtu.be/Q9LC-WN9X4k

Basic Flow
Camera / Stream Source
↓
Encoder
↓
Streaming Server (RTMP)
↓
CDN (Content Delivery Network)
↓
Viewer Devices
Important Concepts

Video Encoding

Streaming Protocols

Content Delivery Networks (CDNs)

Real-time data delivery

This gave me a good overview of how platforms like YouTube Live or Twitch deliver video streams to millions of users.

DevOps Fundamentals

Today I started learning the foundations of DevOps and infrastructure.

Localhost

Refers to the local machine

Usually accessed using:

127.0.0.1
Deployment

Deployment is the process of making an application available to users.

Common Deployment Approaches

Manual deployment

Automated deployment pipelines

Domain vs IP Address

Example:

142.250.183.46 → IP Address
google.com → Domain Name

Domains are easier for humans to remember, while computers communicate using IP addresses.

Routing

Routing is the process of directing traffic between networks.

Servers

Two types of servers I learned today:

Bare Metal Server

A physical machine

Dedicated entirely to one user or application

Virtual Machine (VM)

A virtualized system

Runs on top of a host machine

SSH Protocol

SSH (Secure Shell) is used to securely access remote machines.

Example command:

ssh user@server_ip

This is widely used in cloud infrastructure and DevOps workflows.

Key Takeaways

Recursion helps solve problems using smaller subproblems.

Hashing enables efficient lookups and frequency counting.

Live streaming relies on encoders, streaming servers, and CDNs.

DevOps basics revolve around infrastructure, deployment, and remote server management.

Diving into Cloud Computing.....

Darshan — Thu, 24 Jul 2025 05:39:32 +0000

Hey folks! 👋

After spending some amazing time building projects and learning in the web development space, I’ve recently found a strong interest in cloud computing—and I’ve officially started my journey into this powerful domain!

The world of cloud its scalability, flexibility, and real-world impact—has really piqued my curiosity, and I’m excited to explore areas like AWS, DevOps, Infrastructure as Code, Cloud Architecture, and beyond.

🧠 If you're someone who:

Is currently learning cloud computing

Is already working in the cloud domain

…I'd love to connect, learn from your experiences, and get any suggestions, resources, or guidance you might have.

Let’s learn and grow together in the cloud! 🌩️
Feel free to drop a comment or DM happy to network with like-minded folks! 🙌