DEV Community: Ejibode Ibraheem

Understanding the Lusophone Wikimedia Wishlist: Improving Contributor Experience

Ejibode Ibraheem — Tue, 14 Apr 2026 12:43:21 +0000

When I first heard of Wikimedia, the first thing that came to my mind was Wikipedia. However,as time went by, I understood that behind the scenes, Wikimedia is a large ecosystem of tools, contributors, and communities working together to make knowledge accessible to everyone.

As I began exploring Wikimedia during my Outreachy application, I discovered that a lot of effort goes into improving not just content, but also the experience of contributors—the editors, researchers, and volunteers who make Wikimedia projects possible.

One initiative that really caught my attention is the Lusophone Technological Wishlist.

*What is the Lusophone Technological Wishlist?
*
The Lusophone Technological Wishlist is a community-driven initiative focused on identifying the most important technical needs of Portuguese-speaking Wikimedia contributors.

Rather than leaders making assumptions, this wishlist is created from real feedback from the community. It highlights tools and improvements that can make editing, researching, and contributing more efficient and enjoyable.

This aligns closely with Wikimedia’s broader goal of improving contributor experience, which ensures that contributors have the right tools they need to work effectively.

As part of this effort, specific proposals are selected for implementation—and two of them particularly were prerequisites for Outreachy applicants that will make them eligible to be selected as interns.

Wishlist #3: Detecting Duplicate References in the Visual Editor

One common challenge when editing Wikipedia articles is managing references. Contributors often reuse sources, but without proper checks, they can add the same reference multiple times, leading to duplication.

Wishlist #3 proposes a solution to this problem:

Automatically detect duplicate references in the Visual Editor using identifiers such as DOI, ISBN, or URL, and allow users to reuse existing references instead of creating new ones.

Why does this matter?

It keeps articles cleaner and more organized
It reduces redundancy in citations
It improves the editing experience, especially for new contributors

My Perspective

While working on a related task involving URL validation, I began to understand how important it is to handle identifiers correctly. Even small inconsistencies in URLs or formats can lead to duplication or errors.

I also encountered a situation where date handling behaved differently across time zones, which made me realize that seemingly simple data can introduce subtle issues in real-world applications. This reinforced the importance of carefully handling edge cases when building features like duplicate detection.

Wishlist #8: Adding Wikidata Support to WikiScore
Another interesting proposal is Wishlist #8, which focuses on improving a tool called WikiScore.

WikiScore is used to track and evaluate contributions during events like edit-a-thons and contests. However, it currently has limited support for Wikidata contributions.

Wishlist #8 aims to:

Extend WikiScore to include Wikidata edits, allowing contributions to structured data to be properly counted and recognized.

Why is this important?

Wikidata plays a major role in structuring knowledge across Wikimedia
Contributors working on Wikidata deserve visibility and recognition
It encourages broader participation in different types of contributions

My Perspective

During my tasks, I worked with structured data and learned how important it is to process and present it correctly. Transforming raw data into meaningful output is not always straightforward, especially when consistency and accuracy are required.

This gave me a better appreciation for tools like WikiScore, where contributions need to be tracked reliably and fairly.

What I Learned from Exploring These Tasks

Working on tasks related to these ideas helped me understand that:

Small improvements can have a big impact on user experience Real-world data often comes with inconsistencies and edge cases
Writing functional code is not enough,code must also be reliable and adaptable
Feedback plays a key role in improving both code quality and understanding

For example, through feedback, I learned to:

Handle time zone differences when working with dates
Improve error handling to provide more meaningful output
Follow best practices when making HTTP requests

These lessons helped me move beyond just “making things work” to thinking more deeply about how and why things should work.

Why This Matters

What stood out to me most is how these wishlist items focus on real contributor needs.

Whether it’s reducing duplicate references or recognizing Wikidata contributions, these improvements are about making it easier for people to contribute effectively.

In a global, collaborative platform like Wikimedia, even small enhancements can improve workflows for thousands of contributors.

Conclusion
Exploring the Lusophone Technological Wishlist has given me a deeper appreciation for the work that goes into supporting Wikimedia contributors.

It’s not just about building features—it’s about understanding real problems, handling real-world data, and creating tools that make collaboration smoother and more effective.

As I continue learning and contributing, I’m excited about the opportunity to be part of efforts that improve both the quality of information and the experience of those who help create it.

Fedora, Community, and the Badges Revamp: My Experience

Ejibode Ibraheem — Mon, 30 Mar 2026 15:09:57 +0000

When I first came across the Fedora Project during my initial Outreachy application for the December 2025 cohort, I didn’t fully explore it. At the time, my focus was elsewhere—I was contributing to Debian, another Linux distribution, where I began to understand open source collaboration.

Although I gained valuable experience working with Debian, Fedora remained something I had only seen from a distance. For the May 2026 Outreachy application, however, my approach is completely different. This time, I am very much intentional about diving deeper into Fedora, committed and determined not only to contribute during the internship period but also to remain an active contributor beyond Outreachy.

