DEV Community: Busa Ayim-Odu

Deploying a Scalable, Secure Web App on AWS with Full CI/CD & Observability Part 1

Busa Ayim-Odu — Tue, 24 Jun 2025 08:56:42 +0000

Project Goal (Why It Matters to a Business):

Use AWS, GitHub Actions, Docker, and Terraform to create a scalable, production grade web application that demonstrates how DevOps enhances user experience, security, cost effectiveness, and deployment speed.

Project Setup:

Frontend and backend clones and Dockerization
Create AWS infrastructure (EC2, ECR, IAM) using Terraform.
Move the application from CI/CD to EC2.
Use GitHub Actions to set up a CI/CD pipeline.
Establish cost controls and logging.
Step 1
Clone the Repo & Open in VS Code
Run this command:
cd ~
git clone https://gitlab.com/cloud-devops-assignments/spring-boot-react-example.git
cd spring-boot-react-example
code .
Step 2
I will create the backend and frontend directories now.
Step 3
I’ll be organizing the project by placing each file and directory into the appropriate backend or frontend folder. Additionally, I’ll create separate Dockerfiles for both the backend and frontend to ensure each part of the application can be containerized effectively.

I accidentally deleted the backend folder while organizing files and setting up the Dockerfile. Thankfully, I hadn’t committed the changes yet, so I can either recover it or start fresh. In this case, I’ve decided to start over by deleting the spring-boot-react-example folder and re-cloning the project. Just close VS Code, open Git Bash, and run the commands shown in the image below.

Now I’ll go ahead and manually open the project folder in VS Code and follow the initial setup steps:

File → Open Folder → spring-boot-react-example Everything is now set up. Just a heads-up, you might run into a few errors as you go, and some may require you to create extra files. Don’t worry, I’ll walk you through what each file does, why it’s needed, and how it fits into the project.

-Step 4
Remember I created the dockerfiles for both the backend and frontend. And also the docker compose yaml file as well as shown below.

While everything is being set up, Make sure your Docker Desktop is running.

Step 5: Run these commands docker-compose build frontend docker-compose up Oops! We got an error while running: Docker-compose up. The Reason Why This Occurs:
My backend and the frontend maven-plugin is used by the Spring Boot application, which automatically:
Node.js + npm is downloaded within the Docker container.
The React frontend is then attempted to be built as part of the MVC clean package procedure.

