DEV Community: Emmanuella Adeka

Linux User Creation Automation with Bash Script

Emmanuella Adeka — Wed, 03 Jul 2024 21:27:55 +0000

Introduction

Manually creating users and adding them to groups is a tedious and error-prone task, consuming valuable time and energy that could be better spent on more productive activities. Automating this process eliminates these issues, offering a more consistent, efficient, and time-saving solution. In this article, we'll walk through a bash script designed to read user details from a text file, create users and their specific groups, and log all activities.

Script Overview

The full script is available in a GitHub repository at here.

Let's walk through the steps in the script of automating user management (creation):

1. Verify the input file
Check that an input file has been specified. It ensures that the number of arguments provided is exactly one. If not, it outputs an error message with usage instructions and exits the script.

# Verify that an input file has been specified
# checks the number of arguments ($#) is not equal to 1 (-ne)
if [[ $# -ne 1 ]]; then
    echo "Error: No input file specified."
    echo "usage: $(basename "$0") <input_file>"
    exit 1
fi

2. Set the files as variables
Define variables for the log file and the password file.
LOG_FILE is used to record all actions taken by the script, and PASSWORD_FILE is where the generated passwords will be stored securely.

# Log file to log all actions
LOG_FILE="/var/log/user_management.log"
# store generated passwords in user_passwords.txt
PASSWORD_FILE="/var/secure/user_passwords.txt"

3. Ensure both files exist
Ensure that the log file and the password file exist. This section of the script creates the files if they don't already exist and sets the appropriate permissions on the password file to ensure only the owner can read it.

# Ensure both files exist
touch $LOG_FILE
mkdir -p /var/secure
touch $PASSWORD_FILE

# Set permissions for password file
chmod 600 $PASSWORD_FILE

4. Install password generator package
This script is designed specifically for Ubuntu. If you're using a different Linux distribution, you'll need to adapt the package installation commands accordingly. For Ubuntu, you can install the pwgen utility, which generates random passwords, with the following commands:

# install pwgen to generate random password
sudo apt-get update
sudo apt-get install -y pwgen

# verify installation
if ! pwgen --version &>/dev/null; then
    echo "Error: pwgen installation failed." | tee -a $LOG_FILE
    exit 1
fi

5. Create function to generate password using the installed package
The generate_password function utilises the pwgen utility to generate secure, random passwords. By default, it creates a 12-character password, but you can specify a different length by passing a parameter to the function. The -s option ensures the password is completely random.

generate_password() {
    local password_length=${1:-12}
    pwgen -s $password_length 1
}

6. Create function to create user

create_user() {
    # Create user group with same name as user
    # check iff user exists
    # create user with group
    # set permissions
    # generate random password and set it
    # store password securely
    # add user to group

    local user=$1
    shift
    local groups=$@

    # Check if user already exists
    if id "$user" &>/dev/null; then
        echo "User $user already exists." | tee -a $LOG_FILE
        return 0
    fi


    if ! sudo groupadd "$user" 2>>$LOG_FILE; then
        echo "Failed to create group $user." | tee -a $LOG_FILE
        return 1
    fi

    # Create user and set their primary group
    if ! sudo useradd -m -g "$user" "$user" 2>>$LOG_FILE; then
        echo "Failed to create user $user." | tee -a $LOG_FILE
        return 1
    fi

    # Create additional groups if specified and add the user to them
    if [[ -n "$groups" ]]; then
        for group in $groups; do
            if ! getent group "$group" &>/dev/null; then
                if ! sudo groupadd "$group" 2>>$LOG_FILE; then
                    echo "Failed to create group $group." | tee -a $LOG_FILE
                    return 1
                fi
            fi
            if ! sudo usermod -aG "$group" "$user" 2>>$LOG_FILE; then
                echo "Failed to add user $user to group $group." | tee -a $LOG_FILE
                return 1
            fi
        done
    fi

    # Generate random password
    local password
    password=$(generate_password)
    if ! echo "$user:$password" | sudo chpasswd; then
        echo "Failed to set password for user $user." | tee -a $LOG_FILE
        return 1
    fi

    # Store password securely
    echo "$user:$password" >>$PASSWORD_FILE

    # Set permissions for user's home directory
    if ! sudo chmod 700 "/home/$user"; then
        echo "Failed to set permissions for home directory of user $user." | tee -a $LOG_FILE
        return 1
    fi

    # Log the user creation
    echo "Created user $user with groups: $groups" | tee -a $LOG_FILE
}

7. Read the file and create users
This section of the script reads the user information from the specified file. It processes each line to extract the username and groups, removing any leading or trailing whitespace. The groups are converted from a comma-separated list to a space-separated list. Finally, it calls the create_user function to create the user and assign the specified groups.

while IFS=";" read - r user groups; do
    # remove whitespaces before and after username
    user=$(echo $user | xargs) 
    # remove whitespaces before and after group name
    groups=$(echo $groups | xargs | tr ',' ' ')
    create_user $user $groups
done < "$1"

8. Output once script has run successfully
Output a message indicating that the user has been created successfully. The message is also appended to the log file to keep a record of the script's actions.

echo "User created successfully." | tee -a $LOG_FILE

Conclusion

Automating user management with a bash script streamlines administrative tasks, ensuring consistency and security. By following the steps in this script, you can efficiently manage user accounts and groups in a Linux environment.

Learn more

Learn more about HNG internships and opportunities below:
HNG internship
HNG Premium

Setting up an AWS Free Tier Account: Your First Step to Cloud Mastery

Emmanuella Adeka — Mon, 22 Jan 2024 02:19:35 +0000

Introduction

Hey there, fellow learners on the exciting journey to becoming a DevOps engineer! If you're just starting to explore the vast world of cloud computing, you're in for an exhilarating ride. The cloud has become the backbone of modern IT, and understanding how to harness its power is essential for a DevOps engineer. Today, I want to take you through one of the very first steps in this journey: creating an Amazon Web Services (AWS) Free Tier account.

As someone who was once in your shoes, I know the initial steps can be a bit daunting. However, I'm here to guide you through the process and ensure that you not only create an AWS Free Tier account but also understand why it's crucial for your learning path.

Why Create a Free Tier Account?

Cost Efficiency: The thought of incurring huge bills can be daunting for anyone, especially learners. AWS Free Tier provides access to a range of services at no cost for 12 months.
Hands-on Experience: Learning by doing is the best way to grasp concepts no matter the discipline. AWS Free Tier presents the opportunity to gain hands-on experience with the AWS platform, products, and services.
Extensive Range of Services: AWS has an extensive catalogue of services ranging from compute to storage to database to machine learning among others. Creating a Free Tier account provides access to this range of services.

How to Create a Free Tier Account

Visit the AWS Free Tier Page: Go to the AWS Free Tier Page here and create a free account by clicking the "Create a Free Account" button.

You can also explore the web pages to learn more about the types of offers (Free Trials, 12 months free, and Always free), explore top product categories, and search free tier products.

Watch a demo below 😊:

Account Setup: You'll be prompted to enter your "email address" and "AWS account name". Once you've filled in the fields, click "Verify email address".

Verify your email address: Check your inbox for the verification code and enter the code in the allocated box to confirm your mail.

*If you don't see the code in your inbox, check your Spam or Junk. There's also an option to resend the code by clicking the "Resend Code".

Create Your Password: Enter your chosen Root user password and confirm the password to have sign-in access to AWS. Click on "Continue (step 1 of 5)".

Add your contact information: For how you plan to use AWS, Select "Personal - for your own projects" and fill in the details including Full Name, Country Code, Phone Number, Country or Region, Address, City, and Postal Code. Next, tick the checkbox of the "AWS Customer Agreement". Click on "Continue (step 2 of 5)".

6.Add your billing information: Enter your billing information and click on "Verify and Continue (step 3 of 5)".

Confirm your identity: AWS will require you to confirm your identity. Confirm your identity by entering your phone number and typing the characters in the "Security check". Click "Call me now (step 4 of 5)" for an automated phone call for verification.

Select a support plan: The final step is to select a support plan, for Free Tier select "Basic Support: Free" and click Complete sign up. After completing the above steps, you'll receive a confirmation email.

Congratulations!: That's it, you've successfully created your AWS Free Tier account and have access to surplus AWS products and services. Click "Go to AWS Management Console" to access the AWS services.

Sign in and Get Started!: Sign in using the Root user email address and password you set up earlier and Get Started building awesome projects.

Conclusion
Congratulations! You've just taken a significant step toward your goal of becoming a DevOps engineer. Creating an AWS Free Tier account is your gateway to exploring the world of cloud computing, building skills that are in high demand in the industry, and setting yourself up for a successful career.

Remember, the AWS Free Tier provides you with a safe and cost-effective environment to experiment, learn, and innovate. As you progress in your journey, you can always keep an eye on your usage to ensure that you remain within the Free Tier limits and avoid unexpected charges.

So, go ahead, create that AWS Free Tier account, and start your cloud adventure today. The cloud is your playground, and your skills are your ticket to endless possibilities. Keep learning, keep experimenting, and most importantly, enjoy the journey!

Understanding EC2 Instance States

Emmanuella Adeka — Sun, 15 Oct 2023 20:37:25 +0000

Introduction

Hey there, fellow learners! I'm thrilled to share my experiences as I embark on my journey to become a Cloud engineer. If you're just starting, I promise you're not alone. We're all in this together, and there's so much to explore and learn. Today, I want to dive into a crucial aspect of the AWS (Amazon Web Services) cloud platform: EC2 (Elastic Compute Cloud) instance states.

EC2 instances are the backbone of many cloud-based applications. These virtual servers can run various workloads, from simple web applications to complex data analytics. But to effectively manage them, we need to understand the various states an EC2 instance can have. Don't worry; I've got your back! Let's break it down together.

Understanding EC2 Instance States

Before we delve in, you could check out the "Instance Lifecycle" (by clicking the image below) in the AWS documentation to understand how an EC2 Instance transitions through different states from the moment you launch through to its termination.

On to the business of the day, the instance states are as follows:

Pending: We all start somewhere, and in the EC2 world, that starting point is "Pending." This is where your instance is being created. AWS is working its magic, provisioning the resources you requested, and soon, you'll move on to more exciting states.
Running: This is the good stuff! When your instance is "Running," it's like your virtual server is open for business. It's actively performing the tasks you assigned, whether that's hosting a website, crunching data, or anything else you can imagine.
Stopped: Sometimes you need a pause button. "Stopped" is what you use when you want to halt your instance temporarily. You won't incur charges while it's stopped, but remember, your server won't be accessible either.
Terminated: This one's a bit like breaking up. When you "Terminate" an instance, you're saying goodbye. AWS releases all resources associated with it, so be certain before you hit this button. It's not something you can take back!
Shutting Down: Before your instance stops or terminates, it politely "Shuts Down." It's like the server's way of saying, "I'm preparing to take a break." Once it's done shutting down, you can either stop or terminate it.
** Rebooting:** We all need a reboot sometimes, right? "Rebooting" your instance is like restarting your computer. You do this to apply updates, changes, or troubleshoot minor issues. After a quick reboot, it should return to a "Running" state.
Initializing: You might encounter "Initializing" less often, especially when using custom Amazon Machine Images (AMIs) to launch instances. During initialization, your instance sets up and configures itself to run your specific applications.
Error: This is the state we all dread. "Error" means something went wrong. It could be due to misconfigurations, hardware issues, or other factors. Don't fret – this is all part of the learning process.

Summary

Pending: The instance is being launched or started.
Running: The instance is up and running.
Stopping: The instance is in the process of being stopped, but it is not fully stopped yet.
Stopped: The instance has been stopped, but its data and configuration persist.
** Terminated: **The instance has been permanently deleted and cannot be restarted.
Shutting Down: The instance is in the process of being stopped.
Rebooting: The instance is being rebooted, which involves a restart of the operating system.
Initializing: The instance is configuring itself during launch, often with custom settings.
Error: The instance has encountered an issue or failed to launch correctly.

Conclusion

Understanding EC2 instance states is a fundamental building block for managing and troubleshooting your cloud infrastructure. By grasping the concepts outlined in this blog, you are well on your way to becoming a confident Cloud engineer, capable of efficiently managing instances, resolving issues, and ensuring seamless operations within your cloud environment.

Let's embrace the learning journey, foster a solid understanding of EC2 instance states, and unlock the true potential of our cloud infrastructure. Happy exploring!