AWS Builder Center

Amazon Route 53 Explained: DNS, Routing Policies and Private AWS Connectivity

In AWS environments, Amazon Route 53 provides DNS and domain-management capabilities that can become an important part of the overall infrastructure architecture.

Amazon Route 53 Explained: DNS, Routing Policies and Private AWS Connectivity

When an application connects to a service, engineers often think about IP addresses, routes, and security groups.
But there is another critical component involved before the connection can even begin:
DNS.
An application usually does not connect to:
10.20.15.25

Instead, it connects to something like:
api.example.com

DNS translates that name into information that allows the application to locate the service.
In AWS environments, Amazon Route 53 provides DNS and domain-management capabilities that can become an important part of the overall infrastructure architecture.



What is Amazon Route 53?

Amazon Route 53 is AWS's highly available and scalable DNS service.
It can be used for:
  • Domain registration
  • DNS hosting
  • DNS routing
  • Health checks
  • Public DNS
  • Private DNS within VPCs
  • Traffic management
A simple public DNS flow looks like:
User
|
v
Application
|
v
api.example.com
|
v
Route 53
|
v
Application Endpoint

The important idea is:
Route 53 helps applications find the destination they are trying to reach.



Why DNS Matters in Cloud Infrastructure

Imagine an application hosted on EC2.
Without DNS, an application might depend directly on an IP address:
Application
|
v
10.20.10.25

But infrastructure can change.
The server could be replaced.
The load balancer could change.
The application could move.
The architecture could become highly available.
Hardcoding IP addresses makes those changes harder to manage.
With DNS:
Application
|
v
api.example.com
|
v
Current Application Endpoint

The application can continue using the same name while the underlying infrastructure changes.
This is one of the fundamental reasons DNS is so important.



Route 53 Hosted Zones

A hosted zone is a container for DNS records for a domain.
For example:
example.com
|
+── www.example.com
+── api.example.com
+── app.example.com
└── mail.example.com

A hosted zone contains records that determine how DNS queries for the domain should be answered.



DNS Records

DNS records provide information about how names should resolve.
Common record types include:
A
AAAA
CNAME
MX
TXT
NS

For example:
api.example.com
|
v
A / Alias Record
|
v
Application Endpoint

The specific record type depends on the DNS requirement.



A Record

An A record maps a DNS name to an IPv4 address.
For example:
api.example.com
|
v
10.10.20.50

This is useful when a hostname needs to resolve to an IPv4 address.



AAAA Record

An AAAA record provides IPv6 address information.
Conceptually:
api.example.com
|
v
IPv6 Address

This becomes important for applications designed to support IPv6 connectivity.



CNAME Record

A CNAME record maps one DNS name to another DNS name.
For example:
app.example.com
|
v
service.example.net

The DNS architecture determines how the final destination is resolved.



Alias Records

AWS also provides Alias functionality for supported AWS resources.
This can be useful when pointing a Route 53 DNS name toward supported AWS endpoints.
For example:
api.example.com
|
v
Route 53 Alias
|
v
AWS Load Balancer

This is particularly useful for AWS-native architectures.



Public and Private DNS

One of the most important Route 53 concepts is the distinction between public and private DNS.

Public DNS

Used for names that need to be resolved publicly.
Internet
|
v
DNS Query
|
v
Public Hosted Zone
|
v
Public Endpoint


Private DNS

Used inside private AWS environments.
VPC
|
v
Private DNS Query
|
v
Private Hosted Zone
|
v
Private Resource

This distinction becomes especially important in enterprise AWS architectures.



Route 53 Private Hosted Zones

A private hosted zone allows DNS names to be resolved within associated VPCs.
For example:
Internal Application
|
v
api.internal.example.com
|
v
Private Hosted Zone
|
v
Internal Service

The name does not need to be publicly resolvable.
This is useful for internal applications, services, and private infrastructure.



Example: Internal Application Architecture

Imagine a company has:
Application VPC
|
+── Web Tier
|
+── Application Tier
|
└── Database Tier

The application tier could use:
database.internal.example.com

instead of directly storing a database IP address.
The DNS architecture becomes:
Application
|
v
database.internal.example.com
|
v
Private Hosted Zone
|
v
Database Endpoint

This creates a cleaner separation between application configuration and infrastructure addresses.



Route 53 Resolver

