Reading35 min read·Module 3High exam weight

Amazon RDS & Multi-AZ

Key concepts

  • Supported database engines

  • Multi-AZ synchronous replication

  • Read replicas for read scaling

  • Storage auto scaling

  • Parameter groups

Overview

Amazon RDS (Relational Database Service) is a managed relational database that runs your engine of choice on AWS while AWS handles provisioning, patching, backups, and recovery. You connect through a DNS endpoint and operate the database with familiar SQL, while AWS removes the undifferentiated work of running the underlying servers and storage. RDS is the default answer on the exam whenever a scenario needs a managed SQL database without the operational burden of self-hosting on EC2.

For SAA-C03 this topic is high-yield through availability and performance scenarios. You should know which engines RDS supports, how Multi-AZ delivers high availability through synchronous replication and automatic failover, how read replicas scale read traffic with asynchronous replication, how storage auto scaling grows volumes without downtime, and how parameter groups and option groups tune engine behavior.

Multi-AZ Is for Availability, Read Replicas Are for Scale

A Multi-AZ deployment keeps a synchronous standby in a second Availability Zone for automatic failover and durability. A read replica keeps an asynchronous copy that serves read-only queries to offload the primary. These solve different problems, and many scenarios combine both.

Exam Tip

Map the keyword to the feature: failover and high availability point to Multi-AZ (synchronous standby, same region, no read traffic), read scaling points to read replicas (asynchronous, can be cross-region, serve reads only), and growing disk without downtime points to storage auto scaling. Aurora is a separate engine and is covered on its own.


Key Concepts

Supported Database Engines

Six Engines, One Managed Service

RDS runs six relational engines: PostgreSQL, MySQL, MariaDB, Oracle, Microsoft SQL Server, and Amazon Aurora (a cloud-native, MySQL- and PostgreSQL-compatible engine). The first five are sometimes called the community or commercial engines, while Aurora is AWS-built and offers higher performance and its own storage layer. Oracle and SQL Server are licensed engines, so you choose either License Included pricing or Bring Your Own License (BYOL). For the exam, recognize that a request to migrate an existing PostgreSQL, MySQL, MariaDB, Oracle, or SQL Server database with minimal changes maps directly to RDS.

RDS Engine Notes

EngineNotes for the exam
PostgreSQLPopular open source, strong feature set
MySQLWidely used open source
MariaDBMySQL-compatible fork
OracleCommercial, License Included or BYOL
SQL ServerCommercial, License Included or BYOL
AuroraAWS-built, MySQL and PostgreSQL compatible

Multi-AZ Synchronous Replication

A Synchronous Standby for Failover

A Multi-AZ deployment provisions a primary instance and a standby in a different Availability Zone (an isolated location within a region). Data is replicated synchronously, meaning a write must be committed on both the primary and the standby before it is acknowledged, which gives strong durability with no data loss on failover. The standby does not serve read or write traffic. If the primary fails (or during patching, instance changes, or an AZ disruption), RDS performs an automatic failover by repointing the database DNS endpoint to the standby, usually within one to two minutes. Because clients connect through that endpoint, application connection strings do not change.

Multi-AZ Instance vs Multi-AZ Cluster

DimensionMulti-AZ Instance DeploymentMulti-AZ DB Cluster
TopologyOne primary plus one standbyOne writer plus two readable standbys
Standby readableNoYes, two reader endpoints
Availability ZonesTwoThree
ReplicationSynchronousSemi-synchronous to at least one reader
Primary purposeHigh availability and durabilityHigh availability with read capacity

Read Replicas for Read Scaling

Asynchronous Copies That Serve Reads

