DEV Community: Ibrahim Bio Abubakar

How to Create an EC2 VM in AWS (Step-by-Step Guide for Beginners)

Ibrahim Bio Abubakar — Thu, 25 Sep 2025 14:55:54 +0000

Amazon EC2 (Elastic Compute Cloud) is one of the most popular services in AWS, allowing you to launch and manage virtual machines in the cloud. In this guide, we’ll walk through creating a Demo EC2 instance using the Amazon Linux AMI and a t2.micro free-tier instance type. We’ll also add a simple user data script to run on startup.

Prerequisites

An AWS account
Basic familiarity with AWS Management Console

Step 1: Log in to AWS Management Console

Head over to AWS Console.
From the Services menu, search for EC2 and click on it.

Step 2: Launch an Instance

Click Launch instance.

Give your instance a name: Demo EC2.

Step 3: Choose Amazon Machine Image (AMI)

In the Application and OS Images section, choose:

Amazon Linux (Free Tier eligible).

⚡ Step 4: Select Instance Type

From the Instance type dropdown, select:

t2.micro (Free Tier eligible).

Step 5: Configure User Data (Startup Script)

Scroll down to Advanced details.
In the User data section, paste the following script:

   #!/bin/bash
   echo "Hurray!!! We got this working" > /home/ec2-user/startup.txt

This script will create a file named startup.txt with the message inside.

Step 6: Configure Key Pair

Either select an existing key pair or create a new one.
This will allow you to SSH into your instance later.

Step 7: Configure Network Settings

Choose default VPC and subnet (unless you want custom networking).
Allow SSH traffic from your IP.
Allow HTTP traffic from the internet.

Step 8: Launch the Instance

Review all settings.

Click Launch instance.

Your Demo EC2 instance will now spin up in the cloud!

Step 9: Verify User Data Script

Once the instance is running, select connect for EC2 Instance Connect.

Ensure the Connection type is set to Connect using a Public IP, Puplic IPv4 address is selected and the Username is ec2-user; then select Connect.

We have now successfully connected to the Amazon Linux 2023 machine:

Run:

   cat /home/ec2-user/startup.txt

You should see:

   Hurray!!! We got this working

Conclusion

In just a few steps, you’ve launched your first Amazon EC2 instance using Amazon Linux on a t2.micro free-tier machine. With the user data script, we confirmed automation works right at startup.

Next steps: Try customizing the user data script to install software packages, run web servers, or deploy applications automatically.

Build Once, Deploy Everywhere: Deploying a .NET 8 API with Docker, AKS & GitHub Actions

Ibrahim Bio Abubakar — Wed, 24 Sep 2025 18:39:57 +0000

Cloud-native development can feel overwhelming at first—containers, Kubernetes, CI/CD pipelines, cloud providers, etc. This tutorial walks you step by step from writing a simple .NET 8 Web API to deploying it on Azure Kubernetes Service (AKS) with a fully automated GitHub Actions CI/CD pipeline.

We’ll go beyond just writing code. You’ll also learn how and why each tool fits into the bigger cloud-native picture.

Learning Objective

By completing this tutorial, you will master:

Building production-ready .NET 8 Web APIs
Containerizing applications with Docker
Deploying to Azure Kubernetes Service (AKS)
Setting up CI/CD pipelines with GitHub Actions
Applying cloud-native development best practices

Project Overview

We’ll build a Weather Forecast API and deploy it to the cloud.

Backend → .NET 8 Web API
Containerization → Docker
Cloud Platform → Azure Kubernetes Service (AKS)
Automation → GitHub Actions for CI/CD

Prerequisites

Required Software

Install these tools (in order):

⚠️ Remember: Start Docker Desktop after installation

Azure CLI

kubectl

GitHub CLI (optional)

Required Accounts

GitHub(free)

Azure (free tier with $200 credits)

Verify Installation

Run the following commands in your terminal:

dotnet --version          # Shows installed .NET SDK version (should be 8.x.x)
git --version             # Confirms Git is installed
docker --version          # Confirms Docker CLI works
az --version              # Shows Azure CLI version
kubectl version --client  # Verifies kubectl client

Note: If any fail → reinstall that tool.

💻 Step 1: Create the .NET Application

1.1 Set Up Project Structure

mkdir weather-app-demo   # Create root project folder
cd weather-app-demo
mkdir WeatherApp         # Create app folder
cd WeatherApp

Why? → Organizing code and infra configs in separate folders makes CI/CD pipelines easier to manage.

1.2 Initialize .NET Project

dotnet new webapi -minimal

dotnet new → Creates a new project

webapi → Template for REST APIs

-minimal → Uses the simplified .NET 8 minimal API syntax (less boilerplate)

1.3 Add Dependencies

dotnet add package Microsoft.Extensions.Diagnostics.HealthChecks

HealthChecks → Adds endpoints for monitoring app health (Kubernetes probes rely on this).

dotnet add package Swashbuckle.AspNetCore

Swashbuckle.AspNetCore → Generates Swagger/OpenAPI docs automatically.

1.4 Application Code

Replace the content Program.cs with:

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddHealthChecks();          // Adds /health endpoint
builder.Services.AddEndpointsApiExplorer();  // Enables endpoint discovery for Swagger
builder.Services.AddSwaggerGen();            // Generates Swagger UI

// Configure Kestrel to listen on port 8080 (important for containers)
builder.WebHost.ConfigureKestrel(options =>
{
    options.ListenAnyIP(8080);  // Allows traffic from any network interface
});

var app = builder.Build();

// Enable Swagger UI in Dev & Prod
if (app.Environment.IsDevelopment() || app.Environment.IsProduction())
{
    app.UseSwagger();
    app.UseSwaggerUI(c => 
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "Weather API v1");
        c.RoutePrefix = "swagger";  // URL: /swagger
    });
}

// Welcome endpoint
app.MapGet("/", () => new
{
    Message = "Welcome to the Weather App!",
    Version = "1.0.0",
    Environment = app.Environment.EnvironmentName,
    Timestamp = DateTime.UtcNow
})
.WithName("GetWelcome")
.WithTags("General");

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

    var forecast = Enumerable.Range(1, 5).Select(index => new
    {
        Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)), // Next 5 days
        TemperatureC = Random.Shared.Next(-20, 55),                 // Random °C
        TemperatureF = 0,                                           // Placeholder
        Summary = summaries[Random.Shared.Next(summaries.Length)]
    })
    .Select(temp => new
    {
        temp.Date,
        temp.TemperatureC,
        TemperatureF = 32 + (int)(temp.TemperatureC / 0.5556), // Formula °C → °F
        temp.Summary
    });

    return forecast;
})
.WithName("GetWeatherForecast")
.WithTags("Weather");

// Health check endpoint (important for Kubernetes probes)
app.MapHealthChecks("/health")
.WithTags("Health");

app.Run();  // Starts the web server

Concepts Explained:

