If you need a basic introduction to cloud computing, here’s a beginner-friendly tutorial for you: What is Cloud Computing? A Guide for Beginners.

In this guide, I’ll show you how to create an AWS EC2 instance. This is one of AWS’s top services for building applications. By the end of this guide, you'll know how to launch an AWS EC2 instance and connect it to VS Code.

Table of Contents

• Prerequisites

• What is an AWS EC2 Instance?

• Why Connect Your AWS EC2 Instance to VS Code?

• How to Launch and Connect Your AWS EC2 Instance to VS Code

  • Step 1: Create an AWS EC2 Instance

  • Step 2: Connect the AWS EC2 Instance to Your Code Editor

  • Step 3: Install the Programming Language

  • Step 4: Open a Remote Window

  • Step 5: Access Your Project Folder

• Conclusion

Prerequisites

Before you start, make sure you have:

• An AWS account. If you do not have one, sign up here.

• A GitHub repository with your source code. If you don’t have a GitHub account, sign up here.

• Basic knowledge of web development and version control.

• A code editor. For this tutorial, I’m using VS Code.

Let’s jump right in!

What is an AWS EC2 Instance?

AWS EC2 (Elastic Compute Cloud) allows you to run virtual machines in the cloud. These computers allow you to run your applications without needing physical hardware.

There are a number of things you can you do with AWS EC2, such as hosting websites or apps, running big data or machine-learning tasks, creating testing environments, and handling tasks that need flexible, scalable computing power.

Why Connect Your AWS EC2 Instance to VS Code?

Connecting your AWS EC2 instance to VS Code is helpful for several reasons. Before we start the setup process, it’s important to learn why it’s beneficial.

1. Using VS Code provides a familiar and efficient development space. It feels like coding on your own machine.

2. You don’t have to log into your AWS EC2 instance each time. You can edit files, run commands, and debug code from a distance.

3. You can streamline your workflow with built-in terminal access and extensions. This way, you won't have to switch between SSH clients all the time.

4. You can push changes to GitHub. This makes working together and deploying much smoother.

5. VS Code works well with Java, Node.js, and Python. It supports many languages and frameworks, so it's great for cloud development.

Now that you understand the benefits, let’s move on to setting up the connection.

How to Launch and Connect Your AWS EC2 Instance to VS Code

To launch an EC2 instance on AWS, just follow these steps:

Step 1: Create an AWS EC2 Instance

First, log into your AWS account. Then, use the search bar to find EC2 and select it.

Click EC2 and follow the on-screen instructions to create a new instance.

1. Choose an AMI (Amazon Machine Image): This is a pre-configured template that includes an operating system and may come with additional software.

2. Select an instance type: Pick the right size for your needs. For example, t2.micro is a good option for beginners and small workloads.

3. Configure Your EC2 Instance: Set up networking, storage, security groups, and other options based on your requirements.

4. Launch Your Instance: Start your virtual server and access it remotely to begin using it.

Launched instance running:

So what’s happening in Step 1?

By launching an AWS EC2 instance, you are setting up a remote server in the cloud. AWS offers different AMIs that serve as pre-configured environments.

Step 2: Connect the AWS EC2 Instance to Your Code Editor

To connect your EC2 instance created in AWS to your VS Code, you need SSH.

What is SSH?

SSH (Secure Shell) is a secure way to connect and communicate with other devices. It keeps your connection safe. This is important when you access servers or repositories. In Git, you can use SSH instead of HTTPS to clone repositories with a secure connection.

Why is SSH important here?

With SSH, you can link your local code editor (like VS Code) to your AWS EC2 instance. This allows you to work on files stored on the EC2 instance directly from your editor as if on your local computer.

To connect your AWS EC2 instance to your local editor using SSH, follow these steps:

• Open your terminal.

• Go to the folder where your .pem key file is. The key file (.pem) downloads automatically when you create your EC2 instance (usually in the Downloads folder).

• Update the file permissions to keep your key secure and ensure proper authentication.

For Linux users, use this command to update the file permissions:

chmod 400 codebuild-keypair.pem

For Windows users, first you’ll need to find the username of your laptop, as you’ll need it to update the file permissions.

To do this, open your terminal and type:

whoami

This will display your current username.

Once you have your username, use the following command to update the file permissions:

icacls "codebuild-keypair.pem" /reset
icacls "codbuild-keypair.pem" /grant:r "%USERNAME%:R"
icacls "codebuld-keypair.pem" /inheritance:r

Here's what I mean: My username is ijeon, so you should replace it with your laptop's username and own key, which ends with .pem extension.

Running this command above updates the file permissions. So with this, you can work with your remote server.

Now that you have set the correct file permissions, you can use the SSH command along with the IPv4 address to connect to our EC2 instance. Type the following command:

ssh -i [PATH TO YOUR .PEM FILE] ec2-user@[YOUR PUBLIC IPV4 DNS]

Example:

ssh -i "C:\Users\ijeon\OneDrive\Desktop\devops-series-nextwork\codebuild-keypair.pem" ec2-user@ec2-35-178-142-201.eu-west-2.compute.amazonaws.

Breaking it down:

1. ssh: This starts a secure remote connection.

2. -i "C:\Users\ijeon\...\codebuild-keypair.pem": This tells SSH to use the .pem key file for secure access.

3. ec2-user@ec2-35-178-142-201.eu-west-2.compute.amazonaws.com:

   • ec2-user is the default username for EC2 instances.

   • @ec2-35-178-142-201... is the public address of your EC2 instance.

This command logs you into your EC2 instance remotely from your computer. It then uses the key (.pem file) instead of a password for security. It also lets you control the EC2 instance from your terminal as if you were using it directly.

If everything is set up correctly, a “success message” will appear. This confirms that you've logged in and can access the remote server.

Step 3: Install the Programming Language

Now that you’ve linked your instance to the editor, you can install the packages needed to build your web app. You can use any programming language you're comfortable with, but we’ll use Java for this tutorial. This will be a simple web application – we don’t need to go into advanced details.

1. Install Java

In your terminal, run the following commands to install Java:

sudo dnf install -y java-1.8.0-amazon-corretto-devel

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64

export PATH=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64/jre/bin/:$PATH

This installs Java on your system. You also need Maven. It helps manage Java projects and create templates for web applications.

2. Install Maven

Maven helps you organize Java projects. It also lets you create templates for web applications. Run these commands to install Maven:

wget https://archive.apache.org/dist/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz

sudo tar -xzf apache-maven-3.5.2-bin.tar.gz -C /opt

echo "export PATH=/opt/apache-maven-3.5.2/bin:$PATH" >> ~/.bashrc

source ~/.bashrc

To confirm Maven's correct installation, run this command:

mvn -v

Also, run the following command to check whether you have Java installed:

java -version

Now that you have installed Maven, you can use it to create a Java web app with the following command:

mvn archetype:generate \
  -DgroupId=com.nextwork.app \
  -DartifactId=nextwork-web-project \
  -Dpackage=com.nextwork.app \
  -DarchetypeArtifactId=maven-archetype-webapp \
  -DarchetypeVersion=1.4 \
  -DinteractiveMode=false

Running the command above generates a template for your application. In the terminal, it should show a "Build Success" message. This means the setup worked.

Step 4: Open a Remote Window

Now that you’ve installed the necessary packages and set up your app template, you need to open your IDE or code editor. This will let you access the folders on your remote server.

In your terminal, click the double arrow icon at the bottom left.

When you click on it, it opens a modal window for you.

A window will appear. Click "Connect to Host," which will open another window.

Then choose "Add New SSH Host" to open the SSH connection terminal.

Input your SSH command to configure the host.

After pressing "Enter," a configuration file will open. In this file, ensure that the .pem file and the IP4v DNS addresses from your EC2 instance are correct.

Here’s a GIF view of the image above:

Here’s the configuration file:

Go back to your editor and click on that double arrow again. This will automatically open a new window.

If your editor displays the IPv4 DNS address, your VS Code is successfully connected to the EC2 instance.

Now that you’re connected and a new window has opened, let’s access the folder stored in the cloud.

Step 5: Access Your Project Folder

In step 3, remember when you installed Maven? It created a template for your web app. Now, you’ll access the folder where you created this.

1. Go to the Explorer panel in the window.

2. Click the “Open Folder” button.

Clicking on this button opens a modal box for you to select your folder, which was created by the Maven template:

To access the template file, click the “src” folder. This takes you to the index.jsp file.

With this template created, you can decide to tweak it and send it to your Git repository for storage.

Conclusion

Great job! You’ve set up an AWS EC2 instance, linked it to your code editor, and installed the tools needed for your web app. In this tutorial, we used Java, but you can also choose other languages like Node.js or Python.

If you found this article helpful, please share it with others who may find it interesting.

Stay updated with my projects by following me on Twitter, LinkedIn and GitHub.

Thank you for reading.

Before getting started with this guide, make sure you've read through my previous tutorial on AWS EC2. It covers the essentials of creating and configuring an EC2 instance. You'll learn how to navigate the AWS Management Console, select the right instance type, configure security groups, and more.

This foundational knowledge will make sure you're fully prepared to launch your website effortlessly with the help of user data scripts.

So, grab a coffee, and let’s dive into this fun and simple guide. By the end, you’ll be able to launch your own website without breaking a sweat.

Table of Contents

• What We'll Cover

• Step 1: Launch Your EC2 Instance

• Step 2: Wait… The Script Did Everything Already?

• Step 3: Access Your Website

• Wrapping Up

• Want more?

What We’ll Cover:

Today, we’re going to:

• Launch an EC2 instance (Don’t worry, it’s easier than it sounds).

• Use a user data script to automate setting up a web server.

• Download a CSS template and host it on your instance.

