DEV Community: SUBAIR NURUDEEN ADEWALE

Automated Azure Multi-VM Private Networking with Terraform (Infrastructure as Code

SUBAIR NURUDEEN ADEWALE — Fri, 27 Feb 2026 17:42:49 +0000

Introduction

This project demonstrates how to design and deploy a secure multi-virtual machine environment on Microsoft Azure using Terraform Infrastructure as Code (IaC) principles.

The infrastructure provisions two Linux virtual machines within the same virtual network and subnet, enabling private communication between them without manual configuration inside the operating systems.

By using reusable Terraform modules for networking and compute resources, the deployment follows real-world DevOps practices such as automation, modular design, resource dependency management, and cloud governance through tagging.

The project validates internal connectivity at the infrastructure level using Azure networking diagnostics, proving that both virtual machines can communicate securely over private IP addresses.

Project Objective

The objective of this project is to build a production-style cloud infrastructure that demonstrates practical skills in cloud automation, networking architecture, and Infrastructure as Code.

Specifically, the project aims to:

Automate Azure resource provisioning using Terraform
Deploy and configure two Linux virtual machines
Design a virtual network and subnet for private communication
Implement network security rules allowing internal ICMP traffic
Validate VM-to-VM connectivity without logging into the machines
Apply modular Terraform design for reusable infrastructure
Demonstrate real-world DevOps and Cloud Engineering practices

Architecture You’ll Build

Both VMs can ping each other because:

Same subnet
NSG allows internal traffic
Private networking

Step 1 Create terraform root project folder
Create the directory and create the provider.tf file inside it (Mkdir terraform-azure-2vm-network/provider.tf)

Mkdir terraform-azure-2vm-network
cd terraform-azure-2vm-network
New-item or touch provider.tf

Copy this configuration code into the provider.tf file

terraform {
  required_version = ">= 1.5.0"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.100"
    }
  }
}

provider "azurerm" {
  features {}
}

Create the terraform-azure-2vm-network/variables.tf file
New-item or touch variables.tf

Copy and paste this config into the variables.tf files

variable "location" {
  default = "East US"
}

variable "rg_name" {
  default = "rg-2vm-network"
}

variable "admin_username" {
  default = "azureuser"
}

variable "admin_password" {
  sensitive = true
}

variable "vm_size" {
  default = "Standard_B1s"
}

Create the terraform-azure-2vm-network/terraform.tfvars file
New-item or touch terraform.tfvars

Copy and paste this config into the terraform.tfvars files

admin_password = "P@ssword12345!"

Create the terraform-azure-2vm-network/main.tf file
New-item or touch main.tf

Copy and paste this config into the main.tf files

# Resource Group
resource "azurerm_resource_group" "rg" {
  name     = var.rg_name
  location = var.location
}

# Network Module
module "network" {
  source              = "./modules/network"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
}

# VM 1
module "vm1" {
  source              = "./modules/linux_vm"
  vm_name             = "vm-1"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  subnet_id           = module.network.subnet_id
  nsg_id              = module.network.nsg_id
  admin_username      = var.admin_username
  admin_password      = var.admin_password
  vm_size             = var.vm_size
}

# VM 2
module "vm2" {
  source              = "./modules/linux_vm"
  vm_name             = "vm-2"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  subnet_id           = module.network.subnet_id
  nsg_id              = module.network.nsg_id
  admin_username      = var.admin_username
  admin_password      = var.admin_password
  vm_size             = var.vm_size
}

Create the terraform-azure-2vm-network/outputs.tf file
New-item or touch outputs.tf

Copy and paste this config into the outputs.tf files

output "vm1_private_ip" {
  value = module.vm1.private_ip
}

output "vm2_private_ip" {
  value = module.vm2.private_ip
}

output "ping_instruction" {
  value = "VMs are in same subnet — they can ping using private IPs"
}

Step 2 Create terraform Network Modules **
Create the parent folder **Modules and Create the sub-folder Network and Create the file Variable.tf inside the Network folder.

mkdir Modules
cd Modules
mkdir Network
cd Network
New-item variables.tf

Copy this config into the modules/network/variables.tf

variable "location" {}
variable "resource_group_name" {}

Create the modules/network/main.tf file
New-item or touch main.tf

Copy this config into the main.tf file

resource "azurerm_virtual_network" "vnet" {
  name                = "vnet-2vm"
  address_space       = ["10.0.0.0/16"]
  location            = var.location
  resource_group_name = var.resource_group_name
}

resource "azurerm_subnet" "subnet" {
  name                 = "subnet-2vm"
  resource_group_name  = var.resource_group_name
  virtual_network_name = azurerm_virtual_network.vnet.name
  address_prefixes     = ["10.0.1.0/24"]
}

# Network Security Group allowing internal ping
resource "azurerm_network_security_group" "nsg" {
  name                = "nsg-2vm"
  location            = var.location
  resource_group_name = var.resource_group_name
}

resource "azurerm_network_security_rule" "allow_icmp" {
  name                        = "Allow-Internal-ICMP"
  priority                    = 100
  direction                   = "Inbound"
  access                      = "Allow"
  protocol                    = "Icmp"
  source_port_range           = "*"
  destination_port_range      = "*"
  source_address_prefix       = "VirtualNetwork"
  destination_address_prefix  = "VirtualNetwork"
  resource_group_name         = var.resource_group_name
  network_security_group_name = azurerm_network_security_group.nsg.name
}
resource "azurerm_network_security_rule" "allow_ssh" {
  name                        = "allow-ssh"
  priority                    = 200
  direction                   = "Inbound"
  access                      = "Allow"
  protocol                    = "Tcp"
  source_port_range           = "*"
  destination_port_range      = "22"
  source_address_prefix       = "*"
  destination_address_prefix  = "*"

  resource_group_name         = var.resource_group_name
  network_security_group_name = azurerm_network_security_group.nsg.name
}

Create the modules/network/outputs.tf file.
New-item or touch outputs.tf
Copy this Config into the outputs.tf file

output "subnet_id" {
  value = azurerm_subnet.subnet.id
}

output "nsg_id" {
  value = azurerm_network_security_group.nsg.id
}

Step 3 Create the LINUX VM Module.

Create the sub folder directory linux_vm/variables.tf inside the parent folder Modules.

mkdir linux_vm
cd linux_vm
New-item variables.tf or touch variables.tf

Copy the config into the variables.tf files

variable "vm_name" {}
variable "location" {}
variable "resource_group_name" {}
variable "subnet_id" {}
variable "nsg_id" {}
variable "admin_username" {}
variable "admin_password" {}
variable "vm_size" {}

Create the file modules/linux_vm/main.tf and copy the config into the file.
New-item main.tf

resource "azurerm_network_interface" "nic" {
  name                = "${var.vm_name}-nic"
  location            = var.location
  resource_group_name = var.resource_group_name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = var.subnet_id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.public_ip.id
  }
}

resource "azurerm_network_interface_security_group_association" "assoc" {
  network_interface_id      = azurerm_network_interface.nic.id
  network_security_group_id = var.nsg_id
}

resource "azurerm_linux_virtual_machine" "vm" {
  name                = var.vm_name
  resource_group_name = var.resource_group_name
  location            = var.location
  size                = var.vm_size

  admin_username = var.admin_username
  admin_password = var.admin_password
  disable_password_authentication = false

  network_interface_ids = [
    azurerm_network_interface.nic.id
  ]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "0001-com-ubuntu-server-jammy"
    sku       = "22_04-lts"
    version   = "latest"
  }
}

Create the file modules/linux_vm/outputs.tf and copy the config into the outputs.tf file.

New-item or touch outputs.tf

output "private_ip" {
  value = azurerm_network_interface.nic.private_ip_address
}

Step 4 Run terraform

Inside project root:

terraform init

terraform plan

terraform apply
You will be prompted
Do you want to perform these actions?
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.

Enter a value: yes

*Step 5 Get Ping vm2 from vm1 to confirm communication
use the command

az vm run-command invoke --resource-group rg-2vm-network --name vm-1 --command-id RunShellScript --scripts "ping -c 4 10.0.1.5"

Ping vm1 from vm2 to confirm communication

az vm run-command invoke --resource-group rg-2vm-network --name vm-1 --command-id RunShellScript --scripts "ping -c 4 10.0.1.5"

Step 6 Clean up resource
Run the command terraform destroy

Conclusion

This project successfully demonstrates the practical implementation of Infrastructure as Code using Terraform with the AzureRM provider on Microsoft Azure. Two Linux virtual machines were provisioned within the same virtual network and subnet, configured with appropriate network security rules, and validated for secure internal communication using private IP addressing.

By enabling controlled ICMP traffic through a Network Security Group and verifying connectivity via Azure Run Command, the deployment confirms that both virtual machines can communicate without relying on public exposure. This reflects real-world cloud architecture practices where internal services interact securely within isolated network boundaries.

Beyond resource provisioning, this project showcases end-to-end cloud engineering workflow: modular Terraform structure, reusable infrastructure components, network configuration, security rule management, and operational validation through command-line automation. It highlights the ability to design, deploy, and verify scalable cloud infrastructure using modern DevOps practices.

Deploy .NET 8 App to Azure Kubernetes Service (AKS)

SUBAIR NURUDEEN ADEWALE — Tue, 10 Feb 2026 22:09:02 +0000

Introduction

Modern software delivery increasingly relies on cloud-native technologies such as containers, Kubernetes, and automated deployment pipelines. This project demonstrates the end-to-end process of building, containerizing, and deploying a .NET 8 Web API to Azure Kubernetes Service (AKS) using industry best practices.

By developing a Weather Forecast API, the project simulates a real-world DevOps workflow where applications are tested locally, packaged with Docker, stored in Azure Container Registry, deployed to Kubernetes, and automatically updated through CI/CD. The goal is to gain practical experience in deploying scalable and production-ready applications in a cloud environment.

Architecture Flow

Prerequisites

Required Software
Install the following tools in this order:

Visual Studio Code
.NET 8 SDK
Git
Docker Desktop,Start Docker Desktop after installation
Azure CLI
kubectl
GitHub CLI (optional but recommended)
Required Accounts
GitHub account (free)
Azure account (free tier available)

Verify Installations
Run the following commands:

dotnet --version
git --version
docker --version
az --version
kubectl version --client

If any command fails, fix it before proceeding.

Step 1: Create and Test the .NET Application Locally
Why This Step Matters
You never deploy untested code.

Testing locally allows you to:

Catch errors early
Validate endpoints
Avoid expensive cloud debugging

1.1 Create Project Structure

Use the command to create directory and to enter into the directory

mkdir weather-app-demo
cd weather-app-demo
mkdir WeatherApp
cd WeatherApp

1.2 Initialize the .NET Web API

dotnet new webapi -minimal

This creates a minimal API with fewer files and faster startup.

1.3 Add Required Packages

This command adds the Health Checks library to your .NET project.

In simple terms:
It installs a package that allows your app to report whether it is healthy or not.

dotnet add package Microsoft.Extensions.Diagnostics.HealthChecks

dotnet add package Swashbuckle.AspNetCore
This installs Swagger support into your .NET Web API project.

Swashbuckle is the library that automatically generates:

API documentation
Interactive testing UI In Simple Terms: It gives you a web page where you can see and test all your API endpoints.

Code .

It opens the current folder in Visual Studio Code.

1.4 Replace Program.cs

var builder = WebApplication.CreateBuilder(args);

// Services
builder.Services.AddHealthChecks();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Kestrel config for containers
builder.WebHost.ConfigureKestrel(options =>
{
    options.ListenAnyIP(8080);
});

var app = builder.Build();

// Middleware
app.UseSwagger();
app.UseSwaggerUI();

// Endpoints
app.MapGet("/", () => new
{
    Message = "Welcome to the Weather App!",
    Version = "1.0.0",
    Timestamp = DateTime.UtcNow
});

app.MapGet("/weather", () =>
{
    var summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool",
        "Mild", "Warm", "Hot", "Scorching"
    };

    return Enumerable.Range(1, 5).Select(i => new
    {
        Date = DateOnly.FromDateTime(DateTime.Now.AddDays(i)),
        TemperatureC = Random.Shared.Next(-20, 40),
        Summary = summaries[Random.Shared.Next(summaries.Length)]
    });
});

// Health endpoint for Kubernetes
app.MapHealthChecks("/health");

app.Run();

1.5 Test Locally

dotnet run

Test endpoints:

http://localhost:8080/

http://localhost:8080/weather

http://localhost:8080/swagger

http://localhost:8080/health

If this works, your app is ready for containerization.

Step 2: Containerize the Application with Docker

Why Containerize?
Containers ensure:

Same runtime everywhere
No “works on my machine” issues
Smooth Kubernetes deployment

2.1 Create Dockerfile

Use the command touch or New-item Dockerfile

Copy the docker instruction into the dockerfile

# Runtime
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 8080

# Build
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY weatherApp.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

# Final image
FROM base
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "weatherApp.dll"]

2.2 Create .dockerignore
Use the command touch or New-item .dockerignore

Copy the code into the .dockerignore file.

bin/
obj/
.vs/
.vscode/
.git/
.gitignore
Dockerfile
README.md
*.log

2.3 Build and Test Container Locally

docker build -t weather-app:local .

docker run -p 8080:8080 weather-app:local

Test again in browser or with curl.
If it works locally, it will work in AKS.

Step 3: Create Azure Infrastructure

3.1 Login to Azure
use the command az login or az login --allow-no-subscriptions
once prompted to select a subscription or tenant ID, Click on the ENTER key on your keyboard.

3.2 Create Resource Group
az group create --name student-demo --location eastus

3.3 Create Azure Container Registry (ACR)

3.3.1 Register your subscription to use Microsoft.ContainerRegistry

Use the command to register the service az provider register --namespace Microsoft.ContainerRegistry
and use az provider show --namespace Microsoft.ContainerRegistry --query registrationState to check the registration status.

3.3.2 Create Azure Container Registry (ACR)
Use the command to create Azure Container Registry and give it a Unique name.
az acr create --resource-group student-demo --name studentdemoacr --sku Basic

3.4 Build & Push Image Using ACR

az acr build --registry studentdemoacr --image weather-app:latest . or Instead of using az acr build, you can:

Build locally with Docker and push manually

docker build -t skillstudentdemoacr.azurecr.io/weather-app:latest .

*Login into Azure Container registry *

az acr login --name skillstudentdemoacr

Push image to Azure Container registry

docker push skillstudentdemoacr.azurecr.io/weather-app:latest

3.5 Create AKS Cluster with ACR Attached

az provider register --namespace Microsoft.ContainerService
use this to check the status az provider show --namespace Microsoft.ContainerService --query registrationState

Create aks cluster

az aks create --resource-group student-demo --name skillstudent-aks --node-count 1 --attach-acr skillstudentdemoacr --enable-managed-identity --generate-ssh-keys --location eastus

3.6 Connect kubectl to AKS

az aks get-credentials --resource-group student-demo --name student-aks

Verify kubectl get nodes

Step 4: Deploy to Kubernetes

4.1 Create Kubernetes Manifests

Create a directory mkdir k8s
Enter the direwctory cd k8s
Create deployment.yaml file using New-item or touch deployment.yaml

Copy this code into the deployment.yaml file

apiVersion: apps/v1
kind: Deployment
metadata:
  name: weather-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: weather-app
  template:
    metadata:
      labels:
        app: weather-app
    spec:
      containers:
      - name: weather-app
        image: studentdemoacr.azurecr.io/weather-app:latest
        ports:
        - containerPort: 8080
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
        readinessProbe:
          httpGet:
            path: /health
            port: 8080

Create service.yaml file using New-item or touch service.yaml

Copy this code into the service.yaml

apiVersion: v1
kind: Service
metadata:
  name: weather-service
spec:
  type: LoadBalancer
  selector:
    app: weather-app
  ports:
  - port: 80
    targetPort: 8080

4.2 Apply Manifests

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Check status:
kubectl get pods
kubectl get services

Step 5: CI/CD with GitHub Actions

5.1 Initialize Git

git init
git add .
git commit -m "Initial Weather App"

5.2 Create GitHub Repo
*Login to Github *
Use rename your branch to main using git branch -m main
Use git remote add origin https://github.com/Subair-09/WeatherAPP.git to add repository.
Use git push origin main to push the codes to github

5.3 Create Workflow File

Copy and paste this code in the .github/workflows/deploy.yml file
name: CI/CD to AKS

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - run: |
        az acr build \
          --registry ${{ secrets.ACR_NAME }} \
          --image weather-app:${{ github.sha }} .

    - run: |
        az aks get-credentials \
          --resource-group ${{ secrets.RESOURCE_GROUP }} \
          --name ${{ secrets.CLUSTER_NAME }}

    - run: |
        kubectl set image deployment/weather-app \
        weather-app=${{ secrets.ACR_NAME }}.azurecr.io/weather-app:${{ github.sha }}

Step 6: Access the Application

kubectl get service weather-service

Use the EXTERNAL-IP in your browser.

Push Github workflow to github

Github action running

Conclusion

This project successfully demonstrates a complete, real-world cloud-native deployment workflow using modern DevOps practices. Starting from local development of a .NET 8 Web API, the application was containerized with Docker, securely stored in Azure Container Registry, and deployed to Azure Kubernetes Service with proper health checks, scalability, and service exposure.

By integrating GitHub Actions for CI/CD, the deployment process was fully automated, ensuring that every change pushed to the repository results in a reliable and repeatable update to the Kubernetes cluster. This mirrors how production systems are built, tested, and delivered in professional cloud environments.

Overall, the project reinforces key concepts such as containerization, Kubernetes orchestration, infrastructure provisioning, and continuous delivery on Azure. It provides a strong foundation for building scalable, resilient, and production-ready applications, and serves as a practical reference for engineers transitioning into cloud and DevOps roles.

Branching & Merging Lab: Building Production-Ready DevOps Workflows

SUBAIR NURUDEEN ADEWALE — Tue, 27 Jan 2026 13:36:19 +0000

Introduction

Modern DevOps teams rely on strong source code management practices to deliver software quickly safely and consistently. At the center of this process is branching and merging the workflow that allows multiple developers to work in parallel without breaking production systems.

In this hands on lab project you will simulate how real world DevOps teams manage code changes from development to production using Git. You will practice creating feature branches synchronizing with the main branch resolving changes and merging code using industry best practices.

This project is designed to help you move beyond theory and experience how professional teams collaborate test and ship code in a controlled production safe environment. By the end of this lab you will understand not just how branching works but why it is critical to DevOps success.

Project Objectives

By completing this project you will be able to

Understand the importance of branching in DevOps workflows
Learn why teams avoid working directly on the main branch and how branching reduces risk
Create and manage feature branches effectively
Develop new features in isolated environments without disrupting

** Step 1: Prepare Your Repository**
Run:

git clone https://github.com/Subair-09/Stylish-E-commerce.git (This command downloads a copy of the project from GitHub to your local machine.) and Git creates a new folder called Stylish-E-commerce

cd Stylish-E-commerce (This command moves you into the project folder so you can run Git commands inside it. Without this step, Git will not know which project you are working on.)

git checkout main (This command switches you to the main branch of the project.)

git pull (This command updates your local main branch with the latest changes from GitHub.)

Checkpoint: git status shows a clean working tree

Step 2: Create a Feature Branch

git checkout -b feature/amazing-feature

This command creates a new branch and immediately switches you to it.

It does two things at once:

Creates a new branch
The branch name is feature/amazing-feature
This branch is used to work on a new feature
It is separate from the main branch, so your changes are safe
Switches to the new branch
After running the command, you are no longer on main
Any changes you make now happen only in this feature branch

Step 3: Make a Change

Edit a file OR
Add a new feature OR
Improve documentation add a file feature.html by using the commandNew-item or touch feature.html

use the command code . (This command opens the current folder in Visual Studio Code.)

use the command git status
Checkpoint: Files appear as modified or new

Step 4: Commit Your Work

git add .

This command tells Git to stage all the changes you have made in the project for the next commit.

What it does:
Adds all modified files
Adds new files
Prepares them to be saved in Git history
The dot . means:
“Add everything in this folder and subfolders.”

git commit -m "Add amazing feature"

This command saves your staged changes into Git with a message describing what you did.

What it does:
Creates a new commit (a snapshot of your code)
Records the changes permanently in Git history
Adds a clear message so others understand your work
The -m flag means:
“Use this message to describe the change.”

Checkpoint: Commit created successfully

Step 5: Sync With Main

git checkout main

This command switches you to the main branch, which contains the stable and production ready version of the code.
You do this to make sure you are working from the correct base before updating or merging anything.

git pull

This command updates your local main branch with the latest changes from the remote repository (GitHub).

It:

fetches new commits from GitHub
merges them into your local main
ensures your local main is up to date
This is important so you don’t work with outdated code.

git checkout feature/amazing-feature

This command switches you to your feature branch, where you are developing new functionality.
At this point, your feature branch may be behind main, which is why the next step is important.

git merge main

This command merges the latest changes from main into your feature branch.

Step 6: Merge to Main

git checkout main

This command switches you to the main branch, which contains the production ready and stable version of the code.

You must be on the branch you want to receive the changes before merging.

git merge feature/amazing-feature

This command merges the work from the feature/amazing-feature branch into the main branch.

** Step 7: Clean Up**

git branch -d feature/amazing-feature
This command deletes the feature branch called feature/amazing-feature from your local repository.

Conclusion

In this lab project, you practiced how real DevOps teams manage code changes safely and efficiently using Git branching and merging workflows. By working with feature branches, synchronizing with the main branch, and merging only tested changes, you experienced how teams protect production systems while still moving fast.

This project demonstrated why the main branch must always remain stable and why all development should happen in isolated branches. You also learned how frequent integration, clear commits, and branch cleanup help reduce risk, improve collaboration, and keep codebases production ready.

By completing this lab, you have built a strong foundation in source code management that directly supports CI/CD pipelines, team collaboration, and modern DevOps practices. These skills are essential for working in real world engineering teams where stability, speed, and reliability matter.

You are now ready to apply this workflow in larger projects, automate it with pipelines, and collaborate confidently in any DevOps environment.

Deploying a Node.js Application to AWS Elastic Beanstalk

SUBAIR NURUDEEN ADEWALE — Wed, 31 Dec 2025 11:21:08 +0000

Introduction

Deploying a Node.js application is one thing — deploying it reliably, securely, and at scale is another. As applications grow beyond local development, developers often face challenges around server configuration, environment management, scalability, and deployment automation.

AWS Elastic Beanstalk simplifies this process by abstracting much of the infrastructure complexity while still giving developers control over their application environment. With built-in support for Node.js, Elastic Beanstalk allows you to focus on writing code while AWS handles provisioning, load balancing, scaling, and monitoring behind the scenes.

In this article, we’ll walk through a practical, step-by-step guide to deploying a Node.js application to AWS Elastic Beanstalk. Whether you’re transitioning from local development or looking to standardize your deployment workflow, this guide will help you understand the deployment process, common pitfalls, and best practices for running Node.js applications in production on AWS.

Step 1: Log in to your AWS Management Console.

Step 2: In the search bar, type Elastic Beanstalk and select it from the services list.

Step 3: Navigate to Environments, then click Create Environment to begin the setup process.

Step 4: Select a web server environment and enter an application name (for example, officeApp).

Step 5: The environment name will be populated automatically. Select the platform in this case, choose Node.js since the application is built with Node.js. All other settings, including the **platform branch and platform settings, will be populated by default.

Step 6: Select the Sample application, choose Single instance under configuration, and then click Next.

Step 7: Configure Service Access

For the Service Role, select Create role if no existing role is available.
During the role creation process, leave all configuration parameters at their default values.
Proceed by clicking Next on both the Select trusted entity and Add permissions steps.
Update the Role name to a unique and descriptive identifier.
Complete the process by clicking Create role.

Just as the previous, For EC2 instance profile select Create role if no existing role is available.

During the role creation process, leave all configuration parameters at their default values.
Proceed by clicking Next on both the Select trusted entity and Add permissions steps
Update the Role name to a unique and descriptive identifier.
Complete the process by clicking Create role.

For the EC2 Key Pair, locate the service using the AWS Management Console search bar.

Create a new key pair by providing a unique and descriptive name.
Leave all other configuration options at their default settings.
Complete the process by selecting Create key pair.

Click** Next** on Configure service page afterwards.

Step 8: Set up networking, database, and tags

Select the default VPC from the available options in the dropdown menu.
Enable **Public IP address assignment **for the instances.
From the Instance Subnet options, select any available subnet.
Leave all remaining parameters at their default values, then click Next to proceed.

Step 9: Configure instance traffic and scaling

Select an existing EC2 Security Group from the dropdown list.
Leave all other configuration parameters at their default values, then click Next to continue.

Step 10: Configure updates, monitoring, and logging

Select the appropriate CloudWatch metrics instance and the corresponding CloudWatch metrics environment from their respective fields simultaneously
Leave all other configuration parameters at their default values, then click Next to continue.

Now review the entire steps and click create.

Once the Environment is successfully lunched and the health status shows green and OK. Click the URL link listed for Domain to browse your application.

To access the E*lastic Beanstalk–managed EC2 instance shell, navigate to **Amazon Elastic Compute Cloud (EC2)* and select the relevant Instance ID.

From the Instance Overview page, click Connect, then select Connect again to initiate an in-browser SSH session.

Conclusion

In this project, we successfully deployed a Node.js application to AWS Elastic Beanstalk using a structured and repeatable approach. By leveraging Elastic Beanstalk, we were able to abstract away much of the underlying infrastructure complexity while still maintaining control over critical configuration options such as networking, security, scaling, and monitoring.

Throughout the deployment process, we configured service access roles, networking and subnets, instance settings, and CloudWatch monitoring, ensuring the environment was production-ready. Once the environment was launched and its health status turned green, accessing the application through the provided domain confirmed a successful deployment.

AWS Elastic Beanstalk proves to be a powerful platform for developers who want to deploy Node.js applications quickly without managing servers manually. It offers a balance between simplicity and flexibility, making it ideal for both beginners and experienced developers. With this foundation in place, you can now extend the deployment by integrating CI/CD pipelines, custom domains, HTTPS, environment variables, and scaling policies to support real-world production workloads.

Complete CI/CD Pipeline with Node.js, Docker, and Kubernetes

SUBAIR NURUDEEN ADEWALE — Tue, 23 Dec 2025 16:40:15 +0000

Introduction

This guide provides a hands-on, end-to-end walkthrough for building, testing, containerizing, and deploying a modern Node.js web application using real-world DevOps best practices.

Instead of focusing only on writing application code, this project is designed to help you understand how software is built, tested, packaged, automated, and deployed in professional environments. By the end of this guide, you will have a fully functional Node.js application with:

Automated testing
A CI/CD pipeline using GitHub Actions
Docker containerization
Kubernetes deployment configurations
A clear staging and production workflow

The project intentionally uses core Node.js (without frameworks like Express) to help you understand what happens under the hood, making it ideal for DevOps engineers, backend developers, cloud engineers, and beginners transitioning into DevOps.

This guide follows a step-by-step approach, ensuring you can complete the project in short sessions while gaining practical, job-ready skills.

Objectives

By completing this project, you will be able to:

Build a production-ready Node.js web application

Create a basic HTTP server
Serve HTML pages and JSON APIs
Implement health checks, metrics, and system info endpoints

Apply software engineering best practices

Use Git for version control
Write automated tests with Jest and Supertest
Enforce code quality using ESLint

Implement CI/CD with GitHub Actions

Automatically run tests and linting on every push
Build and push Docker images to a container registry
Scan container images for security vulnerabilities

Containerize applications using Docker

Create optimized, multi-stage Docker images
Run applications securely as a non-root user
Configure health checks and proper signal handling

Run and manage applications locally with Docker Compose

Simplify local development and testing
Manage environment variables and service health

Prepare applications for Kubernetes deployment

Create staging and production Kubernetes manifests
Configure replicas, probes, and resource limits
Follow environment-based deployment strategies

Prepare applications for Kubernetes deployment

Create staging and production Kubernetes manifests
Configure replicas, probes, and resource limits
Follow environment-based deployment strategies

Understand real-world DevOps workflows

Use branch-based deployments (develop - staging, main - production)
Monitor CI/CD pipelines and container builds
Troubleshoot common DevOps and deployment issues

Prerequisites – Download These First

Before we start building the CI/CD pipeline, you need to install a few essential tools. These tools form the foundation of the development, containerization, and automation workflow used throughout this project.

Node.js (v18 or higher)

Node.js is the runtime used to build and run our web application.
Current LTS (2025): v20.x
Download: https://nodejs.org/
Choose the LTS version for stability

Verify installation:
node --version
npm --version

Expected output:

Node.js: v18.x+ or v20.x+

npm: 9.x+ or 10.x+

Git (Latest Stable Version)

Git is used for version control and collaboration. It also triggers our CI/CD pipeline when code is pushed to GitHub.

Download: https://git-scm.com/downloads
Select your operating system and complete the installation

Verify installation:
git --version

Expected output:

Git version 2.34+

Docker Desktop (Latest Version)

Docker allows us to package the application into containers so it runs the same everywhere — solving the classic “it works on my machine” problem.

Download: https://www.docker.com/products/docker-desktop/
Install and start Docker Desktop after installation

Verify installation:

docker --version
docker-compose --version

Expected output:

Docker version 24.x+

Docker Compose available and running

GitHub Account

GitHub hosts your source code and runs the automated CI/CD pipeline using GitHub Actions.
Sign up: https://github.com
You will use GitHub to:
Store your project code
Trigger automated tests
Build Docker images
Deploy to staging and production environments

Code Editor (Optional but Recommended)

A code editor makes writing, reading, and managing your code much easier.

Recommended:

VS Code: https://code.visualstudio.com/
Alternatives:
Sublime Text
Atom
Any editor you’re comfortable with

Final Verification Checklist

Run the following commands to confirm everything is installed correctly:

node --version # v18.x+ or v20.x+
npm --version # 9.x+ or 10.x+
git --version # 2.34+
docker --version # 24.x+

If all commands return valid versions, you’re ready to move on.

Step 1: Set Up Git for Version Control

What this step does: it Configures Git on your machine so it knows who you are when you make commits, and sets up proper project tracking.

One-time Git Configuration

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

1.1 Select** Terminal** at the top of visual studio code and select *new terminal *

1.2 Enter the One-time Git Configuration

What this step does: it Configures Git on your machine so it knows who you are when you make commits, and sets up proper project tracking.

1.3 Create and Initialize Project

mkdir my-devops-project
cd my-devops-project
git init

mkdir my-devops-project
Creates a new folder (directory) named my-devops-project.

cd my-devops-project
What it does: Moves you into the newly created folder, Your terminal is now pointing to: .../my-devops-project Anything you create next will live inside this folder.

git init
What it does: Initializes a new Git repository in the current folder
Behind the scenes: Git creates a hidden .git/ directory This folder stores: Version history, Branches, Commits and configurations.

code .
use code . to open the current folder in Visual Studio Code.

Current folder (my-devops-project)

Step 2: Build a Node.js Web App

What this step does: Creates a web application using Node.js that can serve web pages and API endpoints.

Initialize Node.js Project using npm init -y
What this step does: Creates a package.json file that describes your project and manages dependencies.

2.1 Update package.json

Open the package.json file and update it with the appropriate project details and scripts that will be used throughout the CI/CD pipeline.
This includes:

Project name and description
Entry point (app.js or server.js)
Start and test scripts
Metadata used during builds and deployments

{
  "name": "my-devops-project",
  "version": "1.0.0",
  "description": "DevOps learning project with Node.js",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "test": "jest",
    "dev": "node app.js",
    "lint": "eslint ."
  },
  "keywords": ["devops", "nodejs", "docker"],
  "author": "Your Name",
  "license": "MIT",
  "engines": {
    "node": ">=18.0.0"
  },
  "devDependencies": {
    "jest": "^29.7.0",
    "eslint": "^8.57.0",
    "supertest": "^7.1.4"
  }
}

*2.2 Create Application File (app.js) *
What this code does:

Creates an HTTP server that listens on port 3000
Serves different endpoints (/, /health, /info, /metrics)
Includes security headers and proper error handling
Provides graceful shutdown capability
Exports the server for testing

Create app.js file using touch app.js or New-item app.js.

the app.js file is the entry point i.e the starting point of our application it contains configurations. It is the file that Node.js loads first when the application starts.

Copy this code into the applicagion file app.js.

// core modules
const http = require("http");
const url = require("url");

// environment configuration
const PORT = process.env.PORT || 3000;
const ENVIRONMENT = process.env.NODE_ENV || "development";