However, the npm.tar.gz file is either corrupted or incomplete (most likely as a result of Docker's sluggish or unreliable network).

What should we do?
Build the frontend manually (before backend build).

Now for backend build commands:

Oops! We ran into another error. This one’s related to Node.js being run inside Maven it doesn’t allow the --openssl-legacy-provider flag, which causes the build to fail. Since the frontend is now decoupled and handled separately, I removed all the frontend related plugin blocks from the pom.xml, keeping only the necessary configurations for the Spring Boot backend. This helps streamline the build and avoid unnecessary errors.

Step 6
Run this command: docker-compose build

Both Frontend and Backend are built successfully.
Step 7
Run this command: docker-compose up

This is an error port, Port 8080 on my host machine is already in use. We need to free up port 8080.

What this means is the frontend is working fine but the backend containing is not running. Most like because Docker couldn't bind port 8080, which is probably already used by something else on your system.
Check What's Using Port 8080 (on Windows)
Open PowerShell or CMD and run:

That last number is the PID (process ID) using the port.
Now find the program:

Then force stop it (if safe):
Step 8

Both the frontend and backend are working.

Access the Backend
Open your browser and go to: http://localhost:8080/login

A Spring Boot welcome Login page

Access the Frontend
Since your frontend container maps port 3000 → 80, open:

Connect frontend to backend by adding a proxy in frontend/package.json: proxy: http://backend:8080
This works inside Docker Compose if the service name is backend.

Final Step: Push the Docker Images to Docker Hub First, you’ll need the Docker images, which contain all the necessary components. You can see the details in the image provided:
Next you are ready to push to dockerhub so everyone can see your repo. Repeat the same command for the backend as well. Proceed to your dockerhub where you are logged in and check the images are in your repo. Great job! This is a big step.

Next we will Deploy to the Cloud (AWS ECS or EC2)

Stick around more to come in the next update!.

Summary:
I started by cloning a Spring Boot + React project and restructuring it into frontend/ and backend/ directories. I made docker-compose.yml to run the entire application locally and wrote unique Dockerfiles for both, optimizing them with multi-stage builds. I encountered usual DevOps challenges along the road, such as permission failures, out-of-date Babel settings, JSX build problems, and missing dependencies. I resolved each of them by adjusting configuration files, upgrading dependencies, and clearing out Maven plugins. I tagged and submitted the images (busadev/react-frontend and busadev/react-backend) to my Docker Hub once both services were operating without a hitch in Docker. I learned a lot about debugging, improved my containerization skills, and gained practical experience in organizing a DevOps process thanks to this project. It's a modest but significant step in the direction of developing cloud-deployable, production-ready apps.

My First OpenStack Project: Deploying a VM with MicroStack on Ubuntu

Busa Ayim-Odu — Wed, 11 Jun 2025 08:19:10 +0000

As part of my hands-on cloud journey, I recently tackled the challenge of setting up OpenStack using MicroStack on a local Ubuntu VM running in VMware. This project helped sharpen my troubleshooting skills and gave me deeper insights into how OpenStack operates in a constrained, local environment.

Project Goal

To install and configure OpenStack (MicroStack) on Ubuntu using Snap and successfully launch a virtual machine instance from the OpenStack dashboard or CLI.

Before we begin, ensure you have the following:

A machine running Ubuntu 20.04 or later: This can be a physical machine, a virtual machine, or a cloud instance with at least 8 GB of RAM and 50 GB of disk space.

Basic knowledge of Linux command-line operations: Familiarity with terminal commands will be beneficial.

Step1.

Install OpenStack using MicroStack
Update your system: sudo apt update && sudo apt upgrade -y
Install MicroStack: sudo snap install microstack --classic

Oop! Microstack --classic is not available but --edge is available

Run the command: sudo snap installmicrostack --classic --edge
Initialize MicroStack: sudo microstack init --auto
This command sets up a single-node OpenStack deployment with default configurations.

The error you're seeing means that when using --auto, MicroStack requires you to specify a role: either --compute or --control.

You need to rerun the command and specify a role. If this is the first and only node (single-node setup), choose --control:
sudo microstack init --auto --control

Yes, running the command: sudo microstack init --auto --control
will set up your Ubuntu VM as a single-node control plane. This setup includes the OpenStack dashboard (Horizon), the API endpoints, and compute capabilities — perfect for testing or learning.

Next we run this command: microstack.openstack endpoint list Purpose: Shows all the service endpoints (internal, public, admin URLs) for OpenStack services. It looks for any dashboard or horizon related entries (usually under the public URL section).

Access the OpenStack Dashboard

Retrieve the dashboard URL: sudo microstack.openstack dashboard url Oop! I got this error. openstack dashboard url is not a valid OpenStack CLI command.

Here’s What To Do Instead (No CLI Needed for Dashboard URL):
To access the Horizon Dashboard for MicroStack:

Get Your Ubuntu VM IP Address
Run this in your Ubuntu terminal:ip a I am looking for this information: inet 192.168.129.128 This ip 192.168.129.128 is the IP needed to access the dashboard via the browser.
Visit the Dashboard in a Browser
On your host machine (e.g., Windows or Mac), open a browser and go to: https://192.168.129.128
You Might See a Security Warning. That’s okay — the dashboard uses a self-signed certificate.
Click:Advanced → Proceed (unsafe)

Get the Admin Password

In your terminal, run: sudo snap get microstack config.credentials.password That error means the password isn’t stored under config.credentials.password, which sometimes happens with newer MicroStack versions or if initialization didn’t complete fully.

Lets Try This Instead to Get the Admin Login Credentials:

Run this command: sudo cat /var/snap/microstack/common/etc/microstack.rc This file often contains the exported environment variables including the username, password, project name, and OpenStack endpoint.

Let's try accessing the Horizon Dashboard

Logged in with: Username:admin & Password: from microstack.rc

Bonus Tip (Make It Easy to Load Credentials in Terminal)
To use OpenStack CLI later, you can load the credentials with:
source /var/snap/microstack/common/etc/microstack.rc

Set up a private cloud using MicroStack, launch an instance, and document access via floating IPs and Horizon dashboard.

Step 1: Create a Key Pair (for SSH Access to VMs)
Go to: Project > Compute > Key Pairs
Click Create Key Pair
Give it a name e.g busa-key
Save the private key (.pem file) to your host machine

Step 2: Upload an Image

Go to: Project > Compute > Images

Click Create Image Fill in:
Name: ubuntu-22.04
Image Source: URL or file
Format: QCOW2
You can use Ubuntu Cloud Image: https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64.img
Open a browser in the Ubuntu VM, copy and paste the link above and download the Ubuntu image.
Alternatively, Download the Ubuntu Cloud Image. Open your terminal and run: wget https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64.img -O ubuntu-22.04.img

Upload the Image to OpenStack (MicroStack)
Now, upload it using the microstack.openstack CLI:

My image Ubuntu-22.04 has been successfully created and registered in OpenStack. The status is active, which means it's ready to be used.

Let's find out if it is listed.
Run this command: microstack.openstack image list

Yes, it is listed and as seen below in the image.

Next I am going to Launch an Instance

I can launch on the dashboard
Fill the Launch Instance Form

Instance Name: my-first-vm
Count: 1
Availability Zone: nova
Instance Boot Source: Choose Image
Image Name: Select Ubuntu-22.04
Flavor: Choose m1.small
Select a network, usually called external.
Select a keypair to access your VM via SSH.
Click “Launch Instance"

Or use the terminal, it will get the same result. Run this command:
microstack.openstack server create \
--flavor m1.small \
--image "Ubuntu-22.04" \
--network external \
--key-name microstack \
my-first-instance

I ran into an error because I didn't add my key-pair busa-key.pem. This is the correct command:
microstack.openstack server create \
--flavor m1.small \
--image "Ubuntu-22.04" \
--network external \
--key-name busa-key \
my-first-instance

Project Summary: MicroStack/OpenStack VM Deployment on Ubuntu

Objective
To install and configure OpenStack (MicroStack) on Ubuntu using Snap, and successfully launch a virtual machine (VM) instance.

Challenges Encountered:

Problem->Network connection failed = Cause -> Missing DHCP and DNS = Solution -> Edited netplan, restarted services, added resolv.conf
Problem -> Snap install errors = Cause -> Caused by name resolution = Solution -> Resolved after fixing DNS

What I Learned:
This project was more than just launching a VM. I gained:

Practical knowledge of Linux networking and netplan
How to debug low-level connectivity issues inside VMs
Experience installing OpenStack via Snap using MicroStack
Confidence to work through real-world DevOps roadblocks

What's Next?
Now that the instance is live, I plan to:

Configure floating IPs to access VMs externally
Automate more of the setup process using scripts
Write a follow-up blog on launching applications inside the OpenStack VM

Final Thoughts
This hands-on challenge pushed me to solve real infrastructure issues—just like in production environments. If you're starting out in cloud engineering or DevOps, I highly recommend trying this locally before jumping into full OpenStack deployments in the cloud.

Let me know if you’ve faced similar challenges or want to try this yourself!

🧑‍💻 #OpenStack #MicroStack #Ubuntu #CloudComputing #DevOps #Linux #VMware #HandsOnCloud #BeginnersJourney

Build a Weather Info API Gateway with AWS Lambda & Open Weather Map

Busa Ayim-Odu — Wed, 04 Jun 2025 10:50:47 +0000

Overview:
Create a simple API that returns current weather information for a given city using AWS Lambda, API Gateway, and OpenWeatherMap API.

An API (Application Programming Interface) is a set of rules that allows two software applications to communicate with each other.

Tools & Skills Involved:
AWS Lambda (Python runtime)

Amazon API Gateway

IAM Roles & Permissions

OpenWeatherMap API (free tier)

Python (requests library)

Postman or browser for testing

Powershell

Step 1: Sign Up for OpenWeatherMap
Go to https://openweathermap.org/api

Step 2: Create Your Lambda Function
Go to AWS Console > Lambda > Create Function.

Choose: “Author from scratch”

Runtime: Python 3.x

Name: weather-api-lambda

Click create

Step 3: Add Your Lambda Code
code:

Step 4: Add Environment Variable
Go to your AWS Lambda function.

Scroll down to Environment variables.

Click Edit, then Add environment variable:

Key: WEATHER_API_KEY

Value: (Your API key from OpenWeatherMap)

Step 5: Add Permissions for Internet Access
Attach an execution role with AWSLambdaBasicExecutionRole

Ensure Lambda is in a VPC that allows internet access (or no VPC for easier setup).
Check if Your Lambda Is in a VPC
Go to the Lambda Console

Open your function

Scroll to the "Configuration" > "VPC" section

If it says "Not attached to any VPC", your Lambda already has internet access

Step 6: Create API Gateway

Go to API Gateway > Create API > HTTP API > Click Build

Choose integration → Select Lambda

Select your Lambda function from the dropdown

Click Next

Method: GET

Resource path: /weather

Create a stage name — e.g., APIweather

Click Next, then Create

Step 7: Deploy & Test
Deploy the API

Test your endpoint with:
https://olxheqwg4c.execute-api.us-west-2.amazonaws.com/

I tested the endpoint URl and got this.

That is my base endpoint, but it doesn't tell us which route or resource path is configured. That’s why you’re getting:
{"message":"Not Found"}
Lets fix this error.

Check Your Lambda Integration Path:
If it's an HTTP API:
Click Routes
You’ll see something like: ANY /weather or GET /
Note the full path (e.g., /weather)

I found the error and the correct path which includes a stage name, but it's not working without it, here's exactly how to fix and use the full correct URL:
Breakdown of Your Components
Base endpoint: https://olxheqwg4c.execute-api.us-west-2.amazonaws.com

Stage name: APIweather

Route/Path: /weather-api-lambda

Query string: ?city=Lagos

This is the correct URL PATH:
https://olxheqwg4c.execute-api.us-west-2.amazonaws.com/APIweather/weather-api-lambda?city=Lagos

My API Gateway is correctly connected to your Lambda function,
But my Lambda function isn't running the weather fetching logic yet — it's still using the default "Hello from Lambda!" response.

I need to replace the "Hello from Lambda!" code in your function with the weather-fetching logic.

Open PowerShell
Press Windows + R, type powershell, and hit Enter.

Create the project folder on your local computer/desktop
mkdir lambda-weather
cd lambda-weather

Create the Python file
In the same terminal: notepad lambda_function.py

Here is the lambda code scripted inside

Save and close the notepad.
Install the requests package locally
In the same PowerShell window: pip install requests -t .

Zip everything
Still inside the lambda-weather folder: Compress-Archive -Path * -DestinationPath lambda-weather.zip

Upload to Lambda
Go to AWS Lambda console.

Choose your function.

Click Upload from → .zip file.

Select lambda-weather.zip.

Click Deploy.

Test the Function Directly (Optional)
I ran a test before setting up API Gateway:

Click the Test tab in Lambda
If it works, you’ll see a 200 OK response with weather data.

Test the API via Browser:
https://olxheqwg4c.execute-api.us-west-2.amazonaws.com/APIweather/weather-api-lambda

There you go

Brief Discussion

What problem did I solved getting weather info: I built a serverless solution to fetch real-time weather data using AWS Lambda and API Gateway. The problem was accessing weather info by city without managing servers. Now, users can get live forecasts by simply hitting a public API endpoint.

How API Gateway & Lambda work together: API Gateway acts as the front door, receiving HTTP requests and passing them to AWS Lambda. Lambda runs backend code in response, processes the request, and sends back a result. Together, they enable scalable, serverless APIs without managing servers.

How this demonstrates serverless and cloud-native skills: This project shows serverless and cloud-native skills by using AWS Lambda to run code without managing servers and API Gateway to expose it as a RESTful API. It demonstrates event-driven design, scalability, cost-efficiency, and integration of cloud services.

This project demonstrates the power of serverless architecture using AWS Lambda and API Gateway to build a scalable weather information API. It showcases my ability to integrate third-party APIs, handle cloud deployments, and write clean, resilient code.

VPC Traffic Flow and Security

Busa Ayim-Odu — Sat, 17 May 2025 16:20:28 +0000

VPC traffic flow and security control how data moves within and outside a Virtual Private Cloud. Key components include subnets, route tables, security groups, and NACLs, ensuring secure, filtered communication between resources.

Building a Virtual Private Cloud (VPC) is the first project in our networking series, and we strongly advise starting with it. This project picks up just where the last one left off!

Let's continue exploring the fundamentals of creating an Amazon Virtual Private Cloud (VPC) in VPC Traffic Flow and Security.

Prepare to:
Make a table of routes.
👮‍♀️ Establish a security group.
Make a network access control list, or ACL.

- Step 1
Configure the fundamentals of VPC.

To set up our VPC, subnet, and internet gateway, we are using the same procedures as in the first project. Come on!

Create a route table
You must still instruct the resource on your public subnet on how to access the internet, even after you have built an internet gateway and connected it to your VPC.

To route traffic from your resource to your internet gateway, you will need to set up route tables!

In your situation, any traffic that isn't bound for another resource within your VPC is bound for the internet gateway because the sole alternative route has the destination 10.0.0.0/16!

After that, the internet gateway sends this traffic to the internet, enabling communication between your resources and other networks and users.

💡 A route table: what is it?
Consider a route table to be your subnet's resources' GPS. A route table is a database of rules, or routes, that determine where the data in your network should travel, much like a GPS helps people find their way to their destination in a city.

Because the route table instructs each subnet's traffic where to send and receive data, each subnet in your VPC must be connected to it. For instance, the subnet of an EC2 instance hosting a web server (i.e., an EC2 instance) requires a route table that can determine how to route incoming traffic to the website.

💡 What connection exists between route tables and internet gateways?
A subnet is considered public when it has a route in its route table that routes internet-bound traffic to the internet gateway. This indicates that your subnet is able to connect to the internet.

- In the left navigation pane, choose Route tables.
A couple of route tables! Why are there two?

Note: If there are more than two route tables visible, they were probably put up in previous projects you worked on. To determine where each route table belongs, look to the VPC column on the far right side of the table. Pay attention to both your VPC's route table and the default one.

- Let's rename your NextWork VPC route table so it's easier to recognise.
- Make sure you have your NextWork VPC route table selected - this is the route table with a single route to 10.0.0.0/16.
- Select the pencil icon in the Name column of your route table.

- Enter the name NextWork route table.

- Select Save.

- Select the Routes tab.

- Choose Edit routes.

- Choose Add route near the bottom of the page.

- Destination: 0.0.0.0/0

The destination is 0.0.0.0/0; why is that?
For all IPv4 addresses, use 0.0.0.0/0! Any traffic that doesn't match more specific routes in your route table will be sent via the default route created when you set 0.0.0.0/0 as the destination in your route table.

- Target: Internet Gateway.
- Select NextWork IG.

- Choose Save changes.
- Choose the Subnet associations tab.

- Under the Explicit subnet associations tab, choose Edit subnet associations
- Select Public 1.

- Choose Save associations.

Since the internet gateway has connected your subnet to the Internet, it is now public!

Step 2

Create a security group

In this task, let's add a security group so that users can access resources in your VPC.

Note that we won't be creating EC2 instance in this project, but we're adding it to this diagram to illustrate a security group's scope!

- In the left navigation pane, choose Security groups. Note that this is further down the navigation pane than our other pages so far!

- Choose Create security group.

- Security group name: NextWork Security Group
- Description: A Security Group for the NextWork VPC.
- VPC: NextWork VPC
- Under the Inbound rules panel, choose Add rule.

- Type: HTTP
- Source: Anywhere-IPv4
- At the bottom of the screen, choose Create security group.

Step 3

Create a Network ACL

That's great that your VPC's traffic flow (route table) and fundamental security (security groups) are in order!

Let's add a network access control list, or ACL, to your VPC to increase its security.

- In the left navigation pane, choose Network ACLs.

Existing ACLs?

Choose the network ACL that's associated with your Public 1 subnet, and check out the tabs for Inbound rules and Outbound rules.

What are the meanings of the rules listed under the Inbound and Outbound rules tabs? Similar to security groups, network ACLs determine whether data packets are permitted to enter or exit subnets based on inbound and outgoing rules:

All incoming traffic is permitted to enter the Public Subnet under Rule 100 Inbound.

All traffic is permitted to leave the Public Subnet under Rule 100 Outbound.

Each ruleset's second line displays an asterisk (*), which serves as a catch-all rule in the event that traffic does not meet any of the preceding rules. The asterisk rule won't really apply in our situation because Rule 100 already permits all traffic.

This indicates that, unless otherwise specified, all incoming and outgoing traffic is permitted by default network ACLs.

Let's replicate this setup in the console to reinforce what we've learned! Everything we need is in your default ACL, but setting everything up from scratch is a fantastic practice.

- Select Create new network ACL.
- Name: NextWork Network ACL
- VPC: NextWork VPC
- Select Create network ACL.

- Uncheck the default network ACL you've selected.
- Select the checkbox next to NextWork Network ACL
- Select the Inbound rules tab.

- Select Edit inbound rules.
- Select Add new rule.
- Rule number: 100
💡 For what reason is the rule number 100?
Rule numbers determine the sequence in which rules are checked in network ACLs; lower numbers are checked first. You can add new rules before it if necessary by starting at 100. For instance, you can include a rule with a lower number to ensure that a certain protocol is examined first if you later want to ban it. Otherwise, starting at 100 and adding rules with larger numbers is typical procedure.

- Type: All traffic.
The Protocol and Port range fields were grayed out; why?
You no longer need to specify protocols and port ranges because your rule will be applied to all of them when you choose "All traffic" as the traffic type. Simple as abc!

- Source: 0.0.0.0/0

- Click Save changes.

For the Network ACL's outbound rules?

- Select the Outbound rules tab.
- Select Edit outbound rules.
- Select Add new rule.
- Rule number: 100
- Type: All traffic.
- Destination: 0.0.0.0/0

Well, are we done yet?

- Next to the Outbound rules tab, you should see the Subnet associations tab. Click on it.

Well, we're not done yet. There is nothing on the subnet associations tab!

- Under the Subnet associations tab, select Edit subnet associations.

- Select your Public 1 subnet.

Select Save changes.

Now check: do you have an Allow rule for both your inbound and outbound rules? Do you have a subnet association to Public 1?

Wonderful! You've done a fantastic job configuring a working VPC. Adding a network ACL, security group, and route table is a smart way to manage traffic flow and security.

Here is a summary of your VPC setup as an added bonus. Setting up an EC2 instance and hosting a web application in a public subnet would entail:

💻 Client/User: A user hits enter after entering your website's URL in their browser.

🚪 Internet Gateway: The user's browser sends the request to your internet gateway, NextWork IG, via the internet.

🌐 VPC: The internet gateway sends the user's request to NextWork VPC, the VPC to which it is connected.

🚏 Route Table: Traffic is routed to your EC2 instance hosting the website via your VPC's NextWork route table for your public subnet. The user's request is added to the route table's local route.

📋 Network ACL: The request must go via the network ACL linked to your public subnet on its way to your EC2 instance. Your request is accepted because the network ACL includes an inbound rule (rule 100) that allows traffic from any location (0.0.0.0/0).

🥅 Public Subnet: The request proceeds to your EC2 instance within your public subnet, Public 1.

Security Group: NextWork Security Group, which is connected to the EC2 instance, receives the request. The request can go through because the security group contains an incoming rule that permits HTTP traffic (Port 80) from any location (0.0.0.0/0).

EC2 Instance: Your EC2 instance, which hosts the website, receives the request. The EC2 instance's web server prepares the response after processing the request.

💻 Data is returned: The user receives the content of the website. Outgoing traffic passes via the network ACL, route table, VPC, security group, public subnet, and intern

Well done!

You just finished the project for today and created your own VPC with network ACLs, security groups, and route tables.

Completed WOOOOOOOOOOOOOOO! 🙌 All hands up.

Construct a Private Cloud Virtually

Busa Ayim-Odu — Fri, 16 May 2025 12:38:43 +0000

Technical Description: Construct a Private Cloud Virtually (VPC)

This project involves creating a secure and isolated Virtual Private Cloud (VPC) within a public cloud platform such as AWS, Azure, or GCP. It includes configuring custom IP ranges, subnets (public and private), route tables, internet and NAT gateways, and implementing Security Groups and Network ACLs for traffic control. Virtual machines are launched in appropriate subnets, with private resources accessing the internet via NAT. The setup ensures secure communication and resource segmentation. Infrastructure as Code (e.g., Terraform) may be used for automation. This project showcases essential cloud networking, security, and deployment skills.

- Step 1
Create a VPC

Off we go! Let's kick things off by creating a VPC.

In this step, get ready to:

Access the VPC console in AWS.

In the AWS Management Console search field, type VPC.
Select VPC from the drop down menu.
In the left navigation pane, choose Your VPCs
Make sure you're on the Region that's closest to you. Use the dropdown on the top right hand corner to switch Regions.
You'll notice that there is already a VPC in your account!
Choose Create VPC.
Choose VPC Only.
Name tag: NextWork VPC
IPv4 CIDR: 10.0.0.0/16
Select Create VPC to finish setting up your VPC.

- Step 2
Establish subnets

Good! We've constructed our VPC, which is like building up a completely new city in your AWS Region.

Until we divide our new city into distinct neighborhoods or regions, it is merely a vast open expanse. To begin organizing where various resources will reside and function, you must next partition this vast area into smaller areas known as subnets.

In this phase, prepare to:
Get your VPC's subnet up and running.

In the VPC Dashboard, under Virtual Private Cloud, choose Subnets.
Ooo, there are already subnets in here!
Choose Create subnet.

Configure your subnet settings:
VPC ID: NextWork VPC
Subnet name: Public 1
Availability Zone: Select the first Availability Zone in the list.
IPv4 VPC CIDR block: 10.0.0.0/16
IPv4 subnet CIDR block: 10.0.0.0/24

Choose Create subnet.
Select the checkbox next to Public 1.
In the Actions menu, select Edit subnet settings.

Check the box next to Enable auto-assign public IPv4 address.

Choose Save.

- Step 3

Construct an internet gateway.

VPC completed!

** Subnet completed!**

This project's final step is to connect your VPC to an internet gateway. In order for your resources to communicate outside of your private area, it is similar to constructing an internet gateway, or bridge, that connects your private city (VPC) to the outside world.

In this step, get ready to:

Connect your VPC to the internet using a internet gateway.
In the left navigation pane, choose Internet gateways.

What is an internet gateway?

An internet gateway connects your city** (VPC) and the outside world **(internet).

Internet gateways are key to making applications available on the internet. By attaching an internet gateway, your instances can access the internet and be accessible to external users.

Aha! An existing internet gateway.

Choose Create internet gateway.

Configure your internet gateway settings:
Name tag: NextWork IG
Choose Create internet gateway.
Select your newly created internet gateway and choose Actions, then Attach to VPC.
Select NextWork VPC.
Select Attach internet gateway.

Well done on building an internet gateway and connecting it to your virtual private cloud!

We need to demonstrate to traffic in your public subnet how to locate the internet gateway in your VPC in order to access the internet.

We've just completed today's project and set up your very own virtual private cloud with Amazon VPC.

Amazon VPC is a service that lets you create a private, isolated network in AWS. It’s useful because it gives full control over IP ranges, subnets, routing, and security, helping you securely run resources in the cloud.

Today you've learnt how to:

☁️ Create a VPC: You've taken your first steps by setting up a Virtual Private Cloud (VPC) using Amazon VPC.

🥅 Create subnets: Moving deeper into your VPC, you created subnets, which act like neighborhoods within your city, each with unique access rules. You learned the difference between public and private subnets and set up a subnet to allow instances within it to automatically receive public IP addresses, making them accessible from the internet.

🚪 Set up an internet gateway: Lastly, you added an internet gateway to your VPC, acting as the main gate that allows data to flow in and out. This setup is essential for any applications that require internet access, such as web servers. You've configured the gateway and linked it to your VPC, ensuring your public instances can reach the outside world and vice versa.

🚏 Bonus - configure IP addresses and CIDR blocks: You've configured your VPC with an IPv4 CIDR block, understanding that IP addresses are like street addresses for your resources! You explored how different CIDR blocks dictate the size and scale of your VPC.

It's wild that all these learnings are packed in one project.

Keep it up in the next project of this series on VPC Traffic Flow and Security!

Cheers!

Containerizing a Node.js Application with Docker

Busa Ayim-Odu — Sat, 22 Mar 2025 12:59:27 +0000

Containerizing an application allows you to package your code along with all dependencies into a portable unit called a container. This guide walks you through the process of containerizing a simple to-do list manager built with Node.js. No prior experience with JavaScript is required.

Prerequisites

Before getting started, ensure you have the following installed on your system:

Docker Desktop (latest version)

Git client (for cloning repositories)

An IDE or text editor (e.g., Visual Studio Code)

Step 1: Get the Application Source Code

First, you need to obtain the source code for the application.

Open your terminal or command prompt.

Clone the repository using the following command:

git clone https://github.com/docker/getting-started-app.git

Navigate to the project directory:

cd getting-started-app

View the contents of the cloned repository:

You should see the following files and directories:

├── getting-started-app/
│ ├── .dockerignore
│ ├── package.json
│ ├── README.md
│ ├── spec/
│ ├── src/
│ └── yarn.lock

Step 2: Create a Dockerfile

A Dockerfile is a script containing instructions to build a container image.

Inside the getting-started-app directory, create a new file named Dockerfile.

- Navigate to the Project Directory
cd C:\Users\LAPTOP\DockerProjects\getting-started-app

-Create the Dockerfile

Run this command to create a new empty file named Dockerfile: New-Item -Path . -Name "Dockerfile" -ItemType "File"

-Open the Dockerfile in a Text Editor
To edit the Dockerfile, run: code Dockerfile

Add the following contents: Copy and paste the following into the file:

syntax=docker/dockerfile:1

FROM node:lts-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "src/index.js"]
EXPOSE 3000

