Topic lessonTopic: AWS databases: design, comparison and connectivity
Amazon Aurora explained: RDS, shared storage and endpoints
Amazon Aurora is a MySQL-compatible or PostgreSQL-compatible relational database engine available through Amazon RDS. Distinguish the instances that process SQL from shared storage, and the write destination from read destinations. It is not a higher edition of SQL Server.
Distinguish engines, compute/storage, endpoints and failover in an ordinary Aurora cluster, and explain the application checks.
For readers familiar with RDS responsibilities and database reads/writes. Inspect fictional document-app destinations without creating or connecting to AWS resources.
Separate the RDS service from the Aurora engine
| Candidate | Database engine | Application checks |
|---|---|---|
| RDS for SQL Server | Microsoft SQL Server | Supported version/edition/features and ordinary RDS restrictions |
| RDS for MySQL / PostgreSQL | The chosen MySQL / PostgreSQL engine | Versions, extensions, SQL and operational conditions |
| Aurora MySQL / PostgreSQL compatible | The corresponding Aurora-compatible engine | SQL/feature differences, versions and cluster configuration |
Compatibility does not establish identical features, SQL behavior or performance for every workload. For an existing SQL Server application, first separate keeping SQL Server from changing to another engine.
Separate database instances from shared storage
- Writer: reads and writes → Shared cluster volumeWriter uses shared data
- Reader: reads → Shared cluster volumeReader uses the same volume
- Writer: reads and writes
- The primary accepts updates in this configuration.
- Reader: reads
- An Aurora Replica processes reads.
- Shared cluster volume
- Stores data separately from the DB instances.
The lines represent use of shared storage, not an application path through writer then reader. Storage replication is separate from the number of SQL-processing instances. Adding readers is not the same as adding independent writers.
Use endpoints to select database roles
| Endpoint | Usual purpose | Important distinction |
|---|---|---|
| Cluster / writer endpoint | Read and write through the current primary | The target can change after failover; existing connections do not migrate |
| Reader endpoint | Balance read connections among Aurora Replicas | Balances connection requests, not each SQL statement |
| Instance endpoint | Connect to a particular DB instance | Recheck its intended role when the deployment changes |
Example A2: three SELECTs need not use three instances
| Observation | Target in this example | Conclusion |
|---|---|---|
| Connect through writer endpoint and update | Writer W1 | Validate the required application result |
| Open a reader-endpoint connection | Assume it reaches reader R1 | One connection choice; not a measurement of even distribution across R1/R2 |
| Run three SELECTs on that same connection | The same R1 session | They are not routed once each to W1, R1 and R2 |
| A different configuration has zero replicas | Reader endpoint also reaches W1 | The endpoint name alone does not prevent writes |
Applications using connection pools can reuse sessions. Adding readers does not redistribute work already tied to existing sessions. Evaluate connection counts, query weight and data freshness separately.
After failover, verify connections and business outcomes
- Assume W1 becomes unavailable and R1 becomes the new writer.
- Account for the writer endpoint target, DNS caches and connection pools.
- Re-establish broken connections and reconcile operation outcomes.
- If an update outcome is unknown, check business identifiers and duplication controls instead of blindly repeating it.
This is a role-transition example, not a guarantee that R1 is always selected or a downtime measurement. Recovery differs without readers and depends on configuration, version and workload. Resuming after a writer failure and reversing a bad update need separate plans.
Before choosing, align compatibility, capacity and cost
| Dimension | Decision |
|---|---|
| Engine and version | Choose MySQL/PostgreSQL compatibility and verify features, extensions, SQL and migration |
| Compute and storage | Required writer/readers, AZs, capacity mode and shared-storage conditions |
| Cost | Instances or capacity, storage, configuration-dependent I/O, backups, transfer and optional features |
| Operations | Access, TLS, maintenance, recovery goals, reconnection and result reconciliation |
This lesson covers ordinary Aurora MySQL/PostgreSQL clusters. Do not transfer its instance layout to Aurora DSQL, Limitless or other architectures. A new product name or the word serverless does not establish free usage, zero operational responsibility or a lower total cost.
Check architecture and endpoint decisions
Choose an option to see the result and explanation.
Check, then explain in your own words
- Explain RDS, Aurora and SQL Server separately.
- Distinguish DB instances from the shared volume.
- Explain connection balancing and the zero-replica exception.
- List connection and business-result checks after failover.
Check your understanding: Will adding two Aurora Replicas automatically solve every SQL load and freshness problem?
No. Inspect session reuse, query weight, reader lag, writer work, indexes and application design separately.
More read-processing destinations do not establish that every business requirement is met.
Sources and conditions checked
The official references used in this lesson are collected here with their scope, conditions and corresponding sections. Independent expert review and live AWS comparison have not been performed.
Scope and conditionsAurora is part of RDS and compatible with MySQL/PostgreSQL; it is not SQL Server or guaranteed migration compatibility.
Used in this lessonSeparate the RDS service from the Aurora engine Before choosing, align compatibility, capacity and cost
Scope and conditionsOrdinary RDS and OS-dependent features; distinguish xp_cmdshell restrictions from the SQL Server product generally.
Used in this lessonSeparate the RDS service from the Aurora engine
Scope and conditionsSQL Server client/T-SQL compatibility has differences and restrictions; it is not the SQL Server engine or universal compatibility.
Used in this lessonSeparate the RDS service from the Aurora engine
- AWS: Aurora shared storageChecked:
Scope and conditionsShared distributed cluster storage; storage replication and DB-instance counts are distinct.
Used in this lessonSeparate database instances from shared storage Before choosing, align compatibility, capacity and cost
Scope and conditionsShared volume versus instances; account for reader lag and interrupted connections during failover.
Used in this lessonSeparate database instances from shared storage After failover, verify connections and business outcomes
Scope and conditionsCurrent primary connection in an ordinary cluster; writes/reads, reconnection and DNS after failover.
Used in this lessonUse endpoints to select database roles After failover, verify connections and business outcomes
- AWS: Aurora reader endpointChecked:
Scope and conditionsConnection balancing; without replicas it connects to the primary and can write, so it is not an authorization boundary.
Used in this lessonUse endpoints to select database roles Example A2: three SELECTs need not use three instances
- AWS: Aurora instance endpointsChecked:
Scope and conditionsConnection to a particular instance, distinct from writer/reader role endpoints.
Used in this lessonUse endpoints to select database roles
Scope and conditionsCompute/capacity, storage and configuration-dependent I/O; distinguish other architectures such as DSQL and avoid price guarantees.
Used in this lessonBefore choosing, align compatibility, capacity and cost