let requestCount = 0;

// helper: send JSON responses
function sendJSON(res, statusCode, data) {
  res.statusCode = statusCode;
  res.setHeader("Content-Type", "application/json");
  res.end(JSON.stringify(data, null, 2));
}

// helper: send HTML responses
function sendHTML(res, statusCode, content) {
  res.statusCode = statusCode;
  res.setHeader("Content-Type", "text/html");
  res.end(content);
}

// helper: send Prometheus metrics
function sendMetrics(res) {
  const mem = process.memoryUsage();
  const metrics = `
# HELP http_requests_total Total HTTP requests
# TYPE http_requests_total counter
http_requests_total ${requestCount}

# HELP app_uptime_seconds Application uptime in seconds
# TYPE app_uptime_seconds gauge
app_uptime_seconds ${process.uptime()}

# HELP nodejs_memory_usage_bytes Node.js memory usage
# TYPE nodejs_memory_usage_bytes gauge
nodejs_memory_usage_bytes{type="rss"} ${mem.rss}
nodejs_memory_usage_bytes{type="heapUsed"} ${mem.heapUsed}
nodejs_memory_usage_bytes{type="heapTotal"} ${mem.heapTotal}
nodejs_memory_usage_bytes{type="external"} ${mem.external}
`;
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end(metrics);
}

// main server
const server = http.createServer((req, res) => {
  requestCount++;
  const timestamp = new Date().toISOString();
  const { pathname } = url.parse(req.url, true);

  // logging
  console.log(
    `${timestamp} - ${req.method} ${pathname} - ${
      req.headers["user-agent"] || "Unknown"
    }`
  );

  // CORS headers
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
  res.setHeader("Access-Control-Allow-Headers", "Content-Type");

  // security headers
  res.setHeader("X-Content-Type-Options", "nosniff");
  res.setHeader("X-Frame-Options", "DENY");
  res.setHeader("X-XSS-Protection", "1; mode=block");

  // route handling
  switch (pathname) {
    case "/":
      sendHTML(
        res,
        200,
        `
<!DOCTYPE html>
<html>
<head>
  <title>DevOps Lab 2025</title>
  <style>
    body { font-family: Arial, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; }
    .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 8px; }
    .endpoint { background: #f8f9fa; padding: 15px; margin: 10px 0; border-radius: 5px; border-left: 4px solid #007bff; }
  </style>
</head>
<body>
  <div class="header">
    <h1>DevOps Lab 2025</h1>
    <p>Modern Node.js application with CI/CD pipeline</p>
  </div>
  <h2>Available Endpoints:</h2>
  <div class="endpoint"><strong>GET /</strong> - This welcome page</div>
  <div class="endpoint"><strong>GET /health</strong> - Health check (JSON)</div>
  <div class="endpoint"><strong>GET /info</strong> - System information</div>
  <div class="endpoint"><strong>GET /metrics</strong> - Prometheus metrics</div>
  <p>Environment: <strong>${ENVIRONMENT}</strong></p>
  <p>Server time: <strong>${timestamp}</strong></p>
  <p>Requests served: <strong>${requestCount}</strong></p>
</body>
</html>`
      );
      break;

    case "/health":
      sendJSON(res, 200, {
        status: "healthy",
        timestamp,
        uptime: process.uptime(),
        environment: ENVIRONMENT,
        version: "1.0.0",
        node_version: process.version,
        requests_served: requestCount,
      });
      break;

    case "/info":
      sendJSON(res, 200, {
        platform: process.platform,
        architecture: process.arch,
        node_version: process.version,
        memory_usage: process.memoryUsage(),
        environment: ENVIRONMENT,
        pid: process.pid,
        uptime: process.uptime(),
      });
      break;

    case "/metrics":
      sendMetrics(res);
      break;

    default:
      sendJSON(res, 404, {
        error: "Not Found",
        message: `Route ${pathname} not found`,
        timestamp,
      });
  }
});

// graceful shutdown
function shutdown(signal) {
  console.log(`\nReceived ${signal}, shutting down gracefully...`);
  server.close(() => {
    console.log("Server closed");
    process.exit(0);
  });
}
process.on("SIGTERM", () => shutdown("SIGTERM"));
process.on("SIGINT", () => shutdown("SIGINT"));

// start server
server.listen(PORT, () => {
  console.log(`🚀 Server running at http://localhost:${PORT}/`);
  console.log(`Environment: ${ENVIRONMENT}`);
  console.log(`Node.js version: ${process.version}`);
});

// export for testing
module.exports = server;

2.3 Install Dependencies

Install testing and development tools using
npm install --save-dev jest eslint supertest

Install all dependencies (creates node_modules folder)
npm install

What you'll see:

A node_modules/ folder with all installed packages
A package-lock.json file that locks dependency versions

Step 3: Create Proper Tests

What this step does: Sets up automated testing so you can verify your application works correctly every time you make changes.

3.1 Create tests directory and test file

Create a folder for your tests
mkdir tests

Create the main test file
touch tests/app.test.js or New-item tests/app.test.js

Copy this code into tests/app.test.js:

const request = require('supertest');
const server = require('../app');

describe('App Endpoints', () => {
  afterAll(() => {
    server.close();
  });

  test('GET / should return welcome page', async () => {
    const response = await request(server).get('/');
    expect(response.status).toBe(200);
    expect(response.text).toContain('DevOps Lab 2025');
  });

  test('GET /health should return health status', async () => {
    const response = await request(server).get('/health');
    expect(response.status).toBe(200);
    expect(response.body.status).toBe('healthy');
    expect(response.body.timestamp).toBeDefined();
    expect(typeof response.body.uptime).toBe('number');
  });

  test('GET /info should return system info', async () => {
    const response = await request(server).get('/info');
    expect(response.status).toBe(200);
    expect(response.body.platform).toBeDefined();
    expect(response.body.node_version).toBeDefined();
  });

  test('GET /metrics should return prometheus metrics', async () => {
    const response = await request(server).get('/metrics');
    expect(response.status).toBe(200);
    expect(response.text).toContain('http_requests_total');
    expect(response.text).toContain('app_uptime_seconds');
  });

  test('GET /nonexistent should return 404', async () => {
    const response = await request(server).get('/nonexistent');
    expect(response.status).toBe(404);
    expect(response.body.error).toBe('Not Found');
  });
});

Create Jest configuration

Create jest.config.js using the command touch jest.config.js or New-item jest.config.js

Copy the code into the jest.config.js file*

module.exports = {
  testEnvironment: 'node',
  collectCoverage: true,
  coverageDirectory: 'coverage',
  testMatch: ['**/tests/**/*.test.js'],
  verbose: true
};

Step 4: GitHub Actions CI/CD Pipeline

What this step does: Creates an automated pipeline that runs tests and builds Docker images every time you push code to GitHub.

4.1 Create workflow directory
Create the GitHub Actions directory structure using the command

mkdir -p .github/workflows

4.2 Create CI/CD pipeline file
Create .github/workflows/ci.yml using the command touch .github/workflows/ci.yml or New-item github/workflows/ci.yml

4.3 Copy this code into the CI/CD Pipeline file.

name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
    tags: [ 'v*' ]
  pull_request:
    branches: [ main ]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  test:
    name: Test & Lint
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [20, 22]

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run linting
        run: npm run lint

      - name: Run tests
        run: npm test

      - name: Security audit
        run: npm audit --audit-level=critical || echo "Audit completed with warnings"

  build:
    name: Build & Push Image
    runs-on: ubuntu-latest
    needs: test
    if: github.event_name == 'push'

    permissions:
      contents: read
      packages: write
      security-events: write

    outputs:
      image-tag: ${{ steps.meta.outputs.tags }}
      image-digest: ${{ steps.build.outputs.digest }}

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
        with:
          platforms: linux/amd64,linux/arm64

      - name: Log in to Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=sha,prefix={{branch}}-
            type=raw,value=${{ github.run_id }}
            type=raw,value=latest,enable={{is_default_branch}}
          labels: |
            org.opencontainers.image.title=DevOps Lab 2025
            org.opencontainers.image.description=Modern Node.js DevOps application

      - name: Build and push Docker image
        id: build
        uses: docker/build-push-action@v5
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
          target: production

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@0.24.0
        with:
          image-ref: ${{ steps.meta.outputs.tags }}
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'
        continue-on-error: true

      - name: Upload Trivy scan results
        uses: github/codeql-action/upload-sarif@v3
        if: always() && hashFiles('trivy-results.sarif') != ''
        with:
          sarif_file: 'trivy-results.sarif'

  deploy-staging:
    name: Deploy to Staging
    runs-on: ubuntu-latest
    needs: build
    if: github.ref == 'refs/heads/develop'
    environment: staging

    steps:
      - name: Deploy to Staging
        run: |
          echo "🚀 Deploying to staging environment..."
          echo "Image: ${{ needs.build.outputs.image-tag }}"
          echo "Digest: ${{ needs.build.outputs.image-digest }}"
          # Add your staging deployment commands here (kubectl, helm, etc.)

  deploy-production:
    name: Deploy to Production
    runs-on: ubuntu-latest
    needs: build
    if: github.ref == 'refs/heads/main'
    environment: production

    steps:
      - name: Deploy to Production
        run: |
          echo "🎯 Deploying to production environment..."
          echo "Image: ${{ needs.build.outputs.image-tag }}"
          echo "Digest: ${{ needs.build.outputs.image-digest }}"
          # Add your production deployment commands here

Step 5: Dockerfile

What this step does: Creates instructions for Docker to build a container image of your application that can run anywhere.

What this Dockerfile does:

Uses multi-stage builds for smaller image size
Installs curl for health checks
Creates a non-root user for security
Sets up proper file permissions
Configures health checks

Create Dockerfile:

create a dockerfile using the command touch Dockerfile or New-item Dockerfile

Copy the docker instructions into the Dockerfile.

# Multi-stage build for optimized image
FROM node:20-alpine AS dependencies

# Update packages for security
RUN apk update && apk upgrade --no-cache

WORKDIR /app

# Copy package files first for better caching
COPY package*.json ./

# Install only production dependencies
RUN npm ci --only=production && npm cache clean --force

# Production stage  
FROM node:20-alpine AS production