In VS Code, press Ctrl + S and close the file.

- Verify the Dockerfile Exists
Run the following command to confirm the file was created: Get-ChildItem

You should see Dockerfile listed among the files. Now you have successfully created a Dockerfile!

Step 3: Build the Docker Image

Open a terminal and navigate to the getting-started-app directory.

Run the following command to build the image:

docker build -t getting-started .

The -t flag tags the image as getting-started.

The . at the end specifies that the Dockerfile is in the current directory.

Docker will download necessary dependencies and build the image.

- Verify the Image is Built
After the build completes, check if the image was created: docker images

You should see getting-started in the list.

Step-by-Step Guide to Running Your Docker Container
Step 4: Ensure Your Image is Built
First, confirm that your getting-started Docker image was built successfully.
Run the following command: docker images

Run the Container
Now, start the container using the following command:
docker run -d -p 127.0.0.1:3000:3000 getting-started

Explanation:

-docker run → Starts a new container

-d → Runs in detached mode (background)

-p 127.0.0.1:3000:3000 → Maps port 3000 inside the container to port 3000 on your computer

-getting-started → The name of the image

Open the App in Your Browser
1 Open your browser
2 Go to http://localhost:3000
3 You should see the To-Do List App running 🎉

Verify Running Containers
Check if your container is running with: docker ps

