
## Table of Contents

1. [Introduction](#introduction)
2. [Configure AWS](#configure-aws)
3. [Visual Studio Code Extension for HashiCorp Terraform](#visual-studio-code-extension-for-hashicorp-terraform)
4. [Terraform Commands](#terraform-commands)
5. [Other](#other)
6. [Conclusion](#conclusion)

## Introduction

Prerequisites:

- Terraform CLI
- AWS CLI
- AWS Account
- VS Code Extension: HashiCorp Terraform

## Configure AWS

This will be the first step for this tutorial. You'll need to have an AWS account, create a user, and have the access key and secret configured so we can run Terraform with the correctly configured AWS credentials later.

### Install AWS CLI

This blog skips how to install AWS CLI on your local machine, but you can reference [how to get started with AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

### Verify AWS CLI

Check that AWS CLI is working by typing the below command.

```
aws --version
```

### Retrieve AWS Access Keys

If you don't have an AWS user created, you can log in to AWS and create a new user. Once you create a new user, go to the Security Credentials section and retrieve the access key and secret key.

- Create an AWS user
- Create Security Credentials by retrieving the AWS access keys
- Add a role to the AWS user (to make it simple for this blog, we're adding the **_AmazonEC2FullAccess_** permission for testing)

Once you have the access and secret keys, use `aws configure` to set them.

Now, for the below steps, once you run Terraform, it will create resources under this AWS account.

## Visual Studio Code Extension for HashiCorp Terraform

This blog uses VS Code to modify Terraform files and the VS Code extension `HashiCorp Terraform` for Terraform editing. It is a great tool that provides IntelliSense for editing Terraform.

- VS Code Extension: HashiCorp Terraform

## Terraform Commands

List all the available commands for executing Terraform.

```
terraform -help
```

Prepare the local directory for other commands.

```
terraform init
```

```
terraform validate
```

```
terraform fmt
```

```
terraform apply
```

```
terraform destroy
```

```
terraform show
```

```
terraform state list
```

## Other

Get the public key by key pair name:

```
aws ec2 describe-key-pairs --key-names test --include-public-key
```

## Conclusion

With Terraform and the AWS CLI configured, you can easily create and manage AWS EC2 instances as infrastructure as code. Use `terraform init`, `terraform apply`, and `terraform destroy` to manage the lifecycle of your resources.


This blog demonstrates how to set up AWS EC2 with Terraform locally.

How to Create AWS EC2 by Terraform


## Table of Contents

1. [Introduction](#introduction)
2. [Create AWS EC2 Instance](#create-aws-ec2-instance)
3. [Setup Next.js at EC2](#setup-nextjs-at-ec2)
4. [Verify Next.js at EC2](#verify-nextjs-at-ec2)
5. [Conclusion](#conclusion)

## Introduction

Next.js is a React-based web application framework built on top of Node.js.
AWS EC2 is Amazon's cloud computing service which hosts
VMs in the cloud. In this tutorial, we will manually create an EC2 instance,
then SSH into the instance and install and set up Next.js.

## Create AWS EC2 Instance

![](https://d1p0mp3f1fx0hz.cloudfront.net/upload/2022/3/3PwJEv1hz4cieCLQjUJYbC-h6khs85ldj20220121003150/750-h6khs85ldj20220121003150.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/upload/2022/3/rJUarQRMQEdtxMjxAr6Zmp-1n4bu44bmal20220121003431/750-1n4bu44bmal20220121003431.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/upload/2022/3/qwgZnGrTA12GLFY7DN5C9X-2g35uyafizh20220121003511/750-2g35uyafizh20220121003511.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/upload/2022/3/6JakhL8hCrY7qS7MkUkiZk-26y67gh0er20220305184121/750-26y67gh0er20220305184121.png)

## Setup Next.js at EC2

After setting up the EC2 instance, choose the instance we just created and connect
to it by using EC2 Instance Connect.

### Install Node.js at EC2

SSH into the EC2, then run the following to install Node.js.

```
sudo yum update -y
curl -fsSL https://rpm.nodesource.com/setup_14.x | sudo bash -
sudo yum install -y nodejs
```

### Create Next App

We'll use the Next.js command `create-next-app` to set up the
default app. After finishing the steps mentioned in the command line, run
`npm run dev`. This will start the server on
`localhost:3000`.

```
npx create-next-app
```

## Verify Next.js at EC2

Since we set up the security group and opened port 3000, you can type the
EC2's public IP address with port 3000 to load the page.

`http://EC2-Public-IPAddress:3000`

## Conclusion

This blog provides simple steps for how to set up Next.js on an AWS EC2 instance.
Hopefully this can help you get familiar with EC2 and Next.js.


Next.js is a React-based web application framework built on top of Node.js. AWS EC2 is Amazon's cloud computing service which hosts VMs in the cloud. In this tutorial, we will manually create an EC2 instance, SSH into it, and install and set up Next.js.

Setting Up Next.js on AWS EC2 Instance


## Table of Contents

1. [Introduction](#introduction)
2. [Install the CloudWatch Agent on Amazon Linux EC2](#install-the-cloudwatch-agent-on-amazon-linux-ec2)
3. [Run the CloudWatch Agent Wizard](#run-the-cloudwatch-agent-wizard)
4. [CloudWatch Agent Config File Path](#cloudwatch-agent-config-file-path)
5. [Install collectd for the CloudWatch Agent](#install-collectd-for-the-cloudwatch-agent)
6. [CloudWatch Agent File](#cloudwatch-agent-file)
7. [Run the CloudWatch Agent on EC2 Linux](#run-the-cloudwatch-agent-on-ec2-linux)
8. [Conclusion](#conclusion)

## Introduction

This blog provides a quick guide on how to set up CloudWatch Agent manually on
an EC2 Linux instance. CloudWatch Agent enables you to collect system or custom
metrics from Amazon EC2 instances across operating systems. You can install
CloudWatch Agent on AWS Cloud or on-premises servers, Linux, or Windows as
well.

## Install the CloudWatch Agent on Amazon Linux EC2

```
sudo yum install amazon-cloudwatch-agent
```

You can import the CloudWatch agent configuration if you already have one.
That will be useful if you want to reuse the same CloudWatch agent config over
and over again. The following step uses the default wizard to create a new
config file.

## Run the CloudWatch Agent Wizard

Once you run the following command on a Linux EC2 instance, you'll get started
with the CloudWatch Agent wizard.

```
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-config-wizard
```

## CloudWatch Agent Config File Path

After you finish the CloudWatch agent setup wizard, it will create a JSON
config file at the following location.

```
/opt/aws/amazon-cloudwatch-agent/bin/config.json
```

## Install collectd for the CloudWatch Agent

If you wish to use collectd to collect metrics, you should install it via the
following commands.

```
sudo yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
sudo yum install -y collectd
```

## CloudWatch Agent File

This CloudWatch agent config file is used to specify proxy and region
information.

```
cd /opt/aws/amazon-cloudwatch-agent/etc
nano amazon-cloudwatch-agent.toml
```

## Run the CloudWatch Agent on EC2 Linux

The following is the command to start the CloudWatch agent with the config file
you either created from the wizard or from your previous config file.

```
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-conf
ig -m ec2 -s -c file:/opt/aws/amazon-cloudwatch-agent/bin/config.json
```

## Conclusion

At this point, if everything works out, you should start seeing memory or disk
usage metrics. Go to **CloudWatch** > **Metrics**, click **All metrics**, then
click **CWAgent**. Under CWAgent, you should see a list of metrics you set up
from the CloudWatch Agent, with data being sent from your EC2 instance.


This blog provides a quick guide on how to set up CloudWatch Agent manually on an EC2 Linux instance. CloudWatch Agent enables you to collect system or custom metrics from Amazon EC2 instances across operating systems. You can install CloudWatch Agent on AWS Cloud or on-premises servers, Linux, or Windows as well.

How to Collect Memory Disk Usage By Using CloudWatch Agent


## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Create a New Custom Policy](#create-a-new-custom-policy)
4. [Install the CloudWatch Logs Agent](#install-the-cloudwatch-logs-agent)
5. [Conclusion](#conclusion)

## Introduction

This blog shows how to send application logs from an Amazon Linux 2 EC2
instance to AWS CloudWatch Logs, including how to set up and configure the
agent.

Let's assume you have a running web server on an EC2 instance, and the
application has written logs to the web server. Now you want to move these
logs to CloudWatch for further analysis. The following are the steps to
accomplish this.

## Prerequisites

- Set up an AWS account

- EC2 instance is running and has application logs at
  **/var/app/my-app/error.log**

- EC2 instance has an attached role, **my-ec2-role**

## Create a New Custom Policy

Here, we'll create the following new custom policy for IAM and assign it to
the role **my-ec2-role** for EC2. Once we attach this policy to
the role the EC2 instance is using, the instance will have permission to create
logs in CloudWatch Logs.

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents",
                "logs:DescribeLogStreams"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}
```

## Install the CloudWatch Logs Agent

Update the Amazon Linux 2 instance with the latest repositories.

```
sudo yum update -y
```

Install the AWS Logs agent on the EC2 instance.

```
sudo yum install -y awslogs
```

You'll need to modify the following file to change the AWS region if you're
not using the default region.

```
/etc/awslogs/awscli.conf
```

Open the awslogs.conf file to modify the configuration for CloudWatch Logs.

```
cd /etc/awslogs/
nano awslogs.conf
```

After opening the awslogs.conf file, you need to modify it to specify the path
of the logs, so the CloudWatch Logs agent will look at that file and collect
the logs into CloudWatch. Next, update the log_group_name so that when you go
to the CloudWatch Logs dashboard, the name you enter will appear there.

```
datetime_format = %b %d %H:%M:%S
file = /var/www/my-app/error.log
buffer_duration = 5000
log_stream_name = {instance_id}
initial_position = start_of_file
log_group_name = my-web-logs
```

After modifying the file, you can start the awslog service with the following
command.

```
sudo systemctl start awslogsd
```

If you want to enable the awslog service to start after Amazon Linux 2
reboots, you can run the following command.

```
sudo systemctl enable awslogsd.service
```

Now, that's it. Your application logs should be pushed into CloudWatch Logs.
You can go to AWS CloudWatch Logs and check the log group you configured on
the EC2 instance.

## Conclusion

Logs are important for applications, especially when something goes wrong. You
can use the logs to identify the root cause and figure out what's going on.

What's next: there is a newer way to use the CloudWatch Agent for both
CloudWatch Logs and metrics, so we will create a blog about that next time.
Also, this blog covers how to set up logging on a running instance. We will
also look into how to install the CloudWatch Logs agent when initially setting
up the EC2 instance.


This blog shows how to send application logs from an Amazon Linux 2 EC2 instance to AWS CloudWatch Logs, including how to set up and configure the CloudWatch Logs agent.

How to Send Application Logs from EC2 to CloudWatch Logs


## Table of Contents

1. [Introduction](#introduction)
2. [Requirements](#requirements)
3. [Setup Simple Express.js Web Server by Using Linux EC2](#setup-simple-expressjs-web-server-by-using-linux-ec2)
4. [SSH into the EC2](#ssh-into-the-ec2)
5. [Test the Express.js Web App](#test-the-expressjs-web-app)
6. [Use PM2 to Run Express.js App](#use-pm2-to-run-expressjs-app)
7. [Test PM2 App](#test-pm2-app)
8. [Test by Using the EC2 Public IP](#test-by-using-the-ec2-public-ip)
9. [Create SSL/TLS Certificate via AWS ACM](#create-ssltls-certificate-via-aws-acm)
10. [Hosted Zones - Create New Hosted Zone](#hosted-zones---create-new-hosted-zone-with-domain-name-examplecom)
11. [Update Registered Domain's Name Servers](#update-registered-domains-name-servers)
12. [Request AWS Certificate](#request-aws-certificate)
13. [Setup AWS Application Load Balancer](#setup-aws-application-load-balancer)
14. [Create Target Group for Application Load Balancer](#create-target-group-for-application-load-balancer)
15. [Configure Route 53 with AWS Application Load Balancer](#configure-route-53-with-aws-application-load-balancer)
16. [Conclusion](#conclusion)

## Introduction

This blog is a guide that shows how to set up an HTTPS Node.js web server on EC2 from beginning to end. It'll include how to set up a simple Express.js web app on EC2, how to create an SSL/TLS certificate by using AWS Certificate Manager, how to set up an AWS application load balancer and create redirect rules from non-www to www, HTTP to HTTPS, and how to use Route 53 to configure a route from your custom domain to the AWS application load balancer. This blog will assume the domain name is `example.com`. At the end of the blog, we'd like all the `http://example.com`, `http://www.example.com`, `https://example.com` traffic to redirect to `https://www.example.com`.

## Requirements

- **AWS Account**
  - First of all, you'll need an AWS account. If you don't have one already, you can create one and get an AWS free tier for a year.
- **Custom Domain**
  - Another requirement is a **domain name** if you wish to walk through this blog's steps.
  - Purchase from AWS
    - If you don't have a domain name but you wish to get one, you could get one from AWS Route 53 to register a domain. AWS has the ability to purchase a domain name similar to GoDaddy and any other domain hosting company. Below is the page at AWS where you can search and purchase a domain name.
    - ![AWS Route 53 Register Domain](/images/how-to-setup-a-https-nodejs/img1.png)
    - Once the new domain purchase is done, later in this blog we'll connect this domain's name server to the Route 53 `NS` record. You'll need to create a Route 53 hosted zone with the domain you just purchased.

Below is an example of a domain name's name servers:

```
ns-111.awsdns-11.co.uk.
ns-234.awsdns-22.net.
ns-12312asd.awsdns-33.org.
ns-123a.awsdns-44.com.
```

If you already have a domain name at another domain hosting company and want
to use that at AWS Route 53, most likely what you have to do is use the domain name at `route53` to create a new public hosted zone. Once you create the hosted zone, you will get `NS` and `SOA` records, then you'll use the `NS` record and enter that at your domain host's site (e.g. GoDaddy). In this way, the name server at your hosting site will redirect the traffic to the AWS `route53` account.

For example, if you have a custom domain, example.com at GoDaddy, then go to the GoDaddy DNS management and choose to enter your own nameservers for example.com, then add the above 4 NS records to GoDaddy. After entering all of the name servers from AWS Route 53 to GoDaddy, GoDaddy should be able to route the domain to your AWS Route 53. However, how to point a GoDaddy domain name to AWS Route 53 is not included in this blog.

## Setup Simple Express.js Web Server by Using Linux EC2

The first step of the Route 53 configuration is done. Here, we'll try to set up the Express.js web app on the EC2 manually.
Go to **EC2**, click **Launch Instances** and choose **Amazon Linux 2 AMI**, choose **t2.micro** as Instance type. At the **Configure Instance Details**' User data section, paste the following:

- Enter the EC2 name
- Create a key pair if you don't have one
- Leave the rest as default
- ![Create EC2 Instance](/images/how-to-setup-a-https-nodejs/img4.png)

Put the below code in the **User Data** section. We specify the `node.js` version to be 14 because at the time of creating this blog, that's the version which had been verified to be working.

```
sudo yum update -y
#!/bin/bash -ex
# output user data logs into a separate place for debugging
exec > >(tee /var/log/user-data.log|logger -t user-data -s 2>/dev/console) 2>&1 | sudo bash -
# get node into yum - with version 14.16.1
curl -fsSL https://rpm.nodesource.com/setup_14.x | sudo bash -
# install node (and npm) with yum
sudo yum install -y nodejs
# install pm2 to restart node app
npm i -g pm2@2.4.3
```

Click Launch Instance to create a new instance. It should be done pretty quickly.

### Set Inbound Rule for Port `80`

After setting up the EC2 instance, make sure the inbound rule has `80`, Type is `HTTP`, and Source is `0.0.0.0/0`.

- ![Create EC2 Instance](/images/how-to-setup-a-https-nodejs/img7.png)

At the next step, we'll configure the Security Group. Make sure to open HTTP, HTTPS, and SSH, because later we'll have to SSH into this instance.

Also, once you create the instance, we'll manually SSH into the instance and install the Node.js and PM2 packages.

### SSH into the EC2

There are a few ways to SSH into the instance as shown below. The easiest one is **EC2 Instance Connect**, which uses the browser.

- ![Choice to SSH into the EC2](/images/how-to-setup-a-https-nodejs/img5.png)

After SSHing into the EC2, let's run the following script. Run **sudo su** to make everything easier. Then, we'll create an app folder and create an **app.js** file to start Express.js.

First, let's check the versions by running the following commands. You should see the Node version is `v14.21.0`, npm version is `6.14.17`, and pm2 is `2.4.3`.

```
npm -v
node -v
pm2 -v
```

If you see an error from the output that it cannot recognise the npm command, try running the below commands again.

```
sudo yum update -y
exec > >(tee /var/log/user-data.log|logger -t user-data -s 2>/dev/console) 2>&1 | sudo bash -
curl -fsSL https://rpm.nodesource.com/setup_14.x | sudo bash -
sudo yum install -y nodejs
npm i -g pm2@2.4.3
```

Now, once the `npm` or `node` command is confirmed running, let's run the below script to install `express`.

```
sudo su
# create app folder
mkdir -p /var/www/app && cd /var/www/app
npm init -y
npm install express --save
nano app.js
```

`nano app.js` will create a file called `app.js`, so next add the below code to the command window.

### Add Code to app.js

The following code is a sample to start Express.js. When you type the URL, it will return the **Hello World!** message.

```Javascript
var express = require('express');
var app = express();
app.get('/', function (req, res) {
  res.send('Hello World!');
});
app.listen(80, function () {
  console.log('Example app listening on port 80!');
});
```

### Test the Express.js Web App

Run the following command to test if the Express.js app is able to run on the local Linux instance. If you see this log from the command window 'Example app listening on port 80!', our test is done.

```
node app.js
```

### Use PM2 to Run Express.js App

Using the above command can't keep Express.js running forever. When you exit the SSH window, the Node.js process closes. So we'll use `PM2` here. PM2 is a production process manager for Node.js and can keep your application alive forever.

To run `pm2`, simply run the below command on Linux:

```
pm2 start app.js
```

![PM2 status](/images/how-to-setup-a-https-nodejs/img6.png)

### Test PM2 App

Now, if the above pm2 command succeeds, the Express.js app should be running on the Amazon
Linux EC2 with port 80 even if you stop the SSH session. Let's run the
following command to test it out inside the Linux instance. If it returns the same
message, that's good.

```
curl http://localhost:80
```

### Test by Using the EC2 Public IP

Another test you should do is to copy the EC2 public instance IP to the browser to make sure you see the same **Hello World!** message. If it does, the EC2 part is finished. Now we can create an HTTPS certificate, a load balancer, and configure Route 53.

### Create Public Hosted Zone

Here we start creating a public hosted zone and assume you have either registered a domain name from AWS or routed from another domain registrar.

Create a public hosted zone:

![Create hosted zone](/images/how-to-setup-a-https-nodejs/img2.png)

Verify that 2 records are created: one is **NS** and another is **SOA**.

![Create hosted zone](/images/how-to-setup-a-https-nodejs/img3.png)

## Create SSL/TLS Certificate via AWS ACM

Now, before creating the ACM, we assume we'll use the custom domain **example.com**. We would also expect to see the following URLs and they should all go to the same Linux EC2 instance we created earlier.

- http://example.com
- http://www.example.com
- https://example.com
- https://www.example.com

As you can see, we'll have to create an SSL certificate and should be able to use it by https://example.com and https://www.example.com.

Here, we assume the domain is registered at AWS so we can continue with the below steps.

## Hosted zones - create new hosted zone with domain name `example.com`

Once you create a `example.com`, you should see 2 records, `NS` and `SOA` type, the `NS` should has 4 values, probably something looks like below.

```
......com.
......org.
......co.uk.
......net.
```

Now, this 2 value are important, since we use registered our domain at AWS, we need to update above 4 value to the registered domain.

## Update Registered domain's name servers

Go to the registered domains, click the **Add or edit name servers**, and update the name server values from the NS records' values.
![Update Name servers](/images/how-to-setup-a-https-nodejs/img11.png)

**name servers -> NS records**
Once the above steps are confirmed, we can go to ACM to create the certificate. Otherwise, you might see errors during the process.

## Request AWS Certificate

Go to the AWS ACM, click Request a certificate and choose Request a public certificate. At the window for Add domain names, add **\*.example.com**, then also add the following 2 as another name to this certificate: **example.com** and **www.example.com**. In this way, you can create one certificate that will be valid for both example.com and www.example.com.

**Request a public certificate**

![Request a Public certificate](/images/how-to-setup-a-https-nodejs/img8.png)

**List of domain name and validation method**

![Request a Public certificate](/images/how-to-setup-a-https-nodejs/img9.png)

**Click the Create records in Route 53**

![Create records in Route 53](/images/how-to-setup-a-https-nodejs/img10.png)

At the validation method, choose DNS validation and click Create a record in Route 53, so it will create an HTTPS record in Route 53.

**Success in ACM creation**
We want to create these 3 domain names. Once the domains are created and new records are added to Route 53, you will see the following:
![Success in ACM ](/images/how-to-setup-a-https-nodejs/img12.png)

## Setup AWS Application Load Balancer

Once the EC2 and SSL/TLS certificates are ready, we can set up an AWS
Application load balancer. The reason we use an application load balancer
is for the SSL certificate. If we want to use an AWS ACM certificate, you can't
directly use it for the EC2 instance at this moment. You'll have to use either
an AWS Load Balancer or AWS CloudFront. Also, we'll use the application load
balancer to write redirect rules from HTTP to HTTPS and non-www to www.

### Configure AWS Application Load Balancer

Go to EC2 and click the Load Balancers section, then click to create an Application
Load Balancer. Enter the following in the configure load balancer window:

- Enter a name for this application load balancer
- Choose internet-facing
- Use IPv4
- Make sure it has HTTP with port 80
- Make sure it has HTTPS with port 443
- Choose your VPC and select the availability zone

At the window for selecting the default certificate, we'll choose the certificate we created in ACM. Choose "Choose a certificate from ACM" and select the certificate we created, which should be **\*.example.com**. Leave everything else as default and choose the security group. Make sure the security group has ports open for HTTP and HTTPS because we'll have our load balancer open to the public.

In summary, below is what we just set up for the application load balancer. Note that if you didn't configure ACM correctly, you won't see any choice in the SSL/TLS certificate section.
![Application Load Balancer Summary](/images/how-to-setup-a-https-nodejs/img13.png)

### Create Target Group for Application Load Balancer

As part of the process of creating an AWS Application Load Balancer, it will require creating a target group. You'll need to add the EC2 instance and set up health check configuration, so when we launch the application load balancer it will use the EC2 instance we created before. Here, add the EC2 instance we created earlier in this blog, and leave the health check as default.

### Test Load Balancer Access

To test the load balancer setup, copy the ALB's DNS name we just created and put it in the browser. If you're able to see **Hello World!**, that means we have successfully set up the load balancer and it is using the EC2 instance underneath.

### How to Add Rules for AWS Application Load Balancer

Here, we'll add a redirect rule for the AWS application load balancer to
handle HTTP to HTTPS and non-www to www. At the end, all traffic should go
to https://www.example.com.

First, choose the load balancer, click Listeners, and click **View/edit rules** at HTTP:80. At the rule page, choose to add a new rule, and add the following for the If area:

- Choose **Host header**
- Add **example.com** and **www.example.com**

At the Then area, add the following:

- Choose **Redirect**
- Choose **HTTPS**, and set the port as **443**
- Choose **Custom host, path, query**
- Modify the **Host** to **www.example.com**
- Choose **301**, as permanently moved

Click confirm and update to save your change. The above change is for the HTTP port redirect for example.com, so
http://example.com and http://www.example.com will redirect to https://www.example.com. Now, let's go to the 443 HTTPS port to modify the rule.

At the HTTPS rule's If area, add the following:

- Choose Host
- Add example.com

At the Then area, add the following:

- Choose **Redirect**
- Choose **HTTPS**, and set the port as **443**
- Choose **Custom host, path, query**
- Modify the **Host** to **www.example.com**
- Choose **301**, as permanently moved

Click confirm and update to save your change. The above change is for the HTTPS port redirect for example.com, so
https://example.com will redirect to https://www.example.com. That's all the redirect rules we'll need for the AWS application load balancer.

Now, the last part is we'll configure Route 53 to route traffic to the application load balancer.

## Configure Route 53 with AWS Application Load Balancer

At this point, the EC2 and the application load balancer should all be running, but if you type www.example.com in your browser you will still get a "This site can't be reached" DNS error. We'll fix it here by configuring Route 53 to route to the AWS application load balancer we just created.

Let's go to AWS Route 53 and click the Hosted zones for your custom domain. In this blog we've been using example.com, so you should see 3 records in the hosted zone: NS and SOA from when you first created the hosted zone, and CNAME created by the ACM certificate.

Now, create one record as follows. This will route traffic for www.example.com to the application load balancer. After creating this record, if you type http://www.example.com or https://www.example.com, you should see the same page as when directly opening the EC2 or application load balancer.

- Record name: www.example.com
- Type: A
- Route traffic to: choose Alias
  - Choose Application and Classic Load Balancer, then select the application load balancer we just configured
- Routing policy: choose Simple routing

Now, we need to create the last record. This will route traffic for example.com to the application load
balancer. After creating this record, if you type http://example.com or https://example.com, you should see it
redirect to https://www.example.com.

- Record name: leave as example.com
- Type: A
- Route traffic to: choose Alias
  - Choose Alias to another record in this hosted zone
  - Type: www.example.com
- Routing policy: choose Simple routing

That's all for setting up Route 53. Now, if you type http://example.com, http://www.example.com, or https://example.com, they will all go to https://www.example.com.

## Conclusion

It requires some steps to set up HTTPS Node.js on AWS EC2 with AWS Application Load Balancer and Route 53. Next, we'll see how we can automate these steps.


A complete guide to set up an HTTPS Node.js web server on EC2, including Express.js setup, AWS Certificate Manager SSL/TLS, application load balancer with HTTP to HTTPS redirect, and Route 53 domain configuration.

How to Setup a HTTPS Node JS Server on Amazon EC2


## Table of Contents

1. [Introduction](#introduction)
2. [Update the EBS Volume Size](#update-the-ebs-volume-size)
3. [Verify and Apply the Size Change](#verify-and-apply-the-size-change)
4. [Conclusion](#conclusion)

## Introduction

This quick note shows how to increase AWS EC2 Linux's EBS volume size.

## Update the EBS Volume Size

First, log in to AWS and select the target EBS. Update the size. The volume
size will update right away, but you'll need to do the following steps.

## Verify and Apply the Size Change

Next, SSH into the EC2 Linux instance to check the current Linux disk size.

After SSHing into the EC2, type the following command to check whether the
increased volume has been applied or not.

```
lsblk
```

The following is a sample result when you type `lsblk`. Here we can
see that the disk has a size of 16G but the current EBS partition only has 8G.

```
nvme1n1 30G
nvme0n1 16G
|-----nvme0n1p1 8G
```

Now, the following command will change the partition size to use the maximum size based on
the above sample result. After you run the command, your EBS partition should be 16G
now.

```
sudo growpart /dev/nvme0n1 1
```

Another command that might be useful is to check the folder size:

```
sudo du -sh /var/www/my-folder-size
```

## Conclusion

Increasing an EBS volume size in AWS is straightforward. After updating the volume size in the AWS console, SSH into your EC2 instance and use `growpart` to expand the partition to use the new available space.


This quick note shows how to increase AWS EC2 Linux's EBS volume size.

How to Increase AWS EBS Volume Size


## Table of Contents

1. [Introduction](#introduction)
2. [Setup EC2 Instance](#setup-ec2-instance)
3. [Setup Sample Express.js App](#setup-sample-expressjs-app)
4. [Install Nginx at Amazon Linux](#install-nginx-at-amazon-linux)
5. [Restart the Nginx Service](#restart-the-nginx-service)
6. [Site is Up](#site-is-up)
7. [Handle HTTP to HTTPS Redirect](#handle-http-to-https-redirect)
8. [Conclusion](#conclusion)

## Introduction

This blog shows how to redirect from HTTP to HTTPS on an Amazon Linux EC2
Instance. The example below is a simple Express.js app running under Nginx
with PM2.

## Setup EC2 Instance

Here, we'd like to set up an EC2 Instance. First, you need to have an AWS
account. Once you have an AWS account, you can go to EC2 to set up the instance.

Click Launch Instance at the EC2 page.

Select Amazon Linux 2 AMI, since it's eligible for the free tier.

Select t2.micro.

At the Configure Instance Details page, leave everything as default —
default VPC and subnet. Make sure the VPC and subnet are set up in a way that has public
access.

Click Add Storage, and leave the default setting.

Click and go to Configure Security Group. Make sure the inbound rule has opened
ports 80, 22, and 443, because we'd like the website to be accessible by HTTP and HTTPS and
to be able to SSH in.

Create a key pair if you don't have one.

Once the EC2 Linux Instance setup is finished, SSH into the instance.

## Setup Sample Express.js App

Once you SSH into the Linux instance, to make everything easier, just run this:

```
sudo su
```

### Install Node.js

Run the following command to install Node.js on Amazon Linux.

```
curl -fsSL https://rpm.nodesource.com/setup_lts.x | sudo bash -
yum -y install nodejs
```

### Create Simple Express.js App

The following commands create the folder, run npm init, install Express,
and create the server.js file.

```
mkdir my-app && cd my-app
npm init -y
npm install express
nano server.js
```

Now, add the following code to server.js. Once you run
**node server.js**, you start an Express web server running on
port 3000.

```
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
res.send('yo');
});

app.listen(port, () => {
console.info('app start');
});
```

### PM2 to Keep Node.js Running

Now, you can use PM2 to keep the Node.js app running with the following
commands.

Once you install PM2 and start the app, you can try `curl http://localhost:3000`. You should be able to
see the response from the home route.

```
npm i -g pm2@2.4.3
pm2 start server.js
```

## Install Nginx at Amazon Linux

The following command will install Nginx on the Amazon Linux instance. Once the setup
is finished, we'll update the config to handle the HTTP to HTTPS redirect.

```
sudo amazon-linux-extras install nginx1
```

The Nginx config should exist at /etc/nginx/nginx.conf.

```
cd /etc/nginx
```

Open the nginx.conf file:

```
nano nginx.conf
```

First, we'll set up Nginx to reverse proxy to Express.js, which is running
on port 3000. You can notice that before the change, if you hit the EC2 public IP
address, you will get the message from Chrome: "This site can't be reached..."

```
location / {
proxy_pass http://localhost:3000;
}
```

## Restart the Nginx Service

```
service nginx restart
```

## Site is Up

Now, if you hit the IP address, you should be able to see the site is up and
running, because Nginx routes port 80 to the Express.js port 3000.

## Handle HTTP to HTTPS Redirect

Add the below code to the nginx.conf for redirecting from HTTP to HTTPS.

```
if ($http_x_forwarded_proto = 'http'){
    return 301 https://$host$request_uri;
    }
```

That should be it for redirecting your app from HTTP to HTTPS by using Nginx on
Amazon Linux. If you just use the IP address of the EC2, you probably won't see
the redirect. The setup I used was a Classic Load Balancer in front of
the EC2, with the Classic Load Balancer having an HTTPS certificate set up. You can
get a free one from AWS ACM. I also had Route 53 routing the domain to
the Classic Load Balancer, so if I visit http://my-domain, it
redirects from http://my-domain to https://my-domain.

## Conclusion

Alternatively, you could write the redirect logic at the code level, or if you are
running an Application Load Balancer, you can set up a redirect rule on that as
well.


This blog shows how to redirect from HTTP to HTTPS by using Nginx at Amazon Linux EC2 Instance.

How to Redirect HTTP to HTTPS on Amazon Linux with Node.js


#### Table of Contents

1. Why do you need to use an elastic IP address?
2. Choose Elasti IPs via EC2 page
3. Allocate Elastic IP address
4. Click Allocate
5. EC2 public IP address change to elastic IP address
6. How much is Elastic IP address?

This blog will show how to use AWS elastic IP to assign to EC Instance but
before that...

## Why do you need to use an elastic IP address?

Assume you have the following EC2 had set up, you use your EC2 as a web server
and the public IP address is as follows.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/pc1xj6mnbrbklehrn47u)

Now, if you stop your instance and start again. The EC2 instance public IP
address changed! So this could an issue if you need to know this server's IP
address for processing something else. You could use EC2 instance metadata to
log the IP address somewhere, like using Lambda, or you could use elastic IP
address I will show later.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/r9ykg7ces2ie550nosdo)

Following is how you use AWS elastic IP address.

### Choose Elasti IPs via EC2 page

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/a3jpprpumhrerm5tje8o)

### Allocate Elastic IP address

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/y1bjued63rpsps4hr6uq)

### Click Allocate

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/ciaqtimf9cdesiweueza)

###
After allocating an IP address, you will get a new IP address as follows.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/kkayi0nx1c5tsorknnk1)

Associate Elastic IP address

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/kkayi0nx1c5tsorknnk1)

Now, here we need to associate the elastic IP address to the EC2 instance.

### EC2 public IP address change to elastic IP address

Now, the elastic IP address had associated with your specific EC2 instance,
whenever you stop EC2 instance the public instance will keep the same IP
address.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/r9ykg7ces2ie550nosdo)

### How much is Elastic IP address?

It is free based on the AWS document at this point, as long as the elastic IP
address is assigned to any instance is free, so if your elastic IP address is
not assigned to anything it will be a charge.

Reference to AWS document for more detail about Elastic IP charge.


This blog will show how to use AWS elastic IP to assign to EC Instance.

Use AWS Elastic IP Address


## Table of Contents

1. [Introduction](#introduction)
2. [Create a Snapshot from EC2 EBS Volume](#create-a-snapshot-from-ec2-ebs-volume)
3. [Create Snapshot](#create-snapshot)
4. [Create an Image from Snapshot](#create-an-image-from-snapshot)
5. [Conclusion](#conclusion)

## Introduction

This blog shows how to back up an EC2 instance and create another instance in the same region or a different region.

## Create a Snapshot from EC2 EBS Volume

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/zvpertivi2hqamhip8sd)

## Create Snapshot

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/efqfd1igxmsipmrbmwip)

Once the snapshot is complete, you should be able to check it from the dashboard.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/eyr7mv7k9msemxqngbv3)

## Create an Image from Snapshot

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/vayevryakv8cem8lluf9)

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/c6k2wntndey8bovwmxoa)

Once you create an image, you can launch an EC2 instance from it in the current region. If you want to deploy the image to a different region, you can copy the image to that region and then create an instance there.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/vozitamqrargicff8svs)

## Conclusion

Backing up an EC2 EBS volume by creating a snapshot and then an image is a reliable way to protect your data. You can also use this process to replicate instances across different AWS regions.


This blog shows how to back up an EC2 instance and create another instance in the same region or a different region.

How to Backup EC2 EBS Volume


## Table of Contents

1. [Introduction](#introduction)
2. [SSH into EC2 Instance](#ssh-into-ec2-instance)
3. [Retrieve Metadata](#retrieve-metadata)
4. [Conclusion](#conclusion)

## Introduction

This blog covers a few useful commands to retrieve metadata from an EC2 instance. EC2 instance metadata provides information about the running instance, such as hostname, IP address, and user data.

## SSH into EC2 Instance

To retrieve EC2 instance metadata, first SSH into the EC2 instance and then run the
following commands.

**Run with root privileges**

```
sudo su
```

## Retrieve Metadata

**List all the metadata**

```
curl http://169.254.169.254/latest/meta-data
```

**Get EC2's hostname**

```
curl http://169.254.169.254/latest/meta-data/local-hostname
```

**Get EC2's user data**

```
curl http://169.254.169.254/latest/user-data
```

## Conclusion

The EC2 instance metadata endpoint (`169.254.169.254`) provides a convenient way to retrieve information about your running instance without needing external tools. This is useful for automation scripts, configuration management, and debugging.


A few commands to retrieve EC2 instance metadata, including hostname and user data.

How to Retrieve EC2 Instance Meta Information


## Table of Contents

1. [Introduction](#introduction)
2. [How to Block Traffic from a Specific IP Address](#how-to-block-traffic-from-a-specific-ip-address)
3. [Find the Network ACL from EC2](#find-the-network-acl-from-ec2)
4. [Find the IP Address](#find-the-ip-address)
5. [Create a New Rule to Block Traffic](#create-a-new-rule-to-block-traffic)
6. [Conclusion](#conclusion)

## Introduction

This blog shows a few ways to use AWS Network ACLs to block traffic to your
site.

## How to Block Traffic from a Specific IP Address

AWS has a few ways to block specific targets from accessing your site — for example,
Network ACL or WAF. Let's assume the following scenario: you have a website
running on an EC2 instance as a web server, and there's one IP address you
noticed that you want to block. You can use the Network ACL as
follows.

### Find the Network ACL from EC2

First, you need to find the Network ACL from your EC2 instance. You can click
**Subnet** from EC2, then click **Network ACL**.

### Find the IP Address

Next, you need to have an IP address. If you want to test with your own machine's
IPv4 address, you can either Google
**what's my IP address** or go to
https://whatismyipaddress.com/
to check your public IP address.

### Create a New Rule to Block Traffic

Create a new inbound rule as follows:

- Rule#: a number smaller than the allow traffic rule.

- Type: ALL Traffic

- Protocol: ALL

- Port Range: ALL

- Source: {Your IP address}/32

- Allow/Deny: Deny

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/ydnzxu0ey3zlnfzabuld)

## Conclusion

Now you should be able to block a specific IP address from accessing your EC2 instance using AWS Network ACLs. This is a quick and effective way to deny unwanted traffic at the network level.


This blog shows a few ways to use AWS Network ACLs to block traffic to your site.

Blocking Traffic from Specific IP Address with AWS Network ACL


## Table of Contents

1. [Introduction](#introduction)
2. [Create a VPC](#create-a-vpc)
3. [Create 2 Subnets](#create-2-subnets)
4. [Create an Internet Gateway](#create-an-internet-gateway)
5. [Create NAT Gateway](#create-nat-gateway)
6. [Create and Update Route Tables](#create-and-update-route-tables)
7. [Create Public and Private EC2 Instances](#create-public-and-private-ec2-instances)
8. [SSH to Public EC2](#ssh-to-public-ec2)
9. [SSH to Private EC2](#ssh-to-private-ec2)
10. [Conclusion](#conclusion)

## Introduction

This blog shows how to create a VPC from scratch:

1. Create VPC
2. Create 2 Subnets — one for the public subnet and another for the private subnet
3. Create Internet Gateway
4. Create a Route Table
5. Create 2 EC2 Instances — one public instance and one private instance
6. Set up NAT Gateway for the private EC2 instance

## Create a VPC

Go to VPC and click create VPC, then enter the information to create the VPC.

- Enter any name for the name field

- IPv4 CIDR, enter IPv4 range as `10.0.0.0/16`

- Choose `Amazon provided IPv6 CIDR block`

- Tenancy, choose Default if you wish to use the default tenancy

After creating the VPC, AWS will generate the following default services:

- Default route table

- Network ACL

- Default Security Group

## Create 2 Subnets

Create a public subnet. Click the Subnets link, and click Create subnet.

- Name, enter any meaningful name.

- **VPC**, choose the VPC just created

- **Availability Zone**, choose the AZ for this subnet

- **IPv4 CIDR block**, enter **10.0.1.0/24** as IPv4
  CIDR block

- **Modify auto-assign IP settings**, enable auto-assign IP
  address for the public subnet

Create a private subnet by clicking the **Create subnet** button.

- Name, enter any meaningful name.

- **VPC**, choose the VPC just created

- **Availability Zone**, choose the AZ for this subnet

- **IPv4 CIDR block**, enter **10.0.2.0/24** as IPv4
  CIDR block

- **Modify auto-assign IP settings**, the private subnet doesn't need
  to enable a public IP address

## Create an Internet Gateway

Create an Internet gateway so the public subnet is able to access the Internet.
Click **Internet Gateways** and click the Create Internet
gateway button.

- Name, enter any value for this Internet gateway.

- Attach this Internet gateway to the **VPC** just created

## Create NAT Gateway

Create a NAT Gateway so the private EC2 will be able to connect to the Internet and
download software if needed. Click the
**Create NAT Gateway** button.

- Click **Create NAT Gateway** button

- **Subnet**, choose the public subnet

- Click allocate the IP address

- Click **Edit route table**

- Click **Add route**

- **Destination**, enter **0.0.0.0/0**

- **Target**, choose the NAT Gateway just created

## Create and Update Route Tables

Use the default route table as the main route table, and associate it with the
private subnet.

- Choose the main route table and click
  **Subnet Associations**

- Choose the private subnet

**Create a route table** to use as a public route.

- Name, enter any name for this new route table

- Choose the VPC created earlier

- Click subnet associations and choose the public subnet

- **Click Edit routes** and click **Add route**

- Destination, enter `0.0.0.0/0` for IPv4 address

- Target, choose the **Internet gateway created earlier**

That's all for setting up public and private subnets for the VPC. Now we'll need to
create EC2 instances and attach them to this VPC.

## Create Public and Private EC2 Instances

Let's create the public EC2 instance first. Go to EC2 and click instance to
create a new EC2 instance.

- Enter configure instance details

- **Network**, choose the custom VPC just created

- **Subnet**, choose the public subnet created earlier

- Leave the rest as default settings and create a new instance

Let's create the private EC2 instance. Go to EC2 and click instance to create a
new EC2 instance.

- Enter configure instance details

- **Network**, choose the custom VPC just created

- **Subnet**, choose the private subnet created earlier

- Leave the rest as default settings and create a new instance

## SSH to Public EC2

Test the EC2 by SSHing into the public EC2 instance and downloading software from the
Internet. The following are examples of how to SSH into EC2 from macOS.

- cd to the location that has the **private key**, something
  that looks like **mykey.pem**.

- `chmod 400 {your_private_key.pem}`

- SSH into EC2 by
  `ssh ec2-user@{ec2 public IP address} -i {your_private_key.pem}`

- Run `sudo yum update` to download software

- If you are able to download the software, then this EC2 can connect to the
  Internet

## SSH to Private EC2

Test the EC2 by SSHing into the private EC2 instance and downloading software from
the Internet. The following is an example of how to SSH into EC2 from macOS.

- SSH into the public EC2 instance

- Download the private key

- SSH into the private EC2 by using the private IP

- `chmod 400 {your_private_key.pem}`

## Conclusion

In this blog, we walked through how to create an AWS VPC from scratch with public and private subnets. We set up an Internet gateway for public access, a NAT gateway for private subnet Internet access, configured route tables, and created EC2 instances in both subnets. With this setup, you have a secure network architecture where public-facing resources are in the public subnet and internal resources are isolated in the private subnet.


This blog shows how to create an AWS VPC from scratch with public and private subnets, internet gateway, NAT gateway, and EC2 instances.

How to Create VPC with Public and Private Subnet


## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Create EC2 Instance](#create-ec2-instance)
4. [Setup MongoDB on EC2 Amazon Linux](#setup-mongodb-on-ec2-amazon-linux)
5. [Enable MongoDB on Linux](#enable-mongodb-on-linux)
6. [Create Database, Collection, and Record](#create-database-collection-and-record)
7. [Use mongoexport to Export Data to JSON](#use-mongoexport-to-export-data-to-json)
8. [Conclusion](#conclusion)

## Introduction

This blog shows how to set up a MongoDB database environment on the cloud
using AWS EC2 with Amazon Linux.

## Prerequisites

- You'll need an AWS account. If you have never set up an AWS account before,
  go here to create one.

## Create EC2 Instance

First, we'll need to set up an EC2 instance, then we'll SSH into it and set
up the MongoDB database.

Create an EC2 instance with the AWS Linux AMI.

Choose t2.micro.

During the setup, everything can be left as default for this blog. We'll use
the default VPC, as long as the new EC2 instance can access the internet.

For the security group, we'll just open port 22 so we can SSH into the EC2
instance later to set up MongoDB.

## Setup MongoDB on EC2 Amazon Linux

After SSHing into the EC2 instance, we'll need to create the
mongodb-org-4.4.repo file at the location /etc/yum.repos.d.

```
cd /etc/yum.repos.d
```

Then, let's create the mongodb-org-4.4.repo file.

```
nano mongodb-org-4.4.repo
```

This will open the file editor. Copy the following MongoDB repo configuration
into the file and save it.

```
[mongodb-org-4.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/amazon/2/mongodb-org/4.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc
```

Now the MongoDB 4.4 repo is ready. You should be able to install the MongoDB
package.

```
sudo yum install -y mongodb-org
```

Once you see it start downloading MongoDB packages, that's a good sign. Once
the MongoDB package installation is finished, you can verify by checking
whether the following folder exists. If the folder exists, the MongoDB
installation is done and you should be good to run MongoDB.

```
cd /var/lib/mongo
```

## Enable MongoDB on Linux

Run the following command to start the MongoDB process on the EC2 instance.

```
sudo systemctl start mongod
```

Run this command to enable mongod so it starts automatically even after
rebooting the EC2 instance.

```
sudo systemctl enable mongod
```

Now, at this point, your MongoDB on the Linux server should be ready. If you
have data, you can import or restore it to the MongoDB server.

## Create Database, Collection, and Record

Type `mongo` to start the MongoDB shell. Now let's play around on the server
to check that everything works.

```
mongo
```

### Create Database

The first command will show all the databases, then we'll create a new
database called **myDB**.

```
show dbs
use myDB
```

### Create Table and Record

This command will create the **myUser** table and insert a new
record.

```
db.myUser.insert({name: "john"});
```

## Use mongoexport to Export Data to JSON

We'll use mongoexport to export the data we just added to the **myUser**
table. By default, the mongoexport tools are not installed. You'll need to
install them by running the following command.

```
sudo yum list installed mongodb-database-tools
```

Now, all other tools — mongodump, mongorestore, mongoimport, mongoexport,
bsondump, mongostat, mongotop, and mongofiles — should be available to use.

The following command will export the **myUser** table and generate
data to a myUser.json file.

```
mongoexport --collection=myUser --db=myDB --out=myUser.json
```

## Conclusion

This blog covered how to set up MongoDB on Amazon Linux and use database tools
for backup or restore. Following are all the steps summarized.

```
cd /etc/yum.repos.d

nano mongodb-org-4.4.repo

[mongodb-org-4.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/amazon/2/mongodb-org/4.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc

sudo yum install -y mongodb-org

sudo systemctl start mongod
```


This blog shows how to set up a MongoDB database environment on the cloud using AWS EC2 with Amazon Linux.

How to Setup MongoDB on Amazon Linux EC2


## Table of Contents

1. [Introduction](#introduction)
2. [Steps to Provision an EC2 Instance](#steps-to-provision-an-ec2-instance)
3. [Conclusion](#conclusion)

## Introduction

This blog shows how to create an EC2 instance on AWS step by step.

## Steps to Provision an EC2 Instance

### Launch Instance

  - Go to Compute and click EC2

  - Click Launch Instance at EC2

  - Choose Amazon Linux 2 AMI

  - Choose Free Tier, t2.micro

### Configure Instance Details

  - Launch with default VPC

  - Enable termination protection

  - Tenancy: use shared for now

  - Enable hibernation as an additional stop behavior

### Add Storage

At Add Storage, use the default root volume.

  - Check "Delete on Termination" — when deleting the EC2 instance, this root device will also be deleted

  - Make it encrypted during the creation of the EC2 instance

### Add Tags

  - Add tags so it is easy to differentiate instances

### Configure Security Group

  - Assume you just need SSH

  - So SSH, TCP, Port 22, 0.0.0.0/0

### Review and Launch

  - Click Review and Launch

  - Create a new private key pair

  - Click Launch Instance — you should be able to see the instance launching

## Conclusion

By following the steps above, you can provision an AWS EC2 instance with the Free Tier t2.micro option. Make sure to configure security groups, enable termination protection, and create a key pair for SSH access. You can further customize the instance settings based on your specific requirements.


This blog shows how to create an EC2 instance on AWS step by step.

Provision AWS EC2 Instance


## Table of Contents

- [Introduction](#introduction)
- [Prerequisites](#prerequisites)
- [Connect to EC2 from macOS](#connect-to-ec2-from-macos)
- [Conclusion](#conclusion)

## Introduction

This blog shows how to connect to an AWS Linux or Ubuntu EC2 instance from macOS.

## Prerequisites

First, make sure you have an EC2 instance and the following two things:

- The private key pair file available on your Mac (it should be something like `*.pem`)
- The AWS EC2 instance's public IP address

## Connect to EC2 from macOS

On your Mac, open the terminal window and navigate to the location that has the `*.pem` file.

Type the following command to set the correct permissions:

`chmod 400 {your.pem}`

It should look like this:

`chmod 400 my-test.pem`

The following is for connecting to Amazon Linux:

`ssh ec2-user@{EC2 Public IP address} -i {YourPem.pem}`

It should look like this:

`ssh ec2-user@123.123.123.123 -i my-test.pem`

The following is for connecting to Ubuntu:

`ssh ubuntu@{EC2 Public IP address} -i {YourPem.pem}`

`ssh ubuntu@123.123.123.123 -i my-test.pem`

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/za51itle9uwuy4ai3sae)

## Conclusion

Connecting to an EC2 instance from macOS is straightforward. Set the correct permissions on your `.pem` file using `chmod 400`, then use the `ssh` command with the appropriate username (`ec2-user` for Amazon Linux or `ubuntu` for Ubuntu) along with the instance's public IP address.


This blog shows how to connect to an AWS Linux or Ubuntu EC2 instance from macOS.

SSH to EC2 Instance from Mac OS


## Table of Contents

- [Introduction](#introduction)
- [Set Up the Connection](#set-up-the-connection)
- [Conclusion](#conclusion)

## Introduction

This blog shows how to SSH to an EC2 instance via the Chrome Extension Secure Shell.

## Set Up the Connection

- First, you need to download the Chrome extension, Secure Shell App.

- If it's the first time, click "Connection Dialog" to set up the connection.

- Enter the public IP address from EC2.

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/wu4tgddlxhbrrdqcqri4)

- After connecting via SSH, this is how it looks.

## Conclusion

The Secure Shell Chrome extension provides a quick and easy way to SSH into your EC2 instances directly from the browser, without needing a separate terminal application.


This blog shows how to SSH to an EC2 instance via the Chrome Extension Secure Shell.

SSH to EC2 Instance via Chrome Extension Secure Shell


## Table of Contents

- [Introduction](#introduction)
- [Connect Using EC2 Instance Connect](#connect-using-ec2-instance-connect)
- [References](#references)
- [Conclusion](#conclusion)

## Introduction

This blog shows how to use AWS EC2 Instance Connect to SSH to an AWS EC2 instance. Unlike using Mac or Windows where you have to download private keys or use PuTTY to SSH to the EC2 instance, this is a much easier way to connect to an EC2 instance by simply clicking a button in AWS.

## Connect Using EC2 Instance Connect

- Right-click the instance and select "Connect".

- Choose "EC2 Instance Connect (browser-based SSH connection)".

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/kq1wssqzffs9r59yr4d1)

- Click "Connect".

![](http://res.cloudinary.com/dmwrakaup/image/upload/c_fit,h_600,q_80,w_900/x2kkllsyyyn7ngvhdkkh)

## References

- Connecting to your Linux instance using EC2 Instance Connect

## Conclusion

EC2 Instance Connect provides the simplest way to SSH into your EC2 instances. It eliminates the need for managing private key files or installing third-party tools — just click "Connect" in the AWS Console and you're in.


This blog shows how to use AWS EC2 Instance Connect to SSH to an AWS EC2 instance directly from the browser.