DEV Community: Gbenga Akinbajo Okunniyi

User account creation using BASH

Gbenga Akinbajo Okunniyi — Thu, 04 Jul 2024 15:26:47 +0000

Introduction
In today's fast-paced development environments, automation is key to managing system operations efficiently. As a SysOps engineer, automating the process of creating user accounts, setting up their groups, and managing passwords can save a significant amount of time and reduce errors. This guide walks you through a Bash script designed to automate these tasks, providing detailed explanations for each step.

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

Reads a text file containing usernames and group names.
Creates users and assigns them to specified groups.
Sets up home directories with appropriate permissions.
Generates random passwords for the users.
Logs all actions to /var/log/user_management.log.
Stores generated passwords securely in /var/secure/user_passwords.csv.

#!/bin/bash

# Log file
LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.csv"

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

# Check if the file exists
if [ ! -f "$1" ]; then
    echo "File $1 does not exist."
    exit 1
fi

# Create necessary directories and files
mkdir -p /var/secure
touch $LOG_FILE
touch $PASSWORD_FILE

# Set permissions for the password file
chmod 600 $PASSWORD_FILE

# Function to generate random passwords
generate_password() {
    tr -dc A-Za-z0-9 </dev/urandom | head -c 12
}

# Read the file line by line
while IFS=';' read -r user groups; do
    # Remove whitespace
    user=$(echo "$user" | xargs)
    groups=$(echo "$groups" | xargs)

    # Check if the user already exists
    if id "$user" &>/dev/null; then
        echo "User $user already exists. Skipping password setting." | tee -a $LOG_FILE
        continue
    fi

    # Create the user's personal group if it doesn't exist
    if ! getent group "$user" >/dev/null; then
        groupadd "$user"
        echo "Group $user created." | tee -a $LOG_FILE
    fi

    # Create the user and assign the personal group as their primary group
    useradd -m -g "$user" "$user"
    if [ $? -eq 0 ]; then
        echo "User $user created successfully." | tee -a $LOG_FILE
    else
        echo "Failed to create user $user." | tee -a $LOG_FILE
        continue
    fi

    # Add the user to additional groups
    if [ -n "$groups" ]; then
        IFS=',' read -ra group_array <<< "$groups"
        for group in "${group_array[@]}"; do
            group=$(echo "$group" | xargs)
            if ! getent group "$group" >/dev/null; then
                groupadd "$group"
                echo "Group $group created." | tee -a $LOG_FILE
            fi
            usermod -aG "$group" "$user"
            echo "User $user added to group $group." | tee -a $LOG_FILE
        done
    fi

    # Generate a random password
    password=$(generate_password)
    echo "$user:$password" | chpasswd

    # Store the password securely
    echo "$user,$password" >> $PASSWORD_FILE
    echo "Password for user $user set and stored securely." | tee -a $LOG_FILE

done < "$1"

echo "User creation process completed. Check $LOG_FILE for details."

Explanation
Log and Password Files

The script maintains a log file to record all actions and a password file to store generated passwords securely.

LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.csv"

Input Validation

Ensuring the script is provided with the correct input is crucial for its operation.

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

if [ ! -f "$1" ]; then
    echo "File $1 does not exist."
    exit 1
fi

Directory and File Creation

Creating necessary directories and setting permissions for secure operations.

mkdir -p /var/secure
touch $LOG_FILE
touch $PASSWORD_FILE
chmod 600 $PASSWORD_FILE

Generate Password Function

A simple function to generate random passwords.
generate_password() { tr -dc A-Za-z0-9 </dev/urandom | head -c 12 }

User and Group Management

The core logic to create users, assign groups, and handle existing users gracefully.

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

    if id "$user" &>/dev/null; then
        echo "User $user already exists. Skipping password setting." | tee -a $LOG_FILE
        continue
    fi

    if ! getent group "$user" >/dev/null; then
        groupadd "$user"
        echo "Group $user created." | tee -a $LOG_FILE
    fi

    useradd -m -g "$user" "$user"
    if [ $? -eq 0 ]; then
        echo "User $user created successfully." | tee -a $LOG_FILE
    else
        echo "Failed to create user $user." | tee -a $LOG_FILE
        continue
    fi

    if [ -n "$groups" ]; then
        IFS=',' read -ra group_array <<< "$groups"
        for group in "${group_array[@]}"; do
            group=$(echo "$group" | xargs)
            if ! getent group "$group" >/dev/null; then
                groupadd "$group"
                echo "Group $group created." | tee -a $LOG_FILE
            fi
            usermod -aG "$group" "$user"
            echo "User $user added to group $group." | tee -a $LOG_FILE
        done
    fi

    password=$(generate_password)
    echo "$user:$password" | chpasswd
    echo "$user,$password" >> $PASSWORD_FILE
    echo "Password for user $user set and stored securely." | tee -a $LOG_FILE

done < "$1"

Conclusion
Automating user management tasks using Bash scripts can significantly improve efficiency and accuracy in system operations. This guide and the accompanying script provide a robust solution for user creation, group assignment, and secure password management.

For more information on DevOps and automation, check out these resources:

HNG Internship
HNG Hire
By following these steps, you can ensure a streamlined process for managing users in your development environment.

link to my github: https://github.com/Gbenga001/user_account_automation_with_bash

Developing a Reusable and Readable Bash Script for LAMP Stack Deployment

Gbenga Akinbajo Okunniyi — Mon, 22 Apr 2024 18:43:05 +0000

In the fast-paced world of system administration and DevOps, automation reigns supreme. Deploying a LAMP (Linux, Apache, MySQL, PHP) stack manually can be time-consuming and error-prone. Hence, crafting a reusable and readable Bash script for automating this process not only saves time but also ensures consistency and ease of maintenance for future deployments. Let's embark on a journey to develop a powerful Bash script that automates the deployment of a LAMP stack, including cloning a PHP application from GitHub, installing necessary packages, and configuring Apache web server and MySQL.

`#!/bin/bash

Function to handle errors

handle_error() {
echo "Error: $1" >&2
exit 1
}

Update Linux system

sudo apt update -y || handle_error "Failed to update the system."

Install Apache web server

sudo apt install apache2 -y || handle_error "Failed to install Apache web server."

Add PHP ondrej repository

sudo add-apt-repository ppa:ondrej/php --yes || handle_error "Failed to add PHP repository."

Update repository again

sudo apt update -y || handle_error "Failed to update repository."

Install PHP 8.2 and necessary extensions

sudo apt install php8.2 php8.2-curl php8.2-dom php8.2-mbstring php8.2-xml php8.2-mysql zip unzip -y || handle_error "Failed to install PHP and extensions."

Enable rewrite module for Apache

sudo a2enmod rewrite || handle_error "Failed to enable rewrite module for Apache."

Restart Apache server

sudo systemctl restart apache2 || handle_error "Failed to restart Apache server."

Install Composer globally

cd /tmp || handle_error "Failed to change directory to /tmp."
sudo curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer || handle_error "Failed to install Composer globally."

Change directory to /var/www and clone Laravel repository

if [ -d /var/www/laravel ]; then
echo "Deleting existing Laravel directory"
sudo rm -r /var/www/laravel
else
echo "Creating Laravel directory"
fi
sudo mkdir /var/www/laravel
sudo chown -R $USER:$USER /var/www/laravel
cd /var/www/ || handle_error "Failed to change directory to /var/www/."
sudo git clone https://github.com/laravel/laravel.git laravel || handle_error "Failed to clone Laravel repository."

Set permissions

sudo chown -R $USER:$USER /var/www/laravel || handle_error "Failed to set permissions."

Install Composer dependencies

cd /var/www/laravel || handle_error "Failed to change directory to /var/www/laravel."
composer install --optimize-autoloader --no-dev --no-interaction || handle_error "Failed to install Composer dependencies."
composer update --no-interaction || handle_error "Failed to update Composer dependencies."

Copy .env file and set permissions

sudo cp .env.example .env || handle_error "Failed to copy .env file."
sudo chown -R www-data:www-data storage bootstrap/cache || handle_error "Failed to set permissions."

Configure Apache Virtual Host

sudo tee /etc/apache2/sites-available/latest.conf > /dev/null <
ServerName localhost
DocumentRoot /var/www/laravel/public

<Directory /var/www/laravel>
    AllowOverride All
</Directory>

ErrorLog \${APACHE_LOG_DIR}/laravel-error.log
CustomLog \${APACHE_LOG_DIR}/laravel-access.log combined

EOF

Enable the new Virtual Host and disable the default one

sudo a2ensite latest.conf || handle_error "Failed to enable new Virtual Host."
sudo a2dissite 000-default.conf || handle_error "Failed to disable default Virtual Host."

Restart Apache server

sudo systemctl restart apache2 || handle_error "Failed to restart Apache server."

Install MySQL server and client

sudo apt install mysql-server mysql-client -y || handle_error "Failed to install MySQL server and client."

Start MySQL service

sudo systemctl start mysql || handle_error "Failed to start MySQL service."

Update .env file with MySQL configuration

sudo cp .env.example .env
sudo chown -R $USER:$USER /var/www/laravel/.env
echo "APP_URL=http://localhost

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD= " >> /var/www/laravel/.env

Generate Laravel application key

sudo php artisan key:generate || handle_error "Failed to generate application key."

Create symbolic link for storage

sudo php artisan storage:link || handle_error "Failed to create storage symbolic link."

Migrate database

sudo php artisan migrate

Seed database

sudo php artisan db:seed

Serve page

sudo php artisan serve

Restart Apache server

sudo systemctl restart apache2

echo "Setup completed successfully!"`

