Amazon Aurora & Read Replicas
Key concepts
Aurora storage architecture
Up to 15 read replicas
Aurora Serverless v2
Aurora Global Database
Aurora cloning
Overview
Amazon Aurora is a fully managed relational database engine that is compatible with MySQL and PostgreSQL. It runs on Amazon RDS (Relational Database Service), but it replaces the traditional storage layer with a distributed, cloud-native design that separates compute from storage. The storage layer automatically grows in 10 GB increments up to 256 TiB (128 TiB on older engine versions) and replicates your data six ways across three Availability Zones, so durability and self-healing are built in rather than bolted on.
For SAA-C03 this topic is high-yield because Aurora answers many "high-performing, highly available, low-management database" scenarios. You should know how its shared storage architecture enables fast read replica creation, that it supports up to 15 low-latency read replicas, how Aurora Serverless v2 scales capacity automatically, how Aurora Global Database spans Regions for disaster recovery and low-latency global reads, and how Aurora cloning produces near-instant copies for testing.
One Shared Storage Volume, Many Compute Nodes
Aurora decouples compute (database instances) from a single shared, six-way replicated storage volume across three Availability Zones. Because replicas read from the same storage, you can attach up to 15 read replicas with low replication lag, fail over in seconds, and clone or snapshot without copying the underlying data.
Map the scenario to the right Aurora feature: up to 15 read replicas plus a Reader Endpoint for read scaling, Aurora Serverless v2 for unpredictable or spiky traffic, Aurora Global Database for cross-Region disaster recovery and sub-second replication with low-latency global reads, and Aurora cloning for fast, copy-on-write environments. Aurora storage is six copies across three AZs and grows automatically to 256 TiB (128 TiB on older engine versions).
Key Concepts
Aurora Storage Architecture
The Distributed Storage Layer
Aurora separates the compute layer (the database instances that process SQL) from a shared storage layer that all instances in the cluster read from and write to. The storage volume is a distributed system spread across three Availability Zones (AZs), with six copies of your data (two per AZ). A write is durable once four of six copies acknowledge it, and reads can be served as long as three of six copies are available, which gives Aurora self-healing storage that tolerates the loss of an entire AZ plus one additional copy. Storage grows automatically in 10 GB increments up to 256 TiB (128 TiB on older engine versions), so you never pre-provision disk. Because compute and storage are decoupled, adding a read replica does not copy data; the new instance simply attaches to the existing volume.
Aurora Storage vs Traditional RDS Storage
| Dimension | Aurora | RDS (non-Aurora) |
|---|---|---|
| Data copies | Six copies across three AZs | Primary plus optional standby |
| Scaling | Automatic to 256 TiB in 10 GB steps | Pre-provisioned EBS volume |
| Replica creation | Attaches to shared volume | Copies a full snapshot |
| Write durability | Four of six copies ack | Synchronous to standby (Multi-AZ) |
| Self-healing | Continuous, automatic | Limited |
Up to 15 Read Replicas
Aurora Replicas and the Reader Endpoint
An Aurora cluster has one writer instance (primary) that handles reads and writes, plus up to 15 Aurora Replicas that serve read-only traffic. Because replicas share the same storage volume as the writer, replication lag is typically in the low milliseconds, far lower than the asynchronous binary-log replication used by standard RDS read replicas. Aurora provides two managed connection endpoints: the Cluster (writer) Endpoint always points to the current primary, and the Reader Endpoint load-balances connections across all available replicas. If the writer fails, Aurora automatically promotes a replica, usually within about 30 seconds, and you can assign each replica a failover priority tier (tier 0 is promoted first). This combination scales reads horizontally and provides high availability from the same set of instances.
Aurora Replicas vs RDS Read Replicas
| Dimension | Aurora Replicas | RDS Read Replicas |
|---|---|---|
| Maximum count | 15 per cluster | Up to 15 (engine dependent) |
| Replication method | Shared storage volume | Asynchronous engine replication |
| Typical lag | Low milliseconds | Seconds or more |
| Automatic failover target | Yes, promotes a replica | Manual promotion |
| Read load balancing | Built-in Reader Endpoint | No managed reader endpoint |
Aurora Serverless v2
Capacity That Scales Automatically
Aurora Serverless v2 is an on-demand capacity mode where Aurora adjusts compute automatically based on load. Capacity is measured in Aurora Capacity Units (ACUs), where each ACU is roughly 2 GB of memory with associated CPU and networking. You set a minimum and maximum ACU range, and Aurora scales in fine-grained increments (as small as 0.5 ACU) in response to demand, often within a fraction of a second. Serverless v2 supports the full Aurora feature set, including read replicas, Multi-AZ, and Global Database, which makes it suitable for production. It fits variable, spiky, or unpredictable workloads, and for development or test fleets where many databases sit idle most of the time. You pay for the ACU-seconds consumed plus storage and I/O.
Provisioned vs Serverless v2
| Dimension | Provisioned | Serverless v2 |
|---|---|---|
| Capacity model | Fixed instance class you choose | Auto-scaling ACU range you set |
| Best for | Steady, predictable load | Variable or spiky load |
| Scaling speed | Manual or scheduled | Fast, fine-grained (0.5 ACU steps) |
| Read replicas | Supported | Supported |
| Billing unit | Per instance-hour | Per ACU-second |
Aurora Global Database
Cross-Region Replication and Disaster Recovery
An Aurora Global Database spans multiple AWS Regions. It has one primary Region that handles writes and up to 10 secondary Regions that are read-only. Replication uses the storage layer and a dedicated infrastructure, so data propagates with typical lag under one second, and it does not consume database compute for replication. Secondary Regions serve low-latency reads to users near them, and in a Regional outage you can promote a secondary to be the new primary, typically within about a minute (switchover, previously called managed planned failover, for routine operations and unplanned failover for disaster recovery). This makes Global Database the standard answer for cross-Region disaster recovery with a low Recovery Point Objective (RPO) and low Recovery Time Objective (RTO), and for serving global read traffic.
Read Replicas vs Global Database
| Dimension | In-Region Replicas | Global Database |
|---|---|---|
| Scope | Single Region, multiple AZs | Multiple Regions |
| Purpose | Read scaling and AZ failover | Cross-Region DR and global reads |
| Secondary count | Up to 15 replicas | Up to 10 secondary Regions |
| Replication lag | Low milliseconds | Typically under one second |
| Failover scope | Within the Region | Promote a secondary Region |
Aurora Cloning
Fast Copy-on-Write Copies
Aurora cloning creates a new cluster that shares the source cluster's storage using a copy-on-write protocol. At first the clone references the same data pages as the source, so cloning is fast and consumes almost no additional storage. As either the source or the clone changes data, only the modified pages are copied, and you pay only for that delta. Clones are ideal for spinning up a production-like environment for testing schema changes, running analytics without impacting production, or experimenting safely. Cloning works within an account and across accounts (via AWS Resource Access Manager), and it differs from a snapshot restore, which copies the full dataset and takes longer.
Clone vs Snapshot Restore vs Replica
| Action | Speed | Extra storage | Use case |
|---|---|---|---|
| Aurora clone | Near instant | Only changed pages | Test or analytics copy |
| Snapshot restore | Slower (full copy) | Full dataset | New independent cluster |
| Read replica | Fast (shared volume) | None | Read scaling and HA |
Best Practices
1. Send read traffic to the Reader Endpoint
└── Load-balances across replicas and scales reads horizontally
2. Use failover priority tiers for predictable promotion
├── Tier 0 replicas are promoted first on writer failure
└── Size critical replicas to match the writer
3. Choose Serverless v2 for variable or idle-heavy workloads
├── Set a sensible min ACU to avoid cold scaling delays
└── Cap max ACU to control cost on spikes
4. Use Aurora Global Database for cross-Region DR
├── Sub-second replication gives a low RPO
└── Promote a secondary Region for a low RTO
5. Clone for test and analytics environments
└── Copy-on-write avoids full data duplication and cost
6. Combine with RDS Proxy for connection pooling
└── Reduces failover impact and database connection stormsCommon Pitfalls
Pitfall 1: Pointing Read Traffic at the Writer
Mistake: Sending all application connections to the Cluster (writer) Endpoint and leaving replicas idle.
Why it fails: The writer becomes a bottleneck while up to 15 replicas sit unused, so reads do not scale.
Correct Approach: Route read-only queries to the Reader Endpoint, which load-balances across all available Aurora Replicas.
Pitfall 2: Using In-Region Replicas for Disaster Recovery
Mistake: Relying on in-Region Aurora Replicas to satisfy a cross-Region disaster recovery requirement.
Why it fails: In-Region replicas protect against instance and AZ failure only. A full Regional outage takes the entire cluster offline.
Correct Approach: Use Aurora Global Database with one or more secondary Regions, then promote a secondary Region during a Regional outage.
Pitfall 3: Treating a Clone as an Isolated Backup
Mistake: Using an Aurora clone as a long-term backup or assuming it is a fully independent copy from day one.
Why it fails: A clone starts by sharing storage pages with the source through copy-on-write, so it is tied to the source data and is not a point-in-time archival backup.
Correct Approach: Use automated backups and snapshots for retention and recovery, and reserve clones for fast, short-lived test or analytics environments.
Pitfall 4: Pre-Provisioning Aurora Storage
Mistake: Trying to size or pre-allocate the Aurora storage volume the way you would size an EBS volume on standard RDS.
Why it fails: Aurora storage grows automatically in 10 GB increments up to 256 TiB, so manual sizing adds no value and can cause confusion.
Correct Approach: Let the storage layer scale on its own and focus capacity planning on compute (instance class or ACU range).
Test Your Knowledge
An application is read-heavy and its database tier cannot keep up with query volume during business hours, while writes remain modest. The team wants to scale reads with minimal replication lag and automatic load balancing. What should the architect implement?
A SaaS company runs a database that is busy during random demos and nearly idle the rest of the time. They want production-grade features but want to pay only for the capacity actually used and avoid manual scaling. Which option fits best?
A company must withstand the loss of an entire AWS Region with a recovery point objective measured in seconds and the ability to serve low-latency reads to users on another continent. Which Aurora capability meets all of these needs?
Related Services
Quick Reference
Aurora Limits and Facts
Key Aurora Limits
| Item | Value |
|---|---|
| Storage copies | Six across three AZs |
| Maximum storage | 256 TiB on current engine versions, auto-growing in 10 GB steps |
| Aurora Replicas per cluster | Up to 15 |
| Global Database secondary Regions | Up to 10 |
| Global Database replication lag | Typically under one second |
| Typical writer failover time | About 30 seconds |
| Serverless v2 scaling unit | Aurora Capacity Unit, about 2 GB memory each |
| Compatible engines | MySQL and PostgreSQL |
Common CLI Commands
# Create an Aurora cluster (PostgreSQL compatible)
aws rds create-db-cluster \
--db-cluster-identifier app-cluster \
--engine aurora-postgresql \
--master-username admin --manage-master-user-password
# Add a reader instance (Aurora Replica)
aws rds create-db-instance \
--db-instance-identifier app-reader-1 \
--db-cluster-identifier app-cluster \
--engine aurora-postgresql \
--db-instance-class db.r6g.large
# Configure Serverless v2 capacity range on the cluster
aws rds modify-db-cluster \
--db-cluster-identifier app-cluster \
--serverless-v2-scaling-configuration MinCapacity=0.5,MaxCapacity=16
# Create a fast copy-on-write clone
aws rds restore-db-cluster-to-point-in-time \
--source-db-cluster-identifier app-cluster \
--db-cluster-identifier app-clone \
--restore-type copy-on-write --use-latest-restorable-time
# Create a global database and add a secondary Region
aws rds create-global-cluster \
--global-cluster-identifier app-global \
--source-db-cluster-identifier arn:aws:rds:us-east-1:123456789012:cluster:app-cluster