Reading35 min read·Module 3High exam weight

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.

Exam Tip

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

DimensionAuroraRDS (non-Aurora)
Data copiesSix copies across three AZsPrimary plus optional standby
ScalingAutomatic to 256 TiB in 10 GB stepsPre-provisioned EBS volume
Replica creationAttaches to shared volumeCopies a full snapshot
Write durabilityFour of six copies ackSynchronous to standby (Multi-AZ)
Self-healingContinuous, automaticLimited

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

DimensionAurora ReplicasRDS Read Replicas
Maximum count15 per clusterUp to 15 (engine dependent)
Replication methodShared storage volumeAsynchronous engine replication
Typical lagLow millisecondsSeconds or more
Automatic failover targetYes, promotes a replicaManual promotion
Read load balancingBuilt-in Reader EndpointNo 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

DimensionProvisionedServerless v2
Capacity modelFixed instance class you chooseAuto-scaling ACU range you set
Best forSteady, predictable loadVariable or spiky load
Scaling speedManual or scheduledFast, fine-grained (0.5 ACU steps)
Read replicasSupportedSupported
Billing unitPer instance-hourPer 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

DimensionIn-Region ReplicasGlobal Database
ScopeSingle Region, multiple AZsMultiple Regions
PurposeRead scaling and AZ failoverCross-Region DR and global reads
Secondary countUp to 15 replicasUp to 10 secondary Regions
Replication lagLow millisecondsTypically under one second
Failover scopeWithin the RegionPromote 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

ActionSpeedExtra storageUse case
Aurora cloneNear instantOnly changed pagesTest or analytics copy
Snapshot restoreSlower (full copy)Full datasetNew independent cluster
Read replicaFast (shared volume)NoneRead scaling and HA

Best Practices

TEXTDesign Guidance
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 storms

Common 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

Q

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?

AAdd standard RDS read replicas and update the app to call each one
BAdd Aurora Replicas and send read queries to the Reader Endpoint
CIncrease the writer instance size only
DEnable Aurora Global Database in the same Region
Q

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?

AAurora provisioned with a large fixed instance class
BAurora Serverless v2 with a configured minimum and maximum ACU range
CA single EC2 instance running the database
DAurora Global Database across two Regions
Q

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?

AMulti-AZ deployment within one Region
BAurora cloning into the same account
CAurora Global Database with a secondary Region
DAdding more Aurora Replicas in the primary Region


Quick Reference

Aurora Limits and Facts

Key Aurora Limits

ItemValue
Storage copiesSix across three AZs
Maximum storage256 TiB on current engine versions, auto-growing in 10 GB steps
Aurora Replicas per clusterUp to 15
Global Database secondary RegionsUp to 10
Global Database replication lagTypically under one second
Typical writer failover timeAbout 30 seconds
Serverless v2 scaling unitAurora Capacity Unit, about 2 GB memory each
Compatible enginesMySQL and PostgreSQL

Common CLI Commands

SHAurora CLI
# 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

Further Reading

Related services

AuroraRDS