DEV Community: Kousalya S

Architect and Build an End-to-End AWS Web Application

Kousalya S — Tue, 09 Jul 2024 07:56:13 +0000

Introduction:

Architect and build an end-to-end AWS web application with AWS Amplify for seamless front-end hosting, AWS Lambda for serverless functions, Amazon API Gateway for managing APIs, Amazon DynamoDB for scalable NoSQL databases, and IAM roles for secure access management. This integration ensures a robust, scalable, and secure application infrastructure.

AWS Services used in this tutorial

Amplify
Amazon API Gateway
AWS Lambda
AWS IAM
Amazon DynamoDB

Prerequisites

- An AWS account
- A basic understanding of AWS.
- A text or code editor. I am using VSCode.
- A basic understanding of HTML, CSS and JavaScript is recommended but not necessary.

Architecture Diagram

Step 1: Create an index.html file

Go on and create an index.html file in any folder of your choice and add the following code to it using a text editor.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <link rel="preconnect" href="https://fonts.googleapis.com" />
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
    <link
      href="https://fonts.googleapis.com/css2?family=Rajdhani:wght@400;500;600&display=swap"
      rel="stylesheet"
    />
    <title>Exponential Math ⚡️</title>
    <!-- Styling for the web page -->
    <style>
      h1 {
        color: #fff;
        text-align: center;
        text-transform: uppercase;
        font-size: 50px;
        font-weight: 600;
      }
      body {
        background-color: #34495e;
        font-family: 'Rajdhani', sans-serif;
        display: flex;
        justify-content: center;
        align-items: center;
        position: relative;
      }
      label {
        color: #ffa801;
        font-size: 25px;
        margin-top: 20px;
      }

      label:last-of-type {
        margin-left: 20px;
      }
      button {
        background-color: #05c46b;
        border: none;
        color: #fff;
        font-size: 20px;
        font-weight: bold;
        margin-left: 30px;
        margin-top: 20px;
        padding: 10px 20px;
        font-family: 'Rajdhani', sans-serif;
        cursor: pointer;
      }
      input {
        color: #222629;
        border: none;
        font-size: 20px;
        margin-left: 10px;
        margin-top: 20px;
        padding: 10px 20px;
        max-width: 150px;
        outline-color: #05c46b;
      }
      div {
        width: auto;
        position: absolute;
        top: 35vh;
      }
    </style>
    <script>
      // callAPI function that takes the base and exponent numbers as parameters
      var callAPI = (base, exponent) => {
        // instantiate a headers object
        var myHeaders = new Headers();
        // add content type header to object
        myHeaders.append("Content-Type", "application/json");
        // using built in JSON utility package turn object to string and store in a variable
        var raw = JSON.stringify({ base: base, exponent: exponent });
        // create a JSON object with parameters for API call and store in a variable
        var requestOptions = {
          method: "POST",
          headers: myHeaders,
          body: raw,
          redirect: "follow",
        };
        // make API call with parameters and use promises to get response
        fetch("YOUR_API_GATEWAY_ENDPOINT", requestOptions)
          .then((response) => response.text())
          .then((result) => alert(JSON.parse(result).body))
          .catch((error) => console.log("error", error));
      };
    </script>
  </head>
  <body>
    <div>
      <h1>Exponential Math ⚡️</h1>
      <form>
        <label>Base number:</label>
        <input type="number" id="base" />
        <label>to the power</label>
        <input type="number" id="exponent" />
        <!-- set button onClick method to call function we defined passing input values as parameters -->
        <button
          type="button"
          onclick="callAPI(document.getElementById('base').value,document.getElementById('exponent').value)"
        >
          CALCULATE
        </button>
      </form>
    </div>
  </body>
</html>

This code constitutes our web page i.e. the frontend of our application which we are going to deploy to AWS Amplify.

That’s how our final webpage looks. You can play around with the colours to change the look and feel of the webpage. Now, compress your index.html file i.e. make it a zip file. We are going to use this zip file in the next step.

Step 2: Deploying our web app on Amplify

We are using Amplify for this step.AWS Amplify is a set of tools and services for building scalable mobile and web applications, providing backend services, front-end libraries, and hosting solutions with a focus on ease of use.
Login into the AWS management console and search for Amplify in the management console. Once you have searched for and navigated to AWS Amplify.

1.Click on the Get Started button(will take you to another page where you choose the source of your code i.e. where Amplify is going to get the code you want to deploy from.)
2.Select the “Deploy without Git provider”.(Since the application code we want to host is not on any Git provider and Clicking on the Continue button takes you to the page)
3.Type out the name you’ll like to give your app. I named my app ExponentialMath.
4.In the Environment name input box, write dev Now drag and drop your index.zip file into the area.
5.Next click on the save and deploy button.

If the deployment was successful, the resulting page will be similar to the one in the image shown above. Clicking the URL that’s on that page will open our webpage.

Step 3: Working on our application logic

We are going to use AWS Lambda for this step.AWS Lambda is a serverless computing service that runs code in response to events, automatically managing the underlying infrastructure, allowing you to focus solely on code without provisioning servers.

Using Lambda, we are going to write some Python code using the Python Math library to carry out the calculations feature of our application.

Click on the Create a function button as shown in the image above. On the resulting page select Author from scratch, input a name for your function (as you can see in the image below, I called my lambda function ExponentialMathFunction ). Now select the runtime for the function. As pointed out earlier, we are using Python so select the Python runtime.

On the resulting page, replace the code in the lambda_function.py file with the code below, use Ctrl + S to save it and then click on the Deploy button to deploy the function.

# import the JSON utility package
import json
# import the Python math library
import math
# define the handler function that the Lambda service will use an entry point
def lambda_handler(event, context):
# extract the two numbers from the Lambda service's event object
    mathResult = math.pow(int(event['base']), int(event['exponent']))
    # return a properly formatted JSON object
    return {
    'statusCode': 200,
    'body': json.dumps('Your result is ' + str(mathResult))
    }

What the code does is, it imports the JSON utility package and the Python Math library which will enable us to do our calculations.

Now that our lambda function is deployed, let’s configure a test event and test it to see if it is working

Replaced the JSON code shown in the image above with the code below and click on the Save button.

{
  "base": 3,
  "exponent": 2
}

Now that our test event is configured and saved, we can run a test. So click on the blue Test button to run a test for our lambda function.

As you can see in the image above, our test has returned a response with a status code of 200 (which means that the test was successful) and a response body which says our result is 9. This means our function is working just fine. Let’s move on to the fourth step.

Step 4: Make it possible to invoke the lambda function we created

After having created a lambda function that will perform our calculations, we need to make it possible for our hosted web application to be able to invoke it when needed.Amazon API Gateway is a managed service that allows developers to create, publish, maintain, monitor, and secure APIs at any scale, enabling backend services for web, mobile, and serverless applications.

Open a new management console window in a new tab, search for and navigate to API Gateway.
Click on the Create API button.
Scroll down to the REST API section and click on the Build button.
Add a name for your API click on the Create API button.(make sure you are in the Resources tab.)
Make sure you have the forward slash selected as indicated.
Select the Create Method option.
Select POST and then click on the check icon that appears next to it. The reason we are selecting POST is that our application submits numbers for a calculation to be performed.
Since we are using a lambda function for our application logic, select Lambda Function as the Integration type, input the name of our lambda function in the appropriate input box and then click on the Save button. On the dialogue box that appears after clicking Save, click OK to permit API Gateway to invoke the lambda function.

9.The next thing we have to do is enable CORS (Cross Origin Resource Sharing). What CORS does is that it allows resources on one domain to access resources on another domain. Click the Actions button and select Enable CORS. Make sure you have selected POST sitting directly below the forward slash before you select Enable CORS

10.let’s deploy the API so we can be able to test it.

Copy your Invoke URL and keep it safe somewhere because we are going to use it later on. Now go back to the resource tab and click on POST to see a flow of how the API works. click on the Test .

Step 5: Configure a database where we will store all the results of our calculations.

We are going to use DynamoDB to achieve our objective. Our application doesn’t necessarily need to store the results of calculations in a database. This step is added just to show you have you can store application data in a database. DynamoDB is a managed NoSQL database service that provides fast performance with seamless scalability. In DynamoDB, data is stored in key-value pairs.

Click on Create table

Fill in the necessary details as indicated in the image above and click on Create table This creates a new DynamoDB table for us. Click on the table name to open it.

copy and keep the ARN of your database table somewhere safe as we are going to use it soon.

Step 6: Grant our lambda function permission to write results to DynamoDB

we are going to leverage the IAM roles feature of AWS IAM. IAM is a service provided by AWS that allows you to manage access to your AWS resources. An IAM role is a set of permissions that you can temporarily assign to an entity or an AWS service.

Go back to the browser tab where you have AWS Lambda open.

Click on the Role name highlighted in the image. This will open IAM in a new tab.

Click on the Add permissions dropdown button and select Create inline policy as shown in the image above.

Make sure you are in the JSON tab and replace the JSON policy with the code below. Make sure you replace "YOUR-TABLE-ARN" with the actual table ARN you copied earlier. Once you are done, click on the Next button.

{
"Version": "2012-10-17",
"Statement": [
    {
        "Sid": "LambdaFunctionExecutionPolicy",
        "Effect": "Allow",
        "Action": [
            "dynamodb:PutItem",
            "dynamodb:DeleteItem",
            "dynamodb:GetItem",
            "dynamodb:Scan",
            "dynamodb:Query",
            "dynamodb:UpdateItem"
        ],
        "Resource": "YOUR-TABLE-ARN"
    }
    ]
}

What this policy does is it allows our lambda function to perform various actions on our DynamoDB table.

Input a policy name as indicated in the image above and then click on the Create policy button to create the policy.

Now that we have successfully made it possible for our lambda function to perform various actions on our DynamoDB table, let’s update our lambda function. Copy the code below and use it as a replacement for the current code in the lambda_function.py file found in the code tab of our lambda management console window and then use Ctrl + S to save the file.

# import the JSON utility package
import json
# import the Python math library
import math
# import the AWS SDK (for Python the package name is boto3)
import boto3
# import two packages to help us with dates and date formatting
from time import gmtime, strftime
# create a DynamoDB object using the AWS SDK
dynamodb = boto3.resource('dynamodb')
# use the DynamoDB object to select our table
table = dynamodb.Table('ExponentialMathDatabase')
# store the current time in a human readable format in a variable
now = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
# define the handler function that the Lambda service will use an entry point
def lambda_handler(event, context):
# extract the two numbers from the Lambda service's event object
    mathResult = math.pow(int(event['base']), int(event['exponent']))
# write result and time to the DynamoDB table using the object we instantiated and save response in a variable
    response = table.put_item(
        Item={
            'ID': str(mathResult),
            'LatestGreetingTime':now
            })
# return a properly formatted JSON object
    return {
    'statusCode': 200,
    'body': json.dumps('Your result is ' + str(mathResult))
    }

After updating and saving the code, make sure you deploy it by clicking on the Deploy button. Now click on Test, go back to the DynamoDB tab and open up our database table.

Click on the Explore table items button to see if the results of the test were stored successfully.

the results were stored successfully.

Step 7: Make it possible for our front-end to be able to hit the API Gateway Endpoint.

We are getting close to the finish line!! As of this point, we can perform calculations by inputting numbers and using the CALCULATE button on our webpage because we can't invoke our calculations lambda function from the webpage. To make this possible, we have to connect our webpage to API Gateway using the API Gateway endpoint we copied earlier.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <link rel="preconnect" href="https://fonts.googleapis.com" />
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
    <link
      href="https://fonts.googleapis.com/css2?family=Rajdhani:wght@400;500;600&display=swap"
      rel="stylesheet"
    />
    <title>Exponential Math ⚡️</title>
    <!-- Styling for the web page -->
    <style>
      h1 {
        color: #fff;
        text-align: center;
        text-transform: uppercase;
        font-size: 50px;
        font-weight: 600;
      }
      body {
        background-color: #34495e;
        font-family: 'Rajdhani', sans-serif;
        display: flex;
        justify-content: center;
        align-items: center;
        position: relative;
      }
      label {
        color: #ffa801;
        font-size: 25px;
        margin-top: 20px;
      }

      label:last-of-type {
        margin-left: 20px;
      }
      button {
        background-color: #05c46b;
        border: none;
        color: #fff;
        font-size: 20px;
        font-weight: bold;
        margin-left: 30px;
        margin-top: 20px;
        padding: 10px 20px;
        font-family: 'Rajdhani', sans-serif;
        cursor: pointer;
      }
      input {
        color: #222629;
        border: none;
        font-size: 20px;
        margin-left: 10px;
        margin-top: 20px;
        padding: 10px 20px;
        max-width: 150px;
        outline-color: #05c46b;
      }
      div {
        width: auto;
        position: absolute;
        top: 35vh;
      }
    </style>
    <script>
      // callAPI function that takes the base and exponent numbers as parameters
      var callAPI = (base, exponent) => {
        // instantiate a headers object
        var myHeaders = new Headers();
        // add content type header to object
        myHeaders.append("Content-Type", "application/json");
        // using built in JSON utility package turn object to string and store in a variable
        var raw = JSON.stringify({ base: base, exponent: exponent });
        // create a JSON object with parameters for API call and store in a variable
        var requestOptions = {
          method: "POST",
          headers: myHeaders,
          body: raw,
          redirect: "follow",
        };
        // make API call with parameters and use promises to get response
        fetch("YOUR_API_GATEWAY_ENDPOINT", requestOptions)
          .then((response) => response.text())
          .then((result) => alert(JSON.parse(result).body))
          .catch((error) => console.log("error", error));
      };
    </script>
  </head>
  <body>
    <div>
      <h1>Exponential Math ⚡️</h1>
      <form>
        <label>Base number:</label>
        <input type="number" id="base" />
        <label>to the power</label>
        <input type="number" id="exponent" />
        <!-- set button onClick method to call function we defined passing input values as parameters -->
        <button
          type="button"
          onclick="callAPI(document.getElementById('base').value,document.getElementById('exponent').value)"
        >
          CALCULATE
        </button>
      </form>
    </div>
  </body>
</html>

Replace YOUR_API_GATEWAY_ENDPOINT with the API Gateway endpoint you copied earlier. Save your changes, delete the old index.zip and create a new one by zipping the updated index.html Go back to the AWS Amplify management console window.

Drag and drop your index.zip file here so that our application can be redeployed. Now open the link to our webpage hosted on Amplify, input some numbers and click CALCULATE to perform some calculations. Our webpage will call API Gateway which then triggers our lambda function to perform calculations and store the results of the calculations in our DynamoDB table.

Congratulations!!!You have successfully built an end-to-end, simple web application on AWS.

Conclusion

Congratulations on completing this step-by-step tutorial on building a simple end-to-end web application using Amplify, AWS Lambda, API Gateway, IAM, and DynamoDB

Automating Instance Management Using AWS Lambda and EventBridge

Kousalya S — Mon, 08 Jul 2024 05:38:24 +0000

Introduction:

Automating instance management with AWS Lambda and EventBridge involves using EventBridge to trigger Lambda functions based on specific events or schedules. This setup can automatically start, stop, or manage EC2 instances, optimizing resource usage and costs by responding to predefined conditions or times.

What are AWS Lambda?

AWS Lambda is a serverless computing service that lets you run code without provisioning or managing servers. You write your code and upload it to Lambda, and it automatically scales and executes in response to events, charging only for compute time consumed. It supports various programming languages.

What are Amazon EventBridge?

Amazon EventBridge is a serverless event bus service that makes it easy to connect applications using data from your applications, integrated SaaS applications, and AWS services. It allows you to build event-driven architectures with real-time data processing, routing events to targets like Lambda functions, and automating workflows.

Architecture:

Let’s get down to business!

The next thing is going through the steps from scratch in order to implement our solution. You need not worry about the Python3 code as you only need to copy-paste it.

STEP 1:

Create one Windows/Linux instance.

STEP 2:

Open the IAM service and create a role to access lambda services.

• Select AWS services
• Choose lambda use case.
• Click on permission and use two policies: AWSLambdaBasicExecutionRole (allow to use cloudwatch) and AmazonEC2Full Access. Note: You can create your policies, or you can select existing policies
• Provide a tag.
• Provide Role name and role description.

STEP 3:

Open Lambda services and create a new lambda function.

• Provide function name.
• Use Python as a runtime environment.
• Go to permissions and use the created role in Task 2.
• Now basic function code window will appear, and we need to write code for starting and stopping EC2 instances.

Code:

#Start instance: 
import boto3 
region = 'us-east-2' 
instances = ['i-0f019ff0664238dcb'] 
ec2 = boto3.client('ec2', region_name=region) 

def lambda_handler(event, context): 
ec2.start_instances(InstanceIds=instances) 
print('starting your instances: ' + str(instances))

#Stop Instance: 
import boto3 
region = 'us-east-2' 
instances = ['i-0f019ff0664238dcb'] 
ec2 = boto3.client('ec2', region_name=region) 

def lambda_handler(event, context):
ec2.stop_instances(InstanceIds=instances) 
print('stopped your instances: ' + str(instances))

STEP 4:

Save the code. Select a test event and configure the test event.

STEP 5:

Test the EC2 events by clicking on the startEC2 event and stopEC2 event.

STEP 6:

Provide the execution details of the lambda function.

STEP 7:

Select the event bridge and click on create a rule to trigger the created lambda function.

• Provide a name and description for the rule.
• Define pattern as an event by providing Cron expression.
• Select targets as Lambda function, provide the name of the function, and copy the JSON text from the event window.
• Create the rule now.

Conclusion

Congratulations! You've successfully Automated a Instance Using AWS Lambda and EventBridge.Automating instance management with AWS Lambda and EventBridge enhances efficiency, reduces costs, and optimizes resource allocation by automating responses to events. This streamlines operations and ensures instances are managed according to specific conditions or schedules.

Hosting a Static Website Using S3 in AWS with Terraform

Kousalya S — Thu, 27 Jun 2024 18:26:52 +0000

Hello Everyone!!here's a blog post on hosting a static website using Amazon S3 and Terraform.

Hosting a Static Website on AWS S3 Using Terraform

Hosting a static website on AWS S3 is a cost-effective and efficient way to make your content accessible to the world. By using Terraform, an infrastructure as code tool, you can automate the setup process, making it repeatable and easy to manage. In this tutorial, we'll walk you through the steps to host a static website on AWS S3 using Terraform.

What is Amazon S3?

Amazon S3 (Simple Storage Service) is a scalable object storage service provided by AWS. It allows users to store and retrieve any amount of data at any time. S3 is often used for backup, archiving, and hosting static websites due to its high durability, security, and cost-effectiveness.

Prerequisites

AWS Account: You need an AWS account to create the necessary resources.
Terraform: Install Terraform on your local machine. You can download it from the Terraform website.
AWS CLI: Install and configure the AWS CLI with your credentials.

STEP 1: Setup the Terraform

To set up Terraform, install it from terraform.io, configure AWS CLI, create a main.tf file with your infrastructure code, then run terraform init and terraform apply.

`terraform {
  required_version = "1.7.4"
  required_providers {
    aws = {
        source = "hashicorp/aws"
        version = "5.40.0"
    }
  }
}
provider "aws" {
  profile = "default"
  region = "ap-south-1"
} `

STEP 2: Configuration for S3 Buckets:

Create an S3 bucket in Terraform with aws_s3_bucket, set bucket name, acl to "public-read", and website configuration. Add a policy with aws_s3_bucket_policy for public access.

#Create S3 Bucket
resource "aws_s3_bucket" "terraform-demo-43234" {
  bucket = "terraform-demo-43234"
}

#Upload file to S3
resource "aws_s3_object" "terraform_index" {
  bucket = aws_s3_bucket.terraform-demo-43234.id
  key = "index.html"
  source = "index.html"
  content_type = "text/html"
  etag = filemd5("index.html")
}

#S3 Web hosting
resource "aws_s3_bucket_website_configuration" "terraform_hosting" {
  bucket = aws_s3_bucket.terraform-demo-43234.id

  index_document {
    suffix = "index.html"
  }
}

step 3: configuration for bucket policy

Create a ‘policy.tf’ file to store the terraform configuration related to the bucket policy for public access.

#S3 public access
resource "aws_s3_bucket_public_access_block" "terraform-demo" {
    bucket = aws_s3_bucket.terraform-demo-43234.id
  block_public_acls = false
  block_public_policy = false
}

#S3 public Read policy
resource "aws_s3_bucket_policy" "open_access" {
  bucket = aws_s3_bucket.terraform-demo-43234.id

  policy = jsonencode({
    Version = "2012-10-17"
    Id      = "Public_access"
    Statement = [
      {
        Sid = "IPAllow"
        Effect = "Allow"
        Principal = "*"
        Action = ["s3:GetObject"]
        Resource = "${aws_s3_bucket.terraform-demo-43234.arn}/*"
      },
    ]
  })
  depends_on = [ aws_s3_bucket_public_access_block.terraform-demo ]
}

step 4:Configuration for Output variable

This is an optional step. We are doing this to get a static website URL which we can also get through AWS Console. Create an ‘output.tf’ to print out the URL to access the website.

# Website URL
output "website_url" {
  value = "http://${aws_s3_bucket.terraform-demo-43234.bucket}.s3-website.${aws_s3_bucket.terraform-demo-43234.region}.amazonaws.com"
}

Step 5: Initialize Terraform

To initialize Terraform , navigate to the directory containing your Terraform configuration files and run terraform init. This command initializes the environment, downloads necessary plugins, and prepares Terraform to manage your infrastructure according to the configuration defined in main.tf.

terraform init

Step 6: Terraform Validate

terraform validate

Terraform files in your project directory are verified for syntax and configuration using the terraform validate command. Without actually running the configuration files, it checks them for problems. By doing this, you can make sure that before making any modifications to your infrastructure, your Terraform settings follow the proper syntax and structure.

Step 7: Terraform Plan

terraform plan

Go to the directory of your project and execute the command terraform plan' to create a Terraform execution plan. By comparing the desired state specified in your configuration files (main.tf') with the present infrastructure state, Terraform suggests actions (create, update, and remove). Before using terraform apply to apply changes, review the plan.

Step 8: Terraform Apply

terraform apply

To apply Terraform configuration changes, run terraform apply. Terraform will show a plan of actions to be performed based on your main.tf file. Confirm with yes to execute changes, creating or updating resources as specified.

Step 9: Destroy

terraform destroy

The terraform destroy command in Terraform serves the purpose of tearing down the infrastructure resources that your Terraform configuration currently manages.

Conclusion

Congratulations! You've successfully hosted a static website on AWS S3 using Terraform. This setup is highly scalable, cost-effective, and easy to manage. By using Terraform, you can version control your infrastructure and make deployment a breeze.Happy hosting!

Creating , Modifying , and Destroying an EC2 Instance in AWS with Terraform

Kousalya S — Thu, 27 Jun 2024 17:12:35 +0000

Hi Friends! As part of my internship,We will learn how we can Creating, Modifying, and Destroying an EC2 Instance with Terraform

Introduction

Terraform is an open-source infrastructure as code (IaC) tool developed by HashiCorp. It allows you to define, create, and manage infrastructure resources in a declarative way, using a high-level configuration language. With Terraform, you can easily provision, update, and delete infrastructure resources, such as virtual machines, databases, load balancers, and more, across multiple cloud providers or on-premises data centers.

Prerequisites

Before we begin, make sure you have the following:

An AWS account.
AWS CLI configured with your AWS credentials.
Terraform installed on your machine.

Step 1: Setting Up Your Terraform Configuration

First, create a new directory for your Terraform project and navigate into it.Next, create a new file named main.tf and open it in your favorite text editor. This file will contain the configuration for
your EC2 instance.

Step 2: Configuring AWS Provider

In main.tf, start by defining the AWS provider. This tells Terraform to use AWS as the provider for your infrastructure.

Step 3: Creating an EC2 Instance

To create an EC2 instance on AWS in the simplest way using Terraform,create a file called main.tf and define a provider block for AWS in your .tf file. Add a resource block for the aws_instance
specifying the AMI and instance type. Run terraform init, terraform plan, and terraform apply to provision the instance.

Step 4: Initializing Terraform

To initialize Terraform, create a directory for your configuration files. Inside it, create a main configuration file (e.g., main.tf). Run terraform init in your terminal within this directory. This command downloads necessary plugins and prepares your working directory for other Terraform commands.

Step 5: Applying the Configuration

To apply the Terraform configuration, navigate to your project directory in the terminal. Run terraform init to initialize the project, then use terraform plan to review the changes.Review the plan and type ‘yes’ to apply the changes. Finally, execute terraform apply to apply the
configuration and provision the resources. Confirm whenprompted.Terraform will then create the EC2 instance.

Step 6: Modifying the EC2 Instance

If you want to modify the instance (e.g., change the instance type), simply update the main.tf file. For example, to change the instance type to t2.small, update the instance_type . Save the file and
run the following command ‘terraform apply’to apply the changes . Terraform will update the instance to the new configuration.

Step 7: Destroying the EC2 Instance

When you no longer need the EC2 instance, you can destroy it using Terraform. Run the following command ‘terraform destroy’. Terraform will show you a plan of the resources it will destroy. Review the plan and type yes to proceed. Terraform will then terminate the EC2 instance.

Conclusion

In this blog post, we covered the basics of creating, modifying, and destroying an EC2 instance using Terraform. By using Terraform, you can manage your cloud infrastructure in a consistent and repeatable way, making it easier to scale and maintain your environment. Happy Terraforming