# Update packages and install necessary tools
RUN apk update && apk upgrade --no-cache && \
    apk add --no-cache curl dumb-init && \
    rm -rf /var/cache/apk/*

# Create non-root user with proper permissions
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodeuser -u 1001 -G nodejs

WORKDIR /app

# Copy dependencies from previous stage with proper ownership
COPY --from=dependencies --chown=nodeuser:nodejs /app/node_modules ./node_modules

# Copy application code with proper ownership
COPY --chown=nodeuser:nodejs package*.json ./
COPY --chown=nodeuser:nodejs app.js ./

# Switch to non-root user
USER nodeuser

# Expose port
EXPOSE 3000

# Health check with proper timing for Node.js startup
HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

# Use dumb-init for proper signal handling in containers
ENTRYPOINT ["dumb-init", "--"]

# Start application
CMD ["npm", "start"]

Step 6: Essential Configuration Files

What this step does: Creates configuration files that tell various tools what to ignore, how to behave, and what settings to use.

Create .dockerignore using the command touch .dockerignore or New-item .dockerignore

Copy this code into the .dockerignore file.

# Node.js dependencies
node_modules
npm-debug.log*
yarn-error.log*

# Git & CI/CD
.git
.github

# Environment variables
.env
.env.local
.env.*.local

# Logs
logs
*.log

# Test & coverage files
tests/
coverage
.nyc_output
jest.config.js

# Linting & config files
.eslintrc*
README.md

# IDE & editor files
.vscode
.idea
*.swp
*.swo

# OS-specific files
.DS_Store
Thumbs.db

6.1 Create .gitignore
Create .gitignore usinf the command touch .gitignore or New-item .gitignore

Copy this code into the .gitignore file.

# Node.js dependencies
node_modules
npm-debug.log*
yarn-error.log*

# Git & CI/CD
.git
.github

# Environment variables
.env
.env.local
.env.*.local

# Logs
logs
*.log

# Test & coverage files
tests/
coverage
.nyc_output
jest.config.js

# Linting & config files
.eslintrc*
README.md

# IDE & editor files
.vscode
.idea
*.swp
*.swo

# OS-specific files
.DS_Store
Thumbs.db

6.2 Create environment template
Create .env.example using the command touch .env.example or touch New-item .env.example

Copy this configuration into the .env.example file and save.

# Server Configuration PORT=3000 NODE_ENV=production # Logging LOG_LEVEL=info

6.3 Create ESLint configuration
Create .eslintrc.js file using the command touch .eslintrc.js or New-item .eslintrc.js

Copy this code into the .eslintrc.js file and save.

module.exports = {
  env: {
    node: true,
    es2021: true,
    jest: true
  },
  extends: ['eslint:recommended'],
  parserOptions: {
    ecmaVersion: 12,
    sourceType: 'module'
  },
  rules: {
    'no-console': 'off',
    'no-unused-vars': ['error', { 'argsIgnorePattern': '^_' }]
  }
};

Step 7: Docker Compose for Development

What this step does: Creates a Docker Compose file that makes it easy to run your application and any supporting services with a single command.

Create docker-compose.yml using the command touch docker-compose.yml or New-item docker-compose.yml

Copy this code into the docker-compose.yml file and save.

version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - PORT=3000
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s

Step 8: Test Everything Locally

What this step does: Shows you how to actually run and test your application locally before deploying it.

Install and Test Locally
Install all dependencies from package.json using the command npm install

Run your test suite to make sure everything works using the command
npm test

Start the application server using the command
npm start

What you'll see:

Tests should pass with green checkmarks: ✓ GET / should return welcome page
Server starts and shows: 🚀 Server running at http://localhost:3000/

Test endpoints (in a new terminal window) by copying and pasting each into a terminal.
curl http://localhost:3000/ # Homepage

curl http://localhost:3000/health # Health check JSON

curl http://localhost:3000/info # System info JSON

curl http://localhost:3000/metrics # Prometheus metrics

Copy the url localhost:3000 into a browser to see your application.

Docker Commands
Start docker desktop application to start the docker engine and run the docker command to build the image
# Build image

docker build -t my-devops-app:latest .

Navigate to docker desktop to see the image

Run container
docker run -d --name my-devops-container -p 3000:3000 --restart unless-stopped my-devops-app:latest

Navigate to docker desktop to see the container

Check container status
docker ps

docker logs my-devops-container

Test health check
curl http://localhost:3000/health

Stop container
docker stop my-devops-container

Navigate to Docker desktop to see the stopped container

Remove the container
docker rm my-devops-container

Navigate to Docker desktop to see if the container as been removed.

Docker Compose Commands

Start all services defined in docker-compose.yml
docker-compose up -d

View real-time logs from all services
docker-compose logs -f

Stop all services and clean up
docker-compose down

Step 9: Deploy to GitHub

What this step does: Commits your code to Git and pushes it to GitHub so the automated CI/CD pipeline can start working.
Initial commit

Add all files to Git staging area
git add .

Create your first commit with a descriptive message
git commit -m "Initial commit: Complete DevOps setup with working CI/CD"

Connect to GitHub
IMPORTANT: Before running these commands:

Go to GitHub.com and create a new repository called my-devops-project
DO NOT initialize it with README, .gitignore, or license (we already have these)
Copy the repository URL from GitHub
Replace YOUR_GITHUB_USERNAME below with your actual GitHub username Set main as the default branch git branch -M main
# Connect to your GitHub repository (UPDATE THIS URL!)
git remote add origin https://github.com/YOUR_GITHUB_USERNAME/my-devops-project.git
# Push your code to GitHub for the first time git push origin main

What you'll see: Your code appears on GitHub, and the CI/CD pipeline starts running automatically.

Step 10: Kubernetes Deployment Configurations

What this step does: Creates Kubernetes configuration files that define how your application should run in staging and production environments.

Create directories
Create directories for Kubernetes configurations
mkdir -p k8s/staging

*Create Staging Deployment file *

Create k8s/staging/deployment.yml file using touch k8s/staging/deployment.yml or New-item k8s/staging/deployment.yml

Copy this code into the deployment file
NOTE: Update YOUR_GITHUB_USERNAME in the image URL below!

apiVersion: apps/v1
kind: Deployment
metadata:
  name: devops-app-staging
  namespace: staging
spec:
  replicas: 2
  selector:
    matchLabels:
      app: devops-app
      environment: staging
  template:
    metadata:
      labels:
        app: devops-app
        environment: staging
    spec:
      containers:
      - name: app
        image: ghcr.io/YOUR_GITHUB_USERNAME/my-devops-project:develop-latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "staging"
        - name: PORT
          value: "3000"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: devops-app-service-staging
  namespace: staging
spec:
  selector:
    app: devops-app
    environment: staging
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

Create Production Deployment

Create k8s/production directory using the command mkdir k8s/production and create the depployment file touch k8s/production/deployment.yml or New-item k8s/production/deployment.yml

Copy this code into the k8s/production/deployment.yml file

NOTE: Update YOUR_GITHUB_USERNAME in the image URL below

apiVersion: apps/v1
kind: Deployment
metadata:
  name: devops-app-production
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: devops-app
      environment: production
  template:
    metadata:
      labels:
        app: devops-app
        environment: production
    spec:
      containers:
      - name: app
        image: ghcr.io/YOUR_GITHUB_USERNAME/my-devops-project:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: PORT
          value: "3000"
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: devops-app-service-production
  namespace: production
spec:
  selector:
    app: devops-app
    environment: production
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

Step 11: Complete Deployment Workflow

What this step does: Shows you how to use the complete CI/CD pipeline with proper branching strategy for staging and production deployments.

Branch-based Deployment Strategy

develop branch: Automatically deploys to staging environment
main branch: Automatically deploys to production environment
Pull requests: Run tests only (no deployment)

Deploy Changes

Deploy to staging:

Create and switch to develop branch
use the command git checkout -b develop

Make your changes, then commit and push
git add .
git commit -m "Add new feature
git push origin develop

What happens: GitHub Actions automatically runs tests and deploys to staging.

Deploy to production:

Switch to main branch
git checkout main

Merge changes from develop
git merge develop

Push to trigger production deployment
git push origin main

What happens: GitHub Actions runs full pipeline and deploys to production.

Monitor Deployments

Check GitHub Actions status

Visit: https://github.com/YOUR_GITHUB_USERNAME/my-devops-project/actions

Check your container registry
Visit: https://github.com/YOUR_GITHUB_USERNAME/REPO NAME/pkgs/container/REPO NAME

Test your deployed applications (once you have URLs)

curl https://your-staging-url.com/health # Staging health check
curl https://your-production-url.com/health # Production health check

Conclusion
This project successfully demonstrates a complete DevOps workflow for modern web application development. We transformed a basic Node.js application into a professional, automated system with CI/CD pipelines, containerization, and deployment strategies.

Key Achievements
End-to-End Automation: GitHub Actions automates testing, building, and deployment from code to production
Containerization: Docker creates secure, portable images that run consistently anywhere
Professional Testing: Jest and Supertest ensure application reliability with automated tests
Security Integration: Trivy vulnerability scanning and security headers protect the application
Kubernetes Ready: Production-grade deployment configurations for staging and production
Branch-Based Workflow: Safe deployments using develop/staging and main/production branches

How to Containerize an Application.

SUBAIR NURUDEEN ADEWALE — Thu, 06 Nov 2025 10:59:35 +0000

Introduction

In today’s software development landscape, containerization has become an essential practice for building, deploying, and managing applications efficiently. This project focuses on containerizing a simple Node.js Todo List Manager application using Docker. By packaging the application and its dependencies into a container, developers can ensure consistency across different environments, simplify deployment, and improve scalability. Whether you're new to Docker or just getting started with containerization, this project offers a hands-on experience that demonstrates how to move an application from a local environment to a portable, containerized setup.

Prerequisites

Before you begin, ensure you have the following installed and set up on your system:

Docker Desktop (latest version) – to build, run, and manage containers.
Git client – to clone the project repository and manage source control.
An IDE or text editor – such as Visual Studio Code, for editing and managing project files.
(Optional but recommended) Basic understanding of terminal or command-line operations.

Step 1 : Get the app

Steps to Get the App and Run it in Visual Studio Code
Open Visual Studio Code
Launch VS Code on your computer.

Open the Terminal
Click on Terminal at the top menu and select new terminal

Clone the Application Repository
In the terminal, type the following command and press Enter:

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

Navigate into the App Folder cd getting-started-app
Open the Folder in VS Code (Optional) code .

View the contents of the cloned repository. You should see the following files and sub-directories.

Step 2 : Build image

To build the image, you'll need to use a Dockerfile. A Dockerfile is simply a text-based file with no file extension that contains a script of instructions. Docker uses this script to build a container image.

In the getting-started-app directory, the same location as the package.json file, create a file named Dockerfile with the following contents:
This Dockerfile starts off with a node:lts-alpine base image, a light-weight Linux image that comes with Node.js and the Yarn package manager pre-installed. It copies all of the source code into the image, installs the necessary dependencies, and starts the application.

Build the image using the following commands:

docker build -t getting-started-app .

Step 3: Start an app container

Now that you have an image, you can run the application in a container using the docker run command.
Run your container using the docker run command and specify the name of the image you just created:

** docker run -d -p 127.0.0.1:3000:3000 getting-started**

After a few seconds, open your web browser to http://localhost:3000. You should see your app.

Conclusion

By the end of this project, you will have successfully transformed a simple Node.js Todo List Manager into a fully containerized application. You’ll gain hands-on experience with Docker commands, image creation, and container management — valuable skills for modern DevOps and cloud-based development workflows. This exercise not only strengthens your understanding of containerization but also prepares you to deploy scalable, portable, and efficient applications in real-world environments.

My Personal Info & Stats Display App Using C# Programming.

SUBAIR NURUDEEN ADEWALE — Tue, 14 Oct 2025 13:26:06 +0000

Introduction

The “My Personal Info & Stats Display App” is a beginner friendly C# console project designed to strengthen my understanding of fundamental programming concepts such as data types, literals, and output formatting using Console.WriteLine(). In this project, I explored how to represent different types of data including strings, characters, integers, decimals, and booleans, and how each plays a unique role in programming. By combining these elements, the project displays basic personal details and computed values, helping me understand how C# handles and presents data in real world applications.

Project Description

Create a C# console program that:

Displays your personal information (using string and char)
Shows your academic or skill statistics (using int and decimal)
Indicates if you’ve completed a task or goal (using bool)
Prints everything neatly formatted in the console window

Step 1: Create Your Project

In Visual Studio Code, go to the menu bar and select Terminal, then choose New Terminal from the drop-down menu.

-In your terminal type the command and type the** Enter key** on your keyboard

dotnet new console -n MyInfoApp

Explanation:

dotnet new: tells the .NET SDK to create a new project.
console: specifies the type of project (a console app that runs in the terminal).
-n MyInfoApp: sets the name of the project to MyInfoApp.

Result:

A new folder called MyInfoApp is created, containing files like:
Program.cs (your main C# file)
MyInfoApp.csproj (your project configuration file)

Type the command and press Enter key on your keyboard.

cd MyInfoApp

Explanation:

cd means “change directory.”
This moves you into the newly created project folder so you can start working on your code. Result:
You are now inside the MyInfoApp folder in your terminal.

Type the command and press Enter key on your keyboard. code .

Explanation:

code opens Visual Studio Code.
The . means “open the current folder” (in this case, MyInfoApp).
Result:
VS Code opens your project folder, ready for editing and running your app.

Step 2: Type the code to pratice use of string literals and click the play button to run the program.

Line-by-line Explanation

Console.WriteLine("=====================================");

This prints a line of equal signs on the console — it’s just decoration.
You can think of it like drawing a border or header line.

Console.WriteLine(" My Personal Info Display App");

This prints your app title with a few spaces before it.
The spaces (" ") make the title appear centered visually

Console.WriteLine("=====================================\n");

This prints another line of equal signs (bottom border),
and the \n at the end means go to a new line (line break).
So, it adds one blank line after the header.

string fullName = "Subair Nurudeen Adewale";
string course = "C# Fundamentals at Skill.sch";
string hobby = "Coding and Cloud Projects";

These create 3 string variables and store text in them:
fullName holds your name
course holds your course name
hobby holds your hobby
A string is just text inside double quotes " ".

- Console.WriteLine($"Name: {fullName}");

The $ allows string interpolation, meaning you can insert variable values inside a text using {}.
So here, {fullName} will be replaced by your actual name.

Console.WriteLine($"Course: {course}");

Same idea - prints the text and your course variable.

Console.WriteLine($"Hobby: {hobby}\n");

Prints your hobby, then adds a blank line after it (\n).

Output

Step 3: Type the code to pratice use of **char literals **and click the play button to run the program.

Explanation Step-by-Step

Console.WriteLine("\n======= My Academic Grade ===============\n");

Console.WriteLine() - prints a line to the screen.

The \n at the start and end means “new line” (a blank line).
One before: leaves a space above the header.

Creating grade variables

char Mathgrade = 'A';
Char Enggrade = 'B';
char Chemgrade = 'C';
char Phygrade = 'B';
char Biograde = 'C';
char Econgrade = 'A';
char Comgrade = 'A';

Each line declares a variable that stores a single character (a letter grade).
char is short for character — it stores exactly one letter, number, or symbol. You must use single quotes ' ' for characters (not double quotes " "). Example:

'A' - valid

"A" - invalid (that’s a string, not a char)

Here, each subject has its own variable:

Variable Subject Value
Mathgrade General Mathematics 'A'
Enggrade English Language 'B'
Chemgrade Chemistry 'C'
Phygrade Physics 'B'
Biograde Biology 'C'
Econgrade Economics 'A'
Comgrade Commerce 'A'

Displaying each subject and its grade

Console.WriteLine($"General Mathematics: {Mathgrade}");

Uses string interpolation (the $ symbol) so you can mix text with variables.
The {Mathgrade} is replaced by the value 'A'.

Each following line does the same for other subjects:

Console.WriteLine($"English Language: {Enggrade}");
Console.WriteLine($"Chemistry: {Chemgrade}");
Console.WriteLine($"Physics: {Phygrade}");
Console.WriteLine($"Biology: {Biograde}");
Console.WriteLine($"Economics: {Econgrade}");
Console.WriteLine($"Commerce: {Comgrade}");

Step 4: Type the code to pratice use of **int literals and click the play button to run the program.**

Explanation Step-by-Step

Comment Line
// --- Step 3: Use int literal ---

Anything that starts with // is a comment — it’s ignored by the compiler.
It’s used only for notes or explanations to make your code readable.
This line tells you that this section is demonstrating how to use integer literals.

Integer Variables

int completedProjects = 5;
int xpPoints = 100;

int (short for integer) is a data type used to store whole numbers — no decimal points.
Here you are creating two integer variables:
completedProjects → stores the number 5
xpPoints → stores the number 100
“Literals” just means fixed values written directly into the code (e.g. 5 and 100 are int literals because they are constant numbers).

Display Values

Console.WriteLine($"Projects Completed: {completedProjects}");
Console.WriteLine($"XP Earned: {xpPoints}");

Explanation:

$ → enables string interpolation (mixing text with variable values).
{completedProjects} and {xpPoints} are replaced by the actual values stored in the variables.
\n adds a blank line after printing, for cleaner spacing

Output

Step 4: Type the code to pratice use of **decimal and float literals and click the play button to run the program.**

Line-by-Line Explanation

Comment Line
// --- Step 4: Use decimal and float literals ---

This is a comment (ignored by the computer).
It tells you this section shows how to use decimal and float values — numbers with decimal points.

Decimal Variable
decimal successRate = 95.8m;

decimal is a high-precision number type, used when you need very accurate decimal values (like money, percentages, or scientific data).
The letter m at the end tells C# that 95.8 is a decimal literal.
Without it, C# would think it’s a double and show an error.
Think of decimal as a super accurate number type.

Float Variable
float weeklyProgress = 0.85F;

float is another data type for decimal numbers - less precise but uses less memory.
The letter F tells C# that this is a float literal.
The value 0.85 represents 85% progress (written in decimal form).
Floats are useful when you don’t need extreme accuracy - like averages or progress values.

Displaying the Decimal Value
Console.WriteLine($"Success Rate: {successRate}%");

$ allows you to combine text with the variable value.
{successRate} is replaced by 95.8.
It prints:
Success Rate: 95.8%

Displaying the Float Value (with a Calculation)
Console.WriteLine($"Weekly Progress: {weeklyProgress}%");

Explanation

$ - String Interpolation
The $ before the string means you’re using string interpolation.
It allows you to insert variable values directly into a string.

Step 4: Type the code to pratice use of **decimal and float literals and click the play button to run the program.**

Line-by-line Explanation

bool taskCompleted = true;

bool is short for Boolean, a data type that holds only two possible values:

true or false.

Here, taskCompleted is a variable that stores whether your exercise is finished or not.

bool taskCompleted = true;

This means:

The task is done (true).
If it were false, that would mean the task isn’t done.

Console.WriteLine($"Exercise Completed: {taskCompleted}");

This line prints a message to the console.
The $ allows string interpolation, which lets you embed variables inside strings using {}.
{taskCompleted} will be replaced by the value stored in taskCompleted (in this case, true).

Console.WriteLine("\n=====================================");

The \n means new line — it moves the cursor to the next line before printing the equals signs.
It prints a decorative separator line to make your output look nice.

Console.WriteLine(" Thank you for viewing my profile!");

This prints a simple closing message for your program.

Console.WriteLine("=====================================");

Prints another separator line to complete the section visually.

-Final Code

Output result

Conclusion

This project gave me hands on experience with one of the most important building blocks of C# which is data types. Through creating and displaying literal values, I learned how precision, syntax, and data representation affect program output. It was a great step in developing problem solving skills, logical thinking, and code structure understanding. The Personal Info & Stats Display App marks the beginning of my C# learning journey, setting the foundation for more complex applications such as data driven programs and user interactive systems in the future.

Managing and Hosting My Resume on GitHub Using Git Bash

SUBAIR NURUDEEN ADEWALE — Fri, 03 Oct 2025 09:14:22 +0000

Introduction

In today’s tech-driven world, showcasing both technical skills and personal branding is essential. This project demonstrates how I used Git Bash and GitHub to version control and publish my professional resume. By doing so, I not only practiced core Git commands but also created a transparent, accessible, and always-updated space for recruiters and collaborators to view my career journey.

This project focuses on practical usage of Git for:

Initializing a local repository.
Adding and committing files.
Connecting to a remote GitHub repository.
Pushing updates to maintain the latest version of my resume.

Prerequisites

Before starting, you need to have Git installed on your system. Follow these steps:

Download Git: Visit the official Git website at https://git-scm.com
Install Git: Download the version for your operating system (Windows, macOS, or Linux) and follow the installation prompts.
On Windows, you will also get Git Bash, a command-line tool to run Git commands.

Step 1: Sign in to your Github account to Create a New Repository.

Click the + icon in the top-right corner and select New Repository.

Give your repository a name (e.g., Resume).
Choose whether you want it to be Public or Private.
Click Create Repository.

Step 2: Configure Git environment

Configure your Git environment by logging into GitHub from your Git terminal.
Open Git Bash on your computer.
Type the following command to set your username: -** git config --global user.name "YourGitHubUsername"**

Example:

git config --global user.name "Subair-09"

Type the following command to set the email associated with your GitHub account:

git config --global user.email "youremail@example.com"

Example:

git config --global user.email "nuddywale@gmail.com"

shows all the Git configuration settings currently active on your system using the command git config --list

Step 2: Create a Directory in Git Bash and Name It After My GitHub Repository

Type this command to create a directory in Git bash and name it your repository name you created in GitHub
mkdir Resume
Type this command to CD(Open) into your directory
cd Resume

Type this command to initializes a new Git repository in your current directory and Creates a hidden .git folder inside your project directory.

-git init

Git init will create a new Git repository folder in the current directory on your local host.

Step 3: Create a File Inside the Directory

To create a new file in your directory, use the touch command followed by the file name and extension:
touch filename.extension

Example:

touch resume.html
This will create an empty file named index.html inside your current directory.

Step 3.1 Edit Your File Using the vi Text Editor

Open the file in the vi editor by typing:
vi resume.html

Press the i key to enter insert mode, which allows you to type and edit text in the file.
Add your HTML code of your resume to the resume.html file.
To save and exit:
Press the Esc key to leave insert mode.
Type :wq and press Enter.
w = write (save changes)
q = quit (exit the editor)
Your changes will now be saved to resume.html

*Step 4: Connect Local Repository to GitHub *

Click on the Code button in Github and copy the HTTPs link.

Step 4.1 Connect the local repository to Github using the command

git remote add origin

For example:

git remote add origin https://github.com/Subair-09/Resume.git

Step 4.2: Add Your File to Git

Type the following command to stage your resume.html file so it can be tracked and uploaded to GitHub:

git add resume.html

Step 4.3 : Check the Status

Run this command to view the current status of your repository and confirm the changes you’ve staged:

git status

Step 5: Committing Changes to My Project

Before you can push to GitHub, you need to commit your changes.
A commit is like saving a snapshot of your project history. Always add a message to describe what you’ve done.

git commit -m "Added my professional resume file"

Step 6: Pushing My Code to GitHub

After committing, the next step is to push your code to GitHub so it’s available online.
This command uploads your local commits to the master branch of your GitHub repository.

git push origin master

Step 7: resume.html Successfully Pushed to GitHub

The resume.html file has been successfully pushed and is now available in my GitHub repository. You can view it directly on the GitHub website.

Step 8: Hosting My Resume on GitHub Pages

After pushing my project to GitHub, I noticed the “Compare & Pull Request” option, which usually appears when new commits are pushed. Since my goal was to publish the project as a live site, I moved to GitHub Pages settings.

I navigated to Settings > Pages.
Under Build and Deployment, I changed the branch from main to master and clicked Save.
GitHub automatically generated a deployment URL.
I refreshed the page, and a “Visit site” link appeared.
Clicking the link opened my project, and my resume.html file was successfully displayed online.
Now my resume is live and accessible via a public GitHub Pages URL.

Conclusion

This project successfully demonstrates how Git and GitHub can be used not only as version control tools but also as platforms for personal branding and professional visibility. By walking through the process of initializing a local repository, committing changes, pushing updates, and deploying through GitHub Pages, I was able to transform my resume from a static document into a live, web-accessible portfolio.

Through this workflow, I gained practical experience in:

Mastering essential Git commands (git init, git add, git commit, git push).
Understanding the importance of version control in tracking and managing project changes.
Leveraging GitHub as a hosting platform to create a publicly available professional asset.

The end result is a dynamic, always-up-to-date resume site that recruiters, collaborators, and peers can access with ease. Beyond showcasing technical ability, this project highlights the value of combining technical competence with personal branding, ensuring that my professional journey is both transparent and accessible in today’s digital world.

Mastering Linux: User & Permission Management with a Mock Company Project

SUBAIR NURUDEEN ADEWALE — Sat, 27 Sep 2025 10:02:33 +0000

Introduction

In Linux system administration, managing users, groups, and permissions is one of the most critical skills. It ensures that only the right people have access to sensitive files, while promoting collaboration in shared environments. In this project, we simulate a real-world scenario by creating multiple users, assigning them to groups, and managing access to shared directories and project files. This hands-on approach gives you practical experience with essential commands like adduser, groupadd, usermod, chmod, chown, and id.

Tasks to be Completed

Create Groups
Set up 2 groups (e.g., devs and staff) using groupadd.
Create Users
Add 5 new users with adduser or useradd.
Assign Users to Groups
Use usermod -aG to assign users to the correct group.
Set Up a Shared Project Directory
Create a directory (/home/company_projects) and configure it with the SGID bit so all files inherit the group ownership.
Manage Permissions
Use chmod to enforce rules (e.g., only group members can read/write, others are denied).
Test Group Collaboration
Have one user (e.g., alice) create a file and another group member (e.g., bob) edit it.
Confirm that non-members (e.g., carol) cannot access the directory.
Change File Ownership
Practice with chown and chgrp to assign ownership of files to specific users or groups.
Verify and Troubleshoot
Use commands like id, groups, ls -l, and stat to confirm changes.

Prerequisites

Most commands require root privileges. Prefix with sudo when needed, or run as root:
sudo -i or sudo su - if you want a root shell

Step 1: Create two groups

Choose meaningful group names. Example: devs and staff.

- sudo groupadd devs
- sudo groupadd staff

Verify groups exist:

- getent group devs
- getent group staff

Step 2 : Create five users
Create five user using the command adduser, adduser will prompt for a password and optional info.

sudo adduser alice

sudo adduser bob

sudo adduser carol

sudo adduser dave

sudo adduser eve

logout of the current user to see all new users added

Step 3 :Assign users to groups

Decide group membership. Example mapping:
devs: alice, bob
staff: carol, dave, eve

Add users to groups (use -aG user to each group)

sudo usermod -aG devs alice
sudo usermod -aG devs bob
sudo usermod -aG staff carol
sudo usermod -aG staff dave
sudo usermod -aG staff eve

Verify membership:
verify membership by using the command sudo getent group devs and sudo getent group staff

Step 4 : Create a shared project directory

Create a directory that group members can read/write. We'll create a company_projects folder in the home directory:

- mkdir -p /home/company_projects (create a parent directory in the home directory)

sudo chmod g+s /home/company_projects The g+s (setgid on directory) is what makes a shared project folder behave like a real team workspace.

sudo chown root:devs /home/company_projects

chown → change owner of a file or directory.
root:devs
root = new owner of the directory
devs = new group of the directory
/home/company_projects → the target directory.

sudo chmod u+rwx /home/company_projects

chmod → change file/directory permissions.
u → refers to the owner of the directory.
+rwx → add read (r), write (w), and execute (x) permissions.
Effect: The owner of ~/company_projects can list contents, create/delete files, and enter the directory

sudo chmod g+rwx /home/company_projects

chmod: change permissions.
g: refers to the group of the file/directory (in your case, the group might be devs because of sudo chown root:devs).
+rwx: add three permissions:
r (read): group members can list the files inside.
w (write): group members can create new files, delete files, and make changes.
x (execute): group members can enter the directory and access its contents.

Step 5 : Test the shared directory behavior

switched to the alice account and tried to enter /home/company_projects

su - alice
cd /home/company_projects
touch file_from_alice.txt
ls
shows: file_from_alice.txt
ls -l
shows a line similar to:
-rw-rw-r-- 1 alice devs 0 Sep 27 08:40 file_from_alice.txt
What this shows:
The file owner is alice.
The file group is devs — it inherited the directory group (devs) because the parent directory had the setgid bit.
File permissions are -rw-rw-r-- (owner read/write, group read/write, others read).

5.1 As another devs member (bob), confirm you can edit/delete:

su - bob
cd ~/company_projects
echo "hello" >> testfile_from_alice.txt
cat testfile_from_alice.txt allowed because group has write permission

5.2 A non-member (e.g., carol, in staff) should be denied because they are not a member of the group devs, they belong to the staff group:

su - carol
cd /home/company_projects
this should fail with "Permission denied"
touch should_fail.txt

Step 6 : Manage file ownership and group on existing files

Set owner and group for a file or directory using the command

sudo chown alice:devs /home/company_projects/somefile.txt
The owner of the directory is alice and now belong to the devs team.

6.1 change only group:

sudo chgrp staff ~/company_projects/some_other_file.txt

Before the command

The directory /home/company_projects had:

Owner: alice
Group: devs
Shown by:
drwxrwsr-x 2 alice devs 4096 Sep 27 09:15 /home/company_projects
Step: sudo chgrp staff /home/company_projects
chgrp = change group ownership
staff = new group
So, this command changed the group of the directory from devs ➝ staff.
Now the directory looks like:
drwxrwsr-x 2 alice staff 4096 Sep 27 09:15 /home/company_projects

Meaning:

Owner is still alice
Group is now staff
Next: su - carol
switched to user carol.
Carol goes into /home/company_projects and creates a file:
touch man.txt
Now when you list:
-rw-rw-r-- 1 carol staff 0 Sep 27 09:53 man.txt
-rw-rw-r-- 1 alice devs 16 Sep 27 09:23 testfile_from_alice.txt

Why this happened:

man.txt
Owner = carol (because she created it).
Group = staff (because the directory /home/company_projects now belongs to group staff AND it has the setgid bit s set → that s in drwxrwsr-x).
The setgid bit ensures new files created inside inherit the directory’s group.
testfile_from_alice.txt
This was created earlier by Alice when the group was still devs.
So it keeps alice:devs.

Conclusion

In this project, we explored how Linux handles file ownership, groups, and permissions through practical examples. By using commands such as chown, chgrp, and chmod, we demonstrated how to assign files and directories to specific users and groups, as well as how to control access levels.
A key highlight was the use of the setgid (s) permission on directories, which ensures that newly created files inherit the group ownership of the parent directory. This feature makes collaboration easier in shared project folders, as users automatically create files that belong to the intended group.
From the exercises, we saw how ownership transitions (e.g., alice:devs ➝ alice:staff) affect who can read, write, or execute within shared directories, and how different users (alice, carol, etc.) interact with files depending on group membership.

Overall, this project demonstrates the importance of carefully managing permissions in multi-user environments. By applying these principles, system administrators can create secure, collaborative workspaces while maintaining control and accountability over files and directories.

Mastering Linux: File & Directory Management with a Mock Company Project

SUBAIR NURUDEEN ADEWALE — Mon, 22 Sep 2025 11:53:09 +0000

Introduction

Linux is one of the most powerful and widely used operating systems in the world. From running servers and cloud platforms to powering embedded systems and supercomputers, its flexibility makes it a must-learn skill for anyone in technology. At the heart of Linux usage is the ability to effectively manage files and directories. Mastering this fundamental skill not only boosts efficiency but also lays the groundwork for advanced system administration, DevOps, and automation.

In this project, “File & Directory Management for a Mock Company using Linux”, we simulate a real-world environment by creating and managing a company’s directory structure. This hands-on exercise helps learners understand how to navigate the Linux filesystem, manipulate files, and organize data effectively, using both absolute and relative paths, along with essential commands.

Tasks to Cover in the Project

Here are the step-by-step applied tasks you will complete:

Set Up the Company Structure

Create directories for different departments (HR, Finance, Dev, Marketing).

Create and Manage Files

Add employee records, policy documents, budgets, and project files.
Use commands like touch, ls, cat.

Copy, Move, and Rename Files

Share policies across departments.
Move misplaced project files.
Rename files correctly.

Search and Find Files

Use find to locate files.
Search content inside files with grep.

Compress and Backup Data

Archive the company directory with tar and gzip.
Extract the archive to test backup recovery.

Check Storage Usage

Monitor directory size with du.
Check disk space with df.

Work with Paths

Practice using absolute paths (/home/user/company/...).
Practice using relative paths (../finance/budget.txt).

Step 1 Create the Company Folder Structure

We will first create a parent directory named company, and inside this directory, we will create four subdirectories representing different departments of the organization:

Commands Used and Their Meanings

mkdir -p ~/company
mkdir: Make Directory (creates a new folder)
-p: Parents flag (creates parent directories if they don't exist)
~/company: Path to the new directory (in the user's home folder)
Meaning: Create a directory called "company" in the home directory
mkdir -p ~/company/hr (and similar commands)
Meaning: Create subdirectories (hr, finance, marketing, dev) inside the company directory
ls
Meaning: List contents of the current directory
cd company
cd: Change Directory
Meaning: Move into the company directory

1.1 Create the main company directory:

- mkdir -p ~/company

1.2 Create department subdirectories:

mkdir -p ~/company/hr
mkdir -p ~/company/finance
mkdir -p ~/company/marketing
mkdir -p ~/company/dev

1.3 Verify the directory structure:

ls
This shows all files and directories in your current location, including the new "company" directory.

1.4 Navigate into the company directory:
Navigate into the parent directory (company) using the cd command.
*cd * company

ls
This confirms that all four department directories (dev, finance, hr, marketing) were created successfully.

Step 2: Create Some Sample Files

touch → creates empty files.

Here we simulate real company documents: HR gets employee records and policies, Finance gets budgets, Dev has project files, and Marketing has strategies.

You can confirm they were created with:

ls ~/company/hr
ls ~/company/finance
ls ~/company/dev
ls ~/company/marketing

Step 3: Copy & Rename Files

Copy HR policies to Marketing:

cp copy files from one directory to another directory
ls comfirm the policies.txt file is copied to marketing directory

cp ~/company/hr/policies.txt ~/company/marketing/

mv → use for renaming files.

The file in the dev folder (projectA.txt) is spelt wrongly, rename the file to project2025.txt
cd into the dev directory
ls to list the files in the directory
use mv to rename the directory from projectA.txt to project2025.txt
use ls to verify your change.

Step 4: Search for Files

find → locates files and directories matching a pattern.
grep -r → searches inside files for specific words recursively.
This is useful for quickly tracking down documents.
find ~/company -name "*.txt" locates files and directories that has the .txt files.
find ~/company -name "*.txt" locates files and directories that has the .png files.

Search for the word “policy” inside files:

grep -r "policies" ~/company

Step 5: Organize with Compression

At some point, every company needs to back up its files to protect against accidental deletion, corruption, or system failure. In Linux, one of the most common tools for this is tar (short for tape archive). It allows you to bundle multiple files and directories into a single archive, and with the right options, compress it to save space.

5.1 Compress the company folder

Command:

tar -czvf company_backup.tar.gz ~/company

tar → archives multiple files and directories into one.
-c → create a new archive.
-z → compress the archive using gzip (makes it smaller in size).
-v → verbose mode, shows the progress in the terminal as files are being archived.
-f → specifies the filename of the archive (company_backup.tar.gz).
~/company → the folder you want to back up.
This command creates a compressed backup file named:
company_backup.tar.gz
in your current working directory. Extract the backup to test

Command:

tar -xzvf company_backup.tar.gz -C ~/

-x → extract files from an archive.
-z → tells tar the archive is compressed with gzip.
-v → verbose mode, shows files being extracted.
-f → specifies the filename of the archive.
-C ~/ → tells tar where to extract the files (in this case, your home directory).

This simulates restoring the backup. After extraction, you should see the company folder again in your home directory.

5.2 Compress the company folder:

tar -czvf company_backup.tar.gz ~/company

5.3 Extract it to test:

tar -xzvf company_backup.tar.gz -C ~/

5.4 View whats inside the compressed folder

Check what’s inside your archive before extracting:
This lists all files and directories stored in the archive.

tar -tzvf company_backup.tar.gz

5.5 Extract into a new folder
Create a new folder (Restorefiles) in the company directory which is the parent directory.

5.5.1 Preparation Setup

mkdir -p ~/company/Restorefiles
cd company
ls
cd ..

Created a safe restoration area (Restorefiles) to extract backup files
Verified your existing company structure before restoration
Positioned yourself in the home directory ready for extraction

5.1.2: Backup Extraction

tar xzvf company_backup.tar.gz -C ~/company/Restorefiles

Extracted a compressed backup archive (company_backup.tar.gz)
Used safe extraction to an isolated location instead of overwriting original files
Preserved the complete directory structure and file permissions

5.1.3 Verification & Inspection

cd ~/company/Restorefiles
ls
cd home
ls
cd vboxuser
ls
cd company
ls

Navigated through the extracted backup structure to verify contents
Confirmed all data was intact: departments, files, and hierarchy
Checked that the backup matched your expected company structure
What Your Backup Contained

Step 6: Check Storage & File Sizes

Commands:

6.1 Check company folder size:

du -sh ~/company

the size is 60kilobytes.

6.2 Check overall disk usage

df -h

du -sh → displays size of a directory in human-readable format.

df -h → shows free/used space on mounted filesystems.

Conclusion

This project has demonstrated how Linux can be used to simulate and manage a real-world company’s file system. By creating a structured directory for departments, adding and organizing files, moving and renaming them, and finally securing everything with compression and backups, you have gained practical skills that every system administrator and DevOps engineer must master.

Through these hands-on exercises, you learned how to:

Create and navigate directories with mkdir and cd.
Manage files using commands like touch, ls, cp, and mv.
Search for files and content with find and grep.
Back up and restore data with tar and gzip.
Monitor storage usage with du and df.

By applying these skills to a mock company environment, you not only practiced Linux commands but also understood their importance in real workplace scenarios such as organizing data, maintaining backups, and ensuring efficient file management. Mastering these fundamentals provides a solid foundation for more advanced topics like shell scripting, permissions, user management, automation, and cloud deployment. With these skills in hand, you are well on your way to becoming confident in Linux system administration.

How to Create DNS zones and configure DNS settings

SUBAIR NURUDEEN ADEWALE — Wed, 10 Sep 2025 17:20:07 +0000

Introduction

In modern cloud environments, Domain Name System (DNS) plays a vital role in managing how applications and services communicate. Instead of relying on IP addresses, DNS provides user-friendly names that are easier to manage and remember. In this project, we focus on creating and configuring DNS zones and DNS settings within Microsoft Azure. By setting up private DNS zones, configuring DNS records, and integrating DNS settings with a virtual network, we ensure reliable name resolution for resources, improve security, and simplify network management.

Tasks to Cover

Create and configure a private DNS zone – to manage DNS records within a secure, isolated environment.
Create and configure DNS records – to map domain names to IP addresses or other resources.
Configure DNS settings on a virtual network – to ensure virtual machines and services in the VNet can resolve names efficiently.

Step 1 Create a private DNS zone

Azure Private DNS provides a reliable, secure DNS service to manage and resolve domain names in a virtual network without the need to add a custom DNS solution. By using private DNS zones, you can use your own custom domain names rather than the Azure-provided names.

On the Azure portal, search for and select Private dns zones.

Select + Create and configure the DNS zone.

Subscription: Select your subscription
Resource group: RG1
Name: private.contoso.com
Region: East US
Select Review + create

Select Create.

Wait for the DNS zone to deploy, and then select Go to resource.

Step 2 Create a virtual network link to your private DNS zone

To resolve DNS records in a private DNS zone, resources must be linked to the private zone. A virtual network link associates the virtual network to the private zone.

In the portal, continue working on the private.contoso.com DNS zone.
In the DNS Management blade, select + Virtual network links.

Select + Add” and configure the virtual network link.

Link name: app-vnet-link
Virtual network: app-vnet
Enable auto registration: Enabled
Select Create and wait for the deployment to finish. If necessary, Refresh the page.

The virtual ntework as been link to the private DNS zone

Step 3 Create a DNS record set

DNS records provide information about the DNS zone.

In the portal, continue working on the private.contoso.com DNS zone.
In the DNS Management blade, select + Recordsets.
Notice that two A records have automatically been created for each of the virtual machines.

Select + Add and configure a record set. When finished select Add.
Name: backend
Type: A
TTL: 1
IP address: 10.1.1.5

DNS recordset as been created

Note: This record set implies there is a virtual machine in app-vnet with a private IP address of 10.1.1.5.

Conclusion

By completing this project, a fully functional DNS infrastructure is established within Azure. Private DNS zones and records provide centralized management of domain names, while linking DNS settings to the virtual network ensures seamless name resolution across applications and services. This configuration not only improves accessibility and connectivity but also enhances security by keeping DNS resolution internal to the environment. Overall, the project demonstrates how DNS in Azure can simplify network operations and provide a scalable foundation for future workloads.

How to Configure Network routing in Azure

SUBAIR NURUDEEN ADEWALE — Wed, 10 Sep 2025 15:05:01 +0000

Introduction

In cloud networking, routing plays a vital role in ensuring that traffic between subnets, virtual networks, and external networks is directed efficiently and securely. Within Microsoft Azure, custom route tables allow administrators to control how traffic flows in and out of subnets, providing flexibility beyond the default system routing. This project focuses on configuring network routing in Azure by creating and associating a custom route table with subnets, and defining specific routes for traffic management. By completing this project, you will gain practical knowledge of how routing works in Azure and how to customize it to meet application or organizational requirements.

Tasks to Cover

Create a Route Table – Set up a custom route table that will manage routing rules within the virtual network.
Add the Route Table – Ensure the route table is properly integrated into the Azure environment.
Associate the Route Table to the Subnets – Link the created route table to one or more subnets so that its rules apply to traffic within those subnets.
Create a Route in the Route Table – Define a custom route that controls how specific traffic is directed, ensuring traffic flows as intended.

Step 1 Create a Route Table

Azure automatically creates a route table for each subnet within an Azure virtual network. The route table includes the default system routes. You can create route tables and routes to override Azure’s default system routes.

Record the private IP address of app-vnet-firewall

In the search box at the top of the portal, enter Firewall. Select Firewall in the search results.

Select app-vnet-firewall.

Select Overview and record the Private IP address.

Step 2 Add the route table

In the search box, enter Route tables. When Route table appears in the search results, select it.

In the Route table page, select + Create and create the route table.

Complete the following configuration

Subscription: Select your subscription
Resource group: RG1
Region: East US
Name: app-vnet-firewall-rt
Select Review + create

Select Create.

Wait for the route table to deploy, then select Go to resource.

Step 3 Associate the route table to the subnets

In the portal, continue working with the route table, select app-vnet-firewall-rt.

In the Settings blade, select Subnets and then + Associate.
Configure an association to the frontend subnet, then select OK.
Virtual network: app-vnet (RG1)
Subnet: frontend

Configure an association to the backend subnet, then select OK.
Virtual network: app-vnet (RG1)
Subnet: backend

The Frontend and the Backend subnets as been associated to the route table.

Step 4 Create a route in the route table

In the portal, continue working with the route table, select app-vnet-firewall-rt.

In the Settings blade, select Routes and then + Add.
Configure the route, then select Add.
Route name outbound-firewall
Destination type IP addresses
Destination IP addresses/CIDR range 0.0.0.0/0
Next hop type Virtual appliance
Next hop address: private IP address of the firewall (10.0.2.4)

Route was created successfully in the route table

Conclusion

By completing this project, a custom route table has been successfully created, associated, and configured within Azure. These steps ensure greater control over traffic flow in the virtual network, enabling administrators to optimize performance, enforce security, and implement custom networking requirements. This exercise demonstrates the practical application of Azure’s routing capabilities and establishes a foundation for more advanced network designs.