Forem: Sarah Aligbe

User Management Automation in Linux Using Bash Script

Sarah Aligbe — Wed, 03 Jul 2024 02:27:10 +0000

Scenario

As a SysOps engineer, you have been tasked to write a bash script that creates Users, Groups, and home directories with appropriate permissions for new employees in your company.

This article will walk you through writing the bash script to automate the process of creating users and groups in a Linux system.

Solution

Pre-requisites

An Ubuntu server
Basic Linux knowledge
User with sudo privileges

Script Overview

The script create_users.sh reads a text file containing usernames and group names, creates the specified users and groups, sets up home directories, generates random passwords for each user, and logs all actions. It is important to run the script with a user with sudo privileges as using your root user is not considered best practice. The script takes the input file as a command-line argument.

Breakdown of the create_users.sh script

Initial Checks

The script starts with some important checks:

# Function to check if user has sudo privileges
check_sudo() {
    if sudo -n true 2>/dev/null; then
        return 0
    else
        return 1
    fi
}

# Check if user has sudo privileges
if [ ! check_sudo ]; then
    echo "This script requires sudo privileges to run"
    echo "Please run this script with sudo or as a user with sudo privileges"
    exit 1
fi

# Check if input file is provided
if [ $# -eq 0 ]; then
    echo "Please provide an input file"
    echo "Usage: $0 <input-file>"
    exit 1
fi

These checks ensure that the script is run with root privileges and that an input file is provided.

Directory and File Setup

input_file=$1
log_file="/var/log/user_management.log"
password_csv="/var/secure/user_passwords.csv"
password_file="/var/secure/user_passwords.txt"
password_dir="/var/secure"

#create the password directory if it doesn't exist
if [ ! -d $password_dir ]; then
    sudo mkdir $password_dir
fi

# Create log file, password csv, and password file and set permissions
sudo touch $log_file $password_csv $password_file
sudo chmod 600 $password_csv $password_file

The variables denoting the various files and directories are defined. The input_file containing the user and group names is assigned $1 denoting that it is the first command-line argument supplied.

The if statement checks whether the directory where the user passwords will be stored exists and creates the directory if it doesn’t .

The password files are given restrictive permissions (600) to ensure only the owner can read it.

Helper Functions

Two helper functions are defined:

# Function to log actions
log() {
    echo "$(date): $1" | sudo tee -a "$log_file" > /dev/null
}

# Function to generate random password
generate_password() {
    openssl rand -base64 12
}

The log function appends timestamped messages to the log file, while generate_password creates a random 12-character password.

Reading the input file and Error Handling

The input file is read line-by-line using the while loop

#set line number to zero. to be used in error handling for invalid inputs
line_number=0

# Read input file line by line
while IFS=';' read -r username groups; do
    # Remove leading/trailing whitespace
    username=$(echo $username | xargs)
    groups=$(echo $groups | xargs)

    #increment the line number after reading each line
    line_number=$((line_number + 1))

    # Check that the username and group is present
    if [[ -z "$username" || -z "$groups" ]]; then
        log "Error: Invalid input on line $line_number. Ensure Username and groups are provided"
        echo "Error: Invalid input on line $line_number. Ensure Username and groups are provided"
        continue
    fi

    # Check if user already exists
    if id "$username" &>/dev/null; then
        log "User $username already exists. Skipping."
        continue
    fi

    # Create user's personal group
    sudo groupadd $username
    log "Created personal group $username"

    # Create user with home directory with appropriate ownership and permissions to allow only the user read, write, and execute
    sudo useradd -m -g $username $username
    sudo chmod 700 "/home/$username"
    sudo chown "$username:$username" "/home/$username"
    log "Created user $username with home directory"

    # Set random password for user
    password=$(generate_password)
    echo "$username:$password" | sudo chpasswd
    echo "$username,$password" | sudo tee -a $password_csv > /dev/null
    echo "$username,$password" | sudo tee -a $password_file > /dev/null
    log "Set password for user $username"

    # Add user to additional groups
    IFS=',' read -ra group_array <<< "$groups"
    for group in "${group_array[@]}"; do
        group=$(echo $group | xargs)
        # Create group if it doesn't exist
        if ! getent group $group &>/dev/null; then
            sudo groupadd $group
            log "Created group $group"
        fi
        sudo usermod -a -G $group $username
        log "Added user $username to group $group"
    done

done < "$input_file"

Before the loop, a variable called line_number is defined as 0. This variable will be used as a form of error handling to note any lines in the input file that does not have a username or a group defined.

IFS=';' sets the field separator to semicolon because the user and group names are separated by a semicolon. read -r username groups reads a line, splitting it into username and groups variables. Leading and trailing whitespaces are removed from username and groups using xargs.

line_number=$((line_number + 1)) increases by 1 at the start of each iteration in order to reference the current line number in the error logs and notifications.

The script then goes on to check if the username or groupname is present in the file and sends an error message to the log file and also notifies you on the command line about which line has the error. The script then goes on to the next line to run the script. It also checks whether or not a user has already been created and skips that user to the next.

After that it creates the user's personal group, creates the user with a home directory and permissions set to 700 to only allow the owner access to it, and sets a random password for the user.

The script also handles multiple group assignments in the instance where a user is to join multiple groups. This is separated in the input file by a comma delimiter. The script loops through the array of groups and creates the groups if they don't exist and adds the user to each specified group.

Usage

To use the script, run:

sudo chmod +x create_users.sh
./create_users.sh input_file.txt

Where input_file.txt contains lines in the format

username;group1,group2,group3

Security Considerations

The user running the script must have sudo privileges
Passwords are stored in a file with restricted permissions.
Random passwords are generated using OpenSSL for better security.

Conclusion

This bash script provides a powerful and flexible way to automate user and group creation in Linux systems. By handling various scenarios and providing detailed logging, it simplifies the process of managing multiple user accounts, making it an invaluable tool for system administrators.

This is a practical example of the skills developed at HNG, where participants learn to create efficient, scalable solutions for real-world problems.
Register for the HNG internship to develop these skills.

How to Create an Azure Kubernetes Cluster and Deploy an Application Using Azure CLI

Sarah Aligbe — Fri, 19 May 2023 01:08:40 +0000

Introduction

Azure Kubernetes Service (AKS) cluster is a managed container orchestration platform provided by Microsoft Azure. It enables the deployment, scaling, and management of containerized applications using Kubernetes.

Kubernetes is an open-source container orchestration system that helps you manage and automate the deployment, scaling, and management of containerized applications.

AKS clusters simplify the deployment and management of applications by abstracting away the underlying infrastructure complexities. They offer benefits such as automatic scaling, load balancing, and high availability. AKS clusters provide a reliable and scalable environment for running containerized applications on Azure.

Azure CLI (Command-Line Interface) is a powerful command-line tool for managing Azure resources. It provides a convenient and efficient way to interact with Azure services, including the creation and management of AKS clusters. Azure CLI offers a consistent experience across platforms and can be easily scripted, allowing for automation and streamlined workflows.

Pre-requisites

Before diving into creating an AKS cluster and deploying applications, ensure you have the following prerequisites in place:

An Azure subscription: Sign up for an Azure account if you don't have one.
Azure CLI installed: Install Azure CLI on your local machine.
Kubectl installed
Working knowledge of Kubernetes.
Authenticate Azure CLI with your Azure account by running the command below and following the prompts:

az login

Setting up an AKS Cluster

Step 1. Create a resource group. A resource group is a logical container that holds related Azure resources.

az group create --name <resource-group-name> --location <azure-region>

Step 2. Create the AKS cluster

az aks create --resource-group <resource-group-name> \
--name <aks-cluster-name> \
--node-count 2 \
--generate-ssh-keys

--resource-group: Specifies the name of the resource group where the AKS cluster will be created. Replace with the desired name of the resource group.
--name: Specifies the name of the AKS cluster to be created. Replace with the desired name of the AKS cluster.
--node-count: Specifies the number of nodes (virtual machines) that should be provisioned in the AKS cluster. In this example, we have set the node count to 2, but you can adjust it based on your application requirements.
--generate-ssh-keys: Generates SSH public and private keys to be used for accessing the cluster nodes. This parameter simplifies the process of managing SSH keys. Azure CLI will automatically generate the keys and configure them for you.

Step 3. Get cluster credentials

az aks get-credentials --name <aks-cluster-name> --resource-group <resource-group-name

By executing this command, Azure CLI retrieves the necessary credentials, including the Kubernetes cluster endpoint and authentication token, and configures the Kubernetes context on your local machine. This allows you to interact with the AKS cluster using Kubernetes command-line tools (kubectl) or any other Kubernetes client.

You can run kubectl get nodes to see the nodes in your cluster.

Step 4. Clone the azure voting app github repo here.
The repo already has the Kubernetes deployment and service files needed to deploy the application.

Step 5. Deploy the application.
A Kubernetes manifest file containing all the deployments and services is in the azure-vote-all-in-one-redis.yml file. To deploy this manifest, run this command:

kubectl apply -f azure-vote-all-in-one-redis.yml

Step 6. Visit your deployed site
The azure voting frontend has a service type of LoadBalancer, in order to visit your newly deployed site run the following command to get the external IP address of the LoadBalancer:

kubectl get service --watch

The --watch flag is added because the external IP address takes a little while before it is added to the LoadBalancer so instead of running the command multiple times, just add the watch flag to watch for any changes.

Copy the external IP and paste in your web browser to see the azure voting app website.

Step 7. Clean up your resources
It is important to clean up resources when you no longer have use for them to avoid incurring charges. To delete your resources, simply delete the resource group with the command below:

az group delete --name <resource-group-name>

Conclusion

Throughout this article, we covered key steps for creating an AKS cluster and deploying applications using Azure CLI. We created a resource group, an AKS cluster, and deployed the Azure voting application to our cluster.

By leveraging Azure CLI and the power of AKS clusters, you can efficiently deploy and manage your applications on Azure, taking advantage of the scalability and flexibility of Kubernetes. Happy exploring and deploying your applications on Azure

How To Create an Azure Static Web App

Sarah Aligbe — Wed, 12 Apr 2023 23:03:01 +0000

Introduction

For week 2 at SheCode Africa Cloud School, we were asked to create an Azure static web app.

Azure Static Web Apps is a service offered by Microsoft Azure that allows developers to deploy and host static web applications quickly and easily. Static web applications are web applications that do not require server-side code, which makes them faster and easier to deploy than traditional web applications.

The purpose of this article is to provide a step-by-step guide on how to create an Azure Static Web App. This guide will cover the prerequisites, creating the app, and deploying it. By the end of this article, you should have a good understanding of how to create an Azure Static Web App and how to deploy your static web applications quickly and easily using Microsoft Azure.

Pre-requisites

Microsoft Azure account.
A Github repository. You'll need to have your web app's source code in this repository, and you'll need to connect this repository to your Azure Static Web App to enable automated deployments.

Steps to Create an Azure Static Web App

Sign in to your Azure account, search 'Static Web Apps' in the search bar and select it.
On the Static Web Apps page, click the create button.
Select a subscription, a resource group, and name your Static Web App.

An Azure subscription provides access to Azure resources and to track usage and costs, while an Azure resource group is used to organize and manage related resources within a subscription.
If you do not have a pre-existing resource group, click create new to create a new resource group. All Azure resources must be created within a resource group.
Select your plan type, region, and source

Your plan type should be free.
It is important to select a region closest to you because the closer the region is to your location, the lower the latency or delay in communication between your application and the Azure resources. This can result in faster application performance, lower response times, and better user experiences.
You can visit this website https://www.azurespeed.com/Azure/Latency to tests latency from your IP location to Azure datacenters worldwide. The region with the lowest average latency in milliseconds is the closest region to you.

Select sign in with Github and authorize Azure's access to your Github account.
Select your Github organization (your account), the repository housing your source code and the branch
In the Build details section, add configurations specific to your application

Select Custom in the Build presets since the application is not using any framework.
Select the root directory ("/") since the index.html file of the application is in the root directory. This may be different for you.
Leave the rest of the configurations empty.
Click Preview workflow file to view the Github Actions workflow file generated by Azure.

Azure automatically generates one and pushes it to your Github repository. This file is used to automate the deployment of your app to Azure whenever changes are pushed to the specified branch of your GitHub repository.
Click Review+Create
The deployment takes a few minutes and when it is complete, click Go to resource

Copy the URL link to see your application.

Conclusion

To wrap up, I hope this article has been helpful in guiding you through the process of creating an Azure Static Web App. By following the steps outlined in this article, you can quickly and easily deploy your own static web app in Azure.

Remember to select a region closest to you when deploying resources in Azure, and take advantage of Azure subscriptions and resource groups to manage costs and resources.

If you're interested in learning more about Azure Static Web Apps or other Azure services, Microsoft provides a wealth of documentation and resources for getting started. Some additional resources and links for further learning include:

Microsoft Learn: https://learn.microsoft.com

How to Create an AWS S3 Bucket

Sarah Aligbe — Sun, 09 Apr 2023 13:54:02 +0000

Introduction

Amazon Simple Storage Service (S3) is a cloud-based storage service provided by Amazon Web Services (AWS). It is designed to store and retrieve any amount of data, from anywhere in the world, at any time. S3 provides a simple web interface that can be used to store and retrieve data objects using standard HTTP or HTTPS protocols. It can be used for a wide range of applications, such as storing backup data, hosting static websites, and serving as a content repository for web and mobile applications.

Pre-requisites

An AWS account

Steps to create an S3 Bucket

Log in to your AWS account and search for S3 in the search bar
Navigate to the S3 page and click "Create bucket"
Choose a unique name for your S3 bucket and select the region in which you want to create your bucket. It is required that no two AWS S3 buckets have the same name. If you choose a name that is already taken, you will not be able to create your bucket, and you will need to choose a different name.
Leave the Object ownership ACL as disabled Object ACLs are used to set permissions on individual objects within the bucket. You can use object ACLs to grant read, write, or delete access to specific users, groups, or AWS accounts.
You can choose to enable or disable public access. Public access is disabled by default in AWS S3 buckets to help prevent unauthorized access to your data. When public access is enabled, anyone on the internet can access the data in your S3 bucket, which can put your data at risk. You can always edit it later to enable public access.
You can choose to enable or disable bucket versioning Bucket versioning is important in AWS S3 because it provides a way to protect against accidental deletion or overwriting of objects in your bucket. With versioning enabled, you are able to recover previous versions of the object if it is accidentally deleted or modified. We'll leave ours as disabled just for test purposes.
Leave the rest of the configurations as is and click create bucket.
To upload objects into your bucket, click on your bucket, and click upload You can then drag and drop your objects into your bucket.

Deleting an S3 bucket

It is important to delete resources when you're done using them. To delete an S3 bucket, you must first empty the bucket of its objects and then delete it.

Conclusion

In conclusion, AWS S3 offers a wide range of capabilities for storing and managing data in the cloud.
By following the steps outlined in this article, you can create an S3 bucket, upload objects to it, and manage access control to ensure that your data is secure and available. Additionally, it's important to regularly review your AWS environment and delete resources that are no longer needed, to optimize your cloud environment for cost, security, and compliance.

How To Create an EC2 Instance on AWS

Sarah Aligbe — Fri, 07 Apr 2023 23:17:15 +0000

Introduction

For week 1 at She Code Africa Cloud School, we were required to write an article to document the process of creating an AWS EC2 instance.
An EC2 (Elastic Compute Cloud) instance is a virtual machine hosted on AWS that allows users run their applications.
EC2 instances are highly scalable, flexible, and customizable, allowing users to configure the instances to meet their specific needs. With EC2 instances, users can quickly launch new instances, change the instance type, increase or decrease storage capacity, and scale their applications up or down to meet changes in demand.

Pre-requisites

An AWS account
Familiarity with the AWS management console

Creating an EC2 Instance

Log into your AWS account, search EC2 in the search bar, and click on it.
In the EC2 dashboard select instances
Click Launch instances
Give your instance a name
Select the appropriate AMI for your instance

An Amazon Machine Image (AMI) is a pre-configured virtual machine image that is used to create EC2 instances. It is a fundamental building block in the EC2 service as it enables users to easily and quickly launch an instance that is pre-configured with their desired operating system and application stack, saving significant time and effort in configuring and deploying new instances.
We will be using the Ubuntu 20.04 AMI for this instance.
Select an instance type and a key pair

An Instance type is a specification for the virtual hardware of an EC2 instance. It determines the amount of CPU, memory, storage, and networking capacity that an EC2 instance has.
You can choose the instance type to use based on your specific workload.
AWS offers certain instance types as part of its free tier such t2.micro and t3.micro.

A key pair is a set of security credentials that are used to securely authenticate a user's login credentials to an EC2 instance. It consists of two parts: a public key and a private key. The public key is shared with the instance, while the private key is kept secure by the user.

AWS key pairs can be downloaded in .pem or .ppk formats.
The .pem format is commonly used with SSH clients on Unix/Linux systems.
The .ppk file format is a proprietary format used by PuTTY, a popular SSH client for Windows.

It is important to keep your private keys secure and should not be shared with others as anyone with access to your private key can gain access to your instance.
Enter your preferred network settings

Your network settings include setting your VPC (Virtual Private Cloud) which is a virtual network infrastructure provided by AWS that allows users to launch resources in a logically isolated section of the AWS Cloud.
Your VPC enables you to create your own IP address ranges, subnets, route tables, security groups, etc.
AWS assigns a default VPC to every account, we'll use the default VPC and create a new security group that only allows SSH access to the instance.
Select the number of instances you want to create and review your selection
Click launch instance
The instance is running and has passed the checks

Conclusion

In this article, we discussed how to create an EC2 instance on AWS. We covered the basic steps involved in launching an EC2 instance, including selecting an Amazon Machine Image (AMI), choosing an instance type, configuring security settings, and creating a key pair to connect to the instance.
We also discussed some important concepts related to EC2 instances, such as instance types, key pairs, and the free tier offering. Additionally, we provided a brief overview of VPCs and their importance in creating a secure and isolated environment in the cloud.
If you are new to AWS or cloud computing, creating an EC2 instance can be a great way to get started and learn about the benefits of cloud computing.
So, if you're interested in trying it out for yourself, sign up for an AWS account and launch your own EC2 instance today.