Forem: bankolejohn

𝗙𝗿𝗼𝗺 𝗜𝗱𝗲𝗮 𝘁𝗼 𝗜𝗺𝗽𝗮𝗰𝘁: 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗥𝗲𝗮𝗹-𝗪𝗼𝗿𝗹𝗱 𝗠𝗟 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄

bankolejohn — Thu, 07 Aug 2025 11:56:17 +0000

As I take intentional steps into the world of AI and Machine Learning, one thing has become clear: 𝘮𝘢𝘤𝘩𝘪𝘯𝘦 𝘭𝘦𝘢𝘳𝘯𝘪𝘯𝘨 𝘪𝘴 𝘯𝘰𝘵 𝘫𝘶𝘴𝘵 𝘢𝘣𝘰𝘶𝘵 𝘸𝘳𝘪𝘵𝘪𝘯𝘨 𝘤𝘰𝘥𝘦 𝘰𝘳 𝘵𝘳𝘢𝘪𝘯𝘪𝘯𝘨 𝘮𝘰𝘥𝘦𝘭𝘴 -it’s about solving real problems with clarity, structure, and purpose.

Here’s a breakdown of the ML workflow I’ve been studying and practicing -not just from a technical view, but from a problem-solving mindset that aligns with real business needs:

𝗗𝗲𝗳𝗶𝗻𝗲 𝘁𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗙𝗶𝗿𝘀𝘁, 𝗡𝗼𝘁 𝘁𝗵𝗲 𝗠𝗼𝗱𝗲𝗹
Before touching data or algorithms, the first step is always asking:
“What problem are we trying to solve, and why does it matter?”
Are we predicting customer churn? Detecting fraud? Forecasting demand?
This clarity influences everything that follows, from the type of data we collect to the model we build and how we measure success. A project that starts with a vague goal often leads to wasted effort. But one that starts with a 𝘄𝗲𝗹𝗹-𝗱𝗲𝗳𝗶𝗻𝗲𝗱 𝗼𝗯𝗷𝗲𝗰𝘁𝗶𝘃𝗲 𝗮𝗻𝗱 𝗺𝗲𝗮𝘀𝘂𝗿𝗮𝗯𝗹𝗲 𝘀𝘂𝗰𝗰𝗲𝘀𝘀 𝗰𝗿𝗶𝘁𝗲𝗿𝗶𝗮 is positioned to make real impact.
𝗚𝗮𝘁𝗵𝗲𝗿 𝗮𝗻𝗱 𝗣𝗿𝗲𝗽𝗮𝗿𝗲 𝘁𝗵𝗲 𝗗𝗮𝘁𝗮
Once the problem is clear, the next step is sourcing quality data from databases, logs, APIs, or even unstructured sources like text or images. But raw data is messy.
We clean it, remove duplicates, handle missing values, and organize it for analysis. Then comes 𝗘𝘅𝗽𝗹𝗼𝗿𝗮𝘁𝗼𝗿𝘆 𝗗𝗮𝘁𝗮 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 (𝗘𝗗𝗔) -using visualizations and statistics to understand patterns, correlations, and outliers. This step is critical. It helps us uncover insights and make smarter choices about feature engineering and model selection.
1. 𝗦𝗲𝗹𝗲𝗰𝘁 𝗮𝗻𝗱 𝗧𝗿𝗮𝗶𝗻 𝘁𝗵𝗲 𝗥𝗶𝗴𝗵𝘁 𝗠𝗼𝗱𝗲𝗹 Model selection isn’t about choosing the most advanced algorithm -𝗶𝘁’𝘀 𝗮𝗯𝗼𝘂𝘁 𝗰𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝘁𝗵𝗲 𝗿𝗶𝗴𝗵𝘁 𝘁𝗼𝗼𝗹 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗷𝗼𝗯. If the data is tabular, we might use decision trees or gradient boosting. For text or sequences, maybe transformers or RNNs. And sometimes, the simplest model works best. It’s all about balancing accuracy, interpretability, and efficiency, especially in business scenarios where transparency and speed matter as much as results.
𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗥𝗶𝗴𝗵𝘁 𝗠𝗲𝘁𝗿𝗶𝗰𝘀

You can’t improve what you don’t measure and not all problems use the same yardstick.

• For classification, we look at accuracy, precision, recall, F1-score, and AUC-ROC.

• For regression, we use RMSE, MSE, and R².

• For anomaly detection, we focus on recall vs. precision trade-offs.

It’s not just about getting high scores. It’s about understanding what those scores mean in the real world because catching fraud or diagnosing disease has consequences beyond metrics.
𝗧𝘂𝗻𝗲, 𝗗𝗲𝗽𝗹𝗼𝘆, 𝗮𝗻𝗱 𝗠𝗼𝗻𝗶𝘁𝗼𝗿

After training, we fine-tune hyperparameters (like learning rates or tree depths) to boost performance without overfitting.

Then comes deployment -serving the model via APIs or integrating it into an application. But it doesn’t stop there. The real world changes. Data drifts. So, we 𝗺𝗼𝗻𝗶𝘁𝗼𝗿 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗼𝘃𝗲𝗿 𝘁𝗶𝗺𝗲, retrain when needed, and keep the system adaptive.