What is the Fedora Project?

The Fedora Project is a global community dedicated to building free and open source software. Its flagship product, Fedora Linux, is known for integrating the latest technologies and serving as an upstream source for many other distributions.

But Fedora is more than just an operating system—it is an ecosystem where contributors(which I have become one of them(smiles)) collaborate across development, design, infrastructure, and documentation. What makes Fedora unique is how it blends innovation with community-driven values.I have more to say about Fedora, but let me just stop here for now.

Discovering Fedora Through Fedora Badges

One of the most interesting parts of Fedora that I explored is Fedora Badges, which you can visit here:
https://badges.fedoraproject.org/

Fedora Badges is a platform that recognizes and rewards contributors (hopefully I get a lot of badges soon)for their participation in the Fedora ecosystem. Whether you are contributing code, attending events, or helping others in the community, you earn badges that reflect your journey.

Exploring the live platform helped me see how Fedora celebrates contributions in real time, making the experience both engaging and motivating.

The Fedora Badges Revamp Project

One of the key projects for the current Outreachy internship cycle is the Fedora Badges revamp project, and this is where my interest is strongly focused.

This effort aims to modernize the entire badges system after years of limited updates. From what I have learned, it is not just a redesign—it is a full transformation of the platform, including:

A modernized frontend with improved user experience
A reworked backend architecture
Better tools for contributors and administrators
A containerized development environment using tools like Podman and Vagrant

New features such as global search, dark mode, improved badge collections, and redesigned interfaces are being introduced.

What makes this project particularly exciting is that it directly impacts how contributors are recognized within Fedora. It is a meaningful project that combines technical work with community value, and it is exactly the kind of work I am eager to contribute to during Outreachy.

Why Fedora Matters to Me as a DevOps Engineer

As a DevOps engineer, Linux is part of my daily workflow. I interact with Linux systems constantly—running commands, managing environments, and automating processes.

Fedora, being one of the major Linux distributions, is part of this larger ecosystem. While I have used Linux extensively, I realized that I have not yet explored Fedora deeply.

Contributing to Fedora gives me the opportunity to:

Understand a major Linux distribution from the inside
Improve my practical knowledge beyond daily usage
Connect my DevOps experience with real open source contributions

For me, this is not just about using Linux—it is about understanding how it is built, maintained, and improved by a community.

The Community Experience

One of the most impactful parts of my journey so far has been the Fedora community itself.

I have met many like-minded individuals who are always willing to help, guide, and share knowledge. The sense of openness and collaboration is something I deeply appreciate.

The mentors, in particular, have been incredibly supportive. Even though we are in different time zones, they consistently make time to guide us. On my part, I have had to make adjustments—sometimes sacrificing sleep—because I do not want to miss sessions where I can learn directly from them.

This experience has shown me that open source is not just about code—it is about people.

The Challenge of Getting Started

At the moment, I am still setting up my development environment on my local machine. This process has not been entirely smooth—it has come with its own set of challenges and learning curves.

However, I see this as part of the journey. Every issue I encounter is an opportunity to learn something new and grow more confident in navigating complex systems.

I plan to share more about this experience in my next article, where I will write in detail about the challenges I faced during environment setup and how I was able to overcome them.

Watch out for it.

Fedora’s Four Foundations

As I explored further, Fedora’s Four Foundations—Freedom, Friends, Features, and First—became clearer to me.

Freedom ensures that everything is open and accessible
Friends highlights the importance of community and collaboration
Features reflects Fedora’s commitment to innovation
First emphasizes being at the forefront of new technologies

The Badges revamp project perfectly reflects these values, especially “Features” and “First.”

My Commitment This Time

This time, I am approaching Fedora with clarity and purpose.

My first encounter during the December 2025 Outreachy cycle gave me awareness, and my experience contributing to Debian gave me a foundation. Now, in the May 2026 application cycle, I am bringing both together—actively setting up the development environment, exploring real projects like the Fedora Badges revamp, and identifying where I can contribute meaningfully.

More importantly, my goal is not limited to securing the internship. I am committed to contributing to Fedora long after Outreachy ends, growing within the community and continuing to build impactful work.

Advice for Future Outreachy Applicants

If you are applying to Outreachy and exploring Fedora:

Start small and build gradually
Don’t be discouraged by complexity
Ask questions and engage with the community (I ask questions a lot from peers and mentors)
Explore real projects like Fedora Badges to understand impact

Most importantly, stay consistent. Growth in open source comes from persistence.

Final Thoughts

Fedora is more than an operating system—it is a community-driven platform where innovation and collaboration thrive.

Looking back, I realize that simply “seeing” Fedora during my first Outreachy application was not enough. It takes intentional effort to truly understand and contribute to such a rich ecosystem. Now that I am fully engaging with Fedora, I feel more confident, more prepared, and more motivated than ever.

This journey is no longer just about applying for Outreachy—it is about becoming a long-term contributor to Fedora. And this time, I am ready to give it my all.