A read replica is a read-only copy of the source database that uses asynchronous replication (changes are streamed after they commit on the source, so a replica can lag slightly behind). Read replicas offload read-heavy traffic such as reporting and analytics queries, and you can create up to 15 per source for the major open source engines. Each replica has its own endpoint, so the application must direct read queries to it. Replicas can be created in the same region or in a different region (cross-region), which also supports disaster recovery and low-latency reads near distant users. A read replica can be promoted to a standalone writable database, which is useful for migrations or regional failover. Read replicas are about scaling and offloading reads, while Multi-AZ is about automatic failover.

Multi-AZ vs Read Replicas

DimensionMulti-AZ StandbyRead Replica
Replication typeSynchronousAsynchronous
Serves read trafficNo (instance deployment)Yes
Automatic failoverYesNo (manual promotion)
Primary goalHigh availability and durabilityRead scaling and offload
Cross-regionNo (same region)Yes
Maximum copiesOne standbyUp to 15 per source

Storage Auto Scaling

Grow Storage Without Downtime

RDS Storage Auto Scaling lets the volume grow automatically when free space runs low, so you avoid out-of-space outages without overprovisioning. You enable it and set a maximum storage threshold (an upper cap RDS will not exceed). RDS expands storage when free space falls below about 10 percent of allocated capacity for at least five minutes, and it applies the increase without downtime. It works on the General Purpose SSD (gp2 and gp3) and Provisioned IOPS SSD (io1 and io2) storage types. To avoid runaway growth, RDS limits how often it scales (typically no more than once every six hours). Storage can grow automatically, while shrinking allocated storage is not supported.

RDS Storage Types

Storage TypeBest for
General Purpose SSD (gp3)Most workloads, balanced price and performance
General Purpose SSD (gp2)General workloads with burst IOPS
Provisioned IOPS SSD (io1 or io2)Latency-sensitive, high and consistent IOPS
Magnetic (legacy)Backward compatibility only, avoid for new work

Parameter Groups and Option Groups

Tuning the Engine

A parameter group is a container of engine configuration values (for example max_connections or work_mem) that you attach to an instance to tune behavior without editing files on a server you do not control. Parameters are either dynamic (apply immediately) or static (require a database reboot to take effect). The default parameter group cannot be edited, so you create a custom one to make changes. An option group is related but separate: it enables optional engine features such as Oracle Transparent Data Encryption or SQL Server features. For the exam, remember that parameter groups change runtime settings and that static parameters need a reboot.

TEXTCustom Parameter Group (concept)
Custom parameter group: app-postgres15
  ├── max_connections = 500        (dynamic: applies on apply)
  ├── work_mem = 16384             (dynamic)
  └── shared_buffers = {DBInstanceClassMemory/4}   (static: needs reboot)

Attach to instance --> apply --> reboot only if a static value changed

Best Practices

TEXTDesign Guidance
1. Enable Multi-AZ for any production database
   └── Synchronous standby gives automatic failover and durability

2. Add read replicas to scale read-heavy traffic
   ├── Point reporting and analytics queries at replica endpoints
   └── Use cross-region replicas for disaster recovery and local reads

3. Turn on Storage Auto Scaling with a sensible maximum
   └── Prevents out-of-space outages without overprovisioning upfront

4. Use custom parameter groups for tuning
   ├── Change dynamic parameters live, reboot for static ones
   └── Keep settings in version control or infrastructure as code

5. Secure and back up by default
   ├── Encrypt at rest with KMS and require TLS in transit
   ├── Place instances in private subnets, restrict with security groups
   └── Keep automated backups and test point-in-time restore

Common Pitfalls

Pitfall 1: Expecting Read Replicas to Provide Automatic Failover

Mistake: Adding read replicas and assuming the database is now highly available.

Why it fails: Read replicas use asynchronous replication and require manual promotion. They do not fail over automatically and can lag behind the source.

Correct Approach: Use Multi-AZ for automatic failover and durability, and add read replicas separately to scale reads.

Pitfall 2: Sending Read Traffic to the Multi-AZ Standby

Mistake: Trying to offload queries onto the standby in a Multi-AZ instance deployment.