Minimal APIs → Introduced in .NET 6, let you build APIs with fewer lines.
Swagger → Auto-generates interactive API docs.
Probes → Kubernetes uses health endpoints to restart/retry containers when needed.

1.5 Test Locally

dotnet run

Test endpoints in browser or with curl in the terminal:

http://localhost:8080/ → Welcome message

http://localhost:8080/weather → Forecast data

http://localhost:8080/swagger → Swagger docs

http://localhost:8080/health → Health check

Below is the Weather App on a browser:

Stop the app with Ctrl + C.

🐳 Step 2: Containerize Your Application with Docker

We’ll package the .NET app into a Docker container so it can run consistently anywhere.

2.1 Create Dockerfile

Create a file named Dockerfile inside WeatherApp/ directory:

touch Dockerfile

Add the content below to the Dockerfilecreated:

# Multi-stage build for optimized image size

# Runtime stage
FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
WORKDIR /app
EXPOSE 8080
ENV ASPNETCORE_URLS=http://+:8080
ENV ASPNETCORE_ENVIRONMENT=Production

# Build stage
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src

# Copy project file and restore dependencies
COPY ["WeatherApp/WeatherApp.csproj", "."]
RUN dotnet restore "WeatherApp.csproj"

# Copy source code and build
COPY . .
WORKDIR /src
COPY WeatherApp/ ./WeatherApp/
WORKDIR /src/WeatherApp
RUN dotnet restore "WeatherApp.csproj"
RUN dotnet build "WeatherApp.csproj" -c $BUILD_CONFIGURATION -o /app/build

# Publish stage
FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "WeatherApp.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

# Final stage
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "WeatherApp.dll"]

Concept: Multi-stage builds → build and runtime environments are separate. This keeps the final image small and secure.

2.2 Create .dockerignore

Prevent unnecessary files from bloating your image:

touch .dockerignore

Add the content below to the Dockerfilecreated:


# Build outputs
bin/
obj/
out/

# IDE files
.vs/
.vscode/
*.user
*.suo

# OS files
.DS_Store
Thumbs.db

# Git
.git/
.gitignore

# Docs
README.md
*.md

# Docker
Dockerfile*
.dockerignore

# Logs
*.log
logs/

2.3 Build & Test Container

# Build image
docker build -t weather-app:local .     # Ensure your Docker Desktop is running before you run this command

Below is the built WeatherApp image in Docker Desktop app:

Now let's run the container:

# Run container
docker run -d -p 8080:8080 --name weather-test weather-app:local

Test the running app using curl in the terminal:

# Test endpoints
curl http://localhost:8080/
curl http://localhost:8080/weather

# Clean up
docker stop weather-test
docker rm weather-test

Concept: Containers make your app portable — works the same on your laptop and in the cloud.

Step 3: Set Up Azure Infrastructure

We’ll use Azure CLI to provision resources.

3.1 Login to Azure

az login  #Opens browser for Azure sign-in.

3.2 Select Subscription

az account list --output table     # See subscriptions
az account set --subscription "Your-Subscription-Name"

3.3 Create Resource Group

az group create --name student-demo --location eastus

Concept: A resource group is a logical container for all your Azure resources.

3.4 Create Container Registry (ACR)

az acr create --resource-group student-demo --name studentdemo2042acr --sku Basic

Concept: ACR = private Docker Hub inside Azure.

3.5 Build & Push Image

az acr build --registry studentdemo2042acr --image weather-app:latest .

Why ACR build? → Azure builds inside the cloud, avoiding OS/CPU compatibility issues.

3.6 Create AKS Cluster

az aks create \
  --resource-group student-demo \
  --name student-aks-cluster \
  --node-count 1 \
  --node-vm-size Standard_B2s \
  --attach-acr studentdemo2042acr \
  --enable-managed-identity \
  --generate-ssh-keys

📌 Concept:

AKS = Azure-managed Kubernetes cluster
attach-acr → avoids ImagePullBackOff errors by linking AKS to ACR automatically

3.7 Connect to Cluster

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

kubectl get nodes   # Verify cluster connection

☸️ Step 4: Deploy with Kubernetes

Kubernetes uses YAML manifests to declare your app’s state.

cd ..  # Back to weather-app-demo folder
mkdir k8s
cd k8s
touch deployment.yaml

4.1 Create Deployment

Copy and paste the content below in k8s/deployment.yaml


apiVersion: apps/v1
kind: Deployment
metadata:
  name: weather-app
  labels:
    app: weather-app
    version: v1
spec:
  replicas: 2  # Run 2 pods for high availability
  selector:
    matchLabels:
      app: weather-app
  template:
    metadata:
      labels:
        app: weather-app
        version: v1
    spec:
      containers:
      - name: weather-app
        image: studentdemo2024acr.azurecr.io/weather-app:latest
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
        env:
        - name: ASPNETCORE_ENVIRONMENT
          value: "Production"
        resources:  # Resource requests & limits
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        # Probes for self-healing
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10

📌 Concepts:

Deployment → ensures the desired # of pods run.
Probes → tell Kubernetes when a pod is healthy or ready.

4.2 Create Service

Create k8s/service.yaml file

touch service.yaml

Copy and paste the content below in k8s/service.yaml

apiVersion: v1
kind: Service
metadata:
  name: weather-app-service
spec:
  type: LoadBalancer   # Exposes app to internet
  selector:
    app: weather-app
  ports:
  - port: 80           # External port
    targetPort: 8080   # Maps to container

📌 Concept: A Service gives your pods a stable IP address + load balancing.

4.3 Deploy

# Apply Kubernetes manifests

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

# Check deployment status
kubectl get deployments
kubectl get pods

# Check deployment status
kubectl get services

🔄 Step 5: GitHub Actions CI/CD

We’ll automate build → push → deploy.

5.1 Init Git

cd ..  # Back to weather-app-demo folder

# Initialize Git repository
git init
git add .
git commit -m "Initial commit: Weather App"

5.2 Create Service Principal

# Get your subscription ID
SUBSCRIPTION_ID=$(az account show --query id --output tsv)
echo "Subscription ID: $SUBSCRIPTION_ID"

# Create service principal with contributor role
az ad sp create-for-rbac \
  --name "weather-app-github-sp" \
  --role contributor \
  --scopes /subscriptions/$SUBSCRIPTION_ID/resourceGroups/student-demo \
  --sdk-auth

Save JSON output → add as GitHub Secret AZURE_CREDENTIALS.

5.3 Create GitHub Repo

gh auth login  # Follow the prompts

# Create GitHub repository (using GitHub CLI) and Push to Repo
gh repo create weather-app-demo --public --source=. --push

Alternative: Create the repository manually on GitHub.com and push your code.

5.4 Configure GitHub Secrets

Use JSON output from step 5.2

gh secret set AZURE_CREDENTIALS -b'PASTE_JSON_HERE'

gh secret set ACR_NAME -b"studentdemo2042acr"

gh secret set RESOURCE_GROUP -b"student-demo"