Introduction to Docker: Simplifying Containerized Applications

Ejibode Ibraheem — Sun, 02 Mar 2025 14:23:58 +0000

Table Of Content

Introduction
Basic Docker commands
Running an application using Dockerfile
Docker volume
Docker network
Docker compose file
Clean UP
Conclusion

Prerequisite

An AWS account
A Linux system (Ubuntu 20.04 or Amazon Linux 2 recommended )
Basic knowledge of Linux commands

Introduction
Docker has become an essential tool for building, shipping, and running applications seamlessly across different environments in today's fast-paced software development landscape. Whether you're a developer, DevOps engineer, or system administrator, understanding Docker can significantly enhance your ability to manage applications efficiently.

This article will guide you through key Docker concepts, including:
✅ Dockerfile – Automating image creation
✅ Docker Network – Enabling seamless communication between containers
✅ Docker Volume – Managing persistent data in containers
✅ Docker Compose – Defining and running multi-container applications effortlessly

Each section includes hands-on examples to help you grasp these concepts in a practical way. By the end of this article, you'll be well-equipped to leverage Docker for your containerized workflows. Let's dive in! 🚀

Step 1: launch an EC2 instance

click on Launch instance

Choose your instance name and Amazon Machine Image

Select your instance type and your key pair

Allow traffic from SSH, HTTP, HTTPS and click on launch instance

SSH into the server from your terminal

Step 2: Install Docker

Update and upgrade your system sudo apt-get update -y && sudo apt-get upgrade -y

Install Docker: sudo apt-get install -y docker.io

Enable and start docker : sudo systemctl enable docker && sudo systemctl start docker

Allow the current user to run Docker commands without sudo (optional) sudo usermod -aG docker $USER

Log out and log in again for this change to take effect

Step 3: Explore docker commands

check if docker is running sudo sysetmctl status docker

Pull and run NGINX image from the docker hub docker pull nginx

Verify the downloaded image docker images

Run a container using NGINX image docker run -d -p 8080:80 --name my-nginx nginx

Verify the container is running docker ps

Open your browser and navigate to http://localhost:8080. You should see the Nginx welcome page

Stop the container docker stop my-nginx

Remove the container docker rm my-nginx

Step 4 Create a Custom Docker Image

create a directory
mkdir nginx-image && cd nginx-image
Create a Dockerfile:
vim Dockerfile

Add the following content:

Use the official nginx image as the base image

FROM nginx:latest

Copy a custom HTML file to the nginx document root

COPY index.html /usr/share/nginx/html/index.html

Create a custom index.html
vim index.html
Add the following content:
<!DOCTYPE html>

My Custom Nginx

Welcome to My Custom Nginx Container!
Build the docker image

docker build -t ejibode .

Run the container using the custom image docker run -d -p 8081:80 --name ejibode ejibode

Open your browser and navigate to http://localhost:8081. You should see your custom HTML content.

Step 5 Manage Volumes

Create a volume: docker volume create my-volume

Run a container and mount the volume docker run -d -p 8082:80 --name my-new-nginx -v my-volume:/usr/share/nginx/html nginx

Access the container shell
docker exec -it my-new-nginx
Add a custom HTML
echo "<h1>Persistent Volume Content</h1>" > /usr/share/nginx/html/index.html

Open your browser and navigate to http://localhost:8082. You should see the updated content.

Stop and remove the container: docker stop my-new-nginx && docker rm my-new-nginx

Step 6: Use docker networks

create a docker network: docker network create my-network

Run a container in the network: docker run -d --name network-nginx --network my-network nginx

Inspect the network docker network inspect my-network

Remove the network docker network rm my-network

Step 7 :Multicontainer Application Using Docker compose

Install Docker compose
sudo apt-get install -y docker-compose
Create a docker-compose.yml file
vim docker-compose.yml
paste the following code

version: '3'
services:
web:
image: nginx
ports:
- "8080:80"
app:
image: custom-nginx
build:
context: .

Run the container
docker-compose up -d
Access the application at http://localhost:8080

Stop and remove the application docker-compose down

Step 8 Clean up

Remove all the stopped containers docker container prune

Remove unused images docker image prune -a

Remove unused volumes docker volume prune

Conclusion
Mastering these concepts enables efficient containerization of applications, improves scalability and streamline deployment processes.
Thank you for reading my article!

Demystifying AWS VPC: A Comprehensive Guide to Networking in the Cloud

Ejibode Ibraheem — Fri, 06 Dec 2024 19:06:55 +0000

Introduction
What is AWS VPC
Benefits of AWS VPC
How to create VPC using terraform
Conclusion

Introduction

Networking serves as the foundation of any infrastructure in cloud computing. AWS Virtual Private Cloud (VPC) is a fundamental component of Amazon Web Services (AWS), providing a secure and scalable environment for deploying resources. Whether you’re a cloud enthusiast or a DevOps engineer, understanding VPC is crucial for designing robust architectures.