You might be wondering: why a user data script? Imagine it as a to-do list for your EC2 instance. When the instance boots up, it runs through this list and sets everything up automatically. It’s like having a personal assistant that handles all the tedious setup tasks. Sounds good, right?

Step 1: Launch Your EC2 Instance

First things first, head over to your AWS Management Console. This is where all the magic happens.

Log in to AWS and head to the AWS Console. If you don’t already have an account, don’t worry, you can just sign up – it's free for basic usage.

Now here are the steps you’ll follow to launch the instance:

• In the console, type EC2 in the search bar and click on the EC2 service.

• Click the big Launch Instance button.

• Give your instance a cool name like "Webserver".

• Choose Your AMI: Select the Amazon Linux 2 AMI (free-tier eligible). It’s lightweight, fast, and perfect for our use case.

• Instance Type: Go for the t2.micro (it’s free for most use cases, and we love free things, right?).

• User Data Script: Now, this is where things get good. Scroll down to Advanced Details, and in the User Data field, paste in the following script. This script will handle everything from installing Apache to downloading and unzipping a fancy CSS template.

• 

    #!/bin/bash
  
    # Update the instance and install necessary packages
    yum update -y
    yum install -y httpd wget unzip
  
    # Start Apache and enable it to start on boot
    systemctl start httpd
    systemctl enable httpd
  
    # Navigate to the web root directory
    cd /var/www/html
  
    # Download a CSS template directly
    wget https://www.free-css.com/assets/files/free-css-templates/download/page284/built-better.zip
  
    # Unzip the template and move the files to the web root
    unzip built-better.zip -d /var/www/html/
    mv /var/www/html/html/* /var/www/html/
  
    # Clean up unnecessary files
    rm -r /var/www/html/html
    rm built-better.zip
  
    # Restart Apache to apply changes
    systemctl restart httpd
  

  • Configure Your Security Group: You want the world to be able to see your site, right? So, make sure to allow HTTP (port 80). This will let your website be accessible to anyone with the link.

• Launch Your Instance: After double-checking everything, click Launch. AWS will ask you to choose a key pair (which you’ll need if you want to SSH into your instance later). If you don’t have one, create a new key pair.

Boom! Your EC2 instance is launching. Grab a snack, it’ll be ready in a few minutes.

Step 2: Wait…The Script Did Everything Already?

Yes, that’s right! Thanks to the user data script, all the heavy lifting is done for you.

Here’s what just happened behind the scenes:

• Apache Web Server was installed and started.

• A CSS template called “Built Better” was downloaded directly into the server.

• The template was unzipped and placed in the web directory.

All of this happened while you were sipping your coffee.

Step 3: Access Your Website

The exciting part is finally here! Let’s see your website in action.

• Find Your Instance’s Public IP:

  • Head to your EC2 Dashboard, and you’ll see your running instance.

    Copy the Public IPv4 Address.

• Open Your Browser:

  • In the address bar, type: http://your-public-ip (replace your-public-ip with the one you just copied).

  • Hit enter, and… Voilà! Your website is live, looking all professional with the “Built Better” CSS template.

Wrapping Up

Let’s take a moment to appreciate what you’ve accomplished:

• Launched an EC2 instance ✔️

• Automated the setup using a user data script ✔️

• Hosted a slick website using a CSS template ✔️

You’ve just dipped your toes into the world of AWS and cloud hosting. It’s not as intimidating as it sounds, right? If you enjoyed this, keep exploring AWS – the possibilities are endless. Until next time, happy coding and hosting!

Want more?

Follow me on Twitter or connect on LinkedIn for more awesome cloud tips and tricks. I’m always sharing helpful content and would love to hear about your cloud journey!

You can follow me on

• Twitter

• LinkedIn

In this guide, I’ll show you how to host a website using a pre-designed template from CSS templates directly on your EC2 instance.

Before we dive into this guide, make sure you’ve gone through my previous blog on how to launch and connect to an EC2 instance. If you haven’t set up an EC2 instance yet, head over to that post first to get your instance up and running. Once that’s done, you’re all set to proceed!

Step 1: Download the "Built Better" Template

For this tutorial, we’ll use the Built Better template, which is free and easy to set up.

Head over to this link and download the template.

Right-click on the download button and select "Copy clean link". We’ll use this link to download the template directly into your EC2 instance.

Step 2: Download the Template Directly to Your EC2 Instance

Now that you have the link to the template, let’s download it straight to your EC2 instance using wget.

Log in to your EC2 instance via SSH or MobaXterm (as covered in my previous blog) and navigate to the /var/www/html directory where your website files will be stored:

cd /var/www/html

Use the wget command followed by the copied link to download the "Built Better" template directly into your EC2 instance:

sudo wget https://www.free-css.com/assets/files/free-css-templates/download/page284/built-better.zip

Note: After downloading, it's a good idea to check the file name to ensure it matches the file used in the subsequent commands. You can do this by running the ls command:

ls

Step 3: Unzip the Template Files

Now that the template has been downloaded, it’s time to extract it. Install the unzip utility if it’s not already installed:

sudo dnf install unzip -y

Then unzip the template:

sudo unzip built-better.zip -d /var/www/html/

After unzipping, make sure to check the folder name where the files were extracted from. You can do this by listing the contents of the /var/www/html directory:

ls /var/www/html/

In this case, the unzipped contents are located inside a folder named html. This folder contains all the template files. If the folder name is different in your case, adjust the following steps accordingly.

First, move the files from the html folder to the root /var/www/html/ directory:

sudo mv /var/www/html/html/* /var/www/html/

Then remove the unnecessary folder:

sudo rm -r /var/www/html/html

Lastly, remove the ZIP file:

sudo rm built-better.zip

Step 4: Set Up the Web Server to Host Your Template

If you haven’t already, make sure your Apache HTTPD web server is installed and running. You can follow these steps to ensure your server is ready:

Install Apache (if not installed):

sudo yum install httpd -y

Start the Apache service:

sudo systemctl start httpd

Enable Apache to start on boot:

sudo systemctl enable httpd

Now your web server should be up and running, ready to serve your template.

Step 5: Test Your Website

Now for the exciting part seeing your site live! Open a browser and navigate to your EC2 instance’s public IP address. You should now see the Built Better template live and ready to go.

Here’s how to check:

• Find your EC2 instance’s public IP from the AWS EC2 dashboard.

• Enter the IP in your browser, like so: http://your-ec2-public-ip

• Your website should now be live with the Built Better template! 🎉

Wrapping Up

Congratulations! You’ve successfully hosted a professional-looking website using the Built Better CSS template on your EC2 instance.

With just a few steps, you’ve moved from launching an EC2 instance to hosting a fully styled website, all using the AWS powerful cloud infrastructure.

You can follow me on

• Twitter

• LinkedIn

Don’t worry – it’s simpler than it sounds, and I promise to walk you through it step-by-step with a bit of fun along the way.

By the end of this guide, you’ll feel like a cloud wizard, casting spells that make servers appear out of thin air (well, out of Amazon’s data centers, but you get the point).

Ready? Let’s dive in!

Table Of Content

• What Is EC2?

• What is HTTPD?

• Step 1: How to Launch Your EC2 Instance

• Step 2: How to Connect to Your EC2 Instance

• Step 3: How to Install and Start HTTPD (Apache Web Server)

• Step 4: How to Host Your Custom Web Page

• Wrapping Up

What Is EC2?

Think of EC2 (Elastic Compute Cloud) as a hotel room in the cloud. Instead of booking a physical server to store your website, you’re renting one from Amazon’s magical cloud infrastructure. This room (or instance) comes with all the amenities you need to host a website. Today, we’ll install HTTPD (a web server software) in our “room” to make our website live. 🏨✨

What is HTTPD?

• At its core, HTTPD stands for Hypertext Transfer Protocol Daemon. Let’s break that down:

• Hypertext Transfer Protocol (HTTP): This is the standard protocol used on the web. When you type a URL into your browser or click a link, you’re using HTTP to tell the server, “Hey, send me this web page!”

• Daemon (D): A daemon is just a fancy term for a background process that runs continuously on a server. In this case, the daemon is responsible for responding to requests from web browsers (like Chrome or Firefox) and sending back the appropriate content.

• So, HTTPD is a program that listens for incoming HTTP requests (like when you visit a webpage) and serves back the data (HTML, CSS, images, and so on) needed to display that page.

HTTPD vs. Apache2: Different Names, Same Game

Depending on your Linux distribution, you may encounter different names for the same basic software:

• On RPM-based distributions (like Red Hat, CentOS, or Fedora), it’s called httpd.

• On Debian-based distributions (like Ubuntu or Debian itself), it’s referred to as apache2.

Let’s look at the steps you can use to launch your EC2 instance, and how to set up a web server using HTTPD.

Step 1: How to Launch Your EC2 Instance

First things first, let’s launch our EC2 instance. You’ll need an AWS account—signing up is free, and AWS offers a free tier, so this won’t cost you a dime for small-scale experiments.

Head over to the AWS Management Console and log in. From the search bar, type “EC2” and click on EC2 Dashboard.

Create a new instance by clicking on the orange Launch Instance button.

Next, choose the Amazon Machine Image (AMI) by selecting the Amazon Linux AMI, which is free-tier eligible and super reliable. Don’t forget to give your instance a unique name!

Adding a "Name" tag with a value like "MyFirstInstance" or "ProductionServer" helps you keep track of multiple instances while adding a personal touch to your cloud workspace.

Also, remember to check the default username for the AMI you select. Since you’ve chosen Amazon Linux, the default username is ec2-user. Keep this in mind for connecting to your instance later!

Select an Instance Type: The t2.micro is your best buddy here again, free-tier eligible and perfect for our needs.

Key Pair for SSH Access: Here’s where it gets important to have a .pem file to securely connect to your instance. This file, also known as a key pair, acts like the secret key to your cloud “hotel room,” allowing you to log in via SSH.

If you already have a .pem file for a previously created key pair, go ahead and choose that from the dropdown menu.

If you don’t have a .pem file, no worries! Create a new key pair by clicking Create New Key Pair, and download the .pem file to your computer. Make sure to store this file safely—you’ll need it to log in, and if you lose it, you won’t be able to access your EC2 instance!

Why is this file important? The .pem file is your private key, and AWS uses it to verify that you are the rightful owner trying to connect to the instance. You won’t get access without it, just like how you can’t get into a hotel room without the key.

Configure Security Group: AWS EC2 security groups are like virtual firewalls that control traffic in and out of your instance, ensuring only specific types of access. To allow web visitors, set up an HTTP rule on port 80, and for secure server logins, enable SSH on port 22 with restricted IPs.

You can reuse security groups across instances, making configuration easier and more consistent. Regularly review these settings to keep your instance secure and organized.

Launch the instance: Boom! You’ve just launched your very own server in the cloud.

Wait a minute or two for your instance to come online. Now that we have our EC2 instance running, let’s move to the next step of `setting up our web server.

Step 2: How to Connect to Your EC2 Instance

To connect, we’ll use the .pem file (key pair) we created earlier. If you’re on a Mac or Linux machine, this is super simple with SSH. For Windows folks, I recommend using MobaXterm—it’s a user-friendly terminal with SSH built-in.

If you’re new to connecting EC2 instances using MobaXterm, I’ve written a detailed guide in my previous blog post. You can check it out here, where I show how to set up and connect to an EC2 instance using MobaXterm.

For now, here’s a quick overview of the connection process using SSH:

ssh -i "your-key.pem" ec2-user@your-ec2-public-ip

Replace "your-key.pem" with the name of your key pair and "your-ec2-public-ip" with the public IP of your instance (you can find this in the EC2 dashboard).

If you’ve connected successfully, congratulations! 🎉 You’re inside your cloud server.

Step 3: How to Install and Start HTTPD (Apache Web Server)

Alright, time to install our web server software (HTTPD)! We’ll be using Apache, one of the most popular web servers around. Don’t worry, you don’t need a degree in IT to get this working.

After you successfully connect to your EC2 instance from MobaXterm, you should be all set to start the installation. You’re just a few commands away from having your web server up and running!

It’s always good practice to make sure your server is up to date. To update your server, run:

sudo dnf update -y

Next, we’ll install HTTPD (Apache):

sudo dnf install httpd -y

Then start the HTTPD service. Run this command to get the server running.

sudo systemctl start httpd

Next, enable it to start on boot so that every time your EC2 instance reboots, your web server comes back to life automatically.

sudo systemctl enable httpd

Time to test it out! Open your browser and type in your instance’s public IP. If you see the Apache test page, give yourself a high-five. 🖐️ You’ve just launched a web server!

Step 4: How to Host Your Custom Web Page

Now, let’s get creative! Instead of the default web server message, let’s host your very own custom web page in just one step. This will allow you to display a unique message on your site in no time.

Run the following command in your EC2 instance to create and display a simple, personalized web page:

echo "Welcome to the Cloud! You’re now hosting your own custom web server 
using AWS EC2 and Apache!" > /var/www/html/index.html

What does this command do?

• The echo command outputs the text: "Welcome to the Cloud! You’re now hosting your own custom web server using AWS EC2 and Apache!".

• The > symbol redirects this output to a file.

• /var/www/html/index.html is the path to the file where the message is saved. This file is the homepage of your web server.

By running this command, you're replacing the default Apache test page with your custom message.

Now, select your EC2 instance, and you’ll find its public IP address. Open your browser, enter that IP, refresh the page, and boom! Your custom message is live on the site. 🎉

Feel free to modify the text to make it uniquely yours!

Wrapping Up

And there you have it – you’ve just launched an EC2 instance and set up a simple web server using HTTPD! With these steps, you’ve not only spun up a server in the cloud but also configured it to be accessible to the world. By following along, you’ve learned the essentials of creating instances, setting up security groups, connecting via SSH, and installing Apache to serve up web content.

Keep exploring EC2’s features, and don’t hesitate to test new configurations and ideas. Each step adds to your cloud skills, bringing you one step closer to mastering AWS. So keep building, experimenting, and, most importantly, enjoying the journey. Happy cloud computing!

You can follow me on

• Twitter

• LinkedIn

Table of Contents

• Why MobaXterm?

• Step 1: Install MobaXterm

• Step 2: Get Your EC2 Instance Public IP and Key Pair

• Step 3: Open MobaXterm and Start a New SSH Session

• Step 4: Enter SSH Session Details

• Step 5: Attach Your .pem Key Pair

• Step 6: Connect to Your EC2 Instance

• Step 7: Troubleshooting Common Issues

• Wrapping Up

Why MobaXterm?

You may be wondering why we’re using MobaXterm over other SSH tools. Well, for starters, it’s super beginner-friendly, and it combines a bunch of powerful tools in one. You can use it to transfer files, run scripts, or even open multiple sessions simultaneously.

Plus, it’s like the Swiss Army knife for remote connections. Whether you’re working with AWS, Google Cloud, or even a Raspberry Pi at home, MobaXterm can do it all.

Step 1: Install MobaXterm

If you’re not already familiar with MobaXterm, it’s basically used for all things remote access. You can download it here for free. Installation is super easy – just download, click, and install.

Once you have it set up, fire up MobaXterm and get ready for the fun part.

Step 2: Get Your EC2 Instance Public IP and Key Pair

Before we continue, there are two key pieces of information you’ll need:

Public IP Address: This is the unique address AWS assigns to your EC2 instance. To find it, go to the EC2 Dashboard in AWS, select your running instance, and grab the Public IPv4 Address (it looks like 13.123.45.67).

Your .pem File: This is the private key file you downloaded when you created your EC2 instance. If you didn’t save it, you may have to create a new key pair because AWS only lets you download it once. (No pressure – just don’t lose it this time!)

Step 3: Open MobaXterm and Start a New SSH Session

Time to work some magic with MobaXterm! Open the app, and you’ll see an intuitive interface. Don’t let all the buttons scare you, just focus on the top left where it says Session.

Here’s what to do next:

• Click Session (you’ll feel powerful just pressing that button).

• In the new window, select SSH as the session type.

Step 4: Enter SSH Session Details

It’s time to fill in the details that’ll connect MobaXterm to your EC2 instance. Here’s what you need to know:

• Remote Host: Enter the Public IP Address of your EC2 instance here. Remember, you grabbed that from the EC2 Dashboard earlier.

• Username: If you’re using Amazon Linux, your default username is ec2-user. If you’re on Ubuntu, it’s ubuntu.

Step 5: Attach Your .pem Key Pair

MobaXterm makes it super easy to use your .pem key file for authentication (no converting to .ppk necessary, like you’d have to with other tools).

Here’s how to attach your .pem file:

• Head over to the Advanced SSH Settings tab.

• Check the Use private key option.

• Click Browse and find your .pem file on your computer.

• Select the file and hit OK.

It’s like giving MobaXterm the secret key to unlock your EC2 instance.

Step 6: Connect to Your EC2 Instance

Now that you’ve filled in all the details, click OK to start your session. If everything’s been set up correctly, you should see a terminal pop up, and MobaXterm will work its magic to connect you to your EC2 instance.

🎉 And just like that, you’re in! You should see a terminal window connected to your instance, and now you can start typing commands like a pro.

Step 7: Troubleshooting Common Issues

We all know that tech doesn’t always behave. Here are some common problems you might run into—and how to solve them:

• Connection Timed Out: This could be due to your instance’s security group settings. Make sure your EC2 security group allows inbound traffic on port 22 (the SSH port) from your IP address.

• Authentication Failed: Ensure you’re using the correct username (ec2-user for Amazon Linux, ubuntu for Ubuntu).

Wrapping Up

And there you have it! Connecting to your EC2 instance using MobaXterm with your .pem keypair is as simple as following these steps. It’s not rocket science—but it kind of feels like it, doesn’t it? Now that you’ve got your EC2 instance up and running, the sky’s the limit.

So, go on, take what you've learned here, explore, experiment, and, most importantly, have fun with it! Until next time, happy cloud computing! ☁️

You can follow me on

• Twitter

• LinkedIn

In AWS, there are two important services that help with this: Amazon EC2 Auto Scaling and AWS Auto Scaling. Amazon EC2 Auto Scaling is specifically for managing your EC2 servers, while AWS Auto Scaling can also handle other things like DynamoDB tables and Amazon Aurora databases.

In this article, we'll dive deeper into how Amazon EC2 Auto Scaling works and how you can use it to keep your website running smoothly without overspending on servers.

Prerequisites

• Have an AWS account
• Basic understanding of EC2 instance

Table of Content

• Prerequisites
• Example Use case
• Advantages of Amazon EC2 Auto Scaling
• Components of EC2 Auto Scaling
• What is Launch Configurations vs Launch Templates
• How to create a launch template
• What are Auto Scaling Groups (ASGs)
• How to create an Auto Scaling Group
• What are Scaling Policies
• Conclusion

Example Use Case

Scenario:

Imagine running a website that sells trendy clothes. Sometimes, lots of people visit your site at once, especially during lunch breaks or evenings. Other times, it's pretty quiet.

Problem:

You need enough servers to handle busy times, but you don't want to waste money on too many servers when it's quiet.

Solution with Amazon EC2 Auto Scaling:

Traffic Analysis: Look at when people visit your site the most. This helps you understand when you need more servers.

Set Rules: Decide when to add or remove servers automatically. For example, you might say, "If more than 70% of our servers are busy for more than 5 minutes, add one more server."

Adjust Server Numbers: Tell Amazon the smallest and biggest number of servers you need. You can also say how many you'd like on average. For instance, you might say, "Keep at least 2 servers running all the time. But if it's busy, go up to 10 servers. And usually, we need around 4."

Load Balancing: Make sure all servers get some work. Use a load balancer to send visitors to the least busy server. This keeps everything running smoothly even if you have many servers.

Test and Watch: Before trusting everything, test to see if it works as planned. Keep an eye on it afterward to make sure it's doing its job right.

Save Money: With auto scaling, you don't pay for servers you're not using. When traffic is low, it reduces the number of servers, saving you money. When traffic picks up, it adds more servers, so your site stays fast.

Advantages of Using Amazon EC2 Auto Scaling

Cost Optimization: EC2 Auto Scaling helps optimize costs by automatically adjusting the number of EC2 instances based on demand. During periods of low traffic, it reduces the number of instances, saving on operational costs. Conversely, during high traffic, it scales up to ensure optimal performance without over-provisioning resources.

Improved Availability: By automatically distributing incoming traffic across multiple instances and fault tolerance of your application. If any instance fails/is unhealthy, the Auto Scaling group replaces it with a new one, ensuring minimal disruption to your services.

Scalability: EC2 Auto Scaling allows your application to handle sudden spikes in traffic or increased workload without manual intervention.

Enhanced Performance: With EC2 Auto Scaling, you can maintain consistent performance levels even during peak usage periods. By automatically adding more instances when traffic increases, it prevents performance degradation and ensures a smooth user experience.

Ease of Management: EC2 Auto Scaling simplifies the management of your EC2 fleet by automating instance provisioning, scaling, and monitoring.

Integration with AWS Services: EC2 Auto Scaling integrates seamlessly with other AWS services such as Elastic Load Balancing (ELB) and Amazon CloudWatch.

Highly Customizable: EC2 Auto Scaling offers flexibility and customization options to meet the specific needs of your application.

Components of EC2 Auto Scaling

Let's get a better understanding on how the Auto Scaling works through its different components.

There are two distinct steps to configuration. The first step is the creation of a launch configuration or launch template. The second is the creation of an Auto Scaling group.

Launch Configurations and Launch Templates

Launch configurations or launch templates define the configuration settings for the EC2 instances that will be launched by the Auto Scaling group.

These settings include the AMI (Amazon Machine Image), instance type, security groups, key pair, and user data.

Launch configurations are older and being phased out in favor of launch templates, which offer more features and flexibility.

How to Create a Launch Template

First, navigate to EC2 Instance page

AWS instance page

Select the Launch Templates under the instances and click the create button.

AWS launch templates

The following screen should show up, almost similar to launching an EC2 instance. You can fill the required information accordingly.

Create AWS launch templates

After configuration, click the "Create Launch" template button and allow it to create, then view your newly created launch template with default and latest version as 1. You can use this launch template to create another launch template and specify a different version for it.

View AWS launch templates

Auto scaling requires either a launch template or launch configuration to identify the instance it's launching and its configurations.

What are Auto Scaling Groups (ASGs)

Auto Scaling groups are the core component of EC2 Auto Scaling. They define the group of EC2 instances that are managed together and share the same scaling policies. ASGs ensure that your application can automatically scale out (add instances) or scale in (remove instances) based on demand.

How to create an Auto Scaling Group

First, navigate to EC2 Instance page and under the Auto Scaling group, select and click the create button.

creating an Auto Scaling group

On the create screen, the first step is to give your ASG a Name and then select your launch template created from the steps above.

creating a launch template

The next step requires you to select or override an instance launch template. You also select a VPC and subnet.

selecting instance launch template

The next step is to configure advanced options such as adding a load balancer and monitoring. You can attach or add a new load balancer but for this article we will skip this part.

configuring advanced options

Next, configure the group size and scaling. Here, we want to configure the scale between minimum of 2 and maximum of 5. Also, set the metrics type to track the CPU utilization (set to 50 – you can increase to 70 or more) for scaling.

configuring group size and scaling

Next two steps are for adding notifications (you will need to create an SNS service for this) and tags. In this article, we are going to skip these and create our ASG.

Create and view the ASG created. From its activity folder, you can see those two instances launched. Also, from the instances page, you should see two EC2 instances. This is because we set our desired state to 2.

Auto Scaling groups

Auto Scaling groups

What are Scaling Policies?

Scaling policies define the rules that govern how the Auto Scaling group scales in or out in response to changing demand. There are four types of scaling policies:

Let's break down each type of scaling with examples:

Manual Scaling

Manual scaling involves adjusting the number of EC2 instances in your Auto Scaling group manually, without relying on automated triggers or policies. This type of scaling is typically done in response to predictable events or planned changes in demand.

Example: Assuming you run an e-commerce website, and you know that there will be a flash sale event that will attract a large number of visitors. To handle the expected surge in traffic, you can manually increase the desired capacity of your Auto Scaling group before the event, adding more EC2 instances in advance of the anticipated demand spike. After the event is over, you can manually reduce the desired capacity back to its normal level.

Pros:

• Control: Offers direct control over the number of EC2 instances in the Auto Scaling group.
• Flexibility: Allows for immediate adjustments based on specific requirements or events.

Cons:

• Manual Intervention: Relies on human intervention, which can be time-consuming and prone to errors.
• Lack of Automation: Not suitable for handling dynamic or unpredictable fluctuations in demand efficiently.

Schedule Scaling

Schedule scaling involves defining predefined schedules to adjust the number of EC2 instances in your Auto Scaling group automatically. This type of scaling is useful for applications with predictable traffic patterns, such as daily or weekly fluctuations in demand.

Example: Consider a video streaming service that experiences peak traffic during evenings and weekends. You can set up a schedule scaling policy to increase the desired capacity of your Auto Scaling group every evening at 6 PM and decrease it every morning at 6 AM. This ensures that you have enough capacity to handle peak demand periods without overspending on resources during off-peak hours.

Pros:

• Predictability: Well-suited for applications with predictable traffic patterns, such as daily or weekly fluctuations.
• Cost Optimization: Helps optimize costs by aligning resources with expected demand patterns.

Cons:

• Limited Adaptability: May not be responsive to sudden changes in demand or unexpected traffic spikes.
• Requires Planning: Requires upfront planning and configuration of schedules based on historical data or business insights.

Dynamic Scaling

Dynamic scaling adjusts the number of EC2 instances in your Auto Scaling group automatically based on real-time metrics, such as CPU utilization, network traffic, or other application-specific metrics. This type of scaling is responsive to fluctuations in demand and helps ensure optimal performance and cost-effectiveness.

Types:

• Step Scaling: This policy scales the number of instances based on a series of scaling adjustments defined by step adjustments and associated metrics thresholds.
• Target Tracking: This policy automatically adjusts the number of instances to maintain a specified target metric, such as average CPU utilization or network traffic.

When adding instances to the ASG, it will take a few minutes for them to come online and handle load. This is why a cooldown policy has to be set.

Scaling Cooldowns: Scaling cooldowns help prevent rapid fluctuations in the number of instances by imposing a cooldown period after a scaling activity is triggered. During this cooldown period, EC2 Auto Scaling will not launch or terminate additional instances, allowing time for the newly launched instances to stabilize or for the impact of terminated instances to be observed.

Example: Let's say you operate a ride-sharing platform where demand can vary unpredictably throughout the day. With dynamic scaling, you can configure Auto Scaling policies to add more EC2 instances when the number of ride requests exceeds a certain threshold, and remove instances when demand decreases. This allows you to dynamically adapt to changing traffic patterns in real-time, ensuring a seamless experience for both drivers and passengers.

Pros:

• Real-Time Responsiveness: Adjusts resource allocation dynamically in response to actual demand, ensuring optimal performance.
• Cost Efficiency: Automatically scales resources up or down, helping to optimize costs by only using what is needed.

Cons:

• Potential Over-Provisioning: May lead to over-provisioning during sudden spikes in demand if scaling policies are not properly configured.
• Complexity: Requires careful configuration of scaling policies and monitoring of metrics to ensure effective scaling behavior.

Predictive Scaling

Predictive scaling uses machine learning algorithms and historical data to forecast future demand and proactively adjust the number of EC2 instances in your Auto Scaling group. This type of scaling helps prevent under-provisioning or over-provisioning of resources by anticipating changes in demand before they occur.

Example: Suppose you operate a weather forecasting application that experiences increased demand during severe weather events. By analyzing historical data on weather patterns and user behavior, predictive scaling can predict when a surge in traffic is likely to occur and automatically scale up the capacity of your Auto Scaling group ahead of time. This ensures that your application remains responsive and available during peak usage periods without unnecessary resource waste.

Pros:

• Proactive Optimization: Anticipates future demand based on historical data, ensuring resources are provisioned ahead of time.
• Improved Cost Management: Helps prevent under-provisioning and over-provisioning, optimizing resource usage and costs.

Cons:

• Data Dependence: Relies on accurate historical data and effective machine learning models for accurate predictions.
• Initial Setup: Requires initial setup and configuration of predictive scaling models, which can be complex and resource-intensive.

Conclusion

In conclusion, Amazon EC2 Auto Scaling offers a range of strategies to effectively manage and optimize the performance of applications running on EC2 instances.

Whether it's through manual adjustments, scheduled scaling, dynamic responses to real-time metrics, or proactive measures based on predictive analytics, EC2 Auto Scaling provides the flexibility and automation needed to ensure that resources are aligned with demand.

By leveraging these scaling capabilities, businesses can enhance availability, improve cost efficiency, and deliver a seamless user experience, ultimately driving better outcomes for their applications and customers on the AWS platform.

As always, I hope you enjoyed the article and learned something new. If you want, you can also follow me on LinkedIn or Twitter.

You may want to host your website on a virtual private server or a virtual machine like AWS EC2. But it can be a challenge to connect a domain name that you purchased from providers like Namecheap or Godaddy.

But if you know the steps to follow, this doesn't have to be difficult.

In this post, I'll break the whole process of connecting a domain name to a website hosted on EC2 down. I'll show you how to do it practically with screenshots guiding you through every step. I'll be using a Namecheap domain in this example.

There are 4 major steps that you'll need to follow, and it shouldn't be too tricky if you follow the discussion in this tutorial. Here they are:

• Step1: Set up your website on EC2
• Step 2: Set up Route 53 for DNS management
• Step 3: Update nameservers with your domain provider
• Step 4: Wait for propagation

Let's get started.

Step 1: How to Set Up Your Website on EC2

First, visit https://aws.amazon.com/console/. Click on the sign in button at the top right corner or the Log back in button in the middle.

AWS Management Console

Create an account if you don’t already have one. Otherwise sign in with your credentials.

User Login Page

After logging in, you will be redirected to the main dashboard.

User Dashboard

In the search bar at the very top, you can search for EC2 and click on the first option under Services.

Searching for EC2

This will then open the EC2 dashboard that gives you a summary of all the EC2 resources that you are using. If you are not using any of them, then you are likely to find that the value for each will be zero.

EC2 Dashboard

Launching an EC2 instance

Click on the Launch Instance button.

On the "Launch an instance" page, you will select the specifications for the virtual machine intended to host your website or web application. Initially, assign a name to your machine for easy identification..

For the sake of this example, I used the name "FC Web Server".

Naming your EC2 Instance

Choose the Amazon Machine Image (AMI) which represents the specific operating system and applications you want to have by default on your virtual machine when you boot it.

For the sake of this example, I selected Ubuntu, and I'm using the Free tier eligible Ubuntu Server 22.04 LTS as the AMI. I left the architecture at 64-bit (x86).

Choosing an Amazon Machine Image

For the instance type, you can also stick with the Free tier eligible t2.micro – but if your app or website requires more resources, then you'll have to choose the most appropriate instance based on the number of vCPU and memory required.

Choosing the instance type

To securely connect to your virtual machine, you will need an SSH key pair. Go ahead and click on the Create new key pair link under the Key pair section if you don’t already have an existing key pair that you can use.

Creating a key pair

Give your key pair a name that you can easily identify. Set the key pair type to RSA and the private key file format to .pem. You can also use .ppk if you are in a windows environment and know how to use PuTTY.

Click the Create key pair button. After clicking it, the file will automatically be downloaded. Make sure you keep this file in a secured place.

Move on to the Network settings. You need to set up a firewall that controls the various protocols through which your website or web app can be accessed. For the sake of this example, you can choose Create security group and allow SSH, HTTPS, and HTTP.

You can leave the IP address at Anywhere 0.0.0.0/0.

Network settings for your instance

Finally, you need to configure the storage options. You can also go with the default 8GiB gp2. You can ignore the additional details and click on the Launch instance button.

Storage configuration for your instance

After the instance has successfully be launched, you will get a success message.

Success message after launching instance

Connecting to an EC2 instance

You've now created your virtual machine – so you need to connect to it and turn it on. You can do this by clicking on the Connect to instance. You can also click on View all instances to see the instance that you created.

If you click on view all instances, it will take you to this page where you see your instance (see below). If you have only one, then you will see something like what is shown below. But if you have other instances, then you will see all of the instances created in that same AWS region.

List of EC2 instances launched

Select the specific instance that you just created and click the Actions dropdown at the top right side. You can then click on Connect from the dropdown menu.

Connecting to the selected instance

The third way that you could have used to reach the connect to instance page is to click on the Instance ID from the list of instances. It takes you to the instance page with details about your selected instance. You will then find a Connect button at the top right side.

Details about the selected instance

On the Connect to instance page, you are presented with several options to connect to your instance. For the sake of this example, you can use EC2 Instance Connect. This option will allow you to connect to your virtual machine through the browser. You can stick with the default values and click the Connect button.

Options to connect to the instance

This opens up a terminal in the browser. This is your virtual machine. Remember that you installed Ubuntu so now you have access to an Ubuntu machine with all the specifications you selected.

Ubuntu terminal opened in the browser

It is now time for you to install NGINX. Follow the steps below to install NGINX on your instance.

Update your package list

Use this command to update your package lists:

sudo apt update

Updating the package list

Install NGINX

Use this command to install NGINX:

sudo apt install nginx -y

Installing NGINX

Once the installation is done, you can access the default page for NGINX by entering the public IP address of your instance in the address bar of your browser.

To find the public IP, you can check the bottom of your terminal or go to the instance page and look for Public IPv4 address.

Public IP address of the instance from below the terminal

Public IP address of the instance from the details page

You should get the default page open in your browser like shown below:

Default page for NGINX web server

NB: You may have to refresh the page for it to work.

For the next set of steps to set up your website or web app, it will depend on the programming language or framework that you used. But since this tutorial is focused on connecting a domain name to your EC2, you can proceed with the next steps for connecting the domain.

Default page of NGINX

Working from this image, let’s now connect our domain name to this website. As you can see in the image above, I am accessing it with the public IP address of the EC2 instance.

To connect the website with a domain name simply means to replace its IP address with a more memorable name. In our case, I will be replacing it with the domain name krachy.com.

Step 2: How to Set Up Route 53 for DNS Management

AWS provides a service called Route 53 that you can use for DNS (Domain Name Service) management. So now, we need to set up this service to manage the domain that you purchased.

I have my domain with Namecheap, but the process will be similar for almost every other domain retailing company.

First, you'll need to create a hosted zone in Route 53.

Amazon Route 53

Creating a hosted zone in Route53

To do that, click on the orange Get started button. It takes you to the next page, as shown below.

Getting started options for Route 53

Choose Create hosted zones and click the Get started button. Go ahead and fill out the details on the next page.

Hosted zone configuration

Providing details for hosted zone

Provide the domain name that you want to connect to the EC2 instance and then give it a description that will make it easier for you to distinguish this hosted zone from any others you may have. Choose Public hosted zone since you want your website to be accessible to the public.

Click the orange Create hosted zone button.

Success message for the hosted zone

You'll get a green success message showing that you have successfully created the hosted zone.

Adding records to the created Hosted Zone

From the screenshot above, you can see that Route 53 automatically created two records for us: the NS (Name Server) and the SOA (Start of Authority) records. The NS record is what you will need for pointing your domain to this service. But before you grab those, you have a couple of things to do here.

Because our website is being hosted on an EC2 instance which can be accessed through its public IP address, you need to create an A record for it. Also just so you ensure that people who try accessing your website with the www subdomain are still able to access it, you will also need to add another record with an alias for it.

To do that, start by clicking the orange Create record button, as you can see in the screenshot below:

Adding an A record

For the A record, don't put anything in the subdomain input box. Under Record type, make sure A – Routes traffic to an IPv4 address and some AWS resources is selected. Then paste or type the public IP of your EC2 instance in the textarea for Value.

You can leave everything as default (NB: Check to ensure that the Routing policy is Simple routing).

To get the IP address, visit the instance that you are using and look for the Public IPv4 address and copy that.

IP address from instance details page

It should now look like what is shown below (where 18.232.109.18 is the public IP for my instance). Afterwards, click the orange Create records button in the bottom right corner.

Completing the A Record creation

You should see a success message. Also, that the record will now be added to the records table that you saw earlier, as shown below:

Success message after creating the record

You still have to add the record to cater to the possible use of www when reaching your website. Click the Create record button to add that record. This time around, you will put www into the subdomain input box.

Adding A record to handle the use of www

Also, you will need to turn on Alias which is beneath the Record name. After turning it on, a new set of options (Route traffic to) will be made available.

Turning on the Alias for the record

For the Choose endpoint dropdown, select Alias to another record in this hosted zone and the Region will automatically be populated for you. But it also brings up another field labeled Choose record.

Select an option for "Route traffic to"

Go ahead and click within the Choose record field and it will suggest your domain name for you. Go ahead and select it.

Associate domain with record

Now you are ready to add this record too so proceed to click the Create records button. You will get a success message and see that the new record has been added to the records table.

Success message after adding new record

Once you are done setting up the records, you can now proceed to update your name servers with our Domain retailing company (NameCheap in my case).

Step 3: Update Nameservers with Your Domain Provider

If you already have an account with a domain provider, then log in to your account. But if not, then you'll need to sign up with one to purchase a new domain.

Personally, I use Namecheap for most of my domains. So, I will be showing how to get this done with Namecheap (but again, it will be similar for various Domain providers).

Note that I already have a domain name, and for any domain that you purchase you will have some default nameservers. Your goal here is to change the default nameservers or whatever your nameservers currently are to the ones which Route 53 provides you.

Changing nameservers in Namecheap

Namecheap user Dashboard

Click on the Domain list to see a list of all the domains that you have in that account. Look for the specific domain that you have.

Domain list

Next to each domain name, you will find the Manage button. Click the respective one for the domain that you are using (krachy.com in my case).

Detail page for selected domain

Under Nameservers, make sure you have selected Custom DNS. Then go back to Route 53 and copy the nameservers that you were provided with. Then delete what you currently have and add what you get from Route 53.

In my case, Route 53 gave me four different Nameservers. So I have to copy them one after the other and add them to Namecheap (remember to delete any old ones that were in the domain provider account).

Nameservers for the domain name

In Namecheap, they provide two spaces for the nameservers – but there is a button just below that lets you add more than 2. In my case, I added all four of them as you can see below:

Updating nameservers

Also, after adding them, you need to accept the changes and save them. In the screenshot above, you can see that at the far right of Custom DNS is a check mark and an x mark. Click on the check mark to save the changes.

After saving, you will notice that those buttons are no longer available.

Nameservers updated on Namecheap

Step 4: DNS Propagation

Congratulations, you are now done with the set up. Now you just need to wait for the DNS propagation to be completed.

This step doesn’t involve you taking any action, but just waiting for a couple of minutes. The propagation can take anywhere from a couple of minutes to more than 24 hours.

But after a short while, just enter your domain name in your browser’s address bar and see if it shows the website that you have hosted on the EC2 instance.

Once the DNS propagation goes through, your website will be live on the domain name that you used. Congratulations once again!

Website linked to domain after DNS propagation

As you can see, this is the same interface that I started with – but the good news is that now, I accessed it with the domain name I purchased and not the IP address of the instance.

Wrapping Up

Even though you are done, you are currently using a non-secured transfer protocol (http) for your website. This is because you haven't yet installed an SSL certificate on your website.

Watch out for my next tutorial where I walk you through how to install SSL on your domain to make it secure (https).

This article provides a comprehensive guide on how to set up a continuous deployment pipeline for a Django project hosted on an AWS EC2 instance.

By leveraging GitHub Actions, developers can automate their deployment process, making it more efficient and error-free.

Prerequisites

• A Django project hosted in a GitHub repository.
• An AWS EC2 instance set up for hosting a Django application.
• Basic familiarity with YAML and GitHub workflows.

How to Set up the EC2 Instance

Before diving into GitHub Actions, ensure your EC2 instance is ready to host your Django application.

Use the command below to connect to your EC2 instance:

ssh -i /path/to/your-key.pem ec2-user@your-ec2-instance-public-dns

You can update your system packages using these:

sudo apt-get update
sudo apt-get upgrade

Next, if you haven't already, install Python and Pip:

sudo apt-get install python3
sudo apt-get install python3-pip

Then install Django using this command:

pip3 install django

How to Configure a Web Server

In this section, you'll see how to configure your web server.

First, install Nginx:

sudo apt-get install nginx

Then configure Nginx for Django. Start by creating a new configuration file for your Django project.

sudo nano /etc/nginx/sites-available/mydjangoapp

Then add the following server block:

server {
    listen 80;
    server_name your-domain.com;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /path/to/your/django/project;
    }

    location / {
        include proxy_params;
        proxy_pass http://unix:/path/to/your/gunicorn.sock;
    }
}

Lastly, enable the Nginx configuration:

sudo ln -s /etc/nginx/sites-available/mydjangoapp /etc/nginx/sites-enabled
sudo nginx -t
sudo systemctl restart nginx

How to Setup a Database

You can install PostgreSQL using this:

sudo apt-get install postgresql postgresql-contrib

After the installation, create a database and user using this command:

sudo -u postgres psql

Run this SQL query to create a new database and add a new user:

CREATE DATABASE mydjangodb;
CREATE USER mydjangouser WITH PASSWORD 'password';
ALTER ROLE mydjangouser SET client_encoding TO 'utf8';
ALTER ROLE mydjangouser SET default_transaction_isolation TO 'read committed';
ALTER ROLE mydjangouser SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE mydjangodb TO mydjangouser;
\q

Then configure Django to use PostgreSQL. In your Django settings.py file, update the DATABASES setting:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydjangodb',
        'USER': 'mydjangouser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}

The GitHub Actions workflow for deploying a Django project involves several key steps:

Step #1 - Checkout and Preparation

The first step in your workflow is to check out the latest code from your GitHub repository and set up the environment for the deployment.

name: Deploy Django to EC2

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

Step #2 - Deployment Script

The deployment script involves pulling the latest code, installing dependencies, running migrations, and restarting the web and WSGI servers.

Create a new file deploy_script.sh on your EC2 machine and add the code below:

#!/bin/bash

DRY_RUN=$1

echo "Pulling latest code from repository..."
# Skip actual git pull in dry run
[ "$DRY_RUN" != "true" ] && git pull origin main

echo "Installing dependencies..."
# Skip actual installation in dry run
[ "$DRY_RUN" != "true" ] && pip install -r requirements.txt

echo "Running migrations..."
# Skip actual migrations in dry run
[ "$DRY_RUN" != "true" ] && python manage.py migrate

echo "Restarting the server..."
# Skip actual restart in dry run
[ "$DRY_RUN" != "true" ] && sudo systemctl restart myapp

echo "Deployment complete."

Step #3 - Create a Step to Run the Deployment Script

Use GitHub Actions to SSH into your EC2 instance. You'll need to store your EC2 instance's SSH key as a GitHub secret.

- name: Run Deployment
  run: |
    ssh -i ${{ secrets.EC2_SSH_KEY }} ec2-user@your-ec2-instance 'bash -s' < deploy_script.sh
  env:
    ACTIONS_RUNNER_DEBUG: false

Security Considerations

Here are some security considerations to keep in mind:

• SSH Keys: Store your SSH private keys securely in GitHub Secrets.
• Minimal Permissions: Ensure the EC2 instance's IAM role has minimal permissions necessary for deployment.

Testing and Validation

Before fully implementing this workflow, test it with a development or staging environment to ensure that the deployment process works as expected.

Dry Run Deployment: Implement a step in your GitHub Actions workflow that does a 'dry run' of the deployment process. This can help validate the deployment scripts without affecting the live EC2 instance. Add the step below to pass dry_run = true in deployment script.

- name: Dry Run Deployment
  run: |
    ssh -i ${{ secrets.EC2_SSH_KEY }} ec2-user@your-ec2-instance 'bash -s' < deploy_script.sh true
  env:
    ACTIONS_RUNNER_DEBUG: true

Logging and Monitoring: You can see current action capture logs of the deployment process from deploy_script.sh, which can be reviewed if any issues arise.

Conclusion

Automating Django deployments using GitHub Actions offers a streamlined and reliable way to manage application delivery.

By following the steps outlined above, developers can set up a robust deployment pipeline that pushes their latest Django code to an EC2 instance seamlessly upon every push to the main branch.

In this article, I will go through some things you should consider when selecting an EC2 instance.

You can think of an EC2 instance as not too different from your personal computer. If you are going to buy a computer, three broad technical considerations may cross your mind (ignoring any aesthetic or design preferences you may have, of course):

1. How much processing can it handle?

2. How much memory does it have?

3. How much storage does it have?

These three questions should also cross your mind when selecting an EC2 instance. The difference being, you are only renting the instance from AWS, instead of buying it as you would with a personal computer.

Each EC2 instance is composed of:

1. CPU – how much processing can be achieved

2. Memory

3. Storage – this only applies to some instances that have physically attached storage (called the instance store). For other EC2 instances, you'll need to choose network storage using EBS (Elastic Block Storage) separately.

Compute, Memory, and Storage – An Analogy

A good analogy for an EC2 instance is your work desk.

Your brain is the compute, the surface of your desk is the memory, and your desk drawer is the storage. Note that this analogy (like all analogies) has its limitations. Its purpose is to neatly spilt the role of compute, memory, and storage in an EC2 instance.

What exactly does compute mean? Compute is concerned with parallelism – the ability to execute multiple tasks simultaneously.

Human brains can handle some level of parallelism. You might be able talk on the phone while taking notes simultaneously, for example. You cannot, however, write two different letters simultaneously, or talk on the phone while taking notes and reading a book.

These activities cannot be executed in parallel because our brain can be crudely thought of as a CPU with a single core. To increase compute, we need to increase parallelism, and this can be achieved by having multiple CPU cores. More cores equals more parallelism which equals more compute power.

Memory and storage are theoretically the same thing. We use them both for storing data. Practically, though, they are physically distinct pieces of infrastructure simply because there is no single storage device that is both fast and non volatile.

Memory is fast and volatile while storage is slow and non-volatile. Things kept on the surface of your desk are quickly and easily accessible, just like data in a computer’s memory. But anything left on your desk overnight in a busy office is at risk of being moved, lost, or stolen. The surface of your desk, just like a computer’s memory, is volatile.

Storage, on the other hand, is non-volatile but slower to read/write from. Just like items in your desk drawers are less likely to go missing but take longer to get your hands on.

How to Select the Right EC2 Instance

So, CPU, memory, and sometimes storage are the three levers you can pull when selecting an EC2 Instance. Recall that storage is often selected separately from the EC2 instance using EBS volumes, except for storage optimized instances that have physically attached storage.

When you select an instance type, you are effectively selecting for the lowest price per unit of the metric most important for your workload. This metric can be CPU/GPU performance, memory, or storage.

There are five AWS instance types:

• general purpose: By choosing a general purpose instance, you are taking a balanced approach and not optimizing for any one metric.

• compute optimized: By choosing a compute optimized instance, you are optimizing for the lowest price per unit of CPU performance (number of CPU cores).

• accelerated computing: By choosing an accelerated computing instance, you are optimizing for the lowest price per unit of GPU performance (think of this as a specialised CPU needed for high performance compute workloads).

• storage optimized: By choosing a storage optimized instance, you are optimizing for the lowest price per unit of storage capacity and efficiency.

• memory optimized: And by choosing a memory optimized instance, you are optimizing for the lowest price per unit of memory.

Let’s go through the instance types in more detail.

AWS has a great outline of this here that I have summarised below:

1. General Purpose – For workloads that require a balance of compute, memory and networking. Ideal use case is web servers.

2. Compute Optimized – For workloads that require high performance processors. Lowest dollar cost per number of CPU cores. Ideal for compute intensive workloads like scientific modelling and gaming.

3. Accelerated Computing – For workloads that require even larger amounts of compute resources than compute optimized instances. This type of instance uses GPUs (graphical processing units) which is a specialised CPU designed for machine learning and high performance computing workloads.

4. Storage Optimized - For workloads that require high rates of reads and writes for large amounts of data, that is high IOPS (Input/Output Operations per second).

Unlike other instances, these do not use separate EBS volumes for storage. Instead they come with physically attached storage volumes (called the instance store). This means that data does not have to go through a network, allowing it to achieve high IOPS.

Ideal use case is NoSQL databases – like Elasticsearch, MongoDB, Cassandra and some data warehousing applications. Instance store volumes, however come with a catch: any data stored there does not persist beyond the life of the instance. So, if the instance stops, hibernates, terminates or fails, you lose all data on that instance.

The ideal use case for storage optimized instances is thus for workloads that require high IOPs and can tolerate the failure of an instance (usually by having data replicated to another instance for redundancy). 5. Memory Optimized – For workloads that require large amounts of RAM. Lowest dollar cost per unit of RAM. Ideal for in memory databases, caches, SQL databases.

Anatomy of an EC2 Instance Name

You may have come across EC2 instance names like t2.nano, r6a.large or i3en.6xlarge. What exactly do the letters and numbers mean?

Let’s take a complex name like i3en.6xlarge as an example and break it down.

Anatomy of an EC2 instance name broken down

Instance Family

Reading from left to right, the first letter is the instance family. Every family belongs to only one of the instance types, that is general purpose, compute optimized, accelerated computing, storage optimized or memory optimized.

There is no need to cram trying to learn which instance family belongs to which instance type. As you work more with AWS, it will become almost second nature. You can have a look here for reference if you'd like.

The i3en.6xlarge instance above belongs to the “i” family, which is a storage optimized instance.

Instance Generation

This is a number that shows the instance generation. The higher the number, the more recent the generation.

When given the option between different generations for the same instance, you should, ideally, always select the latest generation. The latest generation instance usually comes with the latest hardware. This typically means lower cost per unit of performance relative to older generations.

The i3en.6xlarge instance in the example above is a third generation instance.

Special Features

These are optional letters that come after the instance generation. Each letter denotes some special feature about the instance.

In this case the “e” signifies extra capacity (can be RAM or storage) and “n” signifies that the instance is network optimized. This means that it has high network bandwidth, meaning the instance can handle a high data transfer rate, typically measured in Gb per second.

Other special feature characters and their capabilities are as follows:

• a – AMD processors

• g – AWS Graviton processors

• i – Intel processors

• d – Instance store volumes

• b – Block storage optimization

• z – High frequency

These extra features do not come for free, so only select an instance with extra features if you need these additional features.

Instance Size

The size appears after the full stop. It consists of two parts: a number and letters denoting size. The size options range from nano to xlarge (extra large).

The number only appears with xlarge instances. It denotes how much larger the instance is compared to an xlarge. So a 2xlarge is twice as large as an xlarge and a 6xlarge is six times as large as the xlarge.

But, what does twice or six times as large really mean?

For the same instance type, the number after the full stop acts as a multiplier for the compute (number of vCPUs), memory (amount of RAM), and storage size (not all the time – some instances use EBS volumes where storage can scale independently of the instance. Storage optimized instances, on the other hand, use physically attached instance storage that scales based on the instance size.).

An i3en.xlarge instance has 4 vCPUs, 32 GiB memory, and 2500 GB storage capacity. An i3en.6xlarge is six times larger since it has six times the number of vCPUs (24), six times the memory (192 GiB), and six times the storage capacity (15,000 GB).

Bringing it All Together – How to Select Your Instance

So, let’s say you need to select an EC2 instance for your web server, or your NoSQL database – what are some logical steps to follow?

Step 1: Select instance type

Choosing between general purpose, compute optimized, accelerated computing, storage optimized and memory optimized is the first and most important decision. Every subsequent decision will be driven by this one.

Here, the decision you are making is primarily one of cost - you are trying to optimize for the lowest dollar cost per unit of the metric that's most important for your workload.

If your workload is generic, like a web server, choose a general purpose instance. If your workload is compute intensive, go with a compute optimized instance type. The same logic applies if your workload is memory or storage intensive.

Step 2: Select instance family

A good mental model for choosing the right instance family is to go through the technical documentation for the application you plan to run on that instance and use their recommendation.

For example, Elasticsearch (a full-text search engine database) recommends the “i” family of instances – specifically the “i3”. Recall that the number after the instance family is simply the instance generation, and the latest is usually the greatest.

When a newer generation of the “i” family arrives, Elasticsearch will likely recommend the “i4” instance. You can reason by analogy when selecting the instance family. Look at what the application recommends, as it's a great way to reduce any errors of omission or commission.

The company behind the application will have a lot of experience testing different families and will have done the experimentation on your behalf. No need to re-invent the wheel (unless, of course, your workload is truly niche and no best practice exists).

Step 3: Select an instance with special features

Do this only if absolutely needed. You will be paying extra for this.

Step 4: Select an instance size

This is purely specific to your workload and is usually an iterative process. You can run some tests while monitoring CPU and memory utilisation to see if the size you selected is appropriate.

You usually try to have some safety margin, so if your workload is consuming, on average, 90% of memory and CPU, you may need to choose a larger instance. A utilisation of 90% does not provide much headroom for any estimation errors you may have made during testing.

Deciding on the amount of headroom you need is more art than engineering, so there are no hard qualitative numbers on this. But as a rough guide, utilisation in the 90% range is bad, 80% range is acceptable, and 70% and below is good.

You need to provide some headroom to prevent any performance problems from occurring during peak demand.

Wrapping Up

When you select an instance type, you are effectively selecting for the lowest price per unit of the metric most important for your workload. This is an important foundation in any project you are working on, as it ensures you are paying the lowest dollar amount per unit of performance.

Selecting the instance size is the most difficult piece of the puzzle and is likely to be an iterative process where you start small, test, and then scale up as required.

AWS is so cool because it is made up of discreet building blocks that you can use to build some fairly complex infrastructure. This is awesome once you get a handle on things. But when you are just starting out you need to know things like "how do I get the IP address of my server" and "wait which SSH key".

Let's go over a few of the key concepts, and then spin up our very own server on the cloud!

What you need to know to administer remote servers on AWS

There are many reasons why you might want to get started on AWS. Maybe your company is moving infrastructure onto the cloud. Maybe you want to start freelancing and don't want to invest in upfront server costs. Or maybe you just want to learn a new skillset.

In order to spin up a remote server on AWS you need to know a few foundational AWS terms and concepts. I'll go over some terms that are directly applicable to spinning up a remote server, but these same concepts are used for more complex infrastructure services such as ElasticBeanstalk, Docker Swarm, and Kubernetes.

Elastic Compute Cloud (EC2)

AWS EC2 instances are where you compute power lives. These are your remote servers. Knowing how to deal with EC2 instances is incredibly important because they appear just about everywhere.

Security Groups

Security groups are what allow access to your various AWS services, in this case an EC2 instance. These define which ports are open for inward and outward bound traffic.

Key Pairs

Key pairs are your SSH keys. Make sure you keep track of these and keep them somewhere safe! Also, if you use AWS a lot you will start a collection of key pairs, so make sure that you give them descriptive names and not just ssh. ;-)

Virtual Private Cloud (VPC)

A VPC is an isolated resource where your compute infrastructure lives. To carry on with my everything is Legos philosophy, the VPC is the Lego box while the EC2, Security Groups, and KeyPairs are the actual Legos.

VPCs take care of all of your networking. When you sign up for an AWS account you will get a default VPC and that is what we will be using today.

How to Launch an EC2 Instance

There are so, so many ways to launch an EC2 instance. Which one you want will depend upon your needs. Today we will go over using the AWS web console and using the python boto3 library.

As a quick aside, because AWS has so many services you have to go into each service individually to manage it. If you're ever lost, just search for your service from the 'Services' Menu.

Launch an EC2 Instance Using the Wizard

First you'll need to login to your AWS Console.

Navigate to the EC2 Dashboard

Bring up the EC2 services page by searching for it in 'Services'

1. Click on Services to bring up the search box.
2. Type in the service name you want - in this case, EC2.
3. Click on your service name from the menu to bring you to that services dashboard.

Select 'Launch Instance'

Once we're at the EC2 Dashboard you'll want to click the 'Launch Instance' button in the middle of the screen. This will start up the the AWS EC2 Launch Wizard, which will walk us through the process of starting up an EC2 instance.

If you want to go through part 2 where we'll startup an EC2 server programatically with Python this is an excellent chance to write down your default VPC id!

EC2 Wizard Overview

Once you select 'Launch Instance' you'll be brought to a wizard. The wizard menu has 7 steps, and you can switch between them as you like to get your instance configured just the way you want it.

EC2 Wizard - Select Your AMI Type

Here is where the magic happens!

This is where you will choose your AMI type, which is mostly what operating system you want. There are any number of preconfigured AMIs for lots of common use cases, including ML applications, web servers, and databases. Check out the AWS Marketplace to see all the cool AMIs out there!

I like the Amazon Linux 2 image, but you can search for any image type, including Ubuntu, Centos, or any number of Bitnami images.

Quick side note here. I love the Bitnami images. They are all awesome, and if you're looking into deploying any kind of web application such as Ghost, Wordpress, Nginx, or even more complex applications like Redash or Airflow I really recommend them.

EC2 Wizard - Choose your Instance Type

I'm going with the free one because I intend on killing this, but if you're actually using this EC2 instance for anything important you'll want to add more power. If you need anything involving internet, such as transferring data, make sure that you pay attention to the internet capabilities and choose something in the moderate range.

Scroll down and choose either 'Launch' to launch with default settings or 'Configure your Instance' to add in additional configurations such as changing the root file system size, choosing a VPC, or adding in user data.

EC2 Wizard - Add Tags

When you're just starting out this doesn't matter too much, but as you get going with AWS you will want to make sure that all of your instances have, at the least, Name tags. This will allow you to more easily search for your instances and do nice things like create resource groups to group together your AWS services.

In the wizard menu select 'Add Tags'. Don't worry, you can switch between steps in the wizard as often as you like.

EC2 Wizard - Configure the Security Group

Before we finish up we'll configure the security group, which is what defines the access rules. AWS will create a security group for you, or you can choose one already. The default is to open port 22 for SSH, but if you'll use this for any web or database applications you will need to open those ports too.

EC2 Wizard - LAUNCH

Now that we've told AWS what we want let's launch our instance! Click on the Review and Launch. You'll get a popup window asking you which SSH Key you want. You can also create a new SSH Keypair here.

EC2 Wizard - Confirmation Page

Once you've launched you'll be brought to a confirmation page with your EC2 Instance ID.

EC2 Dashboard - Get your IP Address

There we go! Now all that is left is to wait for our instance to be ready and SSH on over.

Ok! Now we just have to SSH over to our instance. The details for this will be slightly different depending on which instance type you chose.

This assumes you downloaded your keypair named my-remote-server.pem and moved it to ~/.ssh

chmod 400 ~/.ssh/my-remote-server.pem

# Amazon linux 2 ami
ssh -i ~/.ssh/my-remote-server.pem ec2-user@PUBLIC_DNS

# Ubuntu or Bitnami
ssh -i ~/.ssh/my-remote-server.pem ubuntu@PUBLIC_DNS

That's it! Now you have a remote server on the cloud!

Spin up an EC2 Instance with the Boto3 Python Library

Full disclaimer here. This is well beyond what I would normally do with the boto3 library. For anything beyond launching an EC2 instance I would recommend using the console or using an infrastructure as code tool such as Cloudformation or Terraform. But when you are starting out it is really important to understand the foundations.

I also have an obsessive need to write out reports for absolutely everything. Feel free to remove if you're not as paranoid. ;-)

import boto3
import time
import json
from pprint import pprint
from select import select
import logging
from logging import Logger
from paramiko import SSHClient
import paramiko
from typing import Any
import os

logger = logging.getLogger('launch_ec2')
logger.setLevel(logging.DEBUG)

PROJECT = "my-remote-server"
KEY_PAIR = "my-remote-server"
SECURITY_GROUP="sg-some-number"
# Amazon Linux 2 AMI
AMI_ID="ami-062f7200baf2fa504"
INSTANCE_TYPE="t3a.medium"

report_data = {
    'name': PROJECT,
    'computer_name': KEY_PAIR,
}

def initialize_dir():
    """
    Initialize a directory to write out our keypair and reports
    """
    if not os.path.exists(KEY_PAIR):
        os.mkdir(KEY_PAIR)


def create_key_pair():
    ec2_client = boto3.client('ec2')
    key_pair_response = ec2_client.create_key_pair(KeyName=KEY_PAIR)
    report_data['ssh_key'] = {}
    report_data['ssh_key']['id'] = key_pair_response['KeyPairId']
    report_data['ssh_key']['name'] = key_pair_response['KeyName']
    report_data['ssh_key']['key'] = key_pair_response['KeyMaterial']
    report_data['ssh_key']['key_file'] = os.path.abspath(os.path.join(KEY_PAIR, 'keypair.pem'))
    logger.info('Successfully created ssh key')


def write_key_file():
    """
    Write out the .pem ssh key file
    :return:
    """
    f = open(os.path.join(KEY_PAIR, 'keypair.pem'), 'w+')
    f.write(report_data['ssh_key']['key'])
    f.close()
    os.chmod(os.path.join(KEY_PAIR, 'keypair.pem'), 0o400)
    logger.info(
        'Wrote out ssh key file to {keypair}'.format(
            keypair=
            os.path.abspath(os.path.join(KEY_PAIR, 'keypair.pem'))
        )
    )


def create_instance():
    ec2 = boto3.resource('ec2')
    instance = ec2.create_instances(
        SecurityGroupIds=[SECURITY_GROUP],
        ImageId=AMI_ID,
        MinCount=1,
        MaxCount=1,
        InstanceType=INSTANCE_TYPE,
        KeyName=KEY_PAIR,
        TagSpecifications=[
            {
                'ResourceType': 'instance',
                'Tags': [
                    {
                        'Key': 'Name',
                        'Value': PROJECT
                    },
                ]
            },
        ],
    )
    report_data['ec2'] = {}
    report_data['ec2']['id'] = instance[0].id
    report_data['ec2']['PublicIP'] = None


def get_public_ip():
    print('Waiting for instance to initialize with public IP address...')
    print('This may take some time...')
    time.sleep(10)
    ec2 = boto3.resource('ec2')
    running_instances = ec2.instances.filter(Filters=[
        {
            'Name': 'instance-state-name',
            'Values': ['running']
        },
        {
            'Name': 'instance-id',
            'Values': [report_data['ec2']['id']]
        }
    ])
    for instance in running_instances:
        # Add instance info to a dictionary
        report_data['ec2'] = {
            'instance_id': report_data['ec2']['id'],
            'Type': instance.instance_type,
            'State': instance.state['Name'],
            'PrivateIP': instance.private_ip_address,
            'PublicIP': instance.public_ip_address,
            'LaunchTime': str(instance.launch_time)
        }


def write_report():
    """
    Write out a JSON file with all of the IDs and things we need
    """
    logger.info('Writing report to {}'.format(
        os.path.abspath(os.path.join(KEY_PAIR, 'report.json'))
    ))
    f = open(os.path.abspath(os.path.join(KEY_PAIR, 'report.json'))
             , 'w+')
    json.dump(report_data, f, ensure_ascii=False, indent=4)
    f.close()


def print_helper_commands():
    """
    Print some helper commands for ssh and rsync to the screen
    """
    rsync_command = "rsync -av --progress -e 'ssh -i {key_file}' HOST_DIR ec2-user@{public_id}:/home/ec2-user/efs".format(
        key_file=report_data['ssh_key']['key_file'],
        public_id=report_data['ec2']['PublicIP']
    )
    ssh_command = "ssh -i {key_file} ec2-user@{public_ip}".format(
        key_file=report_data['ssh_key']['key_file'],
        public_ip=report_data['ec2']['PublicIP']
    )
    report_data['ssh_command'] = ssh_command
    report_data['rsync_command'] = rsync_command
    print('Some helpful commands!')
    print('###################################')
    print('# SSH to the instance with: ')
    print(ssh_command)
    print('###################################')

    print('###################################')
    print('# Rsync data to the instance with: ')
    print(rsync_command)
    print('###################################')


def print_end_message():
    print('##################################')
    print('Finished!')
    print('See {dir}/report.json for details'.format(dir=KEY_PAIR))


initialize_dir()
create_key_pair()
write_key_file()
create_instance()
while report_data['ec2']['PublicIP'] is None:
    get_public_ip()
print_helper_commands()
write_report()
print_end_message()

WrapUp

That's all you need to know to get started with spinning up remote servers in the cloud! What kinds of projects do you want to deploy to the cloud?

I created this guide because of an experience I had while teaching. My students needed to use an application that was only available on Windows OS but the students only had macOS.

We will be touching on the technologies shown below:

• Amazon EC2: launch a Windows Server 2019
• Microsoft Remote Desktop: macOS application to remote desktop connect (RDP) to EC2

Amazon EC2

Launching a Windows Server EC2 Instance

1. Sign in to your AWS Management Console.
2. Choose Services, then EC2.
3. In the sidebar, click Instances.

EC2 sidebar

4. Click Launch Instance.

Launch Instance button

5. Scroll down and choose Microsoft Windows Server 2019 Base.

Choose AMI page

6. At the bottom of the Choose Instance Type page, click Review and Launch. This will skip you to the Review page.

Launch with minimal configuration

7. In the Review page, click Launch. You'll be prompted to select an existing key pair or new key pair.

If you choose Create a new key pair, you need to give the new key pair a name, then download the key pair. Then you'll be able to proceed to choose Launch Instance.

Key pair to access the instance

If you choose Choose an existing key pair, you need to select a key pair and tick the checkbox to acknowledge the use of the key pair.

Last step to launch instance

8. Click the generated Instance ID.

Accessing the EC2 Instance

9. Find and save the following information:

10. Public DNS (IP Address)

11. Username
12. Password

To get the IP Address, scroll to the right of your EC2 instance:

IP Address of EC2 Instance

You can also find this in the Description tab below:

IP Address of EC2 Instance

10. To get the username and password, choose the EC2 instance (tick the checkbox), click Actions, then Get Windows Password.

Obtaining the username and password

You may encounter Password not available and you'll need to wait a couple of minutes.

Provisioning the auto-generated password

11. Locate the existing key pair or the newly created key pair you have downloaded in your local machine. Click Choose File.

Retrieve the key pair

12. After uploading the key pair, click Decrypt Password.

13. Copy the following information and save it in a file or clipboard. Click Close when you are done.

Information for remote desktop connection

Microsoft Remote Desktop

Installing the application and connecting to EC2 instance

1. Open your App Store, then search for Microsoft Remote Desktop. Click Install (it shows UPDATE here as I already have installed).

Microsoft Remote Desktop in the App Store

2. After installation, Open Microsoft Remote Desktop.

3. At the top, click the + Icon and choose Desktop.

Creating a new desktop connection

4. In the PC name, copy the EC2 Instance IP address, then click Add.

Adding the IP address

5. Copy the Administrator and Password from earlier and paste it here. Hit Continue.

Signing in with the username and password

You are now connected to your Windows Server EC2 Instance.

Windows Server EC2 Instance

Note: To avoid getting charged after you have used up the free tier for EC2, either click Stop to have a lower cost, or Terminate to remove the instance and not be charged.

You have access to this by selecting the instance and choosing Actions > Instance State > Stop/Terminate.

Here's a video tutorial:

Connect with me on LinkedIn here.