Stop the Container (Optional)
If you want to stop the running container, use:

docker stop

Replace with the actual container ID from docker ps output.

🎯 Summary of What You Did
✅ Cloned a Node.js application
✅ Created a Dockerfile
✅ Built a Docker image
✅ Started the app in a Docker container
✅ Accessed the app via http://localhost:3000
✅ Verified running containers

In addition:

What is Node.js?

🚀 Node.js is a JavaScript runtime that allows you to run JavaScript outside of the browser.

🛠️ Key Features of Node.js
1️⃣ Built on Chrome's V8 Engine → Super fast JavaScript execution ⚡
2️⃣ Non-blocking, Asynchronous → Handles multiple requests at once without waiting ⏳
3️⃣ Uses JavaScript → If you know JS, you can build backend apps with Node.js easily 🏗️
4️⃣ Lightweight & Scalable → Great for building APIs, microservices, and real-time apps 📡

🖥️

What is Node.js Used For?

✅ Web servers & APIs (e.g., Express.js)
✅ Real-time apps (e.g., chat applications, live updates)
✅ Microservices & serverless computing
✅ CLI tools & automation scripts

🎉 Congratulations! You have successfully containerized and run an application using Docker. 🚀

Configure Your Cloud Infrastructure using Terraform and AWS CLI: A Step-by-Step Tutorial