What is AWS VPC

AWS Virtual Private Cloud (VPC) is a isolated section of the AWS Cloud where you can you deploy your resources, such as EC2 instances, in a secure virtual network. It enables complete control over your network, including IP address range, subnets, routing, and security.

Key Components of AWS VPC

Subnets

Public Subnets: Subnets with internet access via an Internet Gateway.

Private Subnets: Isolated for secure resources without direct internet access.

Route Tables
Direct traffic within and outside the VPC using rules. For example:

Public subnets use routes to an Internet Gateway.
Private subnets route traffic through a NAT Gateway for internet access.

Internet Gateway (IGW) and NAT Gateway

IGW: Facilitates internet communication for public resources.

NAT Gateway: Enables outbound internet traffic for private resources.
Security Groups (SGs)
Act as virtual firewalls for your instances, controlling inbound and outbound traffic.

Network Access Control Lists (NACLs)
Stateless firewalls that provide subnet-level traffic control.

Creating Your First AWS VPC with Terraform

Here’s how to create a VPC using Terraform resources:

Set up Terraform: Ensure Terraform is installed on your system.
Terraform Configuration File: Create a file named vpc.tf and include the following:

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "my_vpc" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_support   = true
  enable_dns_hostnames = true
  tags = {
    Name = "MyVPC"
  }
}

resource "aws_subnet" "public_subnet" {
  vpc_id                  = aws_vpc.my_vpc.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
  availability_zone       = "us-east-1a"
  tags = {
    Name = "PublicSubnet"
  }
}

resource "aws_internet_gateway" "igw" {
  vpc_id = aws_vpc.my_vpc.id
  tags = {
    Name = "InternetGateway"
  }
}

resource "aws_route_table" "public_rt" {
  vpc_id = aws_vpc.my_vpc.id
  tags = {
    Name = "PublicRouteTable"
  }
}

resource "aws_route" "default_route" {
  route_table_id         = aws_route_table.public_rt.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.igw.id
}

resource "aws_route_table_association" "public_association" {
  subnet_id      = aws_subnet.public_subnet.id
  route_table_id = aws_route_table.public_rt.id
}

Deploy the Configuration:

Initialize Terraform: terraform init

Plan the infrastructure: terraform plan

Apply the changes: terraform apply -auto-approve

If you check your AWS console a VPC, public subnet, internet gateway, and routes would have been created. Do not forget to delete the resources created by running:
terraform destroy -auto-approve

Use Cases for AWS VPC

Hosting Web Applications: Isolate backend databases in private subnets while keeping the front end in public subnets.

Conclusion

AWS VPC provides a secure, customizable foundation for deploying cloud resources. With its robust features and flexibility, it’s an essential tool for building modern, scalable network architectures.

Exploring AWS EC2 Instances: Uses and How to Create One Using Terraform

Ejibode Ibraheem — Thu, 05 Dec 2024 22:40:50 +0000

Introduction
What is AWS EC2 instance
Uses OF AWS EC2 instance
Benefits of using Terraform to create EC2 instance
Step-by-step guide in creating AWS EC2 instance with Terraform
Conclusion

Introduction

AWS offers more than 200 services, and Amazon Elastic Cloud Compute (EC2) is one of its most widely used services. It plays a crucial role in hosting applications, managing data processing tasks, and enabling modern cloud architecture. In this article, we will explore the use of EC2 and the step-by-step guide for creating EC2 instances using Terraform.

What is AWS EC2 Instance

An EC2 instance is a virtual server in AWS, which enables you to run applications in a secure and scalable environment. It provides resizable computing capacity, helping developers and businesses avoid the upfront costs of physical servers.

Uses of AWS EC2 Instance

Web Hosting: Run web applications, blogs, or static websites
Application Hosting: Deploy scalable backend applications or APIs.
Big Data Processing: Analyze large datasets using tools like Apache Hadoop or Spark.
Machine Learning: Train and deploy ML models with powerful GPU-enabled instances.
Disaster Recovery: Maintain backup environments for high availability.

Benefits of using Terraform to create AWS EC2 Instance

Terraform allows you to automate the provisioning and management of EC2 instances, ensuring consistent infrastructure deployments across environments and preventing manual errors. Key advantages include:

Reusability: Easily replicate infrastructure with minimal changes.
Version Control: Track changes in infrastructure configurations.
Scalability: Handle large and complex infrastructures efficiently.

Step-by-Step Guide: Creating an AWS EC2 Instance Using Terraform

Prerequisites

AWS Account: Ensure you have an AWS account and access keys.
IAM User: Set up an IAM user with sufficient EC2 permissions.
Terraform Installed: Download and install Terraform from terraform.io.

create a main.tf file and paste the below code in the file

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "example" {
  ami           = "ami-0c02fb55956c7d316" # Replace with your preferred AMI ID
  instance_type = "t2.micro"

  tags = {
    Name = "MyEC2Instance"
  }
}

create a variable.tf file for reusability and paste the below code in it