gh secret set CLUSTER_NAME -b"student-aks-cluster"

5.5 Create a GitHub Workflow

Create the workflow directory and file:


mkdir -p .github/workflows
touch .github/workflows/deploy.yml

Copy and paste the content below in .github/workflows/deploy.yml file.

name: Build and Deploy to AKS
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  IMAGE_NAME: weather-app

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: '9.0.x'

      - name: Restore dependencies
        run: dotnet restore WeatherApp/WeatherAPP.csproj

      - name: Build application
        run: dotnet build WeatherApp/WeatherAPP.csproj --configuration Release --no-restore

      - name: Run tests
        run: dotnet test WeatherApp/WeatherAPP.csproj --no-build --verbosity normal || true

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

      - name: Setup Azure CLI
        uses: azure/cli@v2
        with:
          inlineScript: echo "Azure CLI setup complete"

      - name: Build and push Docker image to ACR
        run: |
          IMAGE_TAG=${{ secrets.ACR_NAME }}.azurecr.io/${{ env.IMAGE_NAME }}:${{ github.sha }}
          az acr build \
            --registry ${{ secrets.ACR_NAME }} \
            --image ${{ env.IMAGE_NAME }}:${{ github.sha }} \
            --file WeatherApp/Dockerfile \
            .
          echo "IMAGE_TAG=$IMAGE_TAG" >> $GITHUB_ENV

      - name: Deploy to AKS
        if: github.ref == 'refs/heads/main'
        run: |
          echo "Checking if AKS cluster exists..."
          if ! az aks show --resource-group "${{ secrets.RESOURCE_GROUP }}" --name "${{ secrets.CLUSTER_NAME }}" --output table; then
            echo "ERROR: AKS cluster '${{ secrets.CLUSTER_NAME }}' not found in resource group '${{ secrets.RESOURCE_GROUP }}'"
            exit 1
          fi

          echo "Getting AKS credentials..."
          az aks get-credentials \
            --resource-group ${{ secrets.RESOURCE_GROUP }} \
            --name ${{ secrets.CLUSTER_NAME }} \
            --overwrite-existing

          echo "Testing kubectl connection..."
          kubectl cluster-info

          echo "Updating deployment with image: ${{ env.IMAGE_TAG }}"
          kubectl set image deployment/weather-app \
            weather-app=${{ env.IMAGE_TAG }}

          echo "Waiting for rollout to complete..."
          kubectl rollout status deployment/weather-app --timeout=600s

          echo "Deployment status:"
          kubectl get pods -l app=weather-app
          kubectl get service weather-app-service

📌 Concept:

GitHub Actions → automates the whole pipeline.
Every push to main → build → push image → deploy to AKS.

5.6 Deploy Your Application

git add .
git commit -m "Add GitHub Actions CI/CD pipeline"
git push origin main

Monitor the deployment:

Go to your GitHub repository
Click the Actions tab
Watch your workflow run in real-time

🌐 Step 6: Access Your Deployed App

6.1 Get External IP Address

# Check service status
kubectl get service weather-app-service

# Wait for EXTERNAL-IP (may take 2-5 minutes)
kubectl get service weather-app-service --watch

Wait until EXTERNAL-IP is assigned. Then test:

# Test the endpoints
curl http://YOUR-EXTERNAL-IP/
curl http://YOUR-EXTERNAL-IP/weather
curl http://YOUR-EXTERNAL-IP/health

# Or open in browser
open http://YOUR-EXTERNAL-IP/swagger  # macOS
start http://YOUR-EXTERNAL-IP/swagger  # Windows

🔄 Step 7: Test Continuous Deployment

Edit Program.cs welcome message.

app.MapGet("/", () => new
{
    Message = "Welcome to the Updated Weather App! 🌤️",
    Version = "1.1.0",
    Environment = app.Environment.EnvironmentName,
    Timestamp = DateTime.UtcNow,
    DeployedBy = "GitHub Actions"
})

Commit & push:

git add .
git commit -m "Update welcome message"
git push origin main

GitHub Actions will rebuild & redeploy automatically.

Test again → you should see your new message.

curl http://YOUR-EXTERNAL-IP/

Conclusion

You’ve just taken a local .NET 8 Web API and transformed it into a cloud-native application running on Azure Kubernetes Service, packaged with Docker, and automated with a GitHub Actions CI/CD pipeline. That’s the full lifecycle of modern cloud development — from writing code → to shipping containers → to running resilient workloads in production.

The best part? You now have a repeatable blueprint you can apply to almost any project:

Swap the Weather API with your own service

Reuse the Docker + Kubernetes setup

Extend your GitHub workflow for tests, security scans, or staging environments

This isn’t just about building an app — it’s about learning how to ship production-ready software at scale.

Keep experimenting: add monitoring, autoscaling, or connect a database. The cloud-native journey is iterative, but now you’ve got the foundations locked in.

From Code to Cloud: Seamless CI/CD with GitHub Actions and Azure Web Apps

Ibrahim Bio Abubakar — Sat, 13 Sep 2025 21:39:02 +0000

Have you ever built a cool Node.js app on your local machine and thought, “Now what? How do I get this running in the cloud without manually pushing code every time?” That’s exactly where CI/CD (Continuous Integration and Continuous Deployment) comes to the rescue.

In this article, I’ll walk you through how I took a simple Node.js application from code to cloud using GitHub Actions, Docker, Kubernetes, and Azure Web App Services. We’ll set up a seamless pipeline that automatically builds, tests, and deploys changes the moment you push to GitHub—no more manual deployments, no more “it works on my machine” headaches.

By the end, you’ll see how easy it is to:

Containerize your Node.js app with Docker 🐳
Orchestrate deployments with Kubernetes ⚙️
Automate CI/CD using GitHub Actions 🤖
Deploy effortlessly to Azure Web Apps ☁️

Let’s dive in and turn your local project into a production-ready cloud app!

Prerequisites - Download These First!

Before starting, you need to install these tools on your machine:

Node.js (v18 or higher) – Download (choose LTS version 20.x)

   node --version
   npm --version

Git – Download

   git --version

Docker Desktop – Download

   docker --version
   docker-compose --version

GitHub Account – Sign up here

Code Editor (optional, recommended) – VS Code

Step 1: Set Up Git for Version Control

Configure Git:

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

Output of command in VScode terminal:

Initialize your project:

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

Output of command in VScode terminal:

Step 2: Build a Node.js Web App

Initialize project:

# Create package.json with default settings
npm init -y

Output of command in VScode terminal:

Update package.json with scripts, metadata, and dev tools (Jest, ESLint, Supertest).

{
  "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"
  }
}

Then create app.js with routes for /, /health, /info, /metrics, and graceful shutdown logic.

# Creates file

touch app.js

Copy and paste this into app.js file:

// 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>Fullstack DevOps Lab 2025</h1>
    <p>Modern Node.js application with CI/CD pipeline</p>
    <p>Version: 1.0.0</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;

Install dependencies:

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

# Install all dependencies

npm install

Output of command in VScode terminal:

Step 3: Create Proper Tests

We are going to setup an automated testing that verify the application works correctly everytime a change is made.

Create a test directory and a test file tests/app.test.js

# Create a folder for your tests
mkdir tests

# Create the main test file
touch tests/app.test.js

Output of command in VScode terminal:

Copy and paste the code below 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

Jest is a JavaScript testing framework developed by Facebook (now Meta). It’s widely used in Node.js and React projects for testing code.

Create a jest.config.js file in the root folder for configuration.


touch jest.config.js

Output of command in VScode terminal:

Copy and paste the code below in 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

This creates an automated pipeline that runs tests and builds Docker images every time you push code to GitHub.

Create .github/workflows/ci.yml to:

Run tests and linting
Build & push Docker images to GitHub Container Registry
Run vulnerability scans
Deploy to staging/production based on branch

# Create the GitHub Actions directory structure
mkdir -p .github/workflows

# Create a ci.yml in .github/workflows directory
touch .github/workflows/ci.yml

Output of command in VScode terminal:

name: CI Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

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

jobs:
  test:
    name: Run Tests
    runs-on: ubuntu-latest

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

    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: npx eslint . --ext .js --ignore-pattern node_modules/
        continue-on-error: true

      - name: Run tests
        run: npm test

      - name: Run security audit
        run: npm audit --audit-level=moderate || true

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

    permissions:
      contents: read
      packages: write

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

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

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - 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=sha,prefix={{branch}}-
            type=raw,value=latest,enable={{is_default_branch}}

      - 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

  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 "Would deploy to staging server here"
          # In real scenario, you'd use:
          # - kubectl apply -f k8s/staging/
          # - docker-compose -f docker-compose.staging.yml up -d
          # - ssh staging-server "docker pull $IMAGE && docker-compose up -d"

  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 "Image digest: ${{ needs.build.outputs.image-digest }}"
          echo "Would deploy to production server here"
          # In real scenario, you'd use:
          # - kubectl apply -f k8s/production/
          # - terraform apply
          # - ansible-playbook deploy.yml

  security-scan:
    name: Security Scan
    runs-on: ubuntu-latest
    needs: build
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'

    steps:
      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'ghcr.io/YOU_GITHUB_USERNAME/my-devops-project:latest'  #All in lower case.  
          format: 'sarif'
          output: 'trivy-results.sarif'
    # env:
    #   TRIVY_USERNAME: ${{ github.actor }}
    #   TRIVY_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

Note: You'll need to replace YOU_GITHUB_USERNAME with your GitHub username.

Step 5: Dockerfile

This creates instructions for Docker to build a container image of your application that can run on any machine.

Create a multi-stage Dockerfile that:

Installs dependencies
Uses non-root user for security
Adds health checks
Exposes port 3000

#Create a Dockerfile

touch Dockerfile

Copy and paste the codes below into 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

Lets creates configuration files that tell various tools what to ignore, how to behave, and what settings to use.

Create the following:

.dockerignore
.gitignore
.env.example
.eslintrc.js

Output of command in VScode terminal:

Create .dockerignore, copy and paste the code below:


node_modules 
npm-debug
.log* 
.git 
.github 
.env 
.env.local 
.env.*.local 
logs 
*.log 
coverage 
.nyc_output 
.vscode 
.idea 
*.swp 
*.swo 
.DS_Store 
Thumbs.db 
README.md 
tests/ 
jest.config.js 
.eslintrc*

Create .gitignore, copy and paste the code below:

# Dependencies
node_modules/
npm-debug.log*

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Coverage
coverage/
.nyc_output

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

# Logs
logs
*.log

# IDE
.vscode/
.idea/
*.swp
*.swo

# OS
.DS_Store
Thumbs.db

Create .env.example, copy and paste the code below:


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

Create .eslintrc.js, copy and paste the code below:


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

Now let's create a Docker Compose file that makes it easy to run your application and any supporting services with a single command.

# Create a docker-compose.yml file 

touch docker-compose.yml

Create docker-compose.yml to run the app with, copy and paste the code below:


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

This demonstrates how to run and test your application locally before deploying it.

Run locally:

# Run your test suite to make sure everything works
npm test

Output of command in VScode terminal:

You should see all 5 tests pass successfully:

This starts the app in your local environment:

# Start the application server
npm start

What you'll see:

Server starts running at http://localhost:3000/

Your browser should give this output:

Test endpoints (using terminal windows)


---

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

Docker Commands:

Before running the Docker commands, ensure you've launched your Docker Desktop application.

This command builds the Docker image:


# Build image
docker build -t my-devops-app:latest .

Output of command in VScode terminal:

This shows the newly built container image my-devops-app:latest in Docker Desktop:

# Run container

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

Output of command in VScode terminal:

This shows the running container (my-devops-container) on Docker Desktop:

From your browser (http://localhost:3000), you should see this:

# Check container status
docker ps

# Test health check in terminal
curl http://localhost:3000/health

# Stop container

docker stop my-devops-container

# Delete Container
docker rm my-devops-container

Output of command in VScode terminal:

Docker Compose Commands

Run with Docker Compose:


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

Output of command in VScode terminal:

After running the above syntax, it also runs the application and displays it in the browser via http://localhost:3000

# Stop all services and clean up
docker-compose down

Output of command in VScode terminal:

Step 9: Deploy to GitHub

We'll now commit the code and push it to GitHub, allowing the automated CI pipeline to begin processing.


 # 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"

Output of command in VScode terminal:

IMPORTANT: Before running these commands:

Go to GitHub.com and create a new repository, give it a name of your choice. I called mine "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

Output of command in VScode terminal:


# Push your code to GitHub for the first time
git push -u origin main

Output of command in VScode terminal:

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

Step 10: Deploy to Azure Web Apps via Azure Portal

We’ve built our Node.js app, containerized it with Docker, and set up GitHub Actions for CI/CD. Now it’s time to take it live by deploying to Azure Web Apps, a fully managed Platform-as-a-Service (PaaS) that runs your app in the cloud without you managing servers or clusters.

Why Azure Web Apps?

Zero server management → Microsoft handles scaling, updates, and runtime.
CI/CD ready → GitHub Actions can publish new versions automatically.
Scalable → Apps scale up or out based on load.
Secure & monitored → Logs, metrics, and diagnostics included by default.

Steps in the Azure Portal

Log in to Azure Portal
Go to Azure Portal and sign in with your Azure account.
1. Create a Resource Group

In the left-hand menu, search for Resource Groups.
Click Create → provide a name (e.g., my-devops-app-rg) and select a region (preferably one close to you).

Create an App Service

From the menu, search for App Services → click Create and select web app.

Fill in:

Resource Group: my-devops-app-rg
App Name: my-devops-lab-app (must be unique)
Publish: Code
Operating System: Linux
Region: Choose the same as your resource group
Pricing Plan: Start with B1 (Basic) for testing

Configure Deployment

In the Deployment tab, enable:

Option: Continuous deployment
Select Authorize and connect your GitHub account with the Azure App Service to enable access to your repository.

Select the following details:

Organization: your GitHub account username
Repository: your repository name
Branch: your branch main (e.g main or master)

Review + Create

Click Review + Create and wait for Azure to provision the service.

CI/CD Integration from Portal

Azure Portal can automatically create a GitHub Actions workflow for you:

Azure will generate a workflow file in .github/workflows/
This workflow builds your app and redeploys automatically whenever you push to GitHub

Select Actions to see the pipeline running:

Below depicts the Continuous Integration (CI) pipeline phase:

This depicts the Continuous Deployment (CD) pipeline phase:

Access Your App

This indicates our web app service has been successfully deployed. Select Go to Resource

Select Browse to access the application in your browser

This is the application live in the browser:

Wrapping Up

You just built a complete CI/CD pipeline for a Node.js application:

Automated builds & tests with GitHub Actions
Containerization with Docker
Local orchestration with Docker Compose
Cloud hosting on Azure Web Apps

This workflow eliminates manual deployments, ensures code quality, and makes your app production-ready. 🚀

How to Deploy a Windows Server 2022 Domain Controller with VirtualBox Manager

Ibrahim Bio Abubakar — Thu, 10 Jul 2025 16:54:49 +0000

Introduction

In this lab exercise, we will use VirtualBox Manager as our virtualization tool. It is one of the many available virtualization platforms.

A Windows Server Domain Controller is a server that runs a Windows Server operating system and is responsible for managing security and access to resources within a Windows domain.

Key functions of a Domain Controller include:

Authentication: Validates users’ usernames and passwords when they log in.
Authorization: Controls what users can access (files, folders, applications).
Centralized Management: Enables administrators to manage users, computers, and policies in one place.
Active Directory (AD): Stores and organizes information about network resources (users, groups, computers, etc.).
Group Policy Management: Enforces settings and restrictions across users and computers in the domain.

Prerequisites

Ensure the following before starting:

Your computer (Windows or macOS) has at least 16 GB of RAM.
VirtualBox is downloaded and installed.
The ISO for Windows Server 2022 is downloaded.

Step 1: Launch and Mount Windows Server 2022 in VirtualBox Manager

Click New to create and configure your virtual machine (VM).

Enter a unique name for your Windows Server. I used “Server” for this lab.
For the ISO image, browse your computer and select the downloaded Windows Server 2022 ISO file: SERVER_EVAL_x64FRE_en-us.iso.
Select Skip Unattended Installation to manually configure the VM’s settings, including hardware specifications and OS installation details.

Expand the Hardware dropdown, increase the Base Memory to at least 4096 MB, and set the Processor to 2 CPUs.

Leave the Hard Disk at the default size of 50 GB. Then select Finish to add the VM to the VirtualBox Manager.

The newly created VM ("Server") should now appear in the VirtualBox interface.

Step 2: Launch and Configure the Windows Server 2022 Virtual Machine

Ensure the Server VM is selected, then click Start in VirtualBox Manager.

Select Next.

Click Install now.

Choose Windows Server 2022 Standard Evaluation (Desktop Experience).
Accept the Microsoft Software License Terms and click Next.

Select Custom: Install Microsoft Server Operating System.

Click Next to install.

The installation will begin. Wait until it completes.

Create a password for the Administrator account and click Finish.

Well done! Windows Server 2022 is now successfully installed and ready for use.

Rename the PC (Recommended)

Right-click the Windows Menu and select Settings.

Click Rename this PC.

Enter the same name you used earlier in VirtualBox (e.g., Server), then click Next.

Click Restart now to apply the changes.

Step 3: Create a Domain Controller Using Server Manager

When the VM starts, Server Manager should open automatically.

If not, click the Windows Menu, search for "Server Manager," and launch it.

In Server Manager, select Manage > Add Roles and Features.

On the Before You Begin page, click Next.

On the Installation Type page, select Role-based or feature-based installation, then click Next.

On the Destination Server page, ensure your server is selected, then click Next.

On the Server Roles page, check Active Directory Domain Services. A pop-up will appear.

Click Add Features, then Next through the next few steps.

On the Confirmation page, click Install. Installation may take a few minutes.

Once completed, click the notification flag icon in Server Manager and select Promote this server to a domain controller.

On the Deployment Configuration page, choose Add a new forest, and enter a root domain name (e.g., koraconsult.com), then click Next.

On the Domain Controller Options page, accept the defaults and set a DSRM password (used for recovery). Click Next.

Proceed through the DNS Options, Additional Options, Paths, and Review Options pages by clicking Next.
On the Prerequisites Check page, click Install. This process may take several minutes and the VM will restart when done.

After restarting, log in using your domain credentials, e.g., KORACONSULT\Administrator.

Conclusion

You've successfully configured a Windows Server 2022 virtual machine and promoted it to a Domain Controller using VirtualBox—all from scratch. This hands-on lab not only strengthens your virtualization skills but also lays the foundation for deeper exploration into Active Directory, Group Policies, and enterprise IT environments.

Keep experimenting—and remember to snapshot your VM before making major changes. Happy virtualizing!

How to Set Up Hyper-V for a Windows Server Environment: A Series on Active Directory Domain Services

Ibrahim Bio Abubakar — Wed, 11 Jun 2025 15:26:12 +0000

Introduction

Virtualization is a powerful tool that enables developers, IT professionals, and enthusiasts to run multiple operating systems on a single machine. Windows 11 comes with a native virtualization platform called Hyper-V, which is free, robust, and easy to set up — if you know where to look.

In this guide, I'll walk you through setting up Hyper-V on Windows 11 in a step-by-step manner. Whether you’re looking to test a Linux distro, experiment with Windows Server, or sandbox a dev environment, this post is for you.

Prerequisites:

Before we dive in, make sure your system meets the following requirements:

✅ Windows 11 Pro, Enterprise, or Education
❌ Hyper-V is not available on Windows 11 Home (but there’s a workaround—see the bonus section below)

✅ CPU with virtualization support (Intel VT-x or AMD-V)
✅ At least 8 GB of RAM (16 GB recommended)

The following steps serve as a guide to install Hyper-V on a Windows 11 Computer, where we shall install Hyper-V and configure a NAT Switch.

Step 1: Sign in to the Windows 11 computer with an account that has local Administrator privileges.

Step 2 On the Windows 11 Computer click Start, select Settings and on the Settings page select System.

Step 3: On the System page of settings, scroll down until you locate Optional Features. Select Optional Features.

Step 4: On the Optional Features Page, you can find the More Windows Features option at the top right corner under Related Settings.

Step 5: On the Windows Feature page, select the checkbox next to Hyper-V and click OK as shown below.

Step 6: When the installation completes, on the Windows Features page, click Restart Now.

Step 7: After the computer restarts, sign in again using the same account that has local Administrative privileges.

Step 8 Click Start and search for Hyper-V Manager. Pin Hyper-V Manager to the Taskbar.

Step 9: Open Hyper-V Manager, right click on the local Computer, and select Hyper-V Settings.

Step 10: On the Hyper-V settings dialog box, under Server, select Virtual Machines. Set the location of the Virtual Machine to C:\VirtualMachines

Step 11: Under the Hyper-V settings dialog box, under Server, select Virtual Machine Hard Disks. Set the location of the Virtual Machine Hard Disks to C:\VirtualMachines\VHDs. Click OK to close the Hyper-V Settings dialog box.

Step 12: Open PowerShell with Administrator access and run the following commands to create a NAT Network.

New-VMSwitch -SwitchName “NATSwitch” -SwitchType Internal
New-NetIPAddress -IPAddress 10.10.10.1 -PrefixLength 24 -InterfaceAlias “vEthernet (NATSwitch)”
New-NetNat -Name “NATNetwork” –InternalIPInterfaceAddressPrefix “10.10.10.0/24”

Then close PowerShell.

To continue this series on Active Directory Domain Services, my next post will be on "How to Create Windows Domain Controller Virtual Machine".

Conclusion

Hyper-V turns your Windows 11 machine into a powerful lab for testing, developing, or safely running multiple OSes. While it might not have the most modern UI compared to VirtualBox or VMware Workstation, it’s tightly integrated into Windows and incredibly stable.

Whether you’re building microservices, testing a new OS, or trying containers with Docker (which also uses Hyper-V behind the scenes), mastering Hyper-V is a valuable skill in your toolkit.

Have questions or tips? Drop them in the comments below!

How to Create and Configure Virtual Networks Using Microsoft Azure

Ibrahim Bio Abubakar — Mon, 19 May 2025 11:35:35 +0000

This article on virtual networking (VN) is going to be shared in the form of a series, where we shall cover several hands-on exercises to appreciate the idea of virtual networks in Microsoft Azure.

This series will include the following exercises on:

How to create and configure virtual networks (which we shall cover in this article).
How to create and configure a network security group
How to create and configure Azure Firewall
How to configure network routing
How to create DNS Zones and configure DNS settings

The steps applied in this article are from Microsoft learn

Let's swing into action by learning how to create and configure virtual networks.

Let's assume your organization is migrating a web-based application to Azure, and you've been tasked to put in place the virtual networks and subnets, followed by securely peering the virtual networks.

Outline of Tasks:

Create a virtual network.
Create a subnet.
Configure VNet peering.

Step 1. Sign in to the Azure Portal

Step 2. Search for and select virtual networks

Step 3. Select + Create and complete the configuration of the VN

Resource Group(RG): Create a resource with a name of your choice and ensure you select it. I'm using DemoRG as my RG for this exercise.
Virtual network name: enter app-vnet
Region: Select a region closer to you in the drop-down menu. I'm using (Europe)UK South for mine.

Step 4. Select next to be at the IP Address page, then select Add IPv4 address space, and ensure the IP address range is configure to 10.1.0.0 and the size is 16

Delete the default address space as shown in step 2 above, then select Add a subnet to create a subnet.

Step 5. In the Add a subnet page, enter the following details

Name: frontend
IPv4 address range: the one we added above (in step 4) from the drop-down menu 10.1.0.0/16
Starting address: 10.1.0.0
Size: 24

Select Add to add the frontend subnet to our VN.

We need to repeat the same process above to create another subnet called backend.

However, ensure the Starting address is 10.1.1.0 and the Size is 24 as shown below. Leave all other settings as default, then select Add to add the backend subnet in the VN.

Now select Review + create to create the app-vnet virtual network.

Step 6. We need to create another VN called hub-vnet, which requires only a subnet for the firewall.

We'll repeat the same process from Step 3 to create the second VN.

However, at the IP address page, use the default IPv4 address space and proceed to add a subnet.

For the subnet, select Azure Firewall as the Subnet purpose, then ensure the following:

IPv4 address range: select the default address space with the range 10.0.0.0/16
Starting address: 10.0.1.0.
Size: 26 is selected by default.

Leave other configurations as default and select Add.

The next step is to select Review + create

Step 7. Since our app-vnet and hub-vnet virtual networks are now ready with their respective configurations, we can peer them using the following steps.

Search for and select the app-vnet virtual networks.
In the Settings blade, select Peerings.
Select + Add a peering between the two virtual networks.
- Remote peering link name: api-vnet-to-hub
- Select your subscription
- Virtual network: select hub-vnet here.
- Local peering link name: use hub-to-app-vnet.

Leave other settings as their defaults. Select Add to create the virtual network peering.

Finally, once the deployment completes, verify the Peering status is Connected.

Conclusion

Congratulations, we've completed this phase of the virtual network series. The next exercise will be "creating and configuring network security groups".

A Step-by-Step Guid on How to Set Up and Deploy a LAMP Stack on a Linux Server

Ibrahim Bio Abubakar — Sat, 29 Mar 2025 13:51:52 +0000

How to Deploy a LAMP Stack in Linux

The LAMP stack (Linux, Apache, MySQL, PHP) is a popular open-source web development platform used to host dynamic websites and applications. This guide will walk you through setting up a LAMP stack on a Linux server.

Prerequisites

A Linux-based server (Ubuntu, Debian, CentOS, or any other Linux distribution)
A user account with sudo privileges
Basic knowledge of the Linux command line

Step 1: Update Your System

Before installing any software, update the package repository to ensure you get the latest versions:

sudo apt update && sudo apt upgrade -y   # For Uduntu/Debian-based systems

Step 2: Install Apache Web Server

Apache is the most widely used web server for hosting websites.

Install Apache

sudo apt install apache2 -y   # Ubuntu/Debian

Start and Enable Apache

sudo systemctl start apache2   # Ubuntu/Debian
sudo systemctl enable apache2  # Enable on boot

Verify Apache Installation

Open a web browser and navigate to your server's IP address:

http://your-server-ip

-Use ip addr show to check the IP address of your server.

If Apache is running, you should see the default Apache welcome page.

Step 3: Install MySQL Database Server

MySQL is the database component of the LAMP stack.

Install MySQL

sudo apt install mysql-server -y   # Ubuntu/Debian

Secure MySQL Installation

sudo mysql_secure_installation

Follow the prompts to set a root password and remove unnecessary settings for security.

Step 4: Install PHP

PHP is the scripting language that processes dynamic content.

Install PHP and Required Modules

sudo apt install php libapache2-mod-php php-mysql php-cli php-curl php-json -y    # Ubuntu/Debian

Restart Apache to Apply Changes

sudo systemctl restart apache2   # Ubuntu/Debian

Test PHP Installation

Create a test PHP file:

echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Then access it in a browser:

http://your-server-ip/info.php

If PHP is installed correctly, you will see the PHP info page.

Step 5: Configure Firewall (If Necessary)

To allow web traffic, open the necessary ports:

sudo ufw allow 80/tcp   # Ubuntu/Debian
sudo ufw allow 443/tcp

Conclusion

You have successfully deployed a LAMP stack on your Linux server! You can now start developing and hosting your websites using Apache, MySQL, and PHP.

How to Set Up VS Code for C# Development to Build a Console and Web App

Ibrahim Bio Abubakar — Sun, 23 Mar 2025 13:55:32 +0000

Introduction

Visual Studio Code (VS Code) is a lightweight yet powerful code editor that supports C# development with ease. Whether you're building a simple console application or a basic web app, correctly setting up your development environment is essential. This guide will walk you through setting up VS Code to create a simple C# console app and a minimal web app (a number guessing game) using ASP.NET Core.

Prerequisites

Before you start, ensure you have the following installed:

Once these are installed, open VS Code and install the C# extension if you haven’t already. This extension provides IntelliSense, debugging, and other essential tools for C# development.

Setting Up a C# Console Application

Create a New Project Open a terminal in VS Code and run:

   dotnet new console -o MyConsoleApp
   cd MyConsoleApp
   code .

This creates a new console application and opens it in VS Code.

Write Code Open Program.cs and modify the Main method to print a message:

   using System;

   class Program
   {
       static void Main()
       {
           Console.WriteLine("Hello, VS Code with C# is fun :)!");
       }
   }

Run the Application In the terminal, execute:

   dotnet run

You should see Hello, VS Code with C# is fun :)! printed in the console.

Setting Up a Simple Web App with ASP.NET Core

Create a Web App Run the following command to create a new web project:

   dotnet new web -o MyWebApp
   cd MyWebApp
   code .

Modify the Web App Open Program.cs and update it as follows:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;

namespace NumberGuessGame
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }

    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDistributedMemoryCache();
            services.AddSession();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseSession();
            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapGet("/", async context =>
                {
                    int secretNumber = new Random().Next(1, 101);
                    context.Session.SetInt32("SecretNumber", secretNumber);
                    await context.Response.WriteAsync($"<html><body>");
                    await context.Response.WriteAsync("<h1>Number Guessing Game</h1>");
                    await context.Response.WriteAsync("<form method='post' action='/guess'>");
                    await context.Response.WriteAsync("Enter your guess: <input type='number' name='guess' required> ");
                    await context.Response.WriteAsync("<input type='submit' value='Submit'>");
                    await context.Response.WriteAsync("</form>");
                    await context.Response.WriteAsync("</body></html>");
                });

                endpoints.MapPost("/guess", async context =>
                {
                    var form = await context.Request.ReadFormAsync();
                    int userGuess = int.Parse(form["guess"]);
                    int secretNumber = context.Session.GetInt32("SecretNumber") ?? new Random().Next(1, 101);

                    string message;
                    if (userGuess < secretNumber)
                        message = "Too low! Try again.";
                    else if (userGuess > secretNumber)
                        message = "Too high! Try again.";
                    else
                    {
                        message = "Congratulations! You guessed the right number!";
                        secretNumber = new Random().Next(1, 101); // Reset number after a correct guess
                        context.Session.SetInt32("SecretNumber", secretNumber);
                    }

                    await context.Response.WriteAsync($"<html><body>");
                    await context.Response.WriteAsync($"<h1>{message}</h1>");
                    await context.Response.WriteAsync("<a href='/'>Try Again</a>");
                    await context.Response.WriteAsync("</body></html>");
                });
            });
        }
    }
}