Route 53 Resolver provides DNS resolution capabilities for VPCs.
A simplified model is:
EC2 Instance
|
v
VPC DNS
|
v
Route 53 Resolver

This becomes particularly important when an AWS environment needs to resolve names between AWS and on-premises networks.



Hybrid DNS

Many enterprises have both AWS and on-premises infrastructure.
For example:
On-Premises
|
| DNS
|
v
Corporate DNS

and:
AWS
|
+── VPC A
+── VPC B
└── VPC C

The challenge is making DNS resolution work across both environments.
A conceptual architecture is:
AWS
|
Route 53 Resolver
/ \
/ \
v v
VPC DNS On-Prem DNS
|
v
Corporate DNS

Route 53 Resolver supports architectures where DNS queries can be forwarded between AWS and on-premises environments using Resolver endpoints and rules.
This is an important capability for hybrid cloud environments.



Resolver Endpoints

Resolver endpoints are used to support DNS queries between VPCs and external DNS environments.
There are two important concepts.

Inbound Resolver Endpoint

Allows DNS queries from external networks to be resolved using DNS information available within AWS.
Conceptually:
On-Premises
|
v
Inbound Resolver Endpoint
|
v
AWS DNS


Outbound Resolver Endpoint

Allows DNS queries from AWS environments to be forwarded to external DNS servers.
AWS VPC
|
v
Outbound Resolver Endpoint
|
v
On-Premises DNS

These capabilities are useful when designing hybrid DNS architectures.



Resolver Rules

Resolver rules determine how DNS queries should be handled.
For example:
*.corp.example.com
|
v
Forward to Corporate DNS

A simplified flow is:
Application
|
v
DNS Query
|
v
Route 53 Resolver
|
v
Resolver Rule
|
v
Forwarding Destination

This allows organizations to control how different DNS namespaces are resolved.



Multi-VPC DNS Architecture

Consider an organization with multiple VPCs:
AWS
|
+---------+---------+
| | |
v v v
VPC A VPC B VPC C

Each VPC may contain applications that need to resolve shared internal names.
A centralized DNS architecture can help:
VPC A ───┐
VPC B ───┼──> Central DNS Architecture
VPC C ───┘
|
v
Route 53 Resolver

The exact architecture depends on organizational requirements and DNS ownership.



Route 53 Routing Policies

Route 53 can also use different routing policies to determine how DNS queries are answered.
Some common routing approaches include:
  • Simple routing
  • Weighted routing
  • Latency-based routing
  • Failover routing
  • Geolocation routing
  • Geoproximity routing
  • Multivalue answer routing
Each solves a different problem.



Simple Routing

Simple routing is useful when there is a straightforward DNS mapping.
For example:
api.example.com
|
v
Application Endpoint

There is no complex traffic decision involved.



Weighted Routing

Weighted routing allows traffic to be distributed according to configured weights.
For example:
api.example.com
|
+── Environment A → 90%
|
└── Environment B → 10%

This can be useful for controlled traffic distribution and testing scenarios.
For example, an organization could gradually send a small percentage of traffic toward a new environment.



Latency-Based Routing

Latency-based routing can direct users toward a suitable AWS Region based on latency considerations.
For example:
User
|
+── Region A
|
+── Region B
|
└── Region C

Route 53 can use latency information to determine an appropriate response.
This can be useful for globally distributed applications.



Failover Routing

Failover routing is useful when an application has primary and secondary endpoints.
Conceptually:
Route 53
|
+-------+-------+
| |
v v
Primary Secondary
|
Healthy?
|
NO
|
v
Failover

Health checks can be used as part of appropriate failover configurations.



Route 53 Health Checks

Health checks can help determine whether endpoints are healthy.
A simplified architecture is:
Route 53
|
v
Health Check
|
+── Healthy
|
└── Unhealthy

Routing decisions can then use health information where supported.
This can help improve application availability.



Route 53 and Load Balancers

Route 53 and Elastic Load Balancing often work together.
For example:
User
|
v
api.example.com
|
v
Route 53
|
v
Application Load Balancer
|
+── EC2
+── EC2
└── EC2

DNS provides the application name.
The load balancer distributes traffic across application targets.
Each service has a different responsibility.



Route 53 and PrivateLink