𝗙𝗶𝗻𝗮𝗹 𝗧𝗵𝗼𝘂𝗴𝗵𝘁𝘀
What I’ve learned is this: 𝗔 𝗴𝗼𝗼𝗱 𝗺𝗮𝗰𝗵𝗶𝗻𝗲 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗺𝗼𝗱𝗲𝗹 𝗶𝘀𝗻’𝘁 𝗷𝘂𝘀𝘁 𝘀𝗺𝗮𝗿𝘁 -𝗶𝘁’𝘀 𝘂𝘀𝗲𝗳𝘂𝗹, 𝗱𝗲𝗽𝗲𝗻𝗱𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗮𝗹𝗶𝗴𝗻𝗲𝗱 𝘄𝗶𝘁𝗵 𝗿𝗲𝗮𝗹 𝗴𝗼𝗮𝗹𝘀.
This workflow has helped me connect the dots between technical skills and real-world impact and it’s a big step in my AI/ML learning journey. I'm excited to keep building, exploring, and learning how to use ML to solve meaningful problems.
Keep Learning!

MachineLearning #AI #MLOps #DevOps #DataScience #RealWorldAI #LearningInPublic #KeepBuilding #AWS #AIJourney

Setting Up NGINX on Ubuntu: HNG 12 DevOps Stage 0 Task

bankolejohn — Wed, 05 Feb 2025 06:45:11 +0000

Web servers are fundamental to DevOps, forming the backbone of web applications by handling requests and serving content efficiently. As part of the HNG DevOps Stage 0 task, I installed and configured NGINX on a fresh Ubuntu server to serve a custom HTML page. This task helped me solidify my understanding of web server configurations, system administration, and automation. In this blog post, I will walk through the step-by-step process of setting up NGINX, the challenges I faced, and the key learnings from this experience.

Task Requirements

The objective of this task was to:

Install the NGINX web server on a fresh Ubuntu instance.
Configure it to serve a custom HTML page at /var/www/html/index.html with the message:

"Welcome to DevOps Stage 0 - [Your Name]/[SlackName]"

(Replacing [Your Name] with my real name and [SlackName] with my Slack username.)

Include links to DevOps Engineers and Cloud Engineers resources.

Step-by-Step Implementation

1. Installing NGINX

Before installing NGINX, I updated the package repository to ensure I was fetching the latest software versions:

sudo apt update && sudo apt upgrade -y

Then, I installed NGINX using the following command:

sudo apt install nginx -y

Once the installation was complete, I started and enabled the NGINX service:

sudo systemctl start nginx
sudo systemctl enable nginx

To verify that NGINX was running successfully, I checked its status:

systemctl status nginx

A green "active" status confirmed that NGINX was operational.

2. Configuring NGINX to Serve a Custom HTML Page

NGINX serves files from /var/www/html/ by default. I edited the index.html file in that directory to display my custom message.

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

I replaced the existing content with the following HTML:

<!DOCTYPE html>
<html>
<head>
    <title>DevOps Stage 0</title>
</head>
<body>
    <h1>Welcome to DevOps Stage 0 - [Your Name]/[SlackName]</h1>
    <p>Explore more about DevOps roles:</p>
    <ul>
        <li><a href="https://hng.tech/hire/devops-engineers" target="_blank">DevOps Engineers</a></li>
        <li><a href="https://hng.tech/hire/cloud-engineers" target="_blank">Cloud Engineers</a></li>
    </ul>
</body>
</html>

After saving and exiting (CTRL + X, then Y, and pressing Enter), I restarted NGINX to apply the changes:

sudo systemctl restart nginx

3. Testing the Configuration

To verify that my setup was successful, I accessed the server's IP address in a web browser:

http://your-server-ip

Alternatively, I used curl to fetch the web page:

curl http://localhost

Seeing my custom message confirmed that the NGINX setup was complete.

Challenges Faced and Solutions

1. NGINX Not Starting

Issue: When I initially tried to start NGINX, I encountered an error stating that the service failed to start.

Solution: Checking the logs with sudo journalctl -u nginx --no-pager revealed that another service was using port 80. I identified the conflicting service using:

sudo netstat -tulnp | grep :80

Stopping the conflicting service and restarting NGINX resolved the issue:

sudo systemctl stop apache2
sudo systemctl disable apache2
sudo systemctl restart nginx

2. Changes Not Reflecting in Browser

Issue: After modifying index.html, my browser still displayed the old page.

Solution: I cleared the browser cache and restarted NGINX. I also verified file permissions to ensure NGINX had read access:

sudo chmod 644 /var/www/html/index.html
sudo systemctl restart nginx

Key Learnings from This Task

Understanding Web Server Deployment: Setting up and configuring NGINX deepened my understanding of web server management and static content delivery.
Troubleshooting System Services: Debugging NGINX startup issues provided hands-on experience with Linux system services and networking.
Automation Possibilities: This manual process highlighted the potential for automating server setup with tools like Ansible or Terraform.

How This Task Supports My Career Goals

Completing this task is a stepping stone in my DevOps journey. The ability to configure web servers is essential for DevOps Engineers, who manage infrastructure and CI/CD pipelines. Understanding how NGINX serves as a reverse proxy and load balancer is also valuable for roles like Site Reliability Engineers and Cloud Engineers.

If you're looking to hire professionals in these fields, check out:

This hands-on experience has reinforced my ability to work with production-grade web servers, a critical skill in modern DevOps practices.

Conclusion