Busa Ayim-Odu — Tue, 04 Feb 2025 07:30:40 +0000

Configure Your Cloud Infrastructure using Terraform and AWS CLI: A Step-by-Step Tutorial

Introduction

In this tutorial, you will learn how to set up an EC2 instance on Amazon Web Services (AWS) using Terraform and the AWS CLI. EC2 instances are virtual machines that run on AWS and are widely used in cloud infrastructure projects.

Prerequisites

To follow along with this tutorial, ensure you have:

Terraform CLI (version 1.2.0 or later) installed
AWS CLI installed
An AWS account with the necessary credentials to create resources

IAM credentials configured using environment variables or AWS CLI

Step 1: Configure AWS Credentials

Log into your AWS portal.

Click on your username in the top-right corner and select Security Credentials.

Under Access Keys, click Create access key.

Check the "I Understand" box and click Create.

Copy the Access Key and Secret Key.

Configure AWS CLI

Open your terminal and enter:

Run these command: terraform --version
Second command: aws --version

Follow the prompts and enter your:

AWS Access Key ID

AWS Secret Access Key

Default region name (e.g., us-east-1)

Output format (e.g., json or table)
But in this case, I left it as default

Step 2: Set Up Your Terraform Project

Create a working directory and navigate into it:

mkdir terraformtask