This connects directly to your previous article.
PrivateLink provides private connectivity to a service.
DNS can provide the name that applications use to access that service.
Conceptually:
Application
|
v
service.internal.example.com
|
v
Private DNS
|
v
Interface Endpoint
|
v
PrivateLink
|
v
Service

This combination can make private service consumption much easier for application teams.



Route 53 and Transit Gateway

Transit Gateway provides network connectivity.
Route 53 provides DNS resolution.
These are different layers.
For example:
Application VPC
|
+── DNS Query
| |
| v
| Route 53
|
+── Network Traffic
|
v
Transit Gateway
|
v
Destination VPC

A common troubleshooting mistake is assuming that network connectivity automatically means DNS will work.
It does not.
Both need to be designed correctly.



DNS Troubleshooting

When an application cannot connect to a service by hostname, troubleshoot DNS separately from network connectivity.
A useful process is:
Application
|
v
Hostname
|
v
DNS Query
|
v
Resolver
|
v
Hosted Zone / Rule
|
v
DNS Response
|
v
Network Connection

Ask:
1. Does the hostname resolve?
nslookup
dig

2. Is the correct hosted zone being used?
3. Is the VPC associated with the private hosted zone?
4. Are Resolver rules configured correctly?
5. Is the DNS forwarding path reachable?
6. Does the returned IP address represent the intended service?
Only after DNS is working should you continue investigating routing and security controls.



A Real-World Troubleshooting Example

Suppose an application reports:
"Cannot connect to database.internal.example.com"
An engineer should not immediately change the Security Group.
Start with:
Step 1
Does DNS resolve?
|
v
Yes / No

If DNS fails:
Check:
|
+── Private Hosted Zone
+── VPC Association
+── Resolver Rules
+── DNS Settings
└── Forwarding Configuration

If DNS succeeds:
Resolved IP
|
v
Check Route
|
v
Check Security Group
|
v
Check Network ACL
|
v
Check Destination

This layered troubleshooting method can save significant time.



Best Practices

1. Use meaningful DNS names

Prefer stable service names over hardcoded IP addresses.
database.internal.example.com

is generally easier to manage than:
10.20.30.40




2. Separate public and private DNS

Do not expose internal infrastructure names unnecessarily.
Use private hosted zones for internal DNS requirements.



3. Plan DNS ownership

In multi-account environments, define who owns:
Domains
Hosted Zones
Resolver Rules
DNS Records

Clear ownership prevents configuration conflicts.



4. Design hybrid DNS deliberately

If AWS and on-premises environments need to resolve each other's names, document:
Who resolves what?
Where are queries forwarded?
Which DNS servers are authoritative?
Which VPCs use the rules?




5. Monitor DNS behavior

DNS problems can look like application or networking failures.
Make DNS visibility part of the troubleshooting process.



6. Avoid unnecessary complexity

Not every environment requires a highly centralized DNS architecture.
Start with the simplest design that meets the application's requirements, then introduce additional components as the environment grows.



A Simple Route 53 Mental Model

The easiest way to remember Route 53 is:
Application
|
v
DNS Name
|
v
Route 53
|
+── Public DNS
+── Private DNS
+── Routing Policies
+── Health Checks
+── Resolver
|
v
Destination

And when thinking about your recent networking articles:
Transit Gateway
|
└── Connect networks

PrivateLink
|
└── Connect to services

Route 53
|
└── Find services using DNS

These three concepts solve different layers of the connectivity problem.



Final Takeaway

DNS is easy to ignore when everything is working.
But when DNS fails, an application can appear completely unreachable even when the underlying network is healthy.
Amazon Route 53 provides the DNS foundation for many AWS architectures, from simple public applications to complex multi-account and hybrid-cloud environments.
The key lesson is:
Networking tells traffic where to go. DNS helps applications discover where the service is.
When Route 53 is combined with VPC networking, Transit Gateway, PrivateLink, load balancing, and hybrid connectivity, it becomes an important part of building scalable and maintainable AWS infrastructure.
For cloud infrastructure engineers, understanding DNS as a separate architectural layer makes both AWS design and troubleshooting much easier.

Tags

AWS, Amazon Route 53, AWS Route 53, DNS, AWS Networking, Route 53 Resolver, Private Hosted Zone, Hybrid Cloud, VPC, Transit Gateway, AWS PrivateLink, Cloud Infrastructure, Cloud Security, Network Architecture, Cloud Engineering, DevOps
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article