Setting up NGINX from scratch on an Ubuntu server was an insightful exercise in configuring and troubleshooting a web server. From installation to serving a custom web page, this task helped me build a solid foundation in Linux system administration and web server management. As I continue my DevOps learning path, I look forward to automating such deployments using Infrastructure as Code (IaC) tools like Terraform and Ansible.

This challenge was a rewarding experience, and I am excited about more DevOps tasks ahead in the HNG program!

Week 20 3MTT WEEKLY REFLECTION

bankolejohn — Thu, 07 Nov 2024 09:49:46 +0000

My3MTT #3MTTWeeklyReflection

In reflecting on my 3MTT journey, my proudest accomplishment has been mastering the core principles of CI/CD. Creating automated build, test, and deployment pipelines with GitHub Actions has allowed me to streamline workflows, improve efficiency, and boost project reliability. This achievement has given me hands-on experience in delivering consistent results and deepened my understanding of the DevOps lifecycle.

The biggest challenge I faced was learning Kubernetes. Initially, I struggled to understand its concepts and found cluster management and container orchestration intimidating. To tackle this, I dedicated extra time to tutorials, sought advice from mentors, and practiced setting up simple clusters. Each small success in Kubernetes has boosted my confidence and provided a clearer understanding of the technology.

Moving forward, I want to continue improving my Kubernetes skills. Gaining expertise in container orchestration will allow me to deploy scalable, resilient applications and will be a significant step toward my goal of becoming a well-rounded DevOps engineer.

@3mttNigeria, @IHSTowers, @NITDANigeria

3MTT Week 19 Task: "Quick Impact Challenge"

bankolejohn — Wed, 30 Oct 2024 12:10:27 +0000

Week 19 Task: "Quick Impact Challenge"
**

For this week's Impact Challenge, I focused on increasing participation in my 3MTT group by initiating a “Favorite DevOps Tool” activity. The idea was simple: encourage group members to share a tool or productivity tip that has helped them in their DevOps journey. I posted a prompt with engaging language and a clear call-to-action, using tags like #My3MTT and #3MTTWeeklyReflection to tie it into the program’s community initiatives.

Within 24 hours, the response was encouraging. Many group members chimed in with their favorite tools, including Docker, Jenkins, and Terraform, and shared quick tips for boosting productivity, such as using task automation and command-line shortcuts. The responses created a ripple effect, sparking further discussion as people asked questions and commented on each other’s posts.

This activity not only increased engagement but also helped group members discover new tools and best practices. The positive impact was immediate; members appreciated the opportunity to share insights, and the sense of community felt stronger. Overall, this small initiative made a noticeable difference in participation and knowledge sharing within the group.

My3MTT #3MTTWeeklyReflection

Creating and Managing Docker Containers for a Simple Node.js Application

bankolejohn — Mon, 07 Oct 2024 13:13:10 +0000

Docker is a powerful tool that enables developers to package applications and their dependencies into a portable container, making it easy to deploy and run anywhere. In this article, we'll walk through building a Docker image for a simple Node.js application, and cover key commands for managing Docker containers. This includes writing a Dockerfile, building the image, and running the container.

Prerequisites

Basic knowledge of Docker.
Docker installed on your machine.
Node.js and npm installed for testing the app locally.

Step 1: Create a Simple Node.js Application

First, let’s set up a basic Node.js application. Create a new directory for your project and initialize it:

mkdir node-docker-app
cd node-docker-app
npm init -y

Next, create an index.js file with the following content:

// index.js
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Hello, Docker!');
});

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Install express as a dependency:

npm install express

Now you have a basic Node.js app that responds with "Hello, Docker!" at the root URL.

Step 2: Write the Dockerfile

A Dockerfile is a script that contains instructions for building a Docker image. Create a file named Dockerfile in your project directory and add the following content:

# Use the official Node.js image as the base image
FROM node:18

# Set the working directory inside the container
WORKDIR /app

# Copy package.json and package-lock.json to the working directory
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application files
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Define the command to run the app
CMD ["node", "index.js"]

Explanation of Dockerfile Commands

FROM: Specifies the base image. We use the official Node.js image.
WORKDIR: Sets the working directory inside the container to /app.
COPY: Copies files from your local machine to the working directory inside the container.
RUN: Executes commands in the Docker image (e.g., npm install to install dependencies).
EXPOSE: Exposes port 3000 to allow the application to be accessible.
CMD: Defines the command to run when the container starts.

Step 3: Build the Docker Image

With the Dockerfile in place, build the Docker image using the following command:

docker build -t node-docker-app .

-t node-docker-app: Tags the image with a name for easy reference.
.: Refers to the current directory, which contains the Dockerfile.

Once the build is complete, you can list the Docker images on your system:

docker images

This should show the node-docker-app image you just built.

Step 4: Run the Docker Container

Now that we have an image, let's run a container from it:

docker run -p 3000:3000 node-docker-app

-p 3000:3000: Maps port 3000 on your local machine to port 3000 in the container.
node-docker-app: The name of the image to run.

Once the container is running, you can open your browser and navigate to http://localhost:3000 to see your app in action. It should display "Hello, Docker!".

Step 5: Managing Docker Containers

List Running Containers

To see the currently running containers, use:

docker ps

This will show you the container ID, image name, and other details about running containers.

Stop a Container

To stop a running container, use:

docker stop <container_id>

Replace <container_id> with the ID of your container, which you can get from docker ps.

Remove a Container

To remove a stopped container, use:

docker rm <container_id>

Remove an Image

If you want to remove the Docker image, use:

docker rmi node-docker-app

Make sure that no containers are using the image before you try to remove it.

Step 6: Pushing the Docker Image to Docker Hub (Optional)

If you want to share your Docker image, you can push it to Docker Hub:

Tag the image with your Docker Hub username:

docker tag node-docker-app yourusername/node-docker-app

Push the image to Docker Hub:

docker push yourusername/node-docker-app

Now, anyone can pull and run your image using:

docker pull yourusername/node-docker-app
docker run -p 3000:3000 yourusername/node-docker-app

Conclusion

In this article, we created a simple Node.js application and packaged it into a Docker container using a Dockerfile. We went through building, running, and managing the Docker image, and even pushing it to Docker Hub for easy distribution. Docker simplifies the process of deploying applications by providing a consistent runtime environment, making it a valuable tool for developers.

Setting Up a Basic CI/CD Pipeline with Automated Build and Test Stages

bankolejohn — Mon, 30 Sep 2024 10:38:07 +0000

In today's fast-paced development environments, Continuous Integration and Continuous Deployment (CI/CD) pipelines play a crucial role in ensuring rapid, reliable, and automated software releases. This article will walk you through setting up a basic CI/CD pipeline, focusing on automated build and test stages. Additionally, we'll identify the key stages of a CI/CD pipeline and explore how they can be automated with modern tools.

What is CI/CD?

CI/CD stands for Continuous Integration and Continuous Deployment (or Delivery). CI focuses on automating the integration of code changes from multiple contributors, while CD automates the process of delivering that integrated code to production. Together, they streamline the software development lifecycle, improving efficiency, reliability, and speed.

Key Stages of a CI/CD Pipeline

Source Control:
- This is the first stage where developers push their code changes. A version control system (VCS) like Git is used to manage and track code changes.
- Automation Tool: GitHub, GitLab, Bitbucket, or other Git-based platforms.
Build:
- In this stage, the code is compiled and necessary dependencies are installed. For interpreted languages like JavaScript (Node.js), Python, or Ruby, this might involve installing libraries or setting up the environment.
- Automation Tool: GitHub Actions, Jenkins, CircleCI.
- Example: A Node.js project could use npm install to set up dependencies and then run build commands like npm run build.
Test:
- Automated testing ensures that the new changes don't break existing features. Tests can include unit tests, integration tests, or end-to-end tests.
- Automation Tool: Jest (JavaScript), PyTest (Python), Mocha, etc.
- Example: For a Node.js project, you can automate tests by running npm test or using a CI service like GitHub Actions to run tests on each pull request.
Deploy:
- In this stage, the code is deployed to staging or production environments. This ensures that the pipeline can continuously deploy updates to live environments without human intervention.
- Automation Tool: Docker, Kubernetes, AWS CodeDeploy, GitHub Actions, Jenkins.
Monitoring and Feedback:
- After deployment, monitoring is crucial to ensure the system is working as expected. Feedback loops inform the team of issues, allowing rapid fixes.
- Automation Tool: Prometheus, Grafana, Datadog.

Setting Up a Basic CI/CD Pipeline with GitHub Actions

Let's focus on creating a simple CI/CD pipeline for a Node.js project using GitHub Actions. This will cover the build and test stages.

Step 1: Define a GitHub Workflow

In your GitHub repository, create a new directory called .github/workflows and add a YAML file, such as ci.yml.

name: Node.js CI Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

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

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'

      - name: Install dependencies
        run: npm install

      - name: Run build
        run: npm run build

      - name: Run tests
        run: npm test

Step 2: Automating the Build Stage

The pipeline begins by checking out the repository's code and setting up Node.js (version 16 in this case). It installs the project's dependencies using npm install and runs the build command, typically npm run build.

Step 3: Automating the Test Stage

After building the project, it automatically runs tests using npm test. This ensures that every push and pull request goes through proper testing before merging or deployment.

Step 4: Extending to Deployment

For deployment, you can add additional steps in the workflow to deploy the code to services like AWS, Heroku, or Docker. Here's a quick example for AWS deployment:

      - name: Deploy to AWS
        uses: appleboy/scp-action@v0.1.2
        with:
          host: ${{ secrets.AWS_HOST }}
          username: ${{ secrets.AWS_USER }}
          key: ${{ secrets.AWS_KEY }}
          source: "./"
          target: "/var/www/html"

Tools for Automating Each CI/CD Stage

Source Control: Git, GitHub, GitLab.
Build: GitHub Actions, Jenkins, CircleCI.
Test: Jest, PyTest, Mocha, Selenium.
Deploy: Docker, Kubernetes, AWS CodeDeploy, Ansible.
Monitoring: Prometheus, Grafana, New Relic.

Conclusion

Setting up a CI/CD pipeline with automated build and test stages ensures rapid feedback and higher code quality. By utilizing modern automation tools, you can ensure that your project is tested and deployed consistently with minimal manual intervention. This process is vital for maintaining code reliability and enabling frequent deployments in fast-moving development environments.

This article gives one a good foundation for setting up a simple CI/CD flow.

DevOPs Week 2: ALC Assignment

bankolejohn — Tue, 10 Sep 2024 19:51:09 +0000

A Comprehensive Guide to Committing a Repository to GitHub Using Git

Understanding Git and GitHub

Before diving into the steps, let's clarify the roles of Git and GitHub:

Git: A distributed version control system that tracks changes to files and directories. It's primarily used for managing source code.
GitHub: A web-based hosting service for software development projects that use Git. It provides features like collaboration, issue tracking, and project management.

Setting Up Your Environment

Install Git: Download and install Git from https://git-scm.com/downloads.
Configure Git: Open your terminal or command prompt and set your username and email address:

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

Creating a Repository on GitHub

Log in to GitHub: Visit https://github.com and log in to your account.
Create a New Repository: Click the "New repository" button, provide a name and description, and choose the repository's visibility (public or private).

Cloning the Repository Locally

Copy the Repository URL: From your GitHub repository's page, copy the HTTPS clone URL.
Clone the Repository: Open your terminal and navigate to the desired directory. Use the git clone command:

   git clone <repository_url>

This creates a local copy of the repository on your machine.

Making Changes and Committing

Navigate to the Repository: Open a terminal and navigate to the cloned repository's directory.
Make Changes: Modify files or create new ones as needed.
Stage Changes: Use git add to stage files for commit:

   git add <filename>

Or, to stage all changes in the current directory:

   git add .

Commit Changes: Create a commit using git commit:

   git commit -m "Clear and concise commit message"

Replace "Clear and concise commit message" with a meaningful description of your changes.

Pushing Changes to GitHub

Push to Remote Repository: Use git push to send your local commits to the remote GitHub repository:

   git push origin <branch_name>

Replace <branch_name> with the branch you're currently on (usually main or master).

Additional Tips

Branches: Use Git branches to work on different features or bug fixes simultaneously. Create branches with git branch <branch_name> and switch between them with git checkout <branch_name>.
Pull Requests: To collaborate with others, create pull requests on GitHub to propose changes to a repository.
Remote Repositories: You can add multiple remote repositories to your local project. This is useful for collaborating with others or working on different versions of the same code.
Ignoring Files: Use a .gitignore file to specify files or directories that Git should ignore.

By following these steps and incorporating best practices, you'll be well-equipped to effectively commit your repositories to GitHub using Git.

How I Overcame Course Access and Assignment Submission Challenges in the 3MTT Program

bankolejohn — Tue, 10 Sep 2024 13:24:25 +0000

Introduction:
As a participant in the 3MTT program, recently upgraded from Cohort 3 to Cohort 2, I encountered unexpected challenges. Navigating course access and submitting assignments felt overwhelming initially. However, through the power of community and collaboration, I was able to resolve these issues and keep my learning on track.

The Challenges:

Accessing Courses: Upon moving to Cohort 2, I had difficulty figuring out how to access the relevant courses.
Submitting Assignments: I also needed clarity on how to submit my assignments in a way that would allow mentors and peers to provide feedback.

The Solutions:
I turned to the Telegram community for help, where my colleagues provided invaluable guidance. Here’s how I solved each challenge:

Accessing Courses: I was advised to audit the courses before accessing them. This simple tip allowed me to view and enroll in the materials I needed.
Submitting Assignments: I learned that making my Google Drive links publicly accessible was essential. This ensured that others could view my work and leave comments.

Key Takeaways:
This experience reinforced the importance of community in overcoming obstacles. Asking questions, receiving feedback, and collaborating with others in the program made a significant difference in resolving my challenges quickly.

Conclusion:
Facing challenges is part of any learning journey, but the support of peers and mentors can make all the difference. In the 3MTT program, I’ve learned that when in doubt, turning to the community is always a good solution.

My3MTT #3MTTWeeklyReflection @3mttNigeria @IHSTowers @NITDANigeria

DevOps vs. Traditional Approaches: Navigating the Shift in Software Development

bankolejohn — Mon, 26 Aug 2024 13:40:02 +0000

DevOps vs. Traditional Software Development: A Comparative Analysis

In the rapidly evolving world of software development, organizations continuously seek methodologies that enhance efficiency, improve collaboration, and accelerate delivery. Two prominent approaches in this domain are the Traditional Software Development model and the DevOps methodology. While both aim to produce reliable software, their philosophies, practices, and outcomes differ significantly.

1. Philosophy and Culture

Traditional Approach: Traditionally, software development has been characterized by a clear separation of roles. Developers focus on writing code, while operations teams are responsible for deployment and maintenance. This siloed structure often leads to miscommunication, delays, and a lack of shared responsibility for the end product.
DevOps Approach: DevOps, short for Development and Operations, embodies a culture of collaboration. It emphasizes breaking down silos, promoting cross-functional teams where developers, operations, QA, and even security teams work together from the outset. This shared responsibility ensures that all team members are aligned with the same goals, fostering a culture of continuous improvement and accountability.

2. Development and Release Cycles

Traditional Approach: Traditional software development often follows a linear, waterfall model, where each phase—requirements gathering, design, coding, testing, and deployment—is completed sequentially. This can result in long release cycles, sometimes taking months or even years, which can delay the delivery of new features and updates to end users.
DevOps Approach: In contrast, DevOps embraces agile principles, promoting shorter, iterative development cycles. Continuous Integration (CI) and Continuous Deployment (CD) are core practices in DevOps, enabling teams to release small, incremental updates frequently. This rapid release cycle not only accelerates time-to-market but also allows for quicker feedback and iterative improvements.

3. Collaboration and Communication

Traditional Approach: Communication in traditional software development is often formal and follows a top-down hierarchy. Teams work independently, passing completed work to the next department in the chain, which can lead to bottlenecks and a lack of transparency.
DevOps Approach: DevOps fosters a culture of open communication and collaboration. With tools like Slack, JIRA, and automated pipelines, teams can collaborate in real-time, share progress, and resolve issues faster. This transparency ensures that everyone is on the same page, reducing friction and promoting a more cohesive workflow.

4. Infrastructure Management

Traditional Approach: Infrastructure management in traditional development is typically manual and separate from the development process. Operations teams manage servers, networking, and other infrastructure components independently, which can lead to slow provisioning and scaling.
DevOps Approach: DevOps introduces Infrastructure as Code (IaC), where infrastructure is treated as software. Tools like Terraform, Ansible, and Kubernetes allow teams to automate the provisioning and management of infrastructure, making it scalable, repeatable, and version-controlled. This automation reduces human error, speeds up deployments, and enhances the ability to scale rapidly in response to demand.

5. Quality and Security

Traditional Approach: In traditional models, quality assurance (QA) and security are often addressed at the end of the development cycle. This can lead to significant delays if issues are discovered late in the process, requiring extensive rework.
DevOps Approach: DevOps integrates quality and security into every stage of the development lifecycle. Practices like Test-Driven Development (TDD), Continuous Testing, and DevSecOps (security as code) ensure that code quality and security are maintained throughout the development process. This proactive approach reduces the risk of defects and vulnerabilities, leading to more reliable software.

6. Customer Feedback and Adaptability

Traditional Approach: Due to long release cycles, customer feedback in traditional development often comes late, making it challenging to adapt to changing requirements. This can result in a product that meets the original specifications but not the evolving needs of the market.
DevOps Approach: With its emphasis on continuous delivery, DevOps enables teams to gather and act on customer feedback quickly. This iterative process allows for rapid adaptation to changing market conditions, ensuring that the software remains relevant and valuable to users.

Conclusion

The shift from traditional software development to DevOps represents a fundamental change in how software is built, tested, and delivered. By breaking down silos, automating processes, and fostering a culture of collaboration, DevOps offers a more agile, efficient, and customer-focused approach to software development. Organizations that embrace DevOps are better equipped to navigate the complexities of modern software delivery, ensuring that they can deliver high-quality software at speed.

Whether you're a seasoned developer or new to the field, understanding these differences is crucial for navigating the ever-evolving landscape of software development. Embracing the DevOps mindset can open doors to more innovative, efficient, and impactful ways of working.

DEPLOYING "HNG_BOILERPLATE" EXPRESSJS APPLICATION (BACKEND) TO PROD SERVER

bankolejohn — Sat, 24 Aug 2024 21:49:48 +0000

Overview

This documentation details the deployment process of the backend of an Express.js boilerplate application to a production environment on an EC2 Ubuntu server using a GitHub Actions workflow. The deployment process includes setting up necessary dependencies, pulling the latest code, running tests, building the backend, and ensuring it runs as a service.

Prerequisites

EC2 Ubuntu Server: Running Ubuntu, with SSH access.
Node.js 20 installed on the server.
npm installed on the server.
Nginx installed and configured as a reverse proxy.
GitHub Repository: Hosting the Express.js boilerplate code.
GitHub Actions Runner: Installed and configured on the server to execute the deployment workflow.
Certbot for SSL certificate management.

Dependencies

Node.js 20
npm
Nginx
Yarn (for managing Node.js dependencies)
GitHub Actions Runner (self-hosted runner)

Deployment Workflow

name: Deploy to production

on:
  push:
    branches:
      - prod

jobs:
  deploy:
    runs-on: bp_runner
    defaults:
      run:
        working-directory: /var/www/aihomework/boilerplate/prod

    steps:
      - name: Checkout code
        uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20' 

      - name: Remove old actions remote URL
        continue-on-error: true
        run: |
            git remote rm action

      - name: Stash or remove local changes
        run: |
            if git diff --quiet; then
              echo "No local changes to stash."
            else
              echo "Stashing local changes..."
              git stash --include-untracked || echo "Failed to stash changes. Attempting to reset..."
              git reset --hard || exit 1
            fi

      - name: Pull from GitHub
        id: pull
        run: |
            remote_repo="https://${GITHUB_ACTOR}:${{ secrets.GITHUB_TOKEN }}@github.com/${GITHUB_REPOSITORY}.git"
            git remote add action $remote_repo
            git pull $remote_repo prod

      - name: Install dependencies
        run: yarn install --frozen-lockfile

      - name: Run tests
        run: yarn test

      - name: Build the application
        run: yarn build && sudo rm -rf build

      - name: Setup and restart service
        run: |
          sudo cp server-script/aihomeworkprod.service /etc/systemd/system
          sudo systemctl daemon-reload
          sudo systemctl restart aihomeworkprod.service

      - name: Verify deployment
        run: |
          echo "Waiting for service to start..."
          sleep 10
          if sudo systemctl is-active --quiet aihomeworkprod.service; then
            echo "Deployment successful!"
          else
            echo "Deployment failed!"
            exit 1
          fi

1. Triggering the Workflow

The workflow is triggered by a push to the prod branch.

2. Checking Out the Code

The actions/checkout@v3 action pulls the latest code from the prod branch, ensuring the full history is retrieved (fetch-depth: 0).

3. Setting Up Node.js

The workflow installs Node.js version 20 using the actions/setup-node@v3 action.

4. Managing Git Remotes and Local Changes

Remove Old Remote URL: Deletes any existing remote URL to prevent conflicts.
Stash or Remove Local Changes: Uncommitted changes are stashed or reset to maintain a clean working directory.

5. Pulling Latest Changes

The latest changes are pulled from the prod branch using the GitHub token for authentication.

6. Installing Dependencies

Node.js dependencies are installed using yarn install --frozen-lockfile to ensure consistency with the yarn.lock file.

7. Running Tests

Tests are executed using yarn test to verify the stability of the backend before deployment.

8. Building the Backend

The backend is built using yarn build, and previous build artifacts are removed to prevent conflicts.

9. Setting Up and Restarting the Service

The service file (aihomeworkprod.service) is copied to the /etc/systemd/system directory, and the systemd manager configuration is reloaded. The service is restarted to apply the latest changes.

10. Verifying Deployment

The workflow waits for the service to start and checks its status. If the service is active, the deployment is successful; otherwise, it fails.

Service Configuration (`aihomeworkprod.service`)

The service file defines how the backend of the Express.js application runs on the server. Below is a sample service configuration:

[Unit]
Description=Express.js Backend Application - Production
After=network.target

[Service]
ExecStart=/usr/bin/node /var/www/aihomework/boilerplate/prod/build/index.js
WorkingDirectory=/var/www/aihomework/boilerplate/prod
Restart=always
User=www-data
Group=www-data
Environment=NODE_ENV=production
Environment=PORT=3000

[Install]
WantedBy=multi-user.target

Nginx Configuration

Nginx is used as a reverse proxy to route incoming traffic to the Express.js backend application. The following Nginx configuration includes the SSL setup using Certbot:

server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }

    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}

SSL Certificate Setup

To obtain SSL certificates and configure Nginx with HTTPS, you can use the following command with Certbot:

sudo certbot --nginx -d your-domain.com

This command will automatically configure Nginx with SSL, obtaining certificates from Let’s Encrypt.

Final Steps

Ensure Nginx is configured to point to the backend’s port.
Enable and start the systemd service: sudo systemctl enable aihomeworkprod.service and sudo systemctl start aihomeworkprod.service.
Monitor the service using sudo systemctl status aihomeworkprod.service.

NOTE

Ensure that you update the .env file with the required variables in order to ensure the application runs successfully.

Conclusion

This documentation outlines the automated deployment process for the backend of the Express.js boilerplate application, ensuring that the latest changes are consistently deployed to the production environment. By following the above steps, the backend can be reliably updated and maintained on the EC2 Ubuntu server with SSL-secured access.

Linux User Creation Bash Script - HNG 11 DevOPs Task

bankolejohn — Thu, 04 Jul 2024 12:03:36 +0000

Technical Article

Automating User Creation in Linux with a Bash Script

As a SysOps engineer, managing users and groups efficiently is crucial, especially when onboarding new developers. Automating this process ensures consistency and saves time. Here, I will walk you through a Bash script, create_users.sh, designed to create users and groups, set up home directories, generate random passwords, and log all actions.

Script Overview

The script reads a text file containing usernames and groups, creates users and groups, sets up home directories, generates random passwords, and logs actions to /var/log/user_management.log. Passwords are securely stored in /var/secure/user_passwords.txt.

Prerequisites

Ensure you have root or sudo privileges as the script requires administrative access to create users and groups.

Script Breakdown

Generate Random Password:

Generating a random password using OpenSSL ensures that each user gets a secure, unpredictable password.

generate_password() {
    openssl rand -base64 12
}

Check Input File:

if [ -z "$1" ]; then
    echo "Usage: $0 <input-file>"
    exit 1
fi

This checks if the user has provided the required input file. If not, it provides a usage message and exits the script. This ensures the script is used correctly.

Set Up Logging and Secure Password Storage:

LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.txt"
mkdir -p /var/secure
touch $LOG_FILE
chmod 644 $LOG_FILE
touch $PASSWORD_FILE
chmod 600 $PASSWORD_FILE

Setting up a log file allows tracking of actions, which is crucial for troubleshooting and auditing. Storing passwords securely with restricted permissions ensures that only authorized users can access them, enhancing security.

Read and Process Input File:

while IFS=';' read -r username groups; do
    username=$(echo "$username" | xargs)
    groups=$(echo "$groups" | xargs)

Reading the input file line by line and trimming whitespace ensures that each user and their groups are handled correctly, preventing issues with extra spaces.

Create User and Personal Group:

if id "$username" &>/dev/null; then
    echo "User $username already exists." | tee -a $LOG_FILE
    continue
fi
useradd -m -g "$username" "$username"

Checking if the user exists prevents errors from trying to recreate existing users. Creating a personal group for each user is a common practice to isolate permissions, and then creating the user with that group ensures proper setup.

Assign Additional Groups:

if [ -n "$groups" ]; then
    IFS=',' read -ra ADDR <<< "$groups"
    for group in "${ADDR[@]}"; do
        group=$(echo "$group" | xargs)
        if getent group "$group" &>/dev/null; then
            usermod -aG "$group" "$username"
            echo "User $username added to group $group." | tee -a $LOG_FILE
        else
            echo "Group $group does not exist. Skipping for user $username." | tee -a $LOG_FILE
        fi
    done
fi

Adding users to multiple groups allows for flexible permission management, enabling users to have access to different resources as needed. Creating missing groups on the fly ensures smooth execution without manual intervention.