cd terraformtask

Open a new file named main.tf in a text editor and add the following configuration:

terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 4.16"
}
}

required_version = ">= 1.2.0"
}

provider "aws" {
region = "us-west-2"
}

resource "aws_instance" "app_server" {
ami = "ami-830c94e3"
instance_type = "t2.micro"

tags = {
Name = "ExampleAppServerInstance"
}
}

Step 3: Initialize Terraform

Run the following command to initialize the directory and download required provider plugins:

terraform init

Step 4: Format, Validate, and Apply Configuration

Before applying the configuration, format and validate the files:
terraform fmt
terraform validate

If validation passes, apply the configuration:

terraform apply

Type yes when prompted to confirm.

Step 5: Verify the Infrastructure

To check the current state of your infrastructure, run:

terraform show

This command displays the details of the provisioned resources.

Conclusion

Congratulations! You have successfully deployed an EC2 instance using Terraform and AWS CLI. This process is the foundation for automating cloud infrastructure deployment.

For more information, explore the Terraform Registry and the AWS Provider Documentation.

NGINX Configuration for DevOps.

Busa Ayim-Odu — Thu, 30 Jan 2025 12:45:55 +0000

This task has two major parts:

Install and configure NGINX on an Ubuntu server.
Write a blog article about your experience.

