Forem: Mobi

How to send an HTTP request with Python

Mobi — Sat, 04 Apr 2026 18:27:21 +0000

Introduction

HTTP (Hypertext Transfer Protocol) is a fundamental protocol for data communication between clients and servers on the Internet. It enables the exchange of information between a client (e.g., a web browser) and a server (e.g., a web application).

What is an HTTP Request?

An HTTP request is a message that a client sends to a server over the Hypertext Transfer Protocol (HTTP). It is used to transfer all sorts of data, including HTML pages, images, videos, and JSON objects.

HTTP requests are made up of four parts:

The request method: This specifies the type of request being made. The most common request methods are GET, POST, PUT, and DELETE.
The request URL: This is the address of the resource that the client is requesting.
The request headers: This is a set of key-value pairs that contain additional information about the request. For example, the Content-Type header specifies the type of data that is being sent in the request body.
The request body: This is the optional body of the request, which can contain data such as form data, JSON objects, or XML documents.

Choosing the Right Library

Python offers various libraries for making HTTP requests, including httplib, urllib, and requests. In this article, we will use the "requests" library for its simplicity.

Installing the Requests Library

Before we begin, ensure you have the "requests" library installed. If not, you can easily install it by running the following command on your terminal:

pip install requests

Making a GET Request with Python:

Let's put our knowledge into practice by making a GET request to a Weather API to retrieve real-time weather information.

import requests
import json
import time

# Define an API endpoint URL
URL = "http://api.weatherapi.com/v1/current.json"

# Specify the location and API key
params = {
    'q': "London",  # Location
    'key': "YOUR_API_kEY"  # Your API key
}

# Send a GET request to the API endpoint with the specified parameters in JSON format
response = requests.get(URL, params=params)

# Check if the request was successful (status code 200)
if response.status_code == 200:
    # Extract and parse the JSON response
    data = response.json()
    time.sleep(2)

    # Extract specific information from the JSON response
    location = data['location']
    city = location['name']
    country = location['country']

    current = data['current']
    temp_celsius = current['temp_c']
    condition = current['condition']['text']
    windspeed_mph = current['wind_mph']

    # Print the extracted information
    print(f"City: {city}")
    print(f"Country: {country}")
    print(f"Temperature (Celsius): {temp_celsius}°C")
    print(f"Condition: {condition}")
    print(f"Windspeed (MPH): {windspeed_mph} mph")
else:
    # Print an error message if the request failed
    print(f"Request failed with status code {response.status_code}")

Output

Explanation of the Code

Imports:

import requests

We start by importing the required libraries for this project.

Defining the API Endpoint URL and Parameters:

URL = "http://api.weatherapi.com/v1/current.json"
params = {
    'q': "London",  # Location
    'key': "YOUR_API_kEY"  # Your API key
}

We define the URL and specify the parameters. In this case, we set the address parameter to the location where we want to retrieve weather information.

Sending a GET Request:

response = requests.get(URL, params=params)

We use the requests.get method to send a GET request to the API endpoint with the specified parameters.

Handling the Response:


if response.status_code == 200:
    data = response.json()

We check if the request was successful (status code 200), and if it is, we parse the response as JSON using the response.json() method.

Extracting Specific Information from JSON Response :

location = data['location']
city = location['name']
country = location['country']
temp_celsius = data['current']['temp_c']
condition = data['current']['condition']['text']
windspeed_mph = data['current']['wind_mph']

We extract specific information from the JSON response, such as the city, country, temperature in Celsius, condition, and windspeed in MPH.

Printing the Extracted Information:

print(f"City: {city}")
print(f"Country: {country}")
print(f"Temperature (Celsius): {temp_celsius}°C")
print(f"Condition: {condition}")
print(f"Windspeed (MPH): {windspeed_mph} mph")

Finally, we print the extracted information to the console in an easy-to-understand format.

Conclusion

In this article, we've explored the world of HTTP requests, focusing on the GET method. We've learned how to send HTTP requests in Python using the "requests" library.

The Python Requests library makes it easy to send HTTP requests in Python. It provides a simple and easy-to-use interface for making all types of HTTP requests.

How to Deploy a Static Website on EC2 with Nginx

Mobi — Fri, 03 Apr 2026 23:00:00 +0000

Deploying a website doesn't have to be a headache. With Amazon Web Services (AWS) and its EC2 (Elastic Compute Cloud) service, you can get your static website up and running quickly and easily.

This guide will walk you through the process of deploying a static website on an EC2 instance using Nginx as the web server.

What is AWS EC2?

AWS EC2 (Elastic Compute Cloud) is a web service provided by AWS that offers secure, resizable, and scalable virtual servers known as instances. These virtual machines come pre-configured with operating systems and some necessary software, allowing you to focus on your application.

AWS will manage the infrastructure, so you can launch and terminate the EC2 instance whenever you want. EC2 operates on a pay-as-you-go model, enabling you to scale up or down based on demand.

Deploying a Static Website on AWS EC2

Prerequisites

To follow along with this guide, ensure you have the following:

An AWS account
A static website (HTML/CSS)
Basic knowledge of the Linux command line

Step 1: Create a Static Website

First, create a static website. A simple example of a website structure should include an index.html and a styles.css file. This is the static website I'll be deploying.

Build it using your preferred tools and frameworks. I'll assume you have a simple HTML website ready for this guide.

Create an Nginx Shell Script

Inside the same directory of our static website, I'll create an Nginx shell script file that will help us install the Nginx server on the EC2 instance.

#!/bin/bash
sudo apt update -y
sudo apt install ufw -y
sudo apt install nginx -y
sudo ufw app list
sudo ufw allow 'Nginx HTTP'

This script will automate the installation and configuration of Nginx on your EC2 instance.

Push your website code to a Git repository

Now, we will push the web application code to GitHub for further use.

Note: Ensure that your repo's visibility is set to public. You can find my repo here.

Step 2: Launch an EC2 Instance

Once you have your AWS account, sign in as the root user.

At the top of the AWS management console, search for the EC2 service in the search bar.

To create a new EC2 instance, click on Launch Instances.

Configure your instance with the appropriate settings (AMI, instance type, security groups, key pair, etc.).

Review and launch the instance by clicking on Launch instance. Wait for the instance to change its state from pending to running.

Step 3: Configure Instance Settings

Set up the inbound rules to access the website & SSH into the instance. Select the Security tab and click on the security group.

Inside the security group, click on Edit inbound rules in the Inbound rules section.

Edit inbound rules to add the following:

SSH (port 22) from Anywhere-IPv4

HTTP (port 80) from Anywhere-IPv4

HTTPS (port 443) from Anywhere-IPv4

All traffic

Click on the "Save rules" button to apply the changes to your security group.

Step 4: Connect to Your EC2 Instance and Install Nginx

Go back to the instances, select the instances, and click on Connect to connect the instance.

We would not make any changes here, so click on “Connect” to continue to the AWS terminal.

We have now been connected to our EC2 instance.

Run the following command to update the instance packages:

sudo apt update && sudo apt upgrade -y

Now, go to your GitHub repo and copy the HTTPS link for the repo. You can clone the repo to the instance with the following command:

git clone Your_repo_link

Now, cd into the GitHub repo and observe that all your files have been cloned. Run the nginx shell script using the following command:

bash nginx.sh

This will successfully install Nginx on the instance.

Now, we have to access the nginx default path, where we can add the files of our website. We will cd into this directory.

cd /var/www/html

If we cd into the list of items, we will be able to see the Nginx index page. We will remove this file and add our project files and folder to it.

sudo rm index.nginx-debian.html

Type cd to go back to the working directory. We will move all our GitHub files and folders on the instance to the nginx default path directory ‘/var/www/html.’

cd
sudo mv your-repo-folder/* /var/www/html

Step 5: Assign an Elastic IP Address

We will now assign an Elastic IP address to the instance. Because the public IP address changes when you stop and restart your instance, we will provide an Elastic IP address that does not change when you restart your instance. In the EC2 console, go to "Elastic IPs" under "Network & Security".

To allocate an Elastic IP address, click "Allocate Elastic IP address." We will be using the default settings for this section, so go ahead and click “Allocate”.

Go to Actions and click on Associate Elastic IP address.

In the Instance section, select the instance where you have deployed your website. Check the Reassociation box to reassociate the IP address to another instance. Then click on Associate.

Go to the instance dashboard and select your instance. Under Public IPv4 address, you will see the Elastic IP address associated with the instance.

Copy and paste the public IPv4 address of the instance in your browser’s new tab.

Your static website is now live and accessible! 🎉

Step 6: Clean Up (Important)

Remember to terminate your EC2 instance when you're finished to avoid unnecessary charges.

Go to "Elastic IPs," select the IP, and choose "Actions" > "Release Elastic IP address."

Click on “Release”.

Note*: You can only release the IP address after the instance it was associated with has terminated.*

Wrapping Up

This article provided a comprehensive guide to deploying a static website on an AWS EC2 instance using Nginx. We covered the essential steps, from configuring your instance to setting up a web server and deploying your website content.

By following these steps, you've gained a practical understanding of leveraging AWS services to host your web projects efficiently.

Remember to explore further security best practices and optimization techniques to enhance the performance and security of your deployed website.

How LLMs Actually Generate Text (Every Dev Should Know This)

Mobi — Wed, 25 Feb 2026 10:00:04 +0000

Most developers use LLMs every day.

We use them to write code, explain errors, summarize docs, brainstorm product ideas, and clean up text.

But most people don't realise the model has no idea what it's about to say. Not the full sentence, not even the next word.

So how does it still produce responses that feel coherent and intentional?

In this article, I am going to walk through the actual generation pipeline that runs every time you hit send. Once you see how it really works, a lot of LLM behavior starts to make more sense:

why token count matters for cost
why context windows feel strict
why hallucinations happen
why temperature flips the tone and style of responses
why the same prompt can produce different answers

Alright, let’s get into it.

The surprising truth about LLMs

Let’s start with the biggest misconception.

When you send a prompt to an LLM, it does not plan the whole response in advance. It predicts the next token. Then the next one. Then the next.

At the moment the first word appears, the model genuinely does not know how the sentence will end. Future tokens do not exist yet.

This token-by-token process is why generations can drift halfway through a response, and why small changes in your prompt can lead to very different completions. The model is just following a probability path at each step.

The 5-Step Pipeline at a Glance

Every time you send a prompt, the model goes through these five steps:

Tokenization: your text gets broken into pieces
Embeddings: those pieces become meaningful vectors
The Transformer: context gets processed through attention
Probabilities: every possible next token receives a score
Sampling: One token is selected based on the probability distribution.

Each step builds on the last, then the selected token is appended to the input, and the whole process repeats until the model stops.

This loop is what creates the full response you see.

Step 1: Tokenization

Before the LLM starts generating output, your input goes through a tokenizer.

This is a preprocessing step. It happens before the model starts “thinking.”

A tokenizer splits text into smaller units called tokens. Tokens are not always words. They can be:

full words
parts of words
punctuation
spaces
special symbols

For example, if you type "I love programming. It's awesome." into OpenAI's tokenizer, you get seven tokens. Most tokens correspond to whole words, but punctuation like the period gets its own separate token.

This isn't random — tokenizers are trained on massive text data to find the most efficient patterns for splitting text.

Why tokenization exists

Tokenization exists because language has patterns.

Some words appear all the time, so it is efficient to store them as single tokens. Other words are rare or long, so they get broken into smaller subword pieces that can be reused.

That is why a common word like the may be one token, while a longer word like indistinguishable could be split into several tokens.

Tokenization is basically a compression-friendly way to represent text.

Common words like "the" get a single token. Uncommon or long words get broken into subword pieces. A word like "indistinguishable" becomes four tokens, while "the" remains just one.

Why this matters to you as a developer: When an API says the maximum context is 4,096 tokens, that's not 4,000 words. It can be roughly 3,000 words of English. Tokens are smaller units than words, and every token costs you money on API calls.

After tokenization, each token gets assigned a token ID. So "I love programming. It's awesome." becomes a sequence of seven integers. That's what actually enters the model. But numbers alone don't carry meaning. That's where the next step comes in.

Step 2: Embeddings and Meaning Space

A token ID is just a number. The model needs to understand what it means. So every token gets converted into a vector (a long list of numbers representing its meaning).

These vectors have thousands of dimensions. GPT-3, for example, uses over 12,000 numbers per token. And these aren't random numbers. They're coordinates in what's called a "meaning space."

Think of it like this: words with similar meanings end up near each other in this space. "King" is near "queen." "Python" the programming language is near "JavaScript." But "Python" the snake is somewhere completely different.

There's a famous demonstration of how powerful these vectors are. If you take the vector for "king," subtract the vector for "man," and add the vector for "woman," you land near "queen." The model learned gender relationships purely from text patterns — nobody explicitly taught it.

These rich vectors now flow into the transformer.

Step 3: The Transformer and Attention

Your embedding vectors enter a neural network with billions of parameters. But the one mechanism that makes it all work is called attention.

Imagine a spotlight operator at a concert. The music shifts, and the operator decides which musician to highlight. During a guitar solo, the spotlight lands on the guitarist. During vocals, it shifts to the singer.

Attention works similarly. When processing each token, the model decides which other tokens in the sequence to focus on.

Let's look at this sentence in closer detail: "The cat sat on the mat because it was tired."

In this context, "it" refers to the cat, not the mat. This is exactly what attention does. When the model processes "it," it assigns high attention weight to "cat" and low weight to "mat."

Even though "mat" is closer in the sentence, the model learned from patterns across millions of examples that "was tired" matches with animals, not objects.

This attention calculation happens multiple times in parallel through what are called attention heads. Different heads can capture different types of relationships — some might track grammatical structure, others might track meaning or long-range dependencies.

What then comes out the other end? Vectors that encode not just individual token meanings, but rich contextual information about the entire input.

Step 4: Probabilities

Now, we need to predict the next token.

After the transformer has processed your input. The final layer produces a score for every single token in the vocabulary.

Llama 3 has 128,000 tokens in its vocabulary, and each one gets a score. These raw scores are called logits.

A function called softmax converts those logits into probabilities that sum to one. So for a given input, you might get a distribution like this:

This is the core reality of LLM generation. The model doesn't decide what to say. It produces a probability distribution over all possible next tokens. Your final response is just one path through an enormous space of possibilities.

Step 5: Sampling, Temperature, and Top-P

This is where you, the developer, have direct control.

Greedy decoding is the simplest approach. It picks the highest-probability token every time. At the end of the day, it's consistent, but it can also feel boring and repetitive.

That's where temperature comes in. Temperature adjusts how "confident" the distribution is.

With the same prompt, "What is Python?", different temperature settings produce very different behavior. A low temperature (like 0.2) sharpens the distribution, making safe, predictable choices dominate. A high temperature (like 1.5) flattens it, giving unlikely tokens a real chance. But push it too high and outputs become incoherent.

Then there's top-p, also called nucleus sampling. Top-p says: "only sample from the smallest set of tokens whose probabilities add up to p." If top-p is 0.9, you might be choosing from just 15 tokens or 500, depending on how confident the model is about the current position.

When you set these parameters in an API call, you're directly shaping the token selection process.

The Autoregressive Loop

We've walked through all five steps, but so far we've only generated a single token. How does the model produce an entire response?

Through a loop. Once one token is selected, it gets appended to the input, and the entire five-step pipeline runs again. Tokenize, embed, transform, compute probabilities, and sample. For every single token.

This continues token by token until the model produces a special end-of-sequence token or hits a length limit.

This is called autoregressive generation, and it has two important implications. First, generation slows down for longer outputs because every new token requires attention over all previous tokens. Second, the model genuinely doesn't know what it will say in advance. Each word is decided only when it's that word's turn, based on everything that came before.

What This Means For You

Now that you understand the mechanics, here are three practical takeaways that will improve how you build with LLMs.

Hallucinations aren't lies they're pattern matches. When an LLM hallucinates, it is not being dishonest in a human sense.

It is generating tokens that statistically fit the context and prompt style.

If your prompt asks for a citation and the model does not actually know one, it may still produce something that looks citation-like because that pattern is likely in similar contexts.

The takeaway? always verify factual claims, especially when the model sounds confident. Confidence in tone tells you nothing about accuracy.

Temperature doesn't make models "more creative." It makes them more likely to select lower-probability tokens. What we call "creativity" is a human interpretation of that randomness. For deterministic tasks like coding, data extraction, or formatting, use low temperature. Don't leave the output to chance when precision matters.

Context limits aren't arbitrary product restrictions.

Every token needs to interact with other tokens in context. That becomes expensive as context grows.

This affects:

latency
cost
memory usage

So, next time you hit a context limit, it's not the company being stingy with resources. It's a result of how transformer attention works.

Final Takeaway

The next time you use an LLM, remember what's actually happening.

A tokenizer split your input.
Embeddings turned tokens into meaning vectors.
Attention connected the context.
A probability distribution was computed.
One token was sampled.
Then the entire process was looped.

Once you understand this mechanism, you've taken the first steps to building better systems.

Automating User Management with Bash Scripting

Mobi — Fri, 05 Jul 2024 13:26:20 +0000

Managing users and groups is a fundamental aspect of system administration in Linux environments. As systems grow in complexity and the number of users increases, manual user management becomes tedious, error-prone, and difficult to scale.

This article will guide you through creating a bash script to automate user and group management based on a provided text file.

Problem Statement

The challenge lies in streamlining the process of creating new users with specific group memberships, generating secure passwords, and meticulously logging all actions for auditing and troubleshooting.

Imagine a scenario where a company onboards multiple new employees requiring immediate access to system resources. Manually creating each user account, setting appropriate permissions, and assigning them to the correct groups would be time-consuming and prone to human error.

Requirements

To address this challenge, the following requirements were identified:

Automated User and Group Creation: The script should create new user accounts and groups based on information provided in a structured input file.
Password Generation and Secure Storage: The script must generate strong, random passwords for each user and store them securely to prevent unauthorized access.
Group Membership Management: The script should dynamically assign users to existing or newly created groups as specified in the input file.
Comprehensive Logging: All actions performed by the script, including user and group creation, password settings, and any errors encountered, should be meticulously logged for auditing and debugging.

Creating the Project

To tackle the user management automation task, we'll develop a Bash script. Let's break down the script creation process step by step:

1. Defining Essential Variables and Functions

First, we need to set up some essential variables and functions that our script will use throughout its execution. We'll define where to store log information, where to store generated passwords, how to log actions taken by the script, and how to generate random passwords.

#!/bin/bash

# Log file path
LOG_FILE="/var/log/user_management.log"

# Password file path
PASSWORD_FILE="/var/secure/user_passwords.csv"

# Ensure the secure directory exists
mkdir -p /var/secure
chmod 700 /var/secure

# Log function
log_action() {
    echo "$(date +'%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
}

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

In this code, we define the LOG_FILE variable to hold the path to our log file, recording every action taken by the script. Similarly, PASSWORD_FILE stores the path to a file where we'll securely store the generated usernames and passwords. To ensure the security of the password file, we create a directory /var/secure (if it doesn't exist) and set appropriate permissions using chmod 700.

Next, we define the log_action function. This function streamlines the logging process by automatically adding a timestamp before each message written to the log file. The generate_password function provides a mechanism to generate random 12-character alphanumeric passwords, which we'll use to create secure user accounts.

2. Input Handling and Validation

Now that our script has its basic tools, we need to equip it to handle input. We'll design the script to accept the name of a file containing user information as an argument.

Here's how we implement this:

# Check if the input file is provided
if [ $# -ne 1 ]; then
    echo "Missing Argument: <name-of-text-file>. Only one argument is required."
    exit 1
fi

INPUT_FILE="$1"

# Ensure the log and password files exist
touch "$LOG_FILE"
touch "$PASSWORD_FILE"
chmod 600 "$PASSWORD_FILE"

This section ensures that the script receives exactly one argument—the name of the text file. We use an if statement with the [ $# -ne 1 ] condition to check the number of arguments. If the script is executed without the required input file, it will display an error message and gracefully exit with an error code of 1 exit 1.

The provided file name is then stored in the INPUT_FILE variable. Lastly, we use the touch command to create both the log file ($LOG_FILE) and the password file ($PASSWORD_FILE) if they don't exist. We also set secure permissions (read and write only for the owner) on the PASSWORD_FILE using chmod 600to protect sensitive information.

3. Processing the Input File

With the input mechanism in place, we're ready to process the input file line by line. Each line in the file represents a user, containing their username and group memberships separated by a semicolon.


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

    # Check if the username is empty
    if [ -z "$username" ]; then
        continue 
    fi

    # ... (We'll add user creation and group assignment logic here in the next step) 

done < "$INPUT_FILE"

This code block uses a while loop to iterate through each line of the $INPUT_FILE. We set the IFS (Internal Field Separator) to a semicolon, so each line is split into fields wherever a semicolon (;) appears. The read command then assigns the first field (the username) to the username variable and the remaining fields (the groups) to the groups variable.

We then trim any extra spaces from the username and groups variables using xargs. This ensures consistency and prevents issues that might arise from unintended whitespace. An empty username signifies an invalid entry, prompting us to skip to the next line using the continue statement.

4. User and Group Management

This section is the heart of our script, where we'll implement the logic for creating users, creating their personal groups, and assigning them to the appropriate groups.

# Create the user's personal group
    if ! getent group "$username" > /dev/null; then
        groupadd "$username"
        log_action "Created group $username"
    fi

    # Create the user with the user's personal group
    if ! id -u "$username" > /dev/null 2>&1; then
        useradd -m -g "$username" -s /bin/bash "$username"
        log_action "Created user $username with group $username"
    else
        log_action "User $username already exists"
    fi

    # Set up home directory permissions
    chmod 700 /home/"$username"
    chown "$username":"$username" /home/"$username"

    # Assign 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"
                log_action "Created group $group"
            fi
            usermod -aG "$group" "$username"
            log_action "Added user $username to group $group"
        done
    fi

Let's examine the code closely. First, we use getent group to check if a group with the user's name already exists. If it doesn't, we create the group using groupadd and log the action.

Next, we check for the existence of the user using id -u. If the user doesn't exist, the useradd command comes into play. The -m flag tells useradd to create the user's home directory, -g "$username" assigns the user's personal group as their primary group, and -s /bin/bash sets their default shell to /bin/bash. Of course, we diligently log this successful user creation. If a user already exists, the script logs that information.

After creating the user, we set the appropriate permissions on the user's home directory using chmod 700, giving the owner (the user) full control (read, write, execute). We also ensure the user is the owner of their home directory using chown.

The final part of this section handles additional group assignments. If the groups variable is not empty (meaning additional groups are specified), we split the comma-separated group names into an array called GROUP_ARRAY. We then iterate through each group in the array; for each group, it checks if the group exists and creates it if needed (just like we did for the personal group). Finally, it adds the user to the group using usermod -aG.

5. Password Management

Our final step involves generating a secure password for each user, setting that password for the user's account, and then securely storing this sensitive information.

# Generate a random password and set it
    password=$(generate_password)
    echo "$username:$password" | chpasswd
    log_action "Set password for user $username"

    # Store the username and password securely
    echo "$username,$password" >> "$PASSWORD_FILE"

We first call our generate_password function to obtain a random password, storing it in the password variable. Next, we use the chpasswd command to set this password for the user. The echo "$username:$password" construct pipes the username and password in the required format to chpasswd. As always, we record this successful password setting in our log file.

Finally, we append the newly created username and password pair (separated by a comma) to our secure PASSWORD_FILE.

Testing the Script

It's time to put it to the test. We'll execute the script, providing it with a sample input file containing user information. You can find a sample text file in this GitHub Gist

Make sure you have saved the script as create_users.sh and made it executable using:

sudo chmod +x create_users.sh

Now, run the script by passing the name of your input file as an argument:

sudo ./create_users.sh users.txt

Replace users.txt with the actual name of your input file if it's different.

Verify the Results

After running the script, it's essential to confirm that everything worked as expected.

Check the Log File: To review the actions taken by our script, open the log file located at /var/log/user_management.log. This file serves as a detailed record of the script's execution. Carefully examine the log entries to confirm that users and groups were created as intended and that passwords were successfully set.

ubuntu@mobi:~$ cat /var/log/user_management.log 
2024-07-04 21:31:19 - Created group light
2024-07-04 21:31:19 - Created user light with group light
2024-07-04 21:31:19 - Added user light to group sudo
2024-07-04 21:31:19 - Created group dev
2024-07-04 21:31:19 - Added user light to group dev
2024-07-04 21:31:19 - Added user light to group www-data
2024-07-04 21:31:19 - Set password for user light
2024-07-04 21:31:19 - Created group idimma
2024-07-04 21:31:19 - Created user idimma with group idimma
2024-07-04 21:31:19 - Added user idimma to group sudo
2024-07-04 21:31:19 - Set password for user idimma
2024-07-04 21:31:19 - Created group mayowa
2024-07-04 21:31:19 - Created user mayowa with group mayowa
2024-07-04 21:31:20 - Added user mayowa to group dev
2024-07-04 21:31:20 - Added user mayowa to group www-data
2024-07-04 21:31:20 - Set password for user mayowa
2024-07-04 21:31:20 - Created group alice
2024-07-04 21:31:20 - Created user alice with group alice
2024-07-04 21:31:20 - Added user alice to group sudo
2024-07-04 21:31:20 - Added user alice to group dev
2024-07-04 21:31:20 - Set password for user alice
2024-07-04 21:31:20 - Created group bob
2024-07-04 21:31:20 - Created user bob with group bob
2024-07-04 21:31:20 - Added user bob to group dev
2024-07-04 21:31:20 - Added user bob to group www-data
2024-07-04 21:31:20 - Set password for user bob
2024-07-04 21:31:20 - Created group charlie
2024-07-04 21:31:20 - Created user charlie with group charlie
2024-07-04 21:31:20 - Added user charlie to group sudo
2024-07-04 21:31:20 - Set password for user charlie
2024-07-04 21:31:20 - Created group daniel
2024-07-04 21:31:20 - Created user daniel with group daniel
2024-07-04 21:31:20 - Added user daniel to group dev
2024-07-04 21:31:20 - Added user daniel to group www-data
2024-07-04 21:31:20 - Set password for user daniel
2024-07-04 21:31:20 - Created group eve
2024-07-04 21:31:20 - Created user eve with group eve
2024-07-04 21:31:20 - Added user eve to group sudo
2024-07-04 21:31:20 - Added user eve to group www-data
2024-07-04 21:31:21 - Set password for user eve
2024-07-04 21:31:21 - Created group frank
2024-07-04 21:31:21 - Created user frank with group frank
2024-07-04 21:31:21 - Added user frank to group dev
2024-07-04 21:31:21 - Set password for user frank
2024-07-04 21:31:21 - Created group george
2024-07-04 21:31:21 - Created user george with group george
2024-07-04 21:31:21 - Added user george to group sudo
2024-07-04 21:31:21 - Added user george to group dev
2024-07-04 21:31:21 - Added user george to group www-data
2024-07-04 21:31:21 - Set password for user george
2024-07-04 21:31:21 - Created group henry
2024-07-04 21:31:21 - Created user henry with group henry
2024-07-04 21:31:21 - Added user henry to group sudo
2024-07-04 21:31:21 - Set password for user henry
2024-07-04 21:31:21 - User bob already exists
2024-07-04 21:31:21 - Added user bob to group sudo
2024-07-04 21:31:21 - Added user bob to group dev
2024-07-04 21:31:21 - Added user bob to group www-data
2024-07-04 21:31:21 - Set password for user bob

Verify Password Storage: Next, let's ensure our passwords are stored securely. Verify that the password file exists at the path specified in our script: /var/secure/user_passwords.csv. Open this file and examine its contents. It should contain the generated usernames and their corresponding passwords, formatted as username,password for each entry.

ubuntu@mobi:~$ sudo cat /var/secure/user_passwords.csv
light,Q5RvEhh65dZo
idimma,nKXhAtai7T97
mayowa,HRMmZ6nkIda6
alice,UMZiNsT02NQM
bob,2d1ZfdYZbldF
charlie,K4esdb8BC9Xt
daniel,p0iq7Cstgn4c
eve,DJQB3grtcFQQ
frank,Nh6JxwRJ8azq
george,3VC2ya1b41Xl
henry,DF9FL9HxPYq0
bob,nA4JQvk3skAk

Conclusion

This article has walked you through automating user and group creation in Linux using a Bash script. With this script, system administrators can efficiently onboard new users within their organization, eliminating repetitive manual steps.

The complete script can be found in this GitHub repository.

Huge Thanks to HNG for providing this opportunity. If you're eager to level up your technical skills and embark on a rewarding tech career, be sure to explore the opportunities offered by the HNG Internship program.

Visit the HNG Internship page to learn more about upcoming internship opportunities. If you're looking for top-tier talent for your next project, you can find exceptional individuals within the HNG network at HNG Hire.