Let's break down what each section of this script accomplishes:

Developing a Reusable and Readable Bash Script for Automated LAMP Stack Deployment

Gbenga Akinbajo Okunniyi — Mon, 22 Apr 2024 18:42:26 +0000

Automating the deployment of a LAMP (Linux, Apache, MySQL, PHP) stack is a crucial task for any system administrator or DevOps engineer. In this guide, we'll walk through the creation of a powerful Bash script that automates the entire deployment process, from cloning a PHP application from GitHub to configuring Apache web server and MySQL. Our goal is to ensure ease of maintenance and future deployments by developing a script that is both reusable and readable.

Updating the System and Installing Apache

sudo apt update -y || handle_error "Failed to update the system."
sudo apt install apache2 -y || handle_error "Failed to install Apache web server."

We begin by updating the Linux system and installing the Apache web server. The -y flag is used to automatically confirm any prompts during the installation process.

Adding PHP Repository and Installing PHP


sudo add-apt-repository ppa:ondrej/php --yes || handle_error "Failed to add PHP repository."
sudo apt update -y || handle_error "Failed to update repository."
sudo apt install php8.2 php8.2-curl php8.2-dom php8.2-mbstring php8.2-xml php8.2-mysql zip unzip -y || handle_error "Failed to install PHP and extensions."

We add the PHP repository maintained by Ondřej Surý and install PHP 8.2 along with necessary extensions required for our LAMP stack.

Enabling Apache Modules and Restarting Apache

sudo a2enmod rewrite || handle_error "Failed to enable rewrite module for Apache."
sudo systemctl restart apache2 || handle_error "Failed to restart Apache server."

We enable the rewrite module for Apache to allow for clean URL configuration and then restart the Apache server to apply the changes.

Installing Composer Globally

sudo curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer || handle_error "Failed to install Composer globally."

Composer, a dependency manager for PHP, is installed globally to facilitate dependency management for our PHP applications.

Cloning Laravel Application from GitHub

cd /var/www/ || handle_error "Failed to change directory to /var/www/."
sudo git clone https://github.com/laravel/laravel.git laravel || handle_error "Failed to clone Laravel repository."

We navigate to the web root directory and clone a Laravel application from its GitHub repository.

Configuring Apache Virtual Host

sudo tee /etc/apache2/sites-available/latest.conf > /dev/null <<EOF
<VirtualHost *:80>
    ServerName localhost
    DocumentRoot /var/www/laravel/public

    <Directory /var/www/laravel>
        AllowOverride All
    </Directory>

    ErrorLog \${APACHE_LOG_DIR}/laravel-error.log
    CustomLog \${APACHE_LOG_DIR}/laravel-access.log combined
</VirtualHost>
EOF

We configure a virtual host for our Laravel application, pointing Apache to the application's public directory and setting up error and access logs.

Enabling and Disabling Virtual Hosts

sudo a2ensite latest.conf || handle_error "Failed to enable new Virtual Host."
sudo a2dissite 000-default.conf || handle_error "Failed to disable default Virtual Host."

We enable the newly configured virtual host while disabling the default one to ensure our Laravel application is served correctly.

Installing MySQL Server and Client

sudo apt install mysql-server mysql-client -y || handle_error "Failed to install MySQL server and client."
sudo systemctl start mysql || handle_error "Failed to start MySQL service."

MySQL server and client are installed, and the MySQL service is started to set up the database management system.

Updating .env File with MySQL Configuration


sudo cp .env.example .env
sudo chown -R $USER:$USER /var/www/laravel/.env

echo "APP_URL=http://localhost

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD= " >> /var/www/laravel/.env

We copy the example environment file, set appropriate ownership, and update it with MySQL configuration details.

Generating Laravel Application Key and Creating Symbolic Link

sudo php artisan key:generate || handle_error "Failed to generate application key."
sudo php artisan storage:link || handle_error "Failed to create storage symbolic link."

We generate a unique application key for Laravel and create a symbolic link for storage.

Migrating and Seeding Database


sudo php artisan migrate
sudo php artisan db:seed

Database migration and seeding are performed to set up the database schema and populate it with initial data.

Serving the Application

sudo php artisan serve

Finally, we serve the Laravel application using the built-in PHP development server.

Conclusion
By following this guide and developing a reusable and readable Bash script, one can automate the deployment of a LAMP stack with ease. This script ensures consistency, scalability, and ease of maintenance for future deployments.

Follow-Up: Enhancing Automation with Ansible Playbooks and Cron Jobs

In our previous blog post, we explored the development of a robust Bash script for automating the deployment of a LAMP stack. Building upon that foundation, we will now leverage Ansible playbooks and cron jobs to further enhance our automation capabilities and ensure seamless management of our server infrastructure.

Ansible Playbook for Deployment

Ansible provides a powerful automation framework for orchestrating configuration management tasks across multiple servers. We'll start by creating an Ansible playbook that executes our Bash script on the slave node, ensuring consistent deployment across our server infrastructure.

# deploy.yml

- hosts: slave
  tasks:
    - name: Transfer deployment script to slave node
      copy:
        src: /path/to/deploy.sh
        dest: /tmp/deploy.sh

    - name: Execute deployment script on slave node
      shell: /bin/bash /tmp/deploy.sh

Explanation:

hosts: Specifies the target host or group of hosts where the playbook tasks will be executed. In this case, we target the "slave" server.
copy: Copies the deployment script from the control node to the specified destination on the slave node.
shell: Executes the deployment script on the slave node using the Bash shell.
Cron Job for Uptime Monitoring

# Add the following line to the crontab file
0 0 * * * /usr/bin/uptime >> /var/log/server_uptime.log

Explanation:

0 0 * * *: Specifies the schedule for the cron job. In this case, the job runs every day at midnight (00:00).
/usr/bin/uptime: Executes the uptime command to retrieve information about the server's uptime.
>> /var/log/server_uptime.log: Appends the output of the uptime command to a log file for record-keeping and monitoring.

Execution and Verification
Executing Ansible Playbook:
Run the Ansible playbook (ansible-playbook deploy.yml) from the control node.
Verify successful execution by accessing the PHP application through the slave node's IP address.

Cron Job Verification:
Check the /var/log/server_uptime.log file on the slave node to ensure that uptime logs are being recorded as expected.
Tail the log file (tail -f /var/log/server_uptime.log) to monitor real-time uptime updates.

Conclusion
By incorporating Ansible playbooks and cron jobs into my automation workflow, I have further streamlined the deployment process and implemented proactive monitoring for server uptime. These tools enable one

to maintain a reliable and efficient server infrastructure while reducing manual intervention.

Title: Bridging the Gap: My Journey into Cloud Engineering at Altschool Africa

Gbenga Akinbajo Okunniyi — Tue, 20 Feb 2024 11:32:42 +0000

In the dynamic landscape of technology, embarking on a journey into the realms of cloud engineering can be both exhilarating and challenging. My personal odyssey at Altschool Africa during this second semester has been nothing short of transformative, particularly as I delved into the intricacies of Linux, Bash scripts, and the foundations of web development. What makes this venture truly remarkable is the backdrop of my unconventional transition – from a History and International Studies background, navigating a 9-5 job, and embarking on a journey into the world of coding with zero programming knowledge.

Embracing the Unknown: A New Chapter Unfolds

As someone with a background steeped in humanities, my foray into cloud engineering felt like a leap into the unknown. The semester opened with the vast universe of Linux, a powerful and intricate operating system that would serve as the canvas for my cloud engineering endeavors. The command line, once an alien landscape, gradually became my playground as I learned to navigate, execute commands, and understand the underlying architecture of systems.

From Hello World to the Cloud: A Novice's Tale

The journey commenced with the humble "Hello World." For someone unfamiliar with programming languages, this initial step felt like conquering a mountain. Yet, it was this very ascent that fueled my motivation. Starting with Bash scripts, I began to decipher the syntax and logic behind every line of code. The thrill of seeing my first "Hello World" script run successfully was more than a technical triumph – it was a testament to persistence and the joy of overcoming the challenges of the unknown.

Balancing Act: A Symphony of Learning and Daily Grind

One might wonder how a History and International Studies graduate with a full-time job found the bandwidth for learning cloud engineering. The answer lies in the delicate art of balance. My daily routine, comprising the demands of a 9-5 job, metamorphosed into a symphony where evenings became sacred spaces for learning. The commitment to growth became a compass guiding me through the intricacies of HTML, CSS, and Javascript – languages I had never imagined myself mastering.

Empowering Future Vistas: A Motivational Beacon

What began as an exploration into the world of Linux and Bash scripts evolved into a broader narrative of self-discovery. The journey is more than a conquest of technical skills; it's a testament to the human spirit's capacity to adapt, learn, and thrive in uncharted territories. To my fellow learners, I offer this as a beacon of inspiration – a reminder that the pursuit of knowledge is not confined to academic backgrounds or predetermined paths. The cloud engineering frontier welcomes diversity, and every step, no matter how small, propels us towards empowerment.

Conclusion: The Unwritten Chapters Await

As this semester unfolds, I find myself standing at the intersection of my past and the unwritten chapters of the future. Altschool Africa has not just equipped me with technical skills but has fostered a mindset of perpetual learning and adaptation. The odyssey continues, and with each line of code, I am not just scripting programs but rewriting my narrative. May this account serve as a testament that every individual possesses the potential to carve their niche in the ever-evolving world of technology. Let the next chapter begin.