Part 1: Installing and Configuring NGINX
You will install NGINX, a web server, on an Ubuntu system and configure it to serve a custom HTML page.

Step 1: install NGINX.
Open the Ubuntu terminal.

Update the package lists: sudo apt update

After performing the command sudo apt update, the programming went smoothly, except for these errors, which indicate that my Ubuntu system failed to download package index files from the required repositories. Now we will try and fix this errors with the following commands below:

ping -c 4 google.com
If you receive responses like "64 bytes from...", your internet is working properly.
If not, check your network configuration.
Second Command: sudo apt update --fix-missing

So, obviously, this error has not been cleared away, but it does impede the task in any manner. W: Failed to load https://download.docker.com/linux/ubuntu/dists/noble/InRelease. Cannot wait for server fd - choose (11: Resource temporarily unavailable) [IP: 108.157.78.123 443]

Install NGINX:sudo apt install nginx -y

The installation went well and port 80 is already in use.

Check if NGINX is running:sudo systemctl status nginx
After running the above command I ran into the errors and I have to find a way to fix it.

Solution: Stop the Docker Container Using Port 80
1️⃣ Find the Docker container using port 80
Run this command: sudo docker ps

Look for the container that is exposing port 80 in the PORTS column (e.g., 0.0.0.0:80->80/tcp).

2️⃣ Stop the container
Replace with the actual container ID from the previous command:sudo docker stop

There was a running Nginx called b4e00baaddbb that needed to be stopped before proceeding with the task.

3️⃣ Confirm that Docker has released port 80
Run: sudo lsof -i :80
If nothing appears after this command, Docker has stopped using the port.

4️⃣ Restart Nginx
Now, restart Nginx and check its status:sudo systemctl restart nginx
sudo systemctl status nginx

If everything is working, it should show active (running). As shown above in the imaged pointing at the command.

Enable it to start on boot: sudo systemctl enable nginx

Step 2: Create a Custom HTML Page
Open the default index.html file: sudo nano /var/www/html/index.html

Save and exit:

Press CTRL + X, then Y, then Enter.

Step 3: Restart NGINX
Apply the changes:sudo systemctl restart nginx

Step 4: Find Your IP Address
Run this command: ip a

Step 5: Test in a Browser
Open your browser and go to: http:///
http://192.168.129.128

You should see:
"Welcome to DevOps Stage 0 - Busa Ayim-Odu/chilled_guy"

Challenges and Solutions

Problems I Ran into

To fix APT update issues, ensure network access and run sudo apt update --fix-missing.

Port 80 is already in use. I identified and halted the running Docker container.

The NGINX service fails to start: I restarted NGINX after fixing the port problem.

How Does This Task Help My Career?

The importance of NGINX in DevOps

Web server and reverse proxy: NGINX is commonly used for website hosting and load balancing.

Real-world troubleshooting: Debugging service faults is an essential DevOps skill.

Hands-on experience: This assignment helped me strengthen my Linux server management skills.

Reference Links

I used the following links:

DevOps engineers

Cloud engineers

This work taught me how to set up and debug web servers, which is crucial for DevOps tasks.

Creating a Storage Bucket in AWS Using S3.

Busa Ayim-Odu — Tue, 10 Dec 2024 21:04:47 +0000

Project: Creating a Storage Bucket in AWS Using S3

This guide walks you through creating an AWS S3 bucket, a widely used service for scalable, durable, and secure cloud storage.

Step-by-Step Instructions

Step 1: Log in to AWS Management Console Go to the AWS Management Console. Enter your credentials to access your AWS account. -Step 2: Navigate to S3 In the AWS Console, search for S3 in the search bar at the top. Click on S3 to open the service dashboard. -Step 3: Create a New Bucket Click the "Create bucket" button.

Fill in the following fields:
Bucket Name: Enter a unique name (e.g., my-storage-bucket2).
AWS Region: Choose the region closest to your users or application (e.g., us-east-1).

Configure optional settings:

Block Public Access Settings: Leave the default settings for now to block all public access.
Versioning: Enable this if you want to keep multiple versions of objects for recovery.
Encryption: Choose AES-256 or SSE-S3 for data security.
Click "Create bucket" at the bottom.
Step 4: Upload Objects to the Bucket
Click on the name of your newly created bucket to open it.

Select "Upload" to add files.

Drag and drop files or browse to select them from your local machine.

Click "Upload" to transfer the files to your bucket.
Step 5: Set Bucket Permissions (Optional)
Navigate to the Permissions tab.
Select a Storage class and click upload.
Step 6: Access the Bucket and Files
Each uploaded object gets a unique URL.

Go to the Objects tab and click on an object to view its details.

Creating a Presigned URL.

Copy the Object URL to share or access the file.

Step 7: Automate and Manage Storage (Optional) Lifecycle Policies: Set up rules to move objects to cheaper storage tiers or delete them after a specified time.

Conclusion
Congratulations! You’ve successfully created and configured an AWS S3 bucket for your storage needs. S3 buckets can be used for various purposes like hosting static websites, backing up data, or storing application assets.

For further exploration, try enabling features like Bucket Metrics or configuring Access Logs to monitor usage and performance. Thank you for you time!

How to Create an AWS Account, Launch a Windows EC2 Instance, and Install IIS

Busa Ayim-Odu — Sun, 08 Dec 2024 14:46:40 +0000

Introduction
Creating an EC2 instance on AWS is one of the first steps to getting started with cloud computing. In this guide, you'll learn how to:

Create an AWS account.

Launch a Windows EC2 instance.
Install IIS (Internet Information Services) on the Windows instance using the command prompt. Whether you're a beginner or someone brushing up on AWS basics, this tutorial has you covered!

Step 1: Create an AWS Account
To begin, you'll need an AWS account. Here's how:

