How to Connect a Domain Name to AWS EC2

By Ravindra Bagale, trainer · LinkedIn · Last updated: 18 October 2026

1. Why: nobody remembers IP addresses

Why. Our server answers at an IP address. Suppose we are Instagram: would people type a string of numbers every time they want to open the app's website? No. They type instagram.com. A name is easy to remember, to say aloud and to print on a visiting card.

There are two more problems with bare IPs:

1. One IP shows one default site. With only an IP, Nginx can't tell which of your websites a visitor wants.
2. The IP can change. If the server gets a new IP, every link and bookmark that used the old one breaks.

2. What: DNS turns a name into an IP

What. Computers connect using IP addresses, not names. DNS (Domain Name System) is the internet's phone book: it answers the question "what is the IP address of this name?"

How it works, step by step:

1. You type example.com in the browser. The browser has a name, but it needs an IP.
2. Your computer asks a DNS resolver (usually run by your internet provider, or a public one): "What is the IP of example.com?"
3. The resolver finds the domain's DNS records and gets the answer, for example PUBLIC_IP.
4. The browser sends the request to PUBLIC_IP on port 80, and Nginx on your EC2 server answers.

Example 1. Suppose we are Instagram. When you type instagram.com, steps 1 to 4 happen in a fraction of a second, and you never see the IP. That's the whole point.

Try it. On your own computer, run:

nslookup example.com

The Address: line in the answer is the IP that the name points to.

3. Where to buy a domain: registrars

What. A company that sells and manages domain names is a registrar. Common ones:

1. GoDaddy
2. Hostinger
3. Amazon Route 53 (inside AWS)
4. and many others

In this chapter we use GoDaddy screens, but every registrar has the same ideas: search, cart, and a page to manage DNS records.

4. Choosing a good name

Why it matters. The name is your address for years. Changing it later means new visiting cards, new links and lost visitors.

Two good kinds of names:

1. A business keyword. Suppose we are building a shopping site: a word like cart or shop in the name tells people what you do.
2. A unique brand word. Suppose we are Google or TikTok: those words meant nothing before; the brand gave them meaning. A unique word is easy to own everywhere.

Tips:

1. Short, easy to spell, easy to say on the phone.
2. Avoid words that shrink your audience, for example a word tied to one religion or one country, if you want everyone as customers.
3. Pick the ending (.com, .in and so on) that suits your visitors. For practice, any cheap ending works.

When the name is taken. Suppose we want instagram.com. It's taken, and the search shows it isn't available.

1. Some registrars offer a broker service: they contact the owner for you, for a fee. The owner may still say no.
2. Some people, called domain investors, buy catchy names early to sell them later. That's why many good short names are already taken.
3. Usually the easier way is a different name, or a different ending.

5. Registration: how long, and what to check in the cart

What. You don't buy a domain forever. You register it for a term of 1 to 10 years, then renew it.

1. A longer term keeps the name safe for longer and protects you from renewal price rises during that term.
2. If you forget to renew, the name expires and someone else can register it.

In the cart, step by step:

Step 1. Search the name and add it to the cart.

Step 2. Check the term. Big "first year" discounts often need a multi-year term. Set it to the number of years you actually want.

Step 3. Remove add-ons you don't need (extra email, website builders and so on). Now you see the real price.

Step 4. Read the renewal price, not only the first-year price.

Step 5. Check your contact details, then pay.

6. Owner, admin, technical, billing: keep control

What. A domain registration stores contact details:

1. Owner (registrant): the person or business that owns the domain.
2. Administrative: can change and transfer the domain.
3. Technical: handles DNS and server settings.
4. Billing: pays for registration and renewal.

Why it matters. Suppose we run a bakery and a developer builds our website. If the developer registers the domain in their own account, they control it. If they leave, or there's a fight about money, they can point it somewhere else or let it expire.

How to stay safe:

1. The business owner registers the domain, in their own account and name.
2. Owner and admin stay with the business owner.
3. The developer gets limited access for the technical work (many registrars have a delegate or team-member option), never the owner's login.

7. How: point the domain to EC2 with an A record

What. An A record maps a name to an IPv4 address. The name @ means "the domain itself", so an A record @ -> PUBLIC_IP makes example.com go to your server.

Step 1. In the EC2 console, open Instances, select your server and copy its Public IPv4 address.

Step 2. In GoDaddy, open your products, pick the domain and choose Manage DNS (on other registrars: DNS settings or DNS records).

Step 3. Add a record:

1. Type: A
2. Name: @
3. Value: the public IPv4 address you copied
4. TTL: leave the default

If an A record for @ already exists (new domains often have one pointing to a parking page), edit it instead of adding a second one.

Step 4. Save.

8. Install Nginx and test the domain

Step 1. Connect to the server (Amazon Linux) with ssh. Make sure its Security Group allows HTTP on port 80.

Step 2. Install Nginx:

sudo yum install nginx -y

Step 3. Start it:

[ec2-user@ip-172-31-xx-xx ~]$ sudo service nginx start
Redirecting to /bin/systemctl start nginx.service

What that line means. On Amazon Linux the old service command hands the job to systemctl, the system's service manager, and tells you so. It is not an error: Nginx has started.

Step 4. Open http://PUBLIC_IP/, then http://example.com/. Both show the Welcome to nginx! page. If the name doesn't open yet, wait a few minutes (section 9).

Step 5. Make your own test page:

sudo nano /usr/share/nginx/html/hello.html

Type one line, for example Hello from my own domain, save with Ctrl+O, Enter, then Ctrl+X.

Step 6. Open http://example.com/hello.html. Your line shows. The name now works exactly like the IP did.

9. Two things to know: the IP can change, and DNS takes time

Problem 1: the public IP changes. When you stop an EC2 instance and start it again, AWS gives it a new public IP. A reboot keeps the IP; a stop and start doesn't. The A record still holds the old IP, so example.com stops working.

Problem 2: DNS changes take time. Resolvers remember (cache) an answer for the record's TTL (time to live). After you change a record, some visitors get the old answer until that time runs out. Usually it's minutes; GoDaddy's own message says most updates take effect within an hour but can take up to 48 hours.

Example 2, step by step:

1. Monday: A record @ -> OLD_IP. The site opens.
2. Evening: you stop the server to save money.
3. Tuesday: you start it. EC2 shows a NEW_IP.
4. example.com still points to OLD_IP: the site doesn't open.
5. Quick fix: edit the A record to NEW_IP, save, and wait for the TTL.

The proper fix is an Elastic IP: a public IP that stays the same until you release it. That's the next chapter.

10. Why: many websites on one server (virtual hosting)

Why. Every running server adds to the AWS bill. Most small websites are busy only a little each day.

Example 3: an idle server, with numbers. Suppose a small site gets visitors for about 100 minutes a day.

1. A day has 24 × 60 = 1,440 minutes.
2. Busy: 100 minutes. Idle: 1,440 − 100 = 1,340 minutes.
3. 1,340 ÷ 1,440 ≈ 0.93, so the server sits idle about 93% of the day.

Example 4. Four small sites on four servers means four servers on the bill. The same four sites on one server means one. This is virtual hosting: one server, one Nginx, a folder per site, and Nginx picks the folder by the name the visitor typed. Shared hosting plans are cheap for the same reason: many small sites share one big server.

11. What: TLD, domain and subdomain

Read a name from right to left. Take onepage.example.com:

1. .com is the top-level domain (TLD). Others: .in, .org, .net.
2. example.com is the domain: the part you register and renew.
3. onepage is a subdomain. You create subdomains yourself, as many as you need, with DNS records. No extra registration.

Example 5. Suppose we are Google: mail.google.com, maps.google.com and drive.google.com are subdomains of one domain, google.com, and each opens a different service.

12. How: CNAME records for subdomains

What. A CNAME record says "this name is another name for that name". A CNAME onepage -> example.com makes onepage.example.com follow example.com, which already has the A record with the IP.

Why CNAME and not more A records? All subdomains follow the one A record. When the IP changes, you edit one record, not one per subdomain.

Step 1. In GoDaddy's Manage DNS, click to add a new record.

Step 2. Fill in:

1. Type: CNAME
2. Name: onepage (only the subdomain part)
3. Value: example.com (some registrars also accept @)
4. TTL: default

Step 3. Save, then repeat for each site: landing, scroll, animated.

Step 4. Delete old records you no longer use, so the list stays clean.

Now your records look like this:

Type    Name       Value
A       @          PUBLIC_IP
CNAME   landing    example.com
CNAME   onepage    example.com
CNAME   scroll     example.com
CNAME   animated   example.com

13. How: get the website templates onto the server

We need four different sites. A quick way is a public GitHub repository that holds several HTML templates, one per folder.

Step 1. Go to Nginx's folder:

cd /usr/share/nginx

Step 2. Download the repository as a ZIP (copy the link from Code > Download ZIP). sudo is needed because this folder belongs to root:

sudo wget https://github.com/OWNER/REPO/archive/refs/heads/master.zip

The ZIP has only the files, without the project's history; git clone is the other way to get a repository.

Step 3. Unzip it and give the folder a short name:

sudo unzip master.zip
sudo mv REPO-master websites
cd websites

Step 4. List the folders:

[ec2-user@ip-172-31-xx-xx websites]$ ls
'Animated Template'  'Landing Page Template'  'One Page Template'  'Scroll Template'

Why rename them. Names with spaces are painful in commands and in nginx.conf. In the shell, a space separates words, so a backslash before each space (\) says "this space is part of the name". Quotes do the same job.

Step 5. Rename each folder to one short word:

sudo mv Animated\ Template animated
sudo mv Landing\ Page\ Template landing
sudo mv "One Page Template" onepage
sudo mv Scroll\ Template scroll

Tip: type the first letters and press Tab; the shell adds the backslashes for you.

Step 6. Check:

[ec2-user@ip-172-31-xx-xx websites]$ ls
animated  landing  onepage  scroll
[ec2-user@ip-172-31-xx-xx websites]$ ls landing
index.html  ...

Each folder has its own index.html. Use the folder that holds index.html as the site's folder, as in the previous chapter.

14. How: one Nginx server block per subdomain

What. In nginx.conf, each server { ... } block is one website. Two settings (directives) decide which one:

1. server_name: the name this block answers to.
2. root: the folder it serves.

How Nginx picks a block. The browser sends the name it asked for along with the request. Nginx compares it with each server_name. If one matches, that block's root is served. If none matches, for example a visit by bare IP, the default block answers; in the Amazon Linux nginx.conf that's the first server block.

Step 1. Open the settings file:

sudo nano /etc/nginx/nginx.conf

Step 2. Leave the existing server block (with server_name _;) as it is. Below its closing }, still inside the http { ... } block, add one block per site:

server {
    listen       80;
    listen       [::]:80;
    server_name  landing.example.com;
    root         /usr/share/nginx/websites/landing;
}

server {
    listen       80;
    listen       [::]:80;
    server_name  onepage.example.com;
    root         /usr/share/nginx/websites/onepage;
}

Add the same for scroll and animated. Only server_name and root change from block to block. Save with Ctrl+O, Enter, then Ctrl+X.

Step 3. Test the file, then reload:

[ec2-user@ip-172-31-xx-xx ~]$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
[ec2-user@ip-172-31-xx-xx ~]$ sudo service nginx reload
Redirecting to /bin/systemctl reload nginx.service

reload applies the new settings without stopping the sites that are already running.

15. Test each subdomain

Step 1. Open each address:

1. http://landing.example.com/ shows the landing template.
2. http://onepage.example.com/ shows the one-page template.
3. http://scroll.example.com/ shows the scroll template.
4. http://animated.example.com/ shows the animated template.
5. http://PUBLIC_IP/ still shows the default page from /usr/share/nginx/html.

If one doesn't open:

1. Wait a few minutes after adding the CNAME (TTL), then try again.
2. Check the CNAME's Name has only the subdomain (landing, not landing.example.com).
3. Check server_name and root in that block, and that the folder holds index.html.
4. Run sudo nginx -t again and reload.

Example 6: five sites, one bill. Five names (the domain plus four subdomains), five server blocks counting the default one, and five DNS records (one A, four CNAME), all on one EC2 server.

16. Capital letters: the domain doesn't care, the path can

Q: Does LANDING.Example.COM work? Yes. The domain part of a web address is not case-sensitive; browsers turn it into small letters before asking DNS.

But the path can be. The part after the domain is a file path on the server. On a Linux server /Images/Logo.png and /images/logo.png are two different files, so a wrong capital letter gives 404 Not Found.

Habit. Use small letters for folder and file names, and type links exactly as the files are named.

17. The whole flow on one page

1. Buy a domain; keep owner and admin in your own account.
2. A record: @ -> PUBLIC_IP.
3. sudo yum install nginx -y, sudo service nginx start; open http://example.com/.
4. For each site: a CNAME name -> example.com.
5. sudo wget the templates, sudo unzip, rename folders to short names.
6. One server block per subdomain with server_name and root.
7. sudo nginx -t, sudo service nginx reload, open each subdomain.
8. Stop and start changes the IP: update the A record, or use an Elastic IP (next chapter).

18. Try at home

Recap

Revision, comparison and interview cards

Revise this lesson in a few minutes. Save the cards on your phone or download them as PNG files. The QR code on each card opens this lesson.

More cards: Ravi Sir's Cards.