Why it fails: In a Multi-AZ instance deployment the standby is passive and does not serve read or write traffic. Only a read replica (or a Multi-AZ DB cluster reader) can serve reads.

Correct Approach: Provision read replicas for read scaling, or use a Multi-AZ DB cluster if you need readable standbys plus high availability.

Pitfall 3: Forgetting That Static Parameters Need a Reboot

Mistake: Changing a static parameter and expecting it to take effect immediately.

Why it fails: Static parameters only apply after a database reboot, so the running instance keeps the old value until then.

Correct Approach: Identify whether a parameter is dynamic or static, schedule a maintenance reboot for static changes, and verify the value after the instance restarts.

Pitfall 4: Choosing RDS for a Scale-Out NoSQL or Massive-Throughput Need

Mistake: Forcing a key-value or extreme write-throughput workload onto a single RDS instance.

Why it fails: RDS scales reads with replicas but writes go to one primary, so it does not scale writes horizontally like a purpose-built NoSQL store.

Correct Approach: Match the workload to the data store: use RDS for relational SQL, and consider DynamoDB for key-value at scale or Aurora for higher relational throughput.


Test Your Knowledge

Q

A production PostgreSQL database on RDS must remain available if an Availability Zone fails, with no data loss and minimal application changes. Which configuration meets the requirement?

ACreate five read replicas in the same region
BEnable a Multi-AZ deployment with a synchronous standby
CIncrease the instance size and enable Storage Auto Scaling
DCreate a cross-region read replica and promote it on failure
Q

A reporting workload sends heavy read-only analytics queries that are slowing the primary RDS MySQL instance during business hours. Writes are unaffected. What is the most cost-effective way to relieve the primary?

AConvert the database to a Multi-AZ instance deployment
BAdd one or more read replicas and point analytics queries at them
CIncrease the allocated storage and IOPS
DReboot the primary to apply new parameters
Q

An RDS instance occasionally runs out of disk space during unpredictable data ingest spikes, causing outages. The team wants storage to grow on its own up to a safe ceiling without manual intervention. What should be enabled?

AA Multi-AZ DB cluster with three Availability Zones
BStorage Auto Scaling with a maximum storage threshold
CA custom parameter group raising max_connections
DA larger Provisioned IOPS allocation set manually


Quick Reference

Well-Known Limits and Defaults

RDS Quick Facts

ItemValue
Supported enginesPostgreSQL, MySQL, MariaDB, Oracle, SQL Server, Aurora
Read replicas per source (open source engines)Up to 15
Multi-AZ standby readableNo for instance deployment, yes for Multi-AZ DB cluster
Multi-AZ replicationSynchronous
Read replica replicationAsynchronous
Typical automatic failover timeAbout one to two minutes
Storage Auto ScalingGrows up, never shrinks, capped by maximum threshold
Default backup retentionSeven days (range zero to thirty-five)

Common CLI Commands

SHRDS CLI
# Create a Multi-AZ PostgreSQL instance
aws rds create-db-instance \
  --db-instance-identifier app-prod \
  --engine postgres --db-instance-class db.m6g.large \
  --allocated-storage 100 --storage-type gp3 \
  --master-username admin --manage-master-user-password \
  --multi-az

# Create a read replica
aws rds create-db-instance-read-replica \
  --db-instance-identifier app-prod-reader \
  --source-db-instance-identifier app-prod

# Enable storage auto scaling by setting a maximum threshold
aws rds modify-db-instance \
  --db-instance-identifier app-prod \
  --max-allocated-storage 500 --apply-immediately

# Create and attach a custom parameter group
aws rds create-db-parameter-group \
  --db-parameter-group-name app-postgres15 \
  --db-parameter-group-family postgres15 \
  --description "Custom tuning"

# Promote a read replica to a standalone database
aws rds promote-read-replica \
  --db-instance-identifier app-prod-reader

Further Reading

Related services

RDS