Visit the AWS Signup Page.
Click Create an AWS Account.
Fill in the required details, including:
Email address
Password
Account name

Once your account is created, sign in to the AWS Management Console.

-Step 2: Launch a Windows EC2 Instance
Navigate to the AWS Management Console.
Search for EC2 in the services search bar and click on it.

Click the Launch Instances button.
Configure your instance:
Name: Give your instance a name (e.g., "Windows-IIS-Test").
AMI: Choose Microsoft Windows Server (e.g., Windows Server 2019 Base).

Instance Type: Select a type like t2.micro (free tier eligible).
Key Pair: Create or select an existing key pair to securely connect to your instance.

Network Settings: Ensure that RDP (3389) is allowed in the security group.
Review the settings and click Launch Instance.

Step 3: Connect to Your Windows Instance
Once the instance is running, select it from the EC2 dashboard.
Click Connect and select the RDP Client tab.

Download the Remote Desktop File and retrieve the password:
Click Get Password and upload the private key file you downloaded earlier.

Decrypt and copy the password.

Use the Remote Desktop Protocol (RDP) to connect to the instance:
Open the downloaded .rdp file in your Remote Desktop client.

Enter the username (Administrator) and the decrypted password.

Step 4: Install IIS on the Windows Instance
Once connected to the instance, open the Command Prompt with administrative privileges.

Run the following command to install IIS:

Powershell
Copy code
Install-WindowsFeature -Name Web-Server -IncludeManagementTools

This command:
Installs the IIS Web Server role on the Windows instance.
Includes the management tools needed for configuration.
Once the installation is complete, verify that IIS is running:

Open a web browser on your instance.
Enter http://localhost in the address bar.
You should see the default IIS welcome page.

Step 5: Access the IIS Server from Your Local Machine To make the IIS server accessible from your local machine:

Go to the EC2 Dashboard.
Edit the Security Group attached to your instance.
Add a new inbound rule:
Type: HTTP
Protocol: TCP
Port Range: 80
Source: Anywhere (0.0.0.0/0) or your specific IP address.
Save the changes and access your server by visiting the public IP address of your EC2 instance in your local browser:
http://

Conclusion
Congratulations! You've successfully:

Created an AWS account.
Launched a Windows EC2 instance.
Installed IIS and accessed it from your local machine.
This setup is a great starting point for deploying Windows-based web applications in AWS. Let me know in the comments if you have questions or ideas for extending this tutorial!

Creating Azure DevTest Labs!

Busa Ayim-Odu — Mon, 25 Nov 2024 13:14:52 +0000

Creating an Azure DevTest Lab allows developers and testers to quickly set up and manage isolated environments for building, testing, and experimenting with applications. It provides an efficient, cost-effective solution by leveraging virtual machines and automating infrastructure setups, enabling teams to speed up their development cycles.

In azure portal search for dev test labs and select.
Click on +create.
Give your resource group a name. For example, ayimrg.
Select Auto -shutdown, enable it to on, input the time you want it to shut-down(9pm), activate send notification before shut-down to No.
Once the review and create is successful, it will be deployed for us.

Conclusion:
Azure DevTest Labs simplify the process of managing development and testing environments. With features like cost management, automated deployments, and integration with other Azure services, it allows teams to focus on creating and testing applications without the complexity of managing infrastructure. By using DevTest Labs, organizations can optimize their resources while reducing costs and improving productivity.

Let me know if you'd like to expand on any part or need further help!

LINUX GUIDE USING UBUNTU

Busa Ayim-Odu — Thu, 14 Nov 2024 17:37:13 +0000

Linux is an open-source, Unix-like operating system kernel created by Linus Torvalds in 1991. The kernel is the core part of the operating system, managing system resources and hardware interactions.

This is a thorough template for an Ubuntu learning guide that covers everything from downloading Multipass **to **system information, file and directory operations, search and locate, and text file editing. Ubuntu is a popular Linux distribution developed by Canonical.

Download and configure Ubuntu Desktop:

https://ubuntu.com/download/desktop.
After download follow the default setting to install.
After it has been successfully installed, it appears like this. Go ahead, configure and start running any virtual machine.
This is what it looks like once it is ready for use: To run command as an administrator (user "root"), use "sudo "

I'll now go over how to use Powershell to operate an Ubuntu virtual machine.

We begin by identifying the "Root user" and using this command to do so "sudo su" as seen below.

Navigating the file system

pwd: Print working directory. Shows the current path.
ls: List directory/file content. These shows the contents in the directory/file as shown below. Although we haven't done anything but the command is important and will revisit it.
mkdir: To create a directory/file. Make we will be create some and listing them out using the ls command.
ls -l: shows directory/files with detailed information.
cd ..: Move you in and out directory level. cd as means change directory.
To play around with firsts of commands and introduce some common commands like:
history: this shows you all commands carried out
exit: Exit the root/ or current path.
clear: Clear the terminal
touch: to create an empty file. touch newfile.txt
cp: Copy file or directory. I copied a file into directory Busaspace1 and leaving the original copy in it folder
mv: move file to different locations/paths. Just like the command "cp". Moving a file to directory Busaspace2.
rm: This command remove/delete files.
rmdir: This command remove/delete directory.

Viewing and Editing files

cat: Display the contents of a file. After editing a file using the command "vim", I used cat to show the content edited without opening the whole file

vim: is an editor. Open file and allows you to edit a file after pressing the i key for insert.

System Information and Management

uname -a: Display detailed information about the system

df -h: Display disk space usage.

free -h: Displays usage and available space

top: Display running process and system resource usage. And to stop it press Ctrl C if the terminal keeps running.

Search and Find/Locate

-grep [pattern or search item][file]: Search for a pattern within a file.

How to quit a text editor

![quit](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/72mid4izrxay8kwns4pw.png\

Task

How does one quit a vim file?
how do you list the content of a directory?
what command can be used to delete the content of a directory?
What command can be used to switch from a normal user to a root user?