Run the Web App Execute:

   dotnet run

The app will start on http://localhost:5230. Open a browser and visit the URL to see your message.

Conclusion
Setting up VS Code for C# development is straightforward. By installing the .NET SDK and the C# extension, you can quickly create and run both console and web applications. This setup provides a lightweight yet practical development environment for C# programmers.

Essential Linux Commands for Beginners

Ibrahim Bio Abubakar — Wed, 19 Mar 2025 21:38:14 +0000

Linux is a powerful and flexible operating system used by developers, system administrators, and enthusiasts worldwide. If you're new to Linux, learning basic commands is essential to navigating a system efficiently. This guide covers fundamental Linux commands that will help you manage files, processes, users, and more.

1. Basic Commands

pwd - Print working directory (show the current directory).

ls - List files and directories in the current directory.

cd <directory> - Change directory.

Example: cd Documents - moves into the Documents directory.

mkdir <directory> - Create a new directory.

rmdir <directory> - Remove an empty directory.

rm <file> - Remove a file.

rm -r <directory> - Remove a directory and its contents.

cp <source> <destination> - Copy files or directories.

Example: cp file.txt /home/users/Documents

mv <source> <destination> - Move or rename files.

Example: mv oldname.txt newname.txt

touch <filename> - Create a new empty file.

2. File Viewing Commands

cat <file> - Displays the content of a file.

less <file> - View a file one page at a time.

head <file> - Show the first 10 lines of a file.

tail <file> - Show the last 10 lines of a file.

tail -f <file> - Monitor a file in real-time(useful for logs).

3. File Permissions & Ownership

ls -l - List files with details including permissions.

4. Process Management

ps - Show running processes.

top - Display real-time system resource usage.

5. Disk & Storage

df -h - Show disk usage in a human-readable format.

6. User Management

id - Show user and group IDs

adduser <username> - Add a new user

passwd <username> - Change a user's password

7. Package Management

apt update - Update package lists.

apt upgrade - Upgrade all installed packages.

apt install <package> - Install a package

apt remove <package> - Remove a package.

8. Searching content in a File

grep "text" <file> - Search for text in a file.

9. Detailed Files Viewing Commands

ls -a - Displays hidden files

ls -lh - List files and their sizes in a human-readable format.

10. Other Useful Commands

echo "Hello World!" - Print text to the terminal.

history - Show command history

clear - Clear the terminal screen.

man <command> - Show the manual for a command.

Conclusion

Mastering these basic Linux commands will help you navigate and manage your system more efficiently. As you become more comfortable, you can explore more advanced commands and scripting techniques to automate tasks. Keep practicing, and soon, working with Linux will become second nature. Happy coding!

A Guide on How to Provide Storage for an IT Department Testing and Training using Microsoft Azure

Ibrahim Bio Abubakar — Sat, 15 Mar 2025 14:21:52 +0000

Introduction

Let's assume the IT Department where you work needs to prototype different storage scenarios to train new personnel, and you've been tasked with providing storage where the content is not important enough to be backed up and doesn't need to be restored if the data is overwritten or removed.

In this guide, you'll learn how to create and configure an Azure storage account that meets these requirements. We'll walk through setting up a resource group, deploying a storage account, and applying basic security and networking settings to ensure efficient and cost-effective storage management.

By the end of this tutorial, you'll have a functional storage environment that can be used for training and testing, without unnecessary overhead or long-term commitments. Let’s get started!

Create a resource group and a storage account.

Step 1: Create and deploy a resource group to hold all the project resources

Select + Create.

Give your resource group a name. For example, storagerg.
Select a region. Your choice of region should be used throughout the project.
Select Review and create to validate the resource group.

Select Create to deploy the resource group.

Step 2: Create and deploy a storage account to support testing and training.

In the Azure portal, search for and select Storage account.

Select + Create.

On the Basics tab, select your Resource group.
Provide a storage account name. The storage account name must be unique in Azure.
Set the Performance to Standard. -Select Review, and then create.

Finally, wait for the storage account to deploy and then Go to resource.

Configure simple settings in the storage account

Recall that the data in this storage doesn't require high availability or durability. A lowest-cost storage solution is desired.

Step 3: Configure the Data Redundancy of the Storage Account

In your storage account, in the Data Management section, select the Redundancy blade.

Select Locally-redundant storage (LRS) in the Redundancy drop-down.
Don't forget to Save your changes.
Finally, refresh the page and notice the content only exists in the primary location.

We also need to ensure the storage account only accepts requests from secure connections and uses at least a Transfer Layer Security (TLS) version 1.2.

Until the storage is needed again, disable requests to the storage account.

Step 4: Enable a Secure Transfer in Storage Account

In the Settings section, select the Configuration blade.

Ensure Secure transfer required is enabled.
Ensure the Minimal TLS version is set to Version 1.2.
Finally, ensure the Allow storage account key access is Disabled.

Step 5: Allow the Storage Account to have public Access from all Networks

In the Security + networking section, select the Networking blade.

Ensure Public network access is set to Enabled from all networks.

Conclusion

By following these steps, you've successfully set up a cost-effective Azure storage solution tailored for training and testing scenarios. This storage account is optimized for minimal redundancy, secure data transfers, and public accessibility, making it ideal for non-critical data that doesn't require backup or restoration.

This setup allows your IT team to experiment with different storage configurations without incurring unnecessary costs or complexity. As your needs evolve, you can further refine security, networking, and access policies to align with future projects.

Now that your storage account is ready, you can start using it for training exercises, prototyping, or even exploring additional Azure storage features. Happy testing!

Managing Azure On-the-Go: A Guide to the Azure Mobile App

Ibrahim Bio Abubakar — Wed, 12 Mar 2025 13:41:53 +0000

Introduction

The Azure mobile app is a powerful tool that enables users to manage their Azure resources on-the-go. Available for both iOS and Android platforms, the app provides a range of features designed to help users monitor and control their cloud infrastructure from their mobile devices.

Key Features:

Resource Monitoring: Users can view the status and health of their Azure resources, including virtual machines, web apps, and databases. This allows for real-time monitoring and quick identification of any issues.
Alerts and Notifications: The app provides push notifications for important alerts, ensuring that users are immediately informed of critical events or changes in their resources.
Resource Management: Users can start, stop, and restart virtual machines and web apps directly from the app, providing flexibility and control over their services without the need for a desktop interface.
Cloud Shell Integration: The app integrates with Azure Cloud Shell, allowing users to run scripts and manage resources using the command line interface from their mobile devices.
Secure Access: The app supports multi-factor authentication and integrates with Microsoft Entra ID, ensuring secure access to resources.

Getting Started:

Download the App: The Azure mobile app is available for download on the Apple App Store and Google Play Store.
Sign In: After installation, sign in with your Azure account credentials. Ensure that your account has the necessary permissions to access and manage resources.
Explore Resources: Once signed in, you can browse through your subscriptions and resources. The intuitive interface allows for easy navigation and management.
Set Up Notifications: Configure alerts and notifications to stay informed about the status of your resources. Customize the settings to receive notifications for specific events or thresholds.

Use Cases:

On-Call Administrators: System administrators can respond to critical alerts and perform necessary actions, such as restarting services, without the need for a computer.
Developers: Developers can monitor the performance of their applications and make adjustments as needed, ensuring optimal performance and reliability.
IT Managers: IT managers can keep track of resource utilization and costs, making informed decisions about scaling and resource allocation.

Conclusion:

The Azure mobile app is an essential tool for anyone managing Azure resources. Its comprehensive features and user-friendly interface make it easier to monitor and control cloud services from anywhere, ensuring that your infrastructure remains robust and responsive.

Note: Always ensure that your mobile device is secured and that you follow best practices for account security to protect your Azure resources.

How to Deploy Your Resume using an Azure Web App via the Azure Portal

Ibrahim Bio Abubakar — Sat, 08 Mar 2025 21:47:55 +0000

Introduction

Deploying a web application to Azure is a crucial skill for any cloud engineer. In this guide, I will walk through the step-by-step process of deploying a simple HTML web app resume, on Microsoft Azure using the Azure Portal. By the end of this tutorial, you will have your web app hosted on Azure App Service, making it accessible from anywhere.

Step 1: Create an Azure Account

If you don’t have an Azure account yet, you can create a free one at Azure Portal. Azure offers a free tier with credits that allow you to test and deploy small applications.

Step 2: Create a Resource Group

Log in to the Azure Portal.
Click on Resource Groups in the left-hand menu.
Click Create and enter:
- A Resource Group Name (e.g., MyResourceGroup)
- A Region (e.g., North Europe)
Click Review + Create, then Create.

I will be using a Resource Group created for this lab exercise called SheroGlobalRG.

Step 3: Create a Web App

In the Azure Portal, search for App Services and click Create.
Fill in the details on the Basics page:
- Name: A unique web app name (e.g., ahmadkuraishiresume).
- Resource Group: Select MyResourceGroup (the one you created in step 1). Mine is SheroGlobalRG.
- Publish: Choose Code.
- Runtime Stack: Select HTML.
- Operating System: Choose Windows.
- Region: Select the same region as your resource group.
- App Service Plan: You can create a new one or use the default service plan.
Click Review + Create, then Create. Leaving every other tab in the default setting.

After deploying the web app, select Go to Resource to access it.

Step 5: Use the Advance Tool to Deploy Web Content

Search for the Advance Tool on the left-hand menu, launch the tool, and select Go to access the Kudu+ web page.

Click on Debug Console and select CMD.

Select Site, followed by wwwroot in the next page.

Click on the edit or pen icon shown below to paste the content of your HTML file.

Note: You can easily generate a HTML simple resume of your choice using ChatGPT if you're not familiar with it.

Paste your HTML code here and select Save.

Step 6: Access Your Web App

After saving your code on Kudu+, head back to the web app resource created earlier and copy the default domain, and lunch it on a browser of your choice.

This is the outcome you should expect in yours:

Conclusion

Congratulations! You have successfully deployed a simple HTML resume web app to Azure using the Azure Portal. This guide covered creating a resource group, setting up an App Service Plan, and deploying your code through the Azure Portal. Happy coding!

If you found this guide helpful, feel free to share your thoughts in the comments below.