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.
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
| Engine | Notes for the exam |
|---|---|
| PostgreSQL | Popular open source, strong feature set |
| MySQL | Widely used open source |
| MariaDB | MySQL-compatible fork |
| Oracle | Commercial, License Included or BYOL |
| SQL Server | Commercial, License Included or BYOL |
| Aurora | AWS-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
| Dimension | Multi-AZ Instance Deployment | Multi-AZ DB Cluster |
|---|---|---|
| Topology | One primary plus one standby | One writer plus two readable standbys |
| Standby readable | No | Yes, two reader endpoints |
| Availability Zones | Two | Three |
| Replication | Synchronous | Semi-synchronous to at least one reader |
| Primary purpose | High availability and durability | High 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
| Dimension | Multi-AZ Standby | Read Replica |
|---|---|---|
| Replication type | Synchronous | Asynchronous |
| Serves read traffic | No (instance deployment) | Yes |
| Automatic failover | Yes | No (manual promotion) |
| Primary goal | High availability and durability | Read scaling and offload |
| Cross-region | No (same region) | Yes |
| Maximum copies | One standby | Up 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 Type | Best 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.
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 changedBest Practices
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 restoreCommon 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
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?
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?
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?
Related Services
Amazon RDS
Managed relational database supporting six engines with Multi-AZ and read replicas
Quick Reference
Well-Known Limits and Defaults
RDS Quick Facts
| Item | Value |
|---|---|
| Supported engines | PostgreSQL, MySQL, MariaDB, Oracle, SQL Server, Aurora |
| Read replicas per source (open source engines) | Up to 15 |
| Multi-AZ standby readable | No for instance deployment, yes for Multi-AZ DB cluster |
| Multi-AZ replication | Synchronous |
| Read replica replication | Asynchronous |
| Typical automatic failover time | About one to two minutes |
| Storage Auto Scaling | Grows up, never shrinks, capped by maximum threshold |
| Default backup retention | Seven days (range zero to thirty-five) |
Common CLI Commands
# 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