variable "instance_type" {
  default = "t2.micro"
}

variable "region" {
  default = "us-east-1"
}

Update the main.tf to reference these variables

provider "aws" {
  region = var.region
}

resource "aws_instance" "example" {
  ami           = "ami-0c02fb55956c7d316"
  instance_type = var.instance_type

  tags = {
    Name = "MyEC2Instance"
  }
}

Run the command below terraform init

If successfully initialized, run: terraform validate

-Then, run :
terraform plan

terraform apply -auto-approve

The next step is to go and confirm on the AWS console if the instance has been created.

To destroy the resource created , run this command terraform destroy -auto-approve

Conclusion

AWS EC2 instances are a cornerstone of modern cloud computing, and leveraging Terraform to manage them unlocks the full potential of IaC. With Terraform, you can build scalable, repeatable, and consistent infrastructure in minutes.

Step-by-Step Guide to setting Up Terraform, AWS CLI, and VS Code

Ejibode Ibraheem — Mon, 02 Dec 2024 21:03:36 +0000

In this article, I am going to work you through how you can set up Terraform, AWS CLI, and VScode. I assumed you already have an AWS account.
If your operating system is macOS, and you have homebrew installed, you can run these commands:
brew tap hashicorp/tap
brew install hashicorp/tap/terraform

On Windows, if you are Chocolatey user, you can run:
choco install terraform

If you wish, you can install Terraform manually by going to the Terraform homepage,download the ZIP archive for your operating system and unzipping it into the directory where you want the terraform to be installed.
To confirm if the Terraform is correctly installed, run this command:
terraform

For the Terraform installed to be able to communicate with AWS, AWS credentials (AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY) for the IAM user you created will be needed.If you are on Unix/Linux/macOs terminal run:
export AWS_ACCESS_KEY_ID=(your access key id)

export AWS_SECRET_ACCESS_KEY=(your secret access key
If you are on Windows, run:
set AWS_ACCESS_KEY_ID=(your access key id)
set AWS_SECRET_ACCESS_KEY=(your secret access key)

To install VS Code, install vscodeclick on the link, and follow the process to end.

Getting Started with Infrastructure as Code (IaC) Using Terraform

Ejibode Ibraheem — Sun, 01 Dec 2024 17:38:01 +0000

Table of contents

Introduction
What is infrastructure as a code (IaC)
Five broad categories of IaC tools
Key benefits of IaC
Why terraform?
Getting started with Terraform
Conclusion

Introduction

In the modern era of cloud computing, Infrastructure as Code (IaC) has become a cornerstone of efficient and scalable DevOps practices. IaC allows engineers to manage and provision infrastructure using machine-readable configuration files rather than manual processes. Among the many tools available for implementing IaC, Terraform stands out as a popular choice due to its cloud-agnostic capabilities, strong community support, and ease of use.

What is infrastructure as a code (IaC)

Infrastructure as a code enables you to write and execute code to define,deploy, update, and destroy your infrastructure. By doing so, IaC ensures consistency, reduces manual errors, and simplifies infrastructure management across environments.

Five broad categories of IaC Tools

Ad hoc scripts
Configuration management tools
Server templating tools
Provisioning tools

I would dwell more on these categories in another article

Key benefits of IaC

**Speed and safety: **Since the deployment process is automated, it will be significantly faster, safer, and less prone to manual error.
*Documentation: * Since the infrastructure is defined as code, then the state of the infrastructure is in source files that anyone can read and understand.
Version control: Store infrastructure configurations in repositories like Git for easy tracking and rollback.
Reusability: Infrastructure can be packaged into reusable modules, so instead of starting every deployment for every product in every environment from scratch, you can build on top of known, documented, battle-tested pieces.

Why Terraform?

Terraform, developed by HashiCorp, is an open-source tool that simplifies infrastructure provisioning. It uses a declarative language, HCL (HashiCorp Configuration Language), to define resources and dependencies. Here’s why Terraform is a favorite in the IaC space:

Cloud Agnostic: Manage resources across AWS, Azure, GCP, and even on-premises solutions.
State Management: Keep track of resources using Terraform’s state file.
Modularity: Use modules to organize and reuse configurations.
Community Support: Leverage a robust ecosystem of providers and modules.

Getting started with Terraform

Firstly, you need to install terraform, link on this link Terrform-installation.
Once you are done type this command to confirm the installation

terraform --version

The next step is to install a code editor, I would be using vscode. Click on this link install-vscodeto install vscode.

Setup a cloud provider account.To setup an AWS account, click on this link signup AWS account
To Install AWS CLI and configure it, click on this link AWS-CLI
Run the command below to confirm
aws --version

Conclusion

Terraform simplifies the process of managing and scaling infrastructure through its declarative syntax and robust tooling. By adopting IaC practices and leveraging Terraform, teams can improve efficiency, reduce errors, and build more resilient infrastructure.

What’s your experience with Terraform? Let’s discuss this in the comments!

Efficient User and Group Management on Linux: A Bash Script Tutorial

Ejibode Ibraheem — Wed, 03 Jul 2024 22:44:14 +0000

Table Of Content

Introduction
script overview
Conclusion

Introduction

A Bash script is a text file containing a series of commands written in the Bash (Bourne Again SHell) scripting language, which is a command processor that typically runs in a text window where the user types commands to perform actions. A Bash script allows users to automate repetitive tasks, manage system operations, and perform complex operations by executing commands.

As a SysOps engineer, managing user accounts and groups is crucial for maintaining a secure and organized development environment. In this article, I will guide you through a bash script designed to automate user creation, assign groups, set up home directories, and handle permissions efficiently.

The script, create_users.sh, performs the following tasks:

Reading Input: It reads a text file containing usernames and their associated groups.
User and Group Creation: It creates users and their groups if they do not already exist.
Home Directory Setup: It sets up home directories with appropriate permissions and ownership.
Password Generation: It generates random passwords for the users.
Logging: It logs all actions to /var/log/user_management.log and stores the passwords securely in /var/secure/user_passwords.csv.

Script Overview

Here’s a detailed breakdown of the script:

Checking Input Argument: The script checks if the input file is provided as an argument.

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

Initialization: It initializes log and password files and ensures the secure directory exists.

# Function to generate a random password
generate_password() {




    # using 'openssl rand -base64 12’ to generate a 12-character password
    openssl rand -base64 12
}

# Read input file line by line
while IFS=';' read -r username groups; do
    # Create groups if they don't exist
    for group in $(echo "$groups" | tr ',' ' '); do
      groupadd "$group" 2>/dev/null || echo "Group $group already exists"
    done

create user

useradd -m "$username" -G "$groups" 2>/dev/null || echo "User $username already exists"

command that sets passwords

password=$(generate_password) echo "$username:$password" | chpasswd

Command that logs actions

echo "$(date '+%Y-%m-%d %H:%M:%S') - Created user $username with groups: $groups" >> "$log_file"

Command that stores password securely

echo "$username:$password" >> "$password_file" done < "$input_file"

Conclusion

This script simplifies managing users and groups on a Linux system, ensuring security and efficiency. Automating these tasks not only saves time but also reduces the risk of human error.

For more information on the HNG internship program and to learn how to become a world-class developer, visit HNG Internship and HNG Premium.
You can also find the code to the bash script on my GitHub here Linsmed

Effortless Project Management: Deploying OpenProject with Docker on AWS for Optimal Performance

Ejibode Ibraheem — Fri, 14 Jun 2024 05:40:01 +0000

Table of Contents

Introduction
Prerequisite
Steps
Conclusion

Introdcution

In today's fast-paced and interconnected world, project management solutions have become indispensable for organizations striving to maintain efficiency and team coordination. Open management tool (openproject) is a robust open-source project management software designed to facilitate collaboration, track progress, and manage project timelines. However, deploying and maintaining such complex applications can be daunting, especially when dealing with various dependencies and configurations.

Docker, a leading containerization platform, offers a seamless way to deploy applications by encapsulating them and their dependencies into containers. This approach ensures consistency, scalability, and ease of deployment across different environments. By leveraging Docker, deploying OpenProject becomes significantly more manageable, enabling teams to focus on productivity rather than infrastructure.

I will help you in this article by deploying OpenProject in a Docker container. We will explore the benefits of containerization, discuss the prerequisites, and provide detailed instructions to get your OpenProject instance up and running. Whether you are a seasoned DevOps professional or a project manager looking to streamline your project management processes, this guide will equip you with the knowledge to deploy OpenProject efficiently using Docker.

Prerequisite

Before diving into the deployment of OpenProject using Docker, ensure that you have the following prerequisites in place. These requirements will help guarantee a smooth installation and optimal performance of OpenProject.

AWS Account: An active Amazon Web Services (AWS) account is essential for provisioning and managing the cloud infrastructure required for this deployment. If you don't already have an account, you can create one at AWS.

2.Server Specifications:

Memory: At least 8 GB of RAM to handle the application and its dependencies efficiently.
CPU: A minimum of 4 cores for processing power. Ensure your instance type provides at least 8 vCPUs for optimal performance.

Operating System: Ensure your server is running a compatible operating system, preferably a Linux distribution such as Ubuntu or CentOS, which are well-supported for Docker installations.
GitBash or MobaXterm: For Windows users, GitBash or MobaXterm are recommended for connecting to the server via SSH. These tools provide a Unix-like shell experience, making it easier to execute commands and manage your server.
GitBash or MobaXterm: For Windows users, GitBash or MobaXterm are recommended for connecting to the server via SSH. These tools provide a Unix-like shell experience, making it easier to execute commands and manage your server.
Docker and Docker Compose: Ensure Docker and Docker Compose are installed on your server. Docker simplifies application deployment by using containers, while Docker Compose allows you to manage multi-container applications with ease. Follow the installation instructions provided for your specific operating system.
Basic Knowledge of Docker and Linux Command Line: Familiarity with Docker commands and basic Linux command line operations will be advantageous during the deployment process.

Having these prerequisites in place will ensure a smooth and successful deployment of OpenProject in a Docker container. With the necessary tools and resources ready, you are now prepared to proceed with the installation and configuration steps detailed in this guide.

Steps

UPDATE THE PACKAGES AND DEPENDENCIES
```
` sudo apt update -y `
```

INSTALL DOCKER ON THE SERVER

sudo apt install docker.io -y

CLONE THE OPENPROJECT REPOSITORY

git clone https://github.com/opf/openproject.git

NAVIGATE TO THE COMPOSE DIRECTORY

cd openproject/compose

INSTALL DOCKER COMPOSE IN THIS DIRECTORY

sudo apt install docker-compose

GIVE THE NECESSARY PERMISSIONS

sudo chmod 666 /var/run/docker.sock

PULL THE REQUIRED IMAGE FROM THE DOCKERHUB

docker-compose pull

LAUNCH THE CONTAINERS

OPENPROJECT_HTTPS=false docker-compose up -d

Check the openproject as seen below by pasting your ip address http//ipaddress:8080 on your preferred browser. The default username is admin, while the password is admin as well

Conclusion

Deploying OpenProject using Docker offers a powerful and efficient way to manage your project management software, leveraging the benefits of containerization for consistency, scalability, and ease of deployment. By following this guide, you have set up a robust environment that encapsulates all necessary dependencies, ensuring that OpenProject runs smoothly across various environments.

The journey began with preparing the prerequisites, ensuring you had the necessary AWS account, server specifications, and tools like Docker and Docker Compose. From there, you learned how to deploy OpenProject, leveraging Docker's capabilities to simplify the installation and configuration process. This deployment strategy not only reduces the complexities associated with managing multiple services but also enhances the portability and reliability of your project management setup.

As you move forward, you can take advantage of Docker's features to scale your OpenProject instance, integrate with other tools, and maintain a secure and up-to-date environment. The skills and knowledge gained from this deployment process will be invaluable for managing other applications in a similar fashion, making you well-equipped to handle modern infrastructure challenges.

I hope this helps!

A Comprehensive Guide to Deploying WordPress on Docker: Simplifying Website Hosting with Containerization

Ejibode Ibraheem — Wed, 08 May 2024 17:41:18 +0000

Introduction
Prerequisite
Steps
Conclusion

Introduction

In an era defined by dynamic web development and scalable infrastructure, the deployment of web applications demands efficiency, flexibility, and reliability. Docker, a powerful containerization platform, has emerged as a cornerstone technology in modern software deployment strategies. Its ability to encapsulate applications and their dependencies into lightweight, portable containers offers developers a streamlined approach to building, shipping, and running applications across diverse environments.

WordPress, the world's most popular content management system (CMS), powers millions of websites, ranging from personal blogs to enterprise-level platforms. Deploying WordPress within a Docker container harnesses the advantages of containerization, enabling developers to isolate the application, manage dependencies effortlessly, and scale with ease.

In this article, we delve into the intricacies of deploying a WordPress website on a Docker container. From setting up the Docker environment to configuring WordPress within the container, we explore the step-by-step process to achieve a seamless deployment. Whether you're a seasoned developer seeking to optimize your workflow or a newcomer eager to explore modern deployment practices, this guide will equip you with the knowledge to leverage Docker for WordPress deployment effectively.

Prerequisite

Before diving into the deployment process, there are several prerequisites you'll need to have in place:

AWS Account: To deploy resources on the Amazon Web Services (AWS) cloud platform, you must have an active AWS account. If you haven't already created one, you can sign up for free on the AWS website.
Basic Knowledge of Docker: While you don't need to be an expert, having a fundamental understanding of Docker concepts such as containers, images, and Docker files will be beneficial.
Familiarity with WordPress: It's essential to have a basic understanding of WordPress, including how to navigate its admin dashboard, install plugins, and configure settings.
AWS CLI or Management Console Access: You'll need access to either the AWS Command Line Interface (CLI) or the AWS Management Console to create and manage AWS resources such as EC2 instances and Amazon RDS databases.
Networking Knowledge: Understanding networking concepts like virtual private clouds (VPCs), subnets, security groups, and DNS will help configure the network infrastructure of your WordPress deployment.

By ensuring you have these prerequisites in place, you'll be well-prepared to follow along with the deployment process and effectively leverage AWS services in conjunction with Docker for hosting your WordPress website.

Steps

On your AWS console management, navigate to EC2 service, click on it, and click on launch instance, then name your server any name of your choice.

Choose the OS image of your choice, here I am going with the Amazon Linux

Select the instance type of your choice, here I am going with t2 micro which is free tier eligible

Create a new key pair or select an existing key pair

Configure the security setting and allow traffic from TCP,HTTP, and so on as shown below

Leave storage configuration and advanced settings as default

Click on the launch instance

After a few minutes, your instance should be up and running

Connecting to the EC2 Instance

The next step is to connect to the EC2 instance from the terminal, to do this, click on connect

Then copy the command that is under the example as shown below

The next thing is to open your terminal, either on vscode or gitbash, here I would be using gitbash. Navigate to where your keypair is, mine is in download.
Then, paste the code you copied on the AWS console, then if you get any prompt, type ‘yes’

Boom!! , you have successfully connected to the EC2 instance.
Since the user does not have sudoers privilege, we have to be including sudo in our command. For the purpose of this exercise, I will be using Vim text editor.
Update and upgrade the yum packages and dependencies

sudo yum update && sudo yum upgrade

Installing Docker

Install docker using the command below, the command is flagged with -y to avoid prompting us to enter yes:

sudo yum install docker -y

Start the server and verify the installation using the below command

sudo systemctl start docker && sudo docker run hello-world

Enable the docker sudo systemctl enable docker

Add the current user(ec2-user) to the docker group using this command sudo usermod -a -G docker ec2-user

Installing docker compose

Install the docker compose by using this command:


 sudo curl -L https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

Make the docker compose file executable sudo chmod +x /usr/local/bin/docker-compose

Cloning a github repository on the server

To be able to run git commands, git has to be installed sudo yum install git -y

Now that git has been installed, clone the repository

git clone https://github.com/Iron-chest/wordpress-mysql-dockercompose.git

Execute your docker-compose yaml file for default docker-compose file name

docker-compose up -d

Check the docker containers if they are running

docker container ls

You can access the WordPress website by pasting the IP address of the server to the browser of your choice

By clicking on continue and all other fields imputed correctly, you should see something like this

Conclusion:

In conclusion, deploying a WordPress website on Docker offers a multitude of advantages, from enhanced portability and scalability to simplified management and resource optimization. Throughout this guide, we've explored the step-by-step process of setting up a Docker environment, configuring WordPress within a container, and achieving a seamless deployment.

By harnessing the power of Docker containerization, developers can isolate their WordPress applications, streamline development workflows, and deploy with confidence across various environments. Additionally, leveraging cloud platforms like AWS further enhances the scalability and reliability of the deployment, ensuring optimal performance for your website.

As technology continues to evolve, embracing modern deployment practices such as Docker becomes increasingly essential for staying competitive in the digital landscape. Whether you're a seasoned developer seeking to optimize your workflow or a newcomer eager to explore innovative solutions, mastering WordPress deployment on Docker opens up a world of possibilities for efficient and scalable website hosting.

With the knowledge and skills gained from this guide, you're well-equipped to embark on your Dockerized WordPress journey. Embrace the flexibility, reliability, and efficiency that Docker offers, and empower your WordPress websites for success in the dynamic digital realm.

Happy deploying!

DEV Community: Ejibode Ibraheem

Understanding the Lusophone Wikimedia Wishlist: Improving Contributor Experience

Fedora, Community, and the Badges Revamp: My Experience

What is the Fedora Project?

Discovering Fedora Through Fedora Badges

The Fedora Badges Revamp Project

Why Fedora Matters to Me as a DevOps Engineer

The Community Experience

The Challenge of Getting Started

Fedora’s Four Foundations

My Commitment This Time

Advice for Future Outreachy Applicants

Final Thoughts

Introduction to Docker: Simplifying Containerized Applications

Use the official nginx image as the base image

Copy a custom HTML file to the nginx document root

Welcome to My Custom Nginx Container!

Demystifying AWS VPC: A Comprehensive Guide to Networking in the Cloud

Table of contents

Introduction

What is AWS VPC

Key Components of AWS VPC

Creating Your First AWS VPC with Terraform

Use Cases for AWS VPC

Conclusion

Exploring AWS EC2 Instances: Uses and How to Create One Using Terraform

Table of contents

Introduction

What is AWS EC2 Instance

Uses of AWS EC2 Instance

Benefits of using Terraform to create AWS EC2 Instance

Step-by-Step Guide: Creating an AWS EC2 Instance Using Terraform

Prerequisites

Conclusion

Step-by-Step Guide to setting Up Terraform, AWS CLI, and VS Code

Getting Started with Infrastructure as Code (IaC) Using Terraform

Introduction

What is infrastructure as a code (IaC)

Five broad categories of IaC Tools

Key benefits of IaC

Why Terraform?

Getting started with Terraform

Conclusion

Efficient User and Group Management on Linux: A Bash Script Tutorial

Table Of Content

Introduction

Script Overview

create user

Conclusion

Effortless Project Management: Deploying OpenProject with Docker on AWS for Optimal Performance

Introdcution

Prerequisite

Steps

Conclusion

A Comprehensive Guide to Deploying WordPress on Docker: Simplifying Website Hosting with Containerization

Table of Contents

Introduction

Prerequisite

Steps

Connecting to the EC2 Instance

Installing Docker

Installing docker compose

Cloning a github repository on the server

Conclusion: