DEV Community: Harrison Ifeanyi

Build Infrastructure with Terraform on Google Cloud

Harrison Ifeanyi — Fri, 19 Apr 2024 16:39:01 +0000

TASK TO BE DONE:
Task 1. Create the configuration files
Task 2. Import infrastructure
Task 3. Configure a remote backend
Task 4. Modify and update infrastructure
Task 5. Destroy resources
Task 6. Use a module from the Registry
Task 7. Configure a firewall

Task 1. Create the configuration files

main.tf
variables.tf
modules/
└── instances
├── instances.tf
├── outputs.tf
└── variables.tf
└── storage
├── storage.tf
├── outputs.tf
└── variables.tf

Step 1:

Run:

mkdir -p modules/storage modules/instances

Run:
touch modules/instances/variables.tf modules/instances/outputs.tf modules/instances/instances.tf modules/storage/variables.tf modules/storage/outputs.tf modules/storage/storage.tf

Run:
touch main.tf outputs.tf variables.tf

Then in your main.tf:



terraform {
  required_providers {
    google = {
      source = "hashicorp/google"

    }
  }
}

provider "google" {

  project = var.project_id
  region  = var.region
  zone    = var.zone
}

In all your variables.tf files:



Variable “zone” {
    Default = ”ZONE”
}

Variable “project_id” {
    Default = ”PROJECT_ID”
}

Variable “region” {
    Default = ”REGION”
}

NOTE:
To be added in the VARIABLES.TF in the root, instances.tf and storage.tf

Then run:



terraform init

Task 2. Import Terraform configuration

Step 1:
STEPS IN CREATING VMs

Navigate to Google Cloud Console

Select or Create a Project: if you haven't already, create a new project or select an existing project where you want to create your compute instances
Navigate to Compute Engine: in the Google Cloud Console, navigate to the Compute Engine section. You can find it in the left sidebar under the "Compute" section.
Create a New Instance: click on the "Create" button to create a new virtual machine instance.
Configure Instance Details: fill out the necessary details for your instance, including:

Instance name: Give your instance a descriptive name.
Region and Zone: Choose the region and availability zone where you want to deploy your instance.
Machine type: Select the machine type that suits your requirements, such as CPU and memory specifications.
Boot disk: Choose the operating system and disk size for the boot disk.
Networking: Configure network settings such as VPC network, subnetwork, external IP address, and firewall rules.
Advanced Configuration (Optional): you can also configure additional options such as GPU, metadata, and startup scripts if needed.

Review and Create: review the configuration of your instance to ensure everything is correct.
Once you're satisfied, click the "Create" button to provision the instance.

Repeat to create another instance. We’re creating the instances so we can import them later into our terraform configuration and terraform can be responsible for managing them.

Step 2:
In your instance.tf:



resource "google_compute_instance" "INSTANCE_NAME-1" {
  name         = "tf-instance-1"
  machine_type = "e2-micro"
  zone         = var.zone

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
      Size = “10”
    }
  }

  network_interface {
    network = "default"

  }
}


resource "google_compute_instance" "INSTANCE_NAME-2" {
  name         = "tf-instance-2"
  machine_type = "e2-micro"
  zone         = var.zone

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
      Size = “10”
    }
  }

  network_interface {
    network = "default"

  }
}

Then add the following to your main.tf:



module “instances”{
    source = “./modules/instances”
}

Then run:



terraform init

Next:
Run this command:



terraform import module.instances.google_compute_instance.INSTANCE_NAME-1 INSTANCE_ID

Then:



terraform import module.instances.google_compute_instance.INSTANCE_NAME-2 INSTANCE_ID

NOTE: INSTANCE_ID can be gotten from the console.

Task 3. Configure a remote backend

In your storage.tf file add the following



resource "google_storage_bucket" "STORAGE_BUCKET" {
  name        = "# REPLACE WITH YOUR PROJECT ID"
  location    = "US"
  uniform_bucket_level_access = true
  Force_destroy = true }

Then add the following to your main.tf file:



module “compute_storage”{
        source = “./modules/storage”
}

Then run:



terraform init

Then run:



terraform apply

After the bucket is created add the following to your main.tf in the terraform block



 backend "gcs" {
    bucket  = "# REPLACE WITH YOUR BUCKET NAME"
    prefix  = "terraform/state"
  }

Run:



terraform init

It should prompt you, type yes

Task 4

To update infrastructure:

You only need to change machine-type argument from “e2-micro” to the type provided. This should be done in your instances.tf file

The add a new instance resource in the same file



resource "google_compute_instance" "THIRD INSTANCE NAME" {
  name         = "THIRD INSTANCE NAME"
  machine_type = "SPECIFIED MACHINE TYPE"
  zone         = var.zone

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
      Size = “10”
    }
  }

  network_interface {
    network = "default"

  }
}

Then run:



terraform init

Then:



terraform apply

Task 5

To delete resource: You just remove the third instance configuration from your instances.tf file and then run



terraform apply

Task 6
Add to your main.tf file



module "vpc" {
source  = "terraform-google-modules/network/google"
version = "9.0.0"
project_id   = "<PROJECT ID>"
network_name = "VPC_NAME"
routing_mode = "GLOBAL"
    subnets = [
        {
            subnet_name           = "subnet-01"
            subnet_ip             = "IP_RANGE"
            subnet_region         = var.region
        },
    {
            subnet_name           = "subnet-02"
            subnet_ip             = "IP_RANGE"
            subnet_region         = var.region
        },

]


}

After adding the block, run:



terraform init

Then run:



terraform apply

Task 7

Add to your main.tf file:



resource “google_compute_firewal”l “FIREWALL_NAME”{
    name = “FIREWALL_NAME”
    network = module.vpc.network_name

    allow {
    protocol = "tcp"
    ports    = ["80"]
  }
    source_ranges = [0.0.0.0/0]
}

run :



terraform init

then :



terraform apply

Update the instance.tf file to use the newly created VPC and place each instance in a different subnet



resource "google_compute_instance" "INSTANCE_NAME-1" {
  name         = "tf-instance-1"
  machine_type = "e2-micro"
  zone         = var.zone

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
      size = “10”
    }
  }

  network_interface {
    network = "VPC_NAME"
    subnetwork = “SUBNET_1”

  }
}


resource "google_compute_instance" "INSTANCE_NAME-2" {
  name         = "tf-instance-2"
  machine_type = "e2-micro"
  zone         = var.zone

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
      size = “10”
    }
  }

  network_interface {
    network = "VPC_NAME"
    subnetwork = “SUBNET_2” 

  }
}

Using Amazon S3 with Amazon CloudFront

Harrison Ifeanyi — Fri, 19 Apr 2024 15:54:48 +0000

Step 1
Create S3 bucket and enable it for static website hosting

Go to AWS Management Console > Search for S3

At this junction, we need to create a bucket for the project.

Each S3 bucket in AWS needs to have a unique name as bucket names in AWS have to be unique globally

The region where I ran my account was automatically made the region for the bucket

For Bucket Type: General Purpose
For Bucket Name: I used harrisonawscloudclubproject

Disable the ACL and also untick the Block All Public Access. Without the Block All Public Access unticked, there wouldn’t be any access to the bucket.

Unticking the Block All Public Access box triggered this warning but ignore
Scroll down and click on Create Bucket
Wait for the bucket to be created

Bucket Created Successfully !!

Step 2
Enable Static Website Hosting

Now that the bucket has been created and has been made public, it's time to enable static website hosting

To achieve that;

Click on the name of the bucket that you created
You see the options on the tabs, select the PROPERTIES tab option

Scroll to the end of the PROPERTIES page
Static website hosting is the last option on the page

Click on the Edit Button

Click on the Enable Button

Under the Hosting Type, the Host a Static Website is already enabled.
Fill the index document with index.html
Click on Save Changes

Static Website Hosting enabled successfully!

Go back to PROPERTIES, scroll down again to STATIC WEBSITE HOSTING, then click on the link you see in that section

Once clicked, it opens a new tab that shows an error page:

This is so because we haven’t configured the bucket policy to allow public access. Even though we unticked the Block All Public Access option, we still need to configure the BUCKET POLICY.

Step 3
Enable Public Access to the Bucket

Head to the PERMISSIONS Tab
Scroll down to BUCKET POLICY
Click the EDIT button on BUCKET POLICY
Click on POLICY GENERATOR

Click on SELECT TYPE OF POLICY dropdown
Choose S3 BUCKET POLICY
In the PRINCIPAL box, input “*” (this gives permission to every type of access)
On the ACTIONS dropdown, choose GET OBJECTS
Go back to the EDIT BUCKET POLICY page, copy BUCKET ARN
Go back to the POLICY GENERATOR page and paste it in the AMAZON RESOURCE NAME box

Click on ADD STATEMENT button
Click on GENERATE POLICY
A POLICY JSON DOCUMENT Modal pops up, copy the policy off the modal and click CLOSE
Go back to EDIT BUCKET POLICY and paste it there and click on SAVE CHANGES

NOTE: If you are receiving an error message, make sure you put “/*” at the end of the AMAZON RESOURCE NAME.

STEP 4
Upload Objects into the Bucket

Upload 2 files: index.html and the image that is going to be reflected in the index.html

Click on OBJECTS
Click on UPLOAD
Click on ADD FILES

Files are uploaded and you click on UPLOAD
Wait to get the UPLOADED SUCCEEDED message

STEP 5
Confirm that the static website hosting is working

Click on PROPERTIES
Scroll down to STATIC WEBSITE HOSTING
Click on the URL in that section and it opens a new tab showcasing the files we uploaded to the S3 Bucket

Now, it is important to mark and serve content through CLOUDFRONT DISTRIBUTION to be able to make use of the CACHING FUNCTION of CLOUD FRONT to reduce latency and continuous calls to the S3 Bucket.

STEP 6:
Configure your Cloudfront

Go to CLOUDFRONT

Click on CREATE DISTRIBUTION
ORIGIN DOMAIN: The S3 Bucket you created
Scroll down to ORIGIN ACCESSS
Select ORIGIN ACCESS CONTROL SETTING
Select the bucket you created
Back to the CREATE DISTRIBUTION page,
Under the WEB APPLICATION FIREWALL (WAF), Select DO NOT ENABLE SECURITY PROTECTIONS
Now, scroll down to the DEFAULT ROOT OBJECT, type in the name of your HTML file
Scroll to the end of the page and click on CREATE DISTRIBUTION

Click on the CREATE POLICY button

STEP 7
Back to S3

Now, go back to S3
Select the bucket that you created
Go to PERMISSIONS, go to BLOCK PUBLIC ACCESS, then click on EDIT
Tick on BLOCK ALL PUBLIC ACCESS

Click on SAVE CHANGES
Type CONFIRM in the Modal that pops up
Then click on the CONFIRM button
Now, click on EDIT on the BUCKET POLICY
Paste the policy you copied from CLOUDFRONT
Click on SAVE CHANGES

Step 8
Back to CloudFront

Navigate back to CLOUDFRONT

Click on the DISTRIBUTION
Under GENERAL, locate the DISTRIBUTION DOMAIN NAME under the DETAILS section.
Copy the DISTRIBUTION DOMAIN NAME
Now, go back to the tab created from the STATIC WEBSITE HOSTING and refresh
You will find out that the page isn’t accessible anymore; it will report a 403 FORBIDDEN error message

Now, paste the DISTRIBUTION DOMAIN NAME link on a tab and tap ENTER

You will realize that our S3 Files are being served through CLOUDFRONT.

Build an End-to-End AWS Web Application

Harrison Ifeanyi — Fri, 19 Apr 2024 14:55:44 +0000

Building The Power of Math using the following AWS Services:

AWS Amplify
AWS Lambda
Amazon API Gateway
Amazon DynamoDB
AWS Identity and Access Management

Requirements:

Create/host the webpage
Invoke math functionality
A way to do some math
Store/return the math result
Handle permissions

TASK 1:
A way to create/host the webpage

AWS Amplify: It is used to build and host websites

Created a text document (preferably notepad) named INDEX but saved it as “.html”
Opened the INDEX.HTML file via Notepad and pasted the POWER OF MATH code in it

Once that's done, zip the file

Now, it's time to use AWS Amplify to deploy it

Log into your AWS Management Console and navigated to the AWS Amplify function

Under the AWS Amplify Header, click on the GET STARTED button
Under HOST A WEB APP, click on GET STARTED which takes you to the page below:

Select DEPLOY WITHOUT GIT PROVIDER
Clicked on CONTINUE
On the MANUAL DEPLOY page, under APP-NAME, I called mine PowerOfMath
Under ENVIRONMENT NAME, I typed in DEV
Drag the zipped file and import it into AWS Amplify
Click on SAVE and DEPLOY Button

It was successfully deployed below:

Copy the DOMAIN link and open it in a tab
View the page

TASK 2:
A way to do some math

This is a perfect use case for LAMBDA FUNCTION. This is a piece of code that runs serverless upon some trigger

On the AWS Console, navigate to LAMBDA
Click on CREATE A FUNCTION

Under CREATE FUNCTION, select AUTHOR FROM SCRATCH
Under BASIC INFORMATION;

A. Function Name: I went with PowerOfMathFunction

B. Runtime: I selected PYTHON 3.9

Click on the CREATE FUNCTION button

Once it has been created, scroll down the page and paste the PYTHON code written for this function.

Type CTRL + S to save the code
Clicked the DEPLOY button

Click on the dropdown icon beside the TEST button
Click on CONFIGURE TEST EVENT

On the modal that pops up, choose the CREATE NEW EVENT, I chose to name the event PowerOfMathTestEvent.
Leave the event-sharing settings on private.

On the EVENT JSON section of the modal page, I edited the content made available to the following;

{
“base”: 2,
“exponent”: 8
}

Now, scroll down and clicked the SAVE button

Now, click on the DEPLOY button first and the TEST button after

It gave the following result:
"statusCode": 200,
"body": "\"Your result is 256.0\""

This shows that the LAMBDA FUNCTION is working

TASK 3:
A way to invoke the math functionality

API Gateway - used to build HTTP, REST & WebSocket APIs
Navigate to the AWS API Gateway section of the console
Out of the options displayed, click on the BUILD button under the REST API

On the Create REST API page:

Select NEW API
API Name: PowerOfMathAPI
I left the API Endpoint Type at REGIONAL

Click on the CREATE API button

On the left side of the screen, ensure that RESOURCES was selected
Click on the CREATE METHOD button

On the CREATE METHOD page;

Under Method type, select POST
Under Integration type, choose LAMBDA FUNCTION
Under Lambda function section, I selected the LAMBDA FUNCTION I HAD CREATED FOR THIS PROJECT

Now clicked on CREATE METHOD

At this moment, there is a need to activate Cross-Origin Resources Sharing (CORS)

To get that done, click on the “/” icon between CREATE RESOURCES and POST. The CORS button was on the right.
On the ENABLE CORS page;

Under Access-Control-Allow-Methods section, tick the POST option and clicked on the SAVE button

At this point, click on the DEPLOY API button

Stage: NEW STAGE
Stage Name: Dev
Then click on the DEPLOY button

I copied the INVOKE URL and kept it in my notepad for later

To Test if the API is Working:

Click on RESOURCES
Select POST
Select TEST

I typed in the same equation that was used earlier and the result?
Right below:

TASK 4:
A. Somewhere to store/return the math result
B. Set Permission on the execution role for Lambda

DynamoDB - A Key Value, NoSQL Database
IAM: Identity and Access Management

Navigate to Dynamo DB and clicked on CREATE TABLE
For Table name, I chose PowerOfMathDatabase
For Partition key, I typed ID
Click on CREATE TABLE button

Click on the PowerOfMathDatabase
In the GENERAL INFORMATION section under OVERVIEW, copy the Amazon Resource Name (ARN) and save on your notepad

At this point, it was important to ensure that the LAMBDA FUNCTION would be able to write into Dynamo DB

So navigate back to the LAMBDA page and click on the CONFIGURATION section

Click on the URL under ROLE NAME and it opens the IAM page below:

On this IAM page, click on ADD PERMISSION and chose the CREATE INLINE POLICY
Click on JSON and paste the EXECUTION ROLE POLICY code

Add the DYNAMO DB ARN link that was copied earlier to the RESOURCE part of the code
Click on the NEXT button
For Policy name, I chose PowerOfMath and clicked on CREATE POLICY
Policy Created!

Now, there is a need to update the LAMBDA FUNCTION that writes to the database

Navigate back to LAMBDA and clicked on CODE
Under the PowerOfMathFunction Folder, view the PYTHON code you had saved earlier (lambda_function.py)
I replaced it with the PowerOfMath - LAMBDA FUNCTION FINAL code and pressed CTRL + S to save
Click on DEPLOY. After it had deployed, clicked on TEST.

TASK 5:
Implement a connector by linking AWS Amplify with AWS API Gateway

I updated the code on the INDEX.HTML file
I also inputted the API Gateway URL I had copied earlier

Save the updated file and re-zipped it
Navigate back to AWS Amplify
Click on the CHOOSE FILE button, selected the updated INDEX.HTML file and uploaded it

Now, go back to the web tab you had opened with the DOMAIN URL from AWS Amplify

This was the web page then:

After refreshing, this is the updated and fully functional Power Of Math Page:

Tested it on a math question: