INFRASTRUCTURE LEARNINGINFRASTRUCTURE LEARNING
インフラ大全インフラ大全IT INFRASTRUCTURE / LEARNING
Infrastructure learning guide
Find a lesson or lab/

Esc to close · Search terms stay on your device

LEARNING日本語

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.

What you will learn

Distinguish engines, compute/storage, endpoints and failover in an ordinary Aurora cluster, and explain the application checks.

Prerequisite

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

Engines and operational conditions differ within RDS
CandidateDatabase engineApplication checks
RDS for SQL ServerMicrosoft SQL ServerSupported version/edition/features and ordinary RDS restrictions
RDS for MySQL / PostgreSQLThe chosen MySQL / PostgreSQL engineVersions, extensions, SQL and operational conditions
Aurora MySQL / PostgreSQL compatibleThe corresponding Aurora-compatible engineSQL/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

Database processing and shared storage in an ordinary cluster
Database processing and shared storage in an ordinary cluster1: Writer: reads and writes — Writer uses shared data — Shared cluster volume. 2: Reader: reads — Reader uses the same volume — Shared cluster volume12Writer: reads andwritesReader: readsShared clustervolumeDatabase processing and shared storage in an ordinary cluster1: Writer: reads and writes — Writer uses shared data — Shared cluster volume. 2: Reader: reads — Reader uses the same volume — Shared cluster volume12Writer: readsand writesReader: readsShared clustervolume
  1. Writer: reads and writes → Shared cluster volumeWriter uses shared data
  2. 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

Choose destinations in an ordinary cluster
EndpointUsual purposeImportant distinction
Cluster / writer endpointRead and write through the current primaryThe target can change after failover; existing connections do not migrate
Reader endpointBalance read connections among Aurora ReplicasBalances connection requests, not each SQL statement
Instance endpointConnect to a particular DB instanceRecheck its intended role when the deployment changes

Example A2: three SELECTs need not use three instances

Fictional application observations and conclusions
ObservationTarget in this exampleConclusion
Connect through writer endpoint and updateWriter W1Validate the required application result
Open a reader-endpoint connectionAssume it reaches reader R1One connection choice; not a measurement of even distribution across R1/R2
Run three SELECTs on that same connectionThe same R1 sessionThey are not routed once each to W1, R1 and R2
A different configuration has zero replicasReader endpoint also reaches W1The 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

  1. Assume W1 becomes unavailable and R1 becomes the new writer.
  2. Account for the writer endpoint target, DNS caches and connection pools.
  3. Re-establish broken connections and reconcile operation outcomes.
  4. 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

Checks for a meaningful comparison
DimensionDecision
Engine and versionChoose MySQL/PostgreSQL compatibility and verify features, extensions, SQL and migration
Compute and storageRequired writer/readers, AZs, capacity mode and shared-storage conditions
CostInstances or capacity, storage, configuration-dependent I/O, backups, transfer and optional features
OperationsAccess, 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.

An application uses SQL Server. Is Aurora a newer SQL Server edition?
Read the answer and reason

Answer: No; it is MySQL/PostgreSQL compatible, requiring migration checks. · Separate the managed RDS service from the chosen engine.

A2 runs three SELECTs through the same R1 connection. Does each move to another reader?
Read the answer and reason

Answer: No; that session continues to use R1. · Account for session reuse by connection pools.

With zero replicas, must the reader endpoint reject writes?
Read the answer and reason

Answer: No; it reaches the primary, so restrict DB permissions separately. · Do not use the endpoint name as read-only authorization.

R1 becomes the writer. Does an existing W1 connection move automatically?
Read the answer and reason

Answer: No; check reconnection, DNS/pools and operation outcomes. · A changed destination role is not session continuity.

Check, then explain in your own words

  1. Explain RDS, Aurora and SQL Server separately.
  2. Distinguish DB instances from the shared volume.
  3. Explain connection balancing and the zero-replica exception.
  4. 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.