Set Home Directory Permissions:

Setting strict permissions ensures that only the user can access their home directory, enhancing security and privacy. Changing ownership ensures that the user has full control over their own files.

```chmod 700 "/home/$username"
chown "$username:$username" "/home/$username"





#### Generate and Set Password:



```password=$(generate_password)
echo "$username,$password" >> $PASSWORD_FILE
echo "$username:$password" | chpasswd

Storing passwords securely and setting them for users automates the process, ensuring each user has a unique, strong password. This is crucial for maintaining security standards.

Logging and Completion:

echo "User creation process completed." | tee -a $LOG_FILE

Logging the completion of the process provides a clear end point for auditing purposes and ensures that administrators are aware of the script's progress and any issues that may have occurred.

script running successfully on AWS ubuntu 22.04

Conclusion

Automating user creation in Linux with a Bash script streamlines the onboarding process, ensuring efficiency and security. By following the steps outlined above, you can easily manage user accounts and groups in a consistent manner.

For more information about the HNG Internship and opportunities to enhance your skills, visit the HNG Internship website [https://hng.tech/internship] and learn how you can hire top talents from the program [ https://hng.tech/hire]

Microsoft Powerup Program

bankolejohn — Mon, 04 Mar 2024 14:32:09 +0000

I am thrilled to embark on my journey as a participant in the Microsoft PowerUp Program. Throughout this experience, I will gain a deep understanding of the Microsoft Power Platform and harness the power of tools such as Power Apps, Power Automate, Power Virtual Agents, Power Pages, and Power BI to create innovative solutions for various business requirements.

Follow me, as I keep you updated, sharing valuable knowledge throughout my journey.

If you have any questions as regards this program, do ask in the comment section.

See you in my next post...

microsoftPowerUpProgram #microsoftpowerbi #microsoftpowerautomate #microsoftpowerapps #microsoftpowervirtualagents #microsoftpowerpages

Forem: bankolejohn

𝗙𝗿𝗼𝗺 𝗜𝗱𝗲𝗮 𝘁𝗼 𝗜𝗺𝗽𝗮𝗰𝘁: 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗥𝗲𝗮𝗹-𝗪𝗼𝗿𝗹𝗱 𝗠𝗟 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄

MachineLearning #AI #MLOps #DevOps #DataScience #RealWorldAI #LearningInPublic #KeepBuilding #AWS #AIJourney

Setting Up NGINX on Ubuntu: HNG 12 DevOps Stage 0 Task

Task Requirements

Step-by-Step Implementation

1. Installing NGINX

2. Configuring NGINX to Serve a Custom HTML Page

3. Testing the Configuration

Challenges Faced and Solutions

1. NGINX Not Starting

2. Changes Not Reflecting in Browser

Key Learnings from This Task

How This Task Supports My Career Goals

Conclusion

Week 20 3MTT WEEKLY REFLECTION

My3MTT #3MTTWeeklyReflection

3MTT Week 19 Task: "Quick Impact Challenge"

My3MTT #3MTTWeeklyReflection

Creating and Managing Docker Containers for a Simple Node.js Application

Prerequisites

Step 1: Create a Simple Node.js Application

Step 2: Write the Dockerfile

Explanation of Dockerfile Commands

Step 3: Build the Docker Image

Step 4: Run the Docker Container

Step 5: Managing Docker Containers

List Running Containers

Stop a Container

Remove a Container

Remove an Image

Step 6: Pushing the Docker Image to Docker Hub (Optional)

Conclusion

Setting Up a Basic CI/CD Pipeline with Automated Build and Test Stages

What is CI/CD?

Key Stages of a CI/CD Pipeline

Setting Up a Basic CI/CD Pipeline with GitHub Actions

Step 1: Define a GitHub Workflow

Step 2: Automating the Build Stage

Step 3: Automating the Test Stage

Step 4: Extending to Deployment

Tools for Automating Each CI/CD Stage

Conclusion

DevOPs Week 2: ALC Assignment

A Comprehensive Guide to Committing a Repository to GitHub Using Git

Understanding Git and GitHub

Setting Up Your Environment

Creating a Repository on GitHub

Cloning the Repository Locally

Making Changes and Committing

Pushing Changes to GitHub

Additional Tips

How I Overcame Course Access and Assignment Submission Challenges in the 3MTT Program

My3MTT #3MTTWeeklyReflection @3mttNigeria @IHSTowers @NITDANigeria

DevOps vs. Traditional Approaches: Navigating the Shift in Software Development

DevOps vs. Traditional Software Development: A Comparative Analysis

1. Philosophy and Culture

2. Development and Release Cycles

3. Collaboration and Communication

4. Infrastructure Management

5. Quality and Security

6. Customer Feedback and Adaptability

Conclusion

DEPLOYING "HNG_BOILERPLATE" EXPRESSJS APPLICATION (BACKEND) TO PROD SERVER

Overview

Prerequisites

Dependencies

Deployment Workflow

1. Triggering the Workflow

2. Checking Out the Code

3. Setting Up Node.js

4. Managing Git Remotes and Local Changes

5. Pulling Latest Changes

6. Installing Dependencies

7. Running Tests

8. Building the Backend

9. Setting Up and Restarting the Service

10. Verifying Deployment

Service Configuration (aihomeworkprod.service)

Nginx Configuration

Service Configuration (`aihomeworkprod.service`)