DEV Community: Inioluwa Eunice Atanda

Automating Security Updates for Prometheus LTS: My First CNCF Contribution

Inioluwa Eunice Atanda — Thu, 22 Jan 2026 23:17:45 +0000

I’ve always loved DevOps, but contributing to an actual CNCF project? That felt like standi
ng at the edge of a pool about to dive in without a previous experience. Yet here I am, sharing how I dove in, learned about LTS, Dependabot, and even survived my first PR without breaking anything or my confidence(phew).

Step 1: Learning About LTS
First, let’s talk Long-Term Support (LTS).

In Prometheus, LTS branches are like the “golden retrievers” of releases: reliable, stable, and supported for a long time (over a year!). They only get:

Bug fixes
Security patches
Documentation updates

…everything else? Nope. Experimental features or new fancy stuff are off-limits. The reasoning is simple: companies rely on these branches for monitoring critical systems. They don’t want surprises that could cause sudden breakdown to their large systems.

I focused on two active LTS branches: release-2.53 and release-3.5. Think of them as my training wheels.

Step 2: Why Security Updates Matter
Security updates aren’t glamorous, but they’re life-saving. Imagine a dependency getting hacked while you’re havaing breakfast with the ex you've been trying to get back with, it’s the worst kind of surprise.

GitHub has a neat helper called Dependabot that automatically opens PRs for vulnerable dependencies. My job? Configure it safely for LTS.
Key rules I followed:

Update only Go modules (go.mod) and GitHub Actions
Apply updates only to LTS branches
Make it security-only, no random feature upgrades
Limit PRs to avoid spam: max 2 for Go, 1 for Actions per branch
Schedule weekly checks, because daily emails are a nightmare

Step 3: The Contribution Workflow
Here’s how my first PR went down, step by step:

Forked the Prometheus repo (because direct access is scary)
Cloned my fork locally
Created a branch named ci/dependabot-lts-security (naming matters!)
Added .github/dependabot.yml with the config I just described
Committed my changes with a DCO sign-off (promised I wrote this myself, pinky swear)
Pushed the branch and opened a PR

Step 4: What I Learned

Read the rules first. LTS policies exist for a reason, don’t ignore them.
DCO matters. Sign-off your commits; it’s a CNCF thing, not a bureaucratic nightmare.
Automation is powerful. A single Dependabot config can save maintainers hours of toil.
Initiative is welcome. Maintainers expect new contributors to take the first step.

Honestly, nothing felt cooler than seeing that PR button: “Create Pull Request.” A mix of pride, terror, and adrenaline.

Step 5: The Dependabot Config (Our Tiny Hero)
Here’s what I added(remember, no don't leave a blankspace or a line empty):

version: 2

updates:
  - package-ecosystem: "gomod"
    directory: "/"
    target-branch: "release-2.53"
    schedule:
      interval: "weekly"
    security-updates-only: true
    open-pull-requests-limit: 2

  - package-ecosystem: "gomod"
    directory: "/"
    target-branch: "release-3.5"
    schedule:
      interval: "weekly"
    security-updates-only: true
    open-pull-requests-limit: 2

  - package-ecosystem: "github-actions"
    directory: "/"
    target-branch: "release-2.53"
    schedule:
      interval: "weekly"
    security-updates-only: true
    open-pull-requests-limit: 1

  - package-ecosystem: "github-actions"
    directory: "/"
    target-branch: "release-3.5"
    schedule:
      interval: "weekly"
    security-updates-only: true
    open-pull-requests-limit: 1

Real-Life Scenario: DevOps Engineer in an IT Company

Inioluwa Eunice Atanda — Fri, 21 Mar 2025 22:58:49 +0000

Step 1: Launch & Connect to an EC2 Instance

Scenario:
You have just joined TechFlow Solutions as a DevOps Engineer. Your manager asks you to set up a secure Linux server on AWS to manage company files and ensure proper access control for different departments.

1. Launch an AWS EC2 Linux VM

Your company follows AWS for cloud infrastructure, and they need a secure environment to store and manage data.

You log into the AWS Management Console, navigate to EC2, and launch an Ubuntu instance.

Since the company wants to keep costs low, you select a t2.micro instance (free tier eligible).

To allow remote access, you configure the Security Group to permit SSH (port 22) only for authorized users.

You create a Key Pair (techflow-key.pem), download it, and keep it safe.

Once everything is set, you launch the instance and wait for it to be ready.

2. Connect to EC2 via SSH

Your team needs you to connect to the server and begin setup.

You obtain the public IP of the instance from the AWS Console and use SSH to connect:

ssh -i techflow-key.pem ubuntu@your-ec2-public-ip
If the key permissions are too open, you fix them with:

chmod 400 techflow-key.pem

Step 2: Create Users & Groups
_Scenario:
_Your HR and IT departments want you to create user accounts for employees and ensure each department has proper access.

Create Groups for Each Department

The IT manager gives you a list of departments that need system access.

You create a group for each department:

sudo groupadd sysadmin
sudo groupadd legal
sudo groupadd hr
sudo groupadd sales
sudo groupadd strategy
sudo groupadd executives
sudo groupadd it_interns
sudo groupadd finance

Create Users & Assign Them to Groups

The HR team provides a list of employees. You create users for them and add them to their respective groups:

sudo useradd -m -s /bin/bash -G sysadmin andrew
sudo useradd -m -s /bin/bash -G legal julius
sudo useradd -m -s /bin/bash -G hr chizi
sudo useradd -m -s /bin/bash -G sales jeniffer
sudo useradd -m -s /bin/bash -G strategy adeola
sudo useradd -m -s /bin/bash -G executives bach
sudo useradd -m -s /bin/bash -G it_interns gozie
sudo useradd -m -s /bin/bash -G finance ogochukwu

3. Set Passwords for Users
Each employee needs a password for login. You set their passwords:

sudo passwd andrew
sudo passwd julius
sudo passwd chizi
sudo passwd jeniffer
sudo passwd adeola
sudo passwd bach
sudo passwd gozie
sudo passwd ogochukwu

Employees will be prompted to enter a secure password upon their first login.

Step 3: Create Company Directories & Set Permissions
Scenario:
The company’s data storage policy requires that each department has a separate directory where only authorized employees can access files.

Create Department-Specific Directories

You create folders for different company data storage needs:

sudo mkdir -p /company_data/finance_budgets
sudo mkdir -p /company_data/contract_documents
sudo mkdir -p /company_data/business_projections
sudo mkdir -p /company_data/business_models
sudo mkdir -p /company_data/employee_data
sudo mkdir -p /company_data/vision_mission
sudo mkdir -p /company_data/server_config

Assign Ownership to Groups & Set Permissions

The IT policy states that only relevant departments should access their data. You set the correct permissions:

sudo chown :finance /company_data/finance_budgets
sudo chmod 770 /company_data/finance_budgets

sudo chown :legal /company_data/contract_documents
sudo chmod 770 /company_data/contract_documents

sudo chown :strategy /company_data/business_projections
sudo chmod 770 /company_data/business_projections

sudo chown :strategy /company_data/business_models
sudo chmod 770 /company_data/business_models

sudo chown :hr /company_data/employee_data
sudo chmod 770 /company_data/employee_data

sudo chown :executives /company_data/vision_mission
sudo chmod 770 /company_data/vision_mission

sudo chown :sysadmin /company_data/server_config
sudo chmod 700 /company_data/server_config

**_

Explanation:

**
**_chown :groupname directory_path** → Assigns ownership to a specific department.

chmod(change modification) 770 → Full access to the department, no access for others.

chmod 700 → Restricted access (for sysadmins only).

Step 4: Verify the Setup
Scenario:
Before reporting back to your manager, you need to ensure everything is set up correctly.

Check User List

Check Group Memberships

You verify that each user belongs to the correct department:

groups andrew
groups julius
groups chizi
groups jeniffer
groups adeola
groups bach
groups gozie
groups ogochukwu

Verify Directory Permissions

You check that department directories have the correct ownership and permissions:
ls -ld /company_data/*

All users and groups are set up, and permissions are properly configured!

Conclusion

As the DevOps Engineer, you successfully:

Set up a secure AWS Linux server.
Created users and assigned them to departments.
Implemented access control to protect company data.
Verified everything works as expected.

You have successfully created a properly structured group and folder for your IT company as a devops engineer.

DEPLOYING A STATIC WEB PAGE ON NGINX WEB SERVER

Inioluwa Eunice Atanda — Tue, 11 Mar 2025 13:25:02 +0000

Beginner's Guide: Deploying a Landing Page on Nginx (Azure & AWS EC2)

1. Introduction

This guide will walk you through deploying a simple landing page (HTML, CSS, JavaScript) on Nginx, using both Azure and AWS EC2. The webpage will be fetched from a GitHub repository. Additionally, we will address common SSH key access issues on Windows for AWS users and their solutions.

2. What is Nginx and Why Use It?

What is Nginx?

Nginx (pronounced "Engine-X") is a high-performance web server commonly used for hosting websites and acting as a reverse proxy.

Why Use Nginx?

✅ Fast & Efficient – Handles multiple connections efficiently.
✅ Serves Static Files – Ideal for hosting HTML, CSS, JavaScript pages.
✅ Reverse Proxy & Load Balancing – Used for forwarding requests and balancing traffic.
✅ Security & Scalability – Works well with SSL and large-scale applications.

3. Setting Up a Virtual Machine (VM)

We will set up a Ubuntu 20.04 LTS VM on both Azure and AWS EC2.

🔹 Option 1: Create an Azure Virtual Machine

Log in to Azure Portal → https://portal.azure.com
Go to "Virtual Machines" → Click "Create New"
Choose Configuration:
- OS: Ubuntu 20.04 LTS (Recommended)
- Size: B1s (Cheapest for basic usage)
- Authentication: SSH Key (Download & Save the key)
Allow HTTP & SSH Ports:
- Go to Networking → Add inbound rule for:
  - SSH: Port 22 (For remote access)
  - HTTP: Port 80 (For web traffic)
Click "Review + Create" → Wait for Deployment to Complete

🔹 Option 2: Create an AWS EC2 Instance

Log in to AWS Console → https://aws.amazon.com/
Go to EC2 Dashboard → Launch Instance
Choose Configuration:
- OS: Ubuntu 20.04 LTS
- Instance Type: t2.micro (Free Tier)
- Key Pair: Create or use an existing key (Save .pem file)
Configure Security Group:
- Allow SSH (Port 22) and HTTP (Port 80)
Click "Launch" → Wait for Instance to Start

4. Creating & Uploading Your Landing Page to GitHub

Step 1: Create a New Repository on GitHub

Go to GitHub, log in, and click New Repository.
Enter a repository name (e.g., landing-page).
Select Public or Private.
Click Create Repository.

Step 2: Push Your Code to GitHub

In your local project folder, run:

cd path/to/your/project

git init
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin YOUR_GITHUB_REPO_URL
git push -u origin main

5. Connecting to Your Server (Resolving SSH Key Issues on Windows)

Common Issue: Key Not Accessible (AWS)

When trying to connect:

ssh -i "C:\Users\USER\Downloads\aws-key.pem" ubuntu@YOUR_EC2_IP

You might get:

Warning: Identity file not accessible: No such file or directory.
Permission denied (publickey).

Solution

Move Key to a Secure Folder:

   mkdir C:\Users\USER\.ssh
   move "C:\Users\USER\Downloads\aws-key.pem" C:\Users\USER\.ssh\

Change File Permissions (Windows Alternative to chmod 400):

Open PowerShell as Administrator and run:

 icacls C:\Users\USER\.ssh\aws-key.pem /inheritance:r
 icacls C:\Users\USER\.ssh\aws-key.pem /grant:r USER:F

Connect Again Using Correct Path:

   ssh -i "C:\Users\USER\.ssh\aws-key.pem" ubuntu@YOUR_EC2_IP

6. Installing & Configuring Nginx

Once connected to your server (Azure or AWS EC2):

Step 1: Update and Install Nginx

sudo apt update && sudo apt install -y nginx

Step 2: Start & Enable Nginx

sudo systemctl start nginx
sudo systemctl enable nginx

Step 3: Allow Traffic on Port 80

sudo ufw allow 'Nginx HTTP'
sudo ufw enable
sudo ufw status

7. Fetching the Landing Page from GitHub

Step 1: Install Git (if not installed)

sudo apt install git -y

Step 2: Clone Your GitHub Repository

Replace YOUR_GITHUB_REPO_URL with your actual repository URL:

cd /var/www/html
sudo git clone YOUR_GITHUB_REPO_URL landing-page

Step 3: Set Permissions

sudo chown -R www-data:www-data /var/www/html/landing-page
sudo chmod -R 755 /var/www/html/landing-page

8. Configuring Nginx for Your Website

Step 1: Create Nginx Configuration File

sudo nano /etc/nginx/sites-available/landing-page

Step 2: Add This Configuration

server {
    listen 80;
    server_name YOUR_SERVER_IP;
    root /var/www/html/landing-page;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Save and exit (CTRL + X → Y → ENTER).

Step 3: Enable the Configuration

sudo ln -s /etc/nginx/sites-available/landing-page /etc/nginx/sites-enabled/

Step 4: Restart Nginx

sudo systemctl restart nginx

9. Verify Deployment

Open a browser and visit:

   http://YOUR_SERVER_IP

Your landing page should be visible! 🎉

10. Conclusion

✅ You have successfully deployed your landing page on Nginx using Azure or AWS EC2.
✅ Your site is now live and accessible via the internet.
✅ You also learned how to fetch files from GitHub and fix common SSH key issues in AWS.

Step-by-Step Guide: Installing Jenkins on AWS EC2 and Deploying to Kubernetes

Inioluwa Eunice Atanda — Thu, 20 Feb 2025 11:08:23 +0000

````markdown name=installing-jenkins-on-aws-ec2.md

In this guide, we'll go through the detailed steps to set up Jenkins on an AWS EC2 instance, install necessary plugins, and configure Jenkins for deploying applications to a Kubernetes cluster.

1️⃣ Install Jenkins on AWS EC2

Step 1: Update Your System

First, let's make sure your system is up to date. Run the following command to update your package list and upgrade your installed packages:


sh
sudo apt update && sudo apt upgrade -y

✅ This ensures your system is up-to-date.

Step 2: Install Java (Required for Jenkins)

Jenkins requires Java to run. Install OpenJDK 11 by running:


sh
sudo apt install openjdk-11-jdk -y

Verify the Java installation:


sh
java -version

✅ Expected output:


plaintext
openjdk version "11.0.xx"

Step 3: Install Jenkins

Add the Jenkins repository:


sh
wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo tee /etc/apt/trusted.gpg.d/jenkins.asc > /dev/null

Add the Jenkins package source:


sh
echo "deb http://pkg.jenkins.io/debian-stable binary/" | sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null

Update the package list and install Jenkins:


sh
sudo apt update
sudo apt install jenkins -y

Step 4: Start and Enable Jenkins

Start the Jenkins service:


sh
sudo systemctl start jenkins

Enable Jenkins to start on boot:


sh
sudo systemctl enable jenkins

Check the status of Jenkins:


sh
sudo systemctl status jenkins

✅ You should see "active (running)".

Step 5: Access Jenkins Dashboard

Find your EC2 public IP:


sh
curl ifconfig.me

Now, open your browser and go to:


plaintext
http://<your-ec2-public-ip>:8080

Jenkins should be running! 🎉

Step 6: Unlock Jenkins

Find the admin password:


sh
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy and paste it into the Jenkins setup page. Click "Install suggested plugins" and create an admin user.

✅ Now you have Jenkins running! 🎯

2️⃣ Install Kubernetes and Docker Plugins in Jenkins

Jenkins needs plugins to communicate with Kubernetes.

Step 1: Install Docker & Kubernetes Plugins

Go to Jenkins Dashboard → Manage Jenkins → Manage Plugins. Search for and install the following plugins:

Docker
Kubernetes
Pipeline
GitHub

After installing the plugins, restart Jenkins.

3️⃣ Configure Jenkins to Deploy to Kubernetes

Jenkins will automate deployments to your Kubernetes cluster.

Step 1: Create a Service Account in Kubernetes

On your EC2 instance, run:


sh
kubectl create serviceaccount jenkins
kubectl create clusterrolebinding jenkins --clusterrole=cluster-admin --serviceaccount=default:jenkins

Step 2: Get Kubernetes API Token

Run the following command to get the Kubernetes API token:


sh
kubectl get secret $(kubectl get serviceaccount jenkins -o jsonpath="{.secrets[0].name}") -o jsonpath="{.data.token}" | base64 --decode

Copy this token.

Step 3: Configure Jenkins Credentials

Go to Jenkins Dashboard → Manage Jenkins → Manage Credentials. Under Global Credentials, add:

Type: Kubernetes Configuration (Secret Text)
Secret: Paste the token from Step 2
ID: k8s-api-token

4️⃣ Create a Jenkins Pipeline to Deploy to Kubernetes

Go to Jenkins Dashboard → New Item → Pipeline. Name it K8s-Deployment and choose Pipeline.

In the Pipeline Script section, paste the following script:


groovy
pipeline {
    agent any

    environment {
        KUBECONFIG = credentials('k8s-api-token')
    }

    stages {
        stage('Checkout Code') {
            steps {
                git 'https://github.com/YOUR_GITHUB_REPO.git'  // Replace with your repo
            }
        }

        stage('Build Docker Image') {
            steps {
                sh 'docker build -t myapp:latest .'
            }
        }

        stage('Push Image to Docker Hub') {
            steps {
                withDockerRegistry([credentialsId: 'docker-hub', url: 'https://index.docker.io/v1/']) {
                    sh 'docker tag myapp:latest YOUR_DOCKER_USERNAME/myapp:latest'
                    sh 'docker push YOUR_DOCKER_USERNAME/myapp:latest'
                }
            }
        }

        stage('Deploy to Kubernetes') {
            steps {
                sh 'kubectl apply -f deployment.yaml'
            }
        }
    }
}

✅ Replace:

YOUR_GITHUB_REPO with your GitHub repository
YOUR_DOCKER_USERNAME with your Docker Hub username

5️⃣ Create Kubernetes Deployment Manifest

Create a file named deployment.yaml:


sh
nano deployment.yaml

Paste the following content:


yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: YOUR_DOCKER_USERNAME/myapp:latest
        ports:
        - containerPort: 80

✅ Replace YOUR_DOCKER_USERNAME/myapp:latest with your Docker Hub image.

Apply the deployment:


sh
kubectl apply -f deployment.yaml

✅ Your app is now running on Kubernetes! 🎉

🎯 Final Test

Run the following commands to verify the deployment:


sh
kubectl get pods
kubectl get deployments

✅ You should see your myapp deployment running.

Congratulations! You've successfully set up Jenkins on AWS EC2 and configured it to deploy to a Kubernetes cluster. Happy CI/CD! 🚀

Here's a step-by-step guide for setting up Kubernetes on an EC2 instance

Inioluwa Eunice Atanda — Thu, 20 Feb 2025 09:51:06 +0000

Setting Up Kubernetes on EC2
Step 1: Update System Packages
Before installing any software, update your package lists to ensure you're getting the latest versions.

bash
sudo apt update && sudo apt upgrade -y

Step 2: Install Docker
Kubernetes runs containers, so you need to install Docker first.

Install Required Dependencies Run the following command:

bash
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

Add Docker GPG Key and Repository Run these commands to add the Docker GPG key and repository:

bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker Update the package list and install Docker:

bash
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Start and Enable Docker Ensure Docker runs on system startup:

bash
sudo systemctl start docker
sudo systemctl enable docker

Verify Docker Installation Check the installed version of Docker:

bash
docker --version
Step 3: Install Kubernetes Components (kubectl, kubeadm, kubelet)

Add Kubernetes Signing Key Run this command to add the Kubernetes signing key:

bash
curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/kubernetes-archive-keyring.gpg

Add Kubernetes Repository Add the Kubernetes repository to your system's APT sources list:

bash
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Install Kubernetes Components Update the package list and install kubelet, kubeadm, and kubectl:

bash
sudo apt update
sudo apt install -y kubelet kubeadm kubectl

Prevent Automatic Updates (Optional) To avoid unintended upgrades that may disrupt your cluster, hold these packages at their current versions:

bash
sudo apt-mark hold kubelet kubeadm kubectl

Verify Installation Check the installed versions of Kubernetes components:

bash
kubeadm version
kubectl version --client

Step 4: Enable Docker for Kubernetes
Kubernetes requires Docker’s cgroup driver to be set correctly.

Check Current cgroup Driver Run this command to check the current cgroup driver:

bash
sudo docker info | grep -i cgroup

If it does not say "systemd", proceed to configure it.

Configure Docker to Use Systemd Create a configuration file for Docker:

bash
sudo mkdir -p /etc/docker
cat <<EOF | sudo tee /etc/docker/daemon.json

🔹 step 9: Set Up Ingress for Better Traffic Routing
Instead of accessing our app via a NodePort, we’ll set up an Ingress Controller to handle traffic more efficiently.

🛠️ What is Ingress?
Ingress allows you to define routing rules for Kubernetes services.
It provides a stable URL (e.g., http://yourdomain.com).
It eliminates the need to use random NodePort numbers.
1️⃣ Install an Ingress Controller (NGINX)
Since we’re using AWS EC2, we’ll install the NGINX Ingress Controller.

Run:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml
✅ This deploys the Ingress Controller.

Now, check if the pods are running:

kubectl get pods -n ingress-nginx
✅ Expected output:

NAME                                        READY   STATUS    RESTARTS   AGE
ingress-nginx-controller-xxxx               1/1     Running   0          1m

2️⃣ Create an Ingress Resource
Now, let's create an Ingress Rule to route traffic to our Nginx deployment.

1️⃣ Create a file:

nano nginx-ingress.yaml
2️⃣ Add the following configuration:

`yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: nginx.example.com  # Replace this with your domain or public IP
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx
            port:
              number: 80`

3️⃣ Apply the configuration:

kubectl apply -f nginx-ingress.yaml
✅ This sets up an Ingress route to forward traffic to the Nginx service.

3️⃣ Test the Ingress
Find the external IP of the Ingress Controller:

kubectl get svc -n ingress-nginx
✅ Look for an entry like this:
pgsql

NAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)
ingress-nginx-controller             LoadBalancer  10.96.XXX.XXX   XX.XX.XX.XX    80:XXXXX/TCP

🔹 The EXTERNAL-IP is what you'll use to access your app.

Now, test it:

curl -H "Host: nginx.example.com" http://XX.XX.XX.XX
✅ If successful, you'll see the Nginx welcome page.

Setting Up and Configuring NGINX on an Ubuntu Server

Inioluwa Eunice Atanda — Thu, 06 Feb 2025 22:42:00 +0000

Introduction

For the HNG DevOps Stage 0 task, I was required to set up and configure NGINX on a fresh Ubuntu server and serve a custom HTML page. This task helped reinforce my understanding of Linux server management, web server configuration, and cloud deployment.

My Approach

To complete the task, I followed these structured steps:

1. Setting Up the Server

I created an Ubuntu server instance on AWS EC2. Once the server was up and running, I connected to it using SSH:

ssh -i key-2.pem ubuntu@16.171.226.12

Installing NGINX

Next, I updated the package list and installed NGINX:

sudo apt update && sudo apt install nginx -y

After installation, I ensured NGINX was running:

sudo systemctl start nginx sudo systemctl enable nginx

3. Configuring the Custom HTML Page

I navigated to the default NGINX web root directory and edited the index.html file:

cd /var/www/html sudo nano index.html

I replaced the content with:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Welcome</title>
    <style>
        body {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background: linear-gradient(135deg, #4A90E2, #9013FE);
            font-family: Arial, sans-serif;
            color: #fff;
            text-align: center;
        }
        .container {
            background: rgba(255, 255, 255, 0.1);
            padding: 20px 40px;
            border-radius: 10px;
            box-shadow: 0 4px 10px rgba(0, 0, 0, 0.2);
        }
        h1 {
            font-size: 28px;
            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Welcome to DevOps Stage 0 - Inioluwa/Inioluwa Eunice</h1>
    </div>
</body>
</html>

I then restarted NGINX to apply the changes:

sudo systemctl restart nginx

4. Verifying Deployment

I accessed my server’s public IP in a browser:👉 http://16.171.226.12/ The custom HTML message was successfully displayed.

Challenges and Solutions

Issue: creating an SSH key for my EC2 instance. Initially, I generated a .ppk key instead of a .pem, which caused authentication errors when trying to connect to my server. Solution: After troubleshooting, I successfully created the correct .pem key and gained access!

Issue: NGINX not serving the updated HTML file. Solution: Restarted NGINX after editing the file.

Lessons Learned

✅ Launching an EC2 instance on AWS
✅ Installing and configuring NGINX on Ubuntu
✅ Using nano to edit my HTML file inside /var/www/html/index.html
✅ Troubleshooting SSH authentication errors
✅ Understanding how web servers serve static content

References
DevOps Engineers
Cloud Engineers

Conclusion

This task provided hands-on experience with deploying a web server, working with NGINX, and managing cloud instances. It solidified my understanding of basic DevOps principles and will be beneficial as I advance in the field.