DEV Community: Florence Okoli

Automating User and Group Management Using Bash Script

Florence Okoli — Wed, 03 Jul 2024 21:33:59 +0000

Bash, short for Bourne Again Shell, is a Unix shell and command language that has been a fundamental part of system administration and development for many years. As the default shell on many Unix-like operating systems, including Linux and macOS, Bash is renowned for its powerful capabilities in scripting and automation.

Imagine having to create user accounts, assign them to appropriate groups, set up home directories, and generate secure passwords for each new developer joining your team. Doing this manually can be tedious and error-prone. This is where Bash comes in. You can automate these repetitive tasks with Bash scripting, ensuring consistency and saving valuable time.

In this article, I used a Bash script to automate the onboarding process for new developers. This script reads a text file containing usernames and their respective groups, creates users, assigns them to groups, sets up their home directories, generates random passwords, and logs all actions.

Prerequisites

A Unix-based system (Linux or macOS)
Basic knowledge of Unix commands and Bash scripting

Objective

The script should create users and groups as specified, set up home directories with appropriate permissions and ownership, generate random passwords for the users, and log all actions to /var/log/user_management.log. Additionally, store the generated passwords securely in /var/secure/user_passwords.txt

My create_users.sh Script

#!/bin/bash

# Log file and password storage
LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.txt"

# Ensure the /var/secure directory exists
if [ ! -d "/var/secure" ]; then
    mkdir -p /var/secure
    chmod 700 /var/secure
fi

# Ensure the log file and password file exist and have correct permissions
touch $LOG_FILE
touch $PASSWORD_FILE
chmod 600 $PASSWORD_FILE

# Function to log messages
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

# Check if the file is supplied
if [ $# -ne 1 ]; then
    log_message "ERROR: No input file supplied"
    echo "Usage: $0 <name-of-text-file>"
    exit 1
fi

INPUT_FILE=$1

# Check if input file exists
if [ ! -f $INPUT_FILE ]; then
    log_message "ERROR: Input file does not exist"
    echo "ERROR: Input file does not exist"
    exit 1
fi

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

    # Skip empty lines
    if [ -z "$username" ]; then
        continue
    fi

    # Create a personal group for the user
    if ! getent group $username >/dev/null; then
        groupadd $username
        log_message "Group $username created."
    else
        log_message "Group $username already exists."
    fi

    # Create the user with the personal group
    if ! id -u $username >/dev/null 2>&1; then
        useradd -m -g $username $username
        log_message "User $username created."
    else
        log_message "User $username already exists."
    fi

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

    # Generate a random password
    password=$(openssl rand -base64 12)

    # Set the user's password
    echo "$username:$password" | chpasswd
    log_message "Password set for user $username."

    # Store the password securely
    echo "$username,$password" >> $PASSWORD_FILE
done < "$INPUT_FILE"

# Set the correct permissions on the password file
chmod 600 $PASSWORD_FILE

log_message "User creation process completed."

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

A detailed breakdown of the Script

Here is what this script does:

Shebang
The #!/bin/bash known as the shebang indicates that the script should be run on the BASH shell.
Path to Log file and Password file

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

The LOG_FILE and PASSWORD_FILE are variables that store the path to the log file and password file respectively.

Create /var/secure directory and set permission if it doesn't exist

if [ ! -d "/var/secure" ]; then
    mkdir -p /var/secure
    chmod 700 /var/secure
fi

Create Log file and Password file if they don't exist and set permission

touch $LOG_FILE
touch $PASSWORD_FILE
chmod 600 $PASSWORD_FILE

touch $LOG_FILE and touch $PASSWORD_FILE creates the log and password files if they do not already exist.
chmod 600 $PASSWORD_FILE sets the permissions for the password file so that only the file owner can read and write to it.

Log message function

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

The log_message function takes a message as an argument and appends it to the log file with a timestamp.

Check if input file is provided

if [ $# -ne 1 ]; then
    log_message "ERROR: No input file supplied"
    echo "Usage: $0 <name-of-text-file>"
    exit 1
fi

This checks if [ $# -ne 1 ]; then checks if exactly one argument (the input file) is supplied to the script.
If not, it logs an error, prints a usage message, and exits the script.

INPUT_FILE=$1 assigns the first argument (input file) to the variable INPUT_FILE
Check if the input file exists

if [ ! -f $INPUT_FILE ]; then
    log_message "ERROR: Input file does not exist"
    echo "ERROR: Input file does not exist"
    exit 1
fi

The if [ ! -f $INPUT_FILE ]; then checks if the input file exists.
If not, it logs an error, prints an error message, and exits the script.Cre

Read and process the input file

The while IFS=';' read -r username groups; do starts a loop to read the input file line by line, expecting each line to contain a username and groups separated by a semicolon (;).

The command below trims whitespace from the username and groups variables if any.

    username=$(echo $username | xargs)
    groups=$(echo $groups | xargs)

While

    if [ -z "$username" ]; then
        continue
    fi

Skips empty lines (where username is empty).

Create a group for user

    if ! getent group $username >/dev/null; then
        groupadd $username
        log_message "Group $username created."
    else
        log_message "Group $username already exists."
    fi

This creates a personal group for the user if it doesn't exist and logs the action.

Creates user for group

 if ! id -u $username >/dev/null 2>&1; then
        useradd -m -g $username $username
        log_message "User $username created."
    else
        log_message "User $username already exists."
    fi

This creates the user with their group if they don't already exist and logs the action.

Creates additional groups for users.

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

This command splits the group's string into an array, iterates over it, checks if the group exists (creating it if necessary) and adds the user to the group, logging each action.

Generate a random password
The password=$(openssl rand -base64 12) generates a random password using the OpenSSL
Set the user's password

    echo "$username:$password" | chpasswd
    log_message "Password set for user $username."
    echo "$username,$password" >> $PASSWORD_FILE
done < "$INPUT_FILE"

The code above sets the user's password and then appends the username and password to the PASSWORD_FILE

This done < "$INPUT_FILE" code ends the loop that reads from the INPUT FILE
The chmod 600 $PASSWORD_FILE code ensures the password file's permissions are secure after all passwords have been added.
Log completion of the user creation process
log_message "User creation process completed."

Test the Script

To test this script, let's create a users.txt file
nano users.txt

In the text file, enter the usernames and groups
wendy; engineering,webteam florenceokoli; admins, dev_team chi; support

Execute the Script

`chmod create_users.sh

Run the Script

sudo ./create_users.sh users.txt

Output

Management Log
Password.txt File

Conclusion

Bash is a powerful scripting tool used to automate various tasks on Unix-like operating systems. This script is designed to read a text file containing usernames and their respective groups, create users and their personal groups, assign users to additional groups, set up home directories, generate random passwords, and log all these actions for auditing purposes. Additionally, it stores the generated passwords securely in a dedicated file.

This project is a stage 1 task in the Devops HNG-11 Internship. For more information about the HNG Internship and its various opportunities, visit HNG Internship and HNG Hire.

Hosting WordPress on Ubuntu: A Step-by-Step Guide

Florence Okoli — Sun, 26 May 2024 22:10:15 +0000

Let's say you are a blogger or even a small business owner looking for a way to share your insights or products with the world at large. For this, you would need a perfect platform for your website that is also flexible with a vast array of plugins.
Well, here comes WordPress to the rescue.

You now have a great platform, but you may want the freedom to customize your server environment and ensure that every aspect of your website runs exactly as you want, without relying on managed hosting services.
Okay. Ubuntu comes into play and combined with the power of the LAMP stack (Linux, Apache, MySQL, PHP) gives you complete control over your website.

All these may seem daunting at first but in this guide, I will walk you through the process of hosting WordPress on Ubuntu using the LAMP stack.

Overview of Key Components

Before we delve into the step-by-step process, let's take a brief look at what WordPress, Ubuntu, and the LAMP stack are, and their roles in this project:

WordPress - WordPress is a widely used content management system (CMS) for creating and managing websites. It is well-known for its user-friendly interface and extensive library of plugins and themes. With WordPress, you can build anything from basic blogs to advanced e-commerce sites without requiring advanced technical skills. In this guide, WordPress will serve as the platform for creating and managing your website's content.
Ubuntu - Ubuntu is a popular, open-source Linux operating system known for its stability, security, and ease of use. In this project, Ubuntu serves as the foundation, hosting the web server and other essential software components.
LAMP Stack - LAMP is a set of open-source software for creating web servers, comprising Linux (Ubuntu as the operating system), Apache (webserver), MySQL (database), and PHP (scripting language). Each component is important and here is what they will do in this project:
- Linux: Provides the Operating System foundation.
- Apache: Handles browser requests and serves web pages.
- MySQL: Manages the WordPress database.
- PHP: Processes dynamic content and interacts with the database.

Prerequisites

An Ubuntu Server: You can use either a local machine(Vagrant virtual box)or a cloud-based virtual private server from AWS, Digital Ocean or Google Cloud.
A basic understanding of Linux commands

Steps

Update your package index

This command sudo apt update updates the package lists for upgrades and new package installations from the repositories defined in your system.

Install Dependencies

To install Apache2 and PHP, run the following command

sudo apt install apache2 \
                 ghostscript \
                 libapache2-mod-php \
                 mysql-server \
                 php \
                 php-bcmath \
                 php-curl \
                 php-imagick \
                 php-intl \
                 php-json \
                 php-mbstring \
                 php-mysql \
                 php-xml \
                 php-zip

Copy and paste this command into a text file before pasting it into your virtual environment to avoid errors.

Install WordPress

Let's create a new directory first and change the ownership of this directory to the user www-data to ensure that the webserver has the appropriate access to these files.

sudo mkdir -p /srv/www
sudo chown www-data: /srv/www

Next, let's download the latest version of WordPress and extract it into the /srv/www directory.

curl https://wordpress.org/latest.tar.gz | sudo -u www-data tar zx -C /srv/www

Here is what the code does:

This curl https://wordpress.org/latest.tar.gz command uses curl to download the file at the given URL, which is the latest version of WordPress in a gzipped tarball format.
The pipe | command takes the output of the command on its left and uses it as the input to the command on its right.
sudo -u www-data: This runs the following command as the www-data user. This is done because the /srv/www directory is owned by www-data, which we set earlier if you can remember
This command tar zx -C /srv/www extracts the gzipped tarball. The z option tells tar to uncompress the file (as it is gzipped), the x option tells it to extract the files from the tarball, and the -C /srv/www option tells it to change to the /srv/www directory before doing so.

To confirm you followed the above step correctly, run this command

ls -l /srv/www/wordpress

If you see an image like the one below, then you are on track.

Configure Apache for WordPress

To configure Apache for WordPress, run this command to create and edit WordPress configuration file

sudo vi /etc/apache2/sites-available/wordpress.conf

The command above opens up an empty configuration file. Copy the codes below and paste them into the configuration file. Then, save it

<VirtualHost *:80>
    DocumentRoot /srv/www/wordpress
    <Directory /srv/www/wordpress>
        Options FollowSymLinks
        AllowOverride Limit Options FileInfo
        DirectoryIndex index.php
        Require all granted
    </Directory>
    <Directory /srv/www/wordpress/wp-content>
        Options FollowSymLinks
        Require all granted
    </Directory>
</VirtualHost>

When this is done, enable the site using this command - sudo a2ensite wordpress and then enable URL rewriting using this command sudo a2enmod rewrite lastly, disable the default site using sudo a2dissite 000-default

To finish up with this step, reload apache2 to apply all these changes sudo service apache2 reload

Configure MySQL Database

Before we proceed, it is important to note that MySQL commands end with ; or /g
Let's begin with opening up the MySQL CLI using this command
sudo mysql -u root

This command opens the MySQL command-line client as the root user

Now, we create a database called wordpress, create a user for this database and give it a unique password. Next, we grant privileges to this user and with the flush privileges command, we reload the user privileges from the grant tables in the MySQL database. Here is the code at play:

CREATE DATABASE wordpress;
CREATE USER wordpress@localhost IDENTIFIED BY '<your-password>';
GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER ON wordpress.* TO wordpress@localhost;
FLUSH PRIVILEGES;
quit

Please note that these commands should be copied one after the * other into the CLI to avoid errors.

To apply these changes we made, let's enable the MySQL service with this command here - sudo service mysql start

Configure WordPress to connect to the database

First, let's create a new configuration file for WordPress by copying the sample configuration file to wp-config.php

sudo -u www-data cp /srv/www/wordpress/wp-config-sample.php /srv/www/wordpress/wp-config.php

Next, we configure the credentials in the configuration file. Please note that the only thing you are expected to change in the commands below is your password. Remember the unique password you created when you were creating the MySQL database? Yeah, that's the one.

sudo -u www-data sed -i 's/database_name_here/wordpress/' /srv/www/wordpress/wp-config.php
sudo -u www-data sed -i 's/username_here/wordpress/' /srv/www/wordpress/wp-config.php
sudo -u www-data sed -i 's/password_here/<your-password>/' /srv/www/wordpress/wp-config.php

Now we need to edit the WordPress config file. Use this command to open and edit the config file sudo -u www-data /srv/www/wordpress/wp-config.php
In your config file, scroll down to where you will find the commands below:

define( 'AUTH_KEY',         'put your unique phrase here' );
define( 'SECURE_AUTH_KEY',  'put your unique phrase here' );
define( 'LOGGED_IN_KEY',    'put your unique phrase here' );
define( 'NONCE_KEY',        'put your unique phrase here' );
define( 'AUTH_SALT',        'put your unique phrase here' );
define( 'SECURE_AUTH_SALT', 'put your unique phrase here' );
define( 'LOGGED_IN_SALT',   'put your unique phrase here' );
define( 'NONCE_SALT',       'put your unique phrase here' );

Now delete these commands above and replace them with the content you will find here. (This address is a randomiser that returns completely random keys each time it is opened.) See mine below:

This step is important to ensure that your site is not vulnerable to attacks.

Save the changes.

Customize WordPress to serve your web pages

On your terminal, run this command ip a to copy the IP address of your local machine. Copy and then paste the address on your browser. You will see an image similar to the one below upon loading your browser. Click on "continue" to customize WordPress for hosting your web pages.

Next, enter the title of your new site, username, password, and a valid e-mail address. Note that the username and password you choose here are for the WordPress site and not the ones you used for the MySQL database earlier.

Click on Install WordPress to continue

Now, let's log in with our details

Once you log in to the WordPress dashboard, you will find a variety of icons and options to customize your website according to your preferences.

C'est fini!!

Congratulations on taking the first step toward creating your own WordPress website on Ubuntu using the powerful LAMP stack! By following this guide, you've set up a flexible and customizable platform for sharing your insights, products, or even services with the world.

I hope you found this tutorial helpful and easy to follow.

Automate your tasks and schedule cronjobs with a script

Florence Okoli — Thu, 23 May 2024 12:30:39 +0000

Have you ever wondered how computers can do tasks all by themselves without anyone touching them? It's like magic, but there's a special way to tell the computer what to do, step by step. This is called scripting.
This article will explore the basics of Bash scripting, provide practical examples, and guide you through creating your scripts.
Let's dive in!

Introduction

What is Bash Scripting?
Bash scripting is a powerful tool for automating tasks on Unix-like operating systems, such as Linux and macOS.
Bash, short for the "Bourne Again Shell," is a powerful scripting language that enables users to automate repetitive tasks, streamline complex workflows, and efficiently manage system operations instead of doing them manually.
Overall, bash scripting is an essential skill for system administrators, developers, and anyone looking to optimize their computing tasks.

In Bash scripting, the Shebang #!/bin/bash, serves as the interpreter used to execute tasks on any script. In other words, it tells the system to use the specified interpreter to run the script.

Prerequisite

Vagrant virtual machine
Good understanding of Linux commands

Basics to Know Before Writing a Bash Script

Before diving into writing Bash scripts, it's essential to understand some fundamental concepts and components of Bash scripting. Here are the basics you need to know:

Familiarize yourself with basic Unix commands like mkdir, touch, and echo.
Understand file permissions and how to change them using chmod. For example, to make your script executable, use chmod +x. The X stands for execution
Use a text editor like Nano or Vim to write and edit scripts.
For Nano - nano myscript.sh For Vim - vi myscript.sh
Add comments in your scripts using # symbol. They help explain what the script does and are ignored during execution.
# This is a comment
Always start your script with a Shebang. It specifies the interpreter to be used.
Lastly, for every script, you must make sure to follow the syntax which includes the spacing, indentation, and punctuation.

Let's begin

Practical Examples of Bash Scripting

Let's start by creating a new directory that will house all our scripts. Once the directory is created, cd into the folder and create a file with the .sh extension. The .sh tells you that the file is a script.

mkdir bashscript
cd bashscript
touch myscript.sh

Let's make our newly created scripts executable. This will enable us to run our script

chmod +x myscript.sh

The ll command shows the permissions for the myscript.sh file

Next, let's play around with automation.

To do this, let's write a script that updates and upgrades our system.
This command vi myscript.sh opens the file named script.sh in the vi text editor.

When the file is opened in the Vim text editor, write the following codes below:

#!/bin/bash
sudo apt update -y
sudo apt upgrade -y

Close your text editor and run this command - ./myscript.sh

Now that we have seen what automation looks like using a bash script, let's get more practical.

Statements in Bash Scripting

i. Printing statements using the echo command.
The echo command in Bash scripting is used to print output to the terminal. Let's try it out.

First, create a script. I called my script myscript.sh. Then use the Vim text editor to open it vi myscript.sh Remember to start your script with the Shebang #!/bin/bash interpreter followed by the echo command and your text in quotes. Then close the editor.

#!/bin/bash
echo "Florence is a Cloud Engineer who loves bash Scripting"

Run your script using the ./<name of your script> The output will look like the image below

ii. Declaring variables.
Variables in bash scripting are used to store data and can be referenced in your script to perform operations. Here is how to declare a variable:

#!/bin/bash
name="Florence"
job="Cloud Engineer"

There should be no spaces around the equals sign. The value can be a number, a string, or the result of a command.
To read or use the value stored in a variable, you prepend the variable name with a dollar sign $. For example:

#!/bin/bash
echo "My name is $name and I'm a $job"

When this script is run using the ./myscript.sh this is what it will look like

iii. If Statements
The If statement allows your script to make decisions and perform different actions depending on whether a condition is true or false. In the example below, we are going to run a script that checks whether a given number is an even or odd number.

read -p "Enter a number: " number

if (( $number % 2 == 0 )); then
   echo "$number is an even number"
else
   echo "$number is an even number"
fi

A breakdown of the script:

read -p "Enter a number: " number: Prompts the user to enter a number and stores it in the number variable.
if (( number % 2 == 0 )); then: Checks if the number is even.
echo "The number $number is even.": Prints that the number is even if the condition is true.
else: Executes the following code if the number is not even.
echo "The number $number is odd.": Prints that the number is odd.
fi: Ends the if statement.

When the above script is run, here is what the result will look like

iv. While Loop
In Bash scripting, the while loop allows you to repeatedly execute a block of code as long as a specified condition remains true. Once the condition becomes false, the loop stops executing. This is similar to a washing machine cycle: it keeps running until the timer reaches zero.

Let's write a script that checks if a particular directory exists or not. In this case, we are checking if the ~bash/loopdir exists in our system

#!/bin/bash

while [ -d ~bash/loopdir ]; do
    echo "Directory exists"
done
    echo"Directory does not exist"

A breakdown of the script:

while [ -d ~/bash/loopdir ]; do: Starts a while loop that checks if the directory ~/bash/loopdir exists.
echo "Directory exists": If the directory exists, prints "Directory exists".
done: Ends the while loop when the directory no longer exists.
echo "Directory not found": After exiting the loop, prints "Directory not found" when the directory is no longer present.

Now, that you have gotten to this point, let's do something interesting. Let's create a script that monitors the uptime of a server and logs it periodically. In this script, we are also going to incorporate a cronjob that will record the server's uptime at specified intervals.

Before we start, let me explain what a cronjob does and why it is needed.

A cron job is just like that magical clock for your computer! It helps your computer remember to do certain tasks automatically, without you having to tell it every time.
Let me be more technical now.
A cron job is a time-based job scheduler in Unix-like operating systems, including Linux. It allows users to schedule commands or scripts to run periodically at fixed times, dates, or intervals. These scheduled tasks are referred to as cron jobs, and they can automate repetitive tasks, such as backups, system maintenance, uptime monitoring, log rotation, etc.

Now, let's create that script!
With this command sudo vi log_uptime.sh I will create a script for this particular task and make it executable using sudo chmod +x log_uptime.sh

Let's write the script.

#!/bin/bash

# Define the log file
LOG_FILE="$HOME/uptime_log.txt"

# Create the log file if it doesn't exist
if [ ! -f "$LOG_FILE" ]; then
    touch "$LOG_FILE"
    echo "Log file created at $LOG_FILE"
fi

# Get the current date and uptime
CURRENT_DATE=$(date '+%Y-%m-%d %H:%M:%S')
UPTIME=$(uptime -p)

# Append the uptime to the log file
echo "$CURRENT_DATE - Uptime: $UPTIME" >> "$LOG_FILE"
echo "Uptime logged at $CURRENT_DATE"

# Define the cron job command
CRON_JOB="0 * * * * $HOME/log_uptime.sh"

# List existing cron jobs
echo "Current Cron Jobs:"
crontab -l

# Add the cron job
echo "Adding new cron job:"
echo "$CRON_JOB" | crontab -

# Confirmation of added cron job
echo "New cron job added:"
crontab -l

When this script is run using the ./log_uptime.sh command, here is what the output will be

Conclusion

Scripting in Bash is like giving instructions to your computer to do tasks automatically. This article introduced the basics of Bash scripting, providing practical examples by creating readable scripts. With Bash scripting, you can automate repetitive tasks and manage system operations efficiently.

Your feedback is very important to me. Were the explanations clear? Did the examples make sense? Let me know if there's anything specific you'd like me to cover in more detail. I'm here to ensure I meet your needs.

Thank you for reading!

Hosting a static website on an S3 bucket using Amazon CloudFront

Florence Okoli — Sat, 11 May 2024 20:27:55 +0000

Imagine you're an aspiring photographer, eager to share your stunning portfolio with the world. You've spent countless hours perfecting your website, featuring captivating images that showcase your talent. And you want viewers from across the globe to visit your website and explore your work. Here is where Amazon S3 bucket and CloudFront come in.
Here is what happens when you deploy your photography website using Amazon S3 bucket and CloudFront. S3 securely stores your high-resolution images and website files in a bucket, while CloudFront ensures that these objects are delivered swiftly to visitors worldwide.
In this guide, we will host a static website on an Amazon S3 bucket(private bucket) but with a public read policy assigned, using CloudFront for Content Delivery Network.

Introduction

Static Website

A static website is a type of website that presents fixed content to users, using basic web technologies. It is lightweight, fast-loading, and easy to maintain. A static website consists of only client-side technologies such as HTML, CSS, and JavaScript. It doesn't require a server to generate or serve content dynamically.

Amazon S3

An Amazon S3 (Simple Storage Service) bucket is a fundamental component of Amazon Web Services (AWS) that provides scalable object storage in the cloud. An Amazon S3 (Simple Storage Service) bucket serves as a fundamental storage container within the S3 service.

Amazon CloudFront

Amazon CloudFront is a content delivery network (CDN) service provided by Amazon Web Services (AWS). Its primary function is to deliver content, such as web pages, videos, images, and other static or dynamic assets, to users with low latency and high transfer speeds.

By integrating these two services, you can easily store your website's content on Amazon S3 and deliver it quickly to your users using CloudFront's content delivery network (CDN)

Prerequisite

An AWS account
Files or folders for your static website. I used this template here

Follow the steps below to host a static website on an S3 bucket using CloudFront.

Step 1. Create an Amazon S3 bucket

Select the general purpose type for your bucket and a unique name for your bucket. If the name is not unique, you won't be able to create a bucket.

Leave all other settings on default. Scroll down and click on Create Bucket.

Once the bucket has been successfully created, click on view details or your bucket name to view the details of the bucket created.

Step 2. Upload files into the S3 bucket

In the bucket overview page, under the objects tab, click on upload to upload the files/folders for your website.

Drag and drop your files or add them as files/folders.

Scroll to the end of the page and click on upload.

Once the upload has been successful as seen in the image below, close the page.

Step 3. Create a CloudFront Distribution for content delivery

On the AWS management console, search for Cloudfront and click on it. Then proceed to create a CloudFront distribution

Next, enter an origin name. It should be the same as the name you have as your bucket. Proceed to create a new Origin Access Control.

The reason for introducing Origin Access Control is to restrict access to the bucket. Remember we are trying to make our S3 bucket private right? The Origin Access Control will do that for us.

See the image below:

Set your WAF to Do not enable security protection since this is for practice.

Leave every other setting on default and proceed to create your distribution

To complete the distribution configuration, copy the policy and click on Go to S3 permissions to update policy

On the permissions tab under your bucket, scroll to bucket policy and click edit. Then paste the policy. Here is what it should look like

{
        "Version": "2008-10-17",
        "Id": "PolicyForCloudFrontPrivateContent",
        "Statement": [
            {
                "Sid": "AllowCloudFrontServicePrincipal",
                "Effect": "Allow",
                "Principal": {
                    "Service": "cloudfront.amazonaws.com"
                },
                "Action": "s3:GetObject",
                "Resource": "arn:aws:s3:::florence-okoli/*",
                "Condition": {
                    "StringEquals": {
                      "AWS:SourceArn": "arn:aws:cloudfront::xxxxxxxxxxxx:distribution/E1FC6K30Z0Z15Y"
                    }
                }
            }
        ]
      }

Save changes and proceed to your CloudFront page to copy your Distribution domain name. Paste it on your browser and add /index.html to it. Make sure to use your Distribution domain name.

Finally, the outcome of your page should look like this

To avoid incurring charges on AWS, delete the resources you used in this guide, including S3 buckets and the CloudFront Distribution.

Conclusion

Congratulations on successfully hosting your static website with Amazon S3 and CloudFront!
By combining the benefits of storage durability with the global performance optimization of a content delivery network (CDN), you have created a fast and reliable website for users across the world to enjoy.
By configuring your CloudFront with an Origin Access Identity (OAI), you have ensured that your S3 bucket remains private while delivering content swiftly and securely.

How to host a web page with Apache

Florence Okoli — Mon, 29 Apr 2024 15:41:49 +0000

Deploying websites on cloud servers has become a standard practice due to its scalability, flexibility, and accessibility. This article delves into the process of hosting a custom web page on Amazon Web Services (AWS) using Apache as the web server and Ubuntu as the operating system.

Table of Contents

Introduction
Set up EC2 Instance
Install Apache webserver
Deploy your custom web page.
Conclusion

- Introduction
The Apache web server is like a reliable backbone that confidently handles the traffic powering websites and applications worldwide. Its versatility goes beyond simply hosting web pages. It is a powerhouse of features designed to keep your online presence secure, performant, and easily customizable.
In other words, Apache is a widely used open-source web server software that serves web content over the internet with key functionalities such as HTTP protocol handling, content delivery, virtual hosting among others. Apache is also highly compatible with various operating systems (e.g., Linux, Unix, Windows)
This article provides a detailed guide on how to host your custom web page with Apache.

Let's begin!

- Set up EC2 Instance
Log in to your AWS console. On the search bar, type in EC2. On the EC2 dashboard, scroll down and proceed to launch an instance.

Choose a name for your EC2 instance

Proceed to select your AMI(Amazon Machine Image). For this article, we will select the Ubuntu AMI.

Scroll down to generate your key pair. We need it to be able to connect to the terminal. If you already have a key pair, you can use it at this point.

Let's create a key pair. Choose a name for your key pair, select the key pair type and proceed to create it.

On the security group settings, set the SSH, HTTPS and HTTP to allow traffic from anywhere and also from the internet.

Leave every other setting on default and proceed to launch your instance.
Once the EC2 instance has been launched successfully, you will see 2/2 checks passed underneath the status check.

Next, click on the instance ID

And connect via the EC2 Instance Connect.
See the images below

Take note of the public IP address.

- Install Apache Web Server
Once you have connected and are in the terminal, run this command first to update your packages and dependencies.
sudo apt update

Next, install apache2.
sudo apt install apache2 -y

The "-y" flag in the command above instructs the package manager to proceed with the installation without asking for confirmation. In other words, it bypasses the user's input during installations.

- Deploy your custom web page
i. Let's install git since we will be cloning a Github repo for this article.
sudo apt install git

ii. Create a directory. This directory will be the location where you clone your Github repo. I'm using Florence as my directory, you can use any name of your choice.

mkdir Florence

Let's change our directory to the one we just created.
cd Florence/

iii. Let's initialize git in the Florence directory.
git init

iv. Let's clone our GitHub repository. This is the link to my GitHub repository.

See the image below on how to copy the link.

To clone the GitHub repo
git clone https://github.com/WendyOkoli/AltSchool-Assignment-3

iv. Let's create another directory but this time the directory will store web server files like index.html, index.css, etc.
To do this, let's run this command
sudo mkdir /var/www/FlorenceOkoli
Whatever name you choose to call your directory, please note that the '/var/www/'should be in it for it to achieve the purpose of storing web server files.

v. Let's copy the content of our 'Florence' directory into the one we just created.
sudo cp -R ./* /var/www/FlorenceOkoli

Here's a breakdown of the command:

sudo: This stands for "superuser do". This command allows you to run other commands with administrative (root) privileges. It's necessary for commands that change system settings or modify system files, like this one.

cp: This is the command to copy files and directories.

-R: This option tells cp to copy directories recursively, meaning it will copy all the files and subdirectories within any directory you specify.

.*: This is a wildcard that matches all files and directories in the current directory.

/var/www/FlorenceOkoli: This is the destination directory where the files and directories will be copied.

vi. Let's create a new file named FlorenceOkoli.conf
sudo touch /etc/apache2/sites-available/ForenceOkoli.conf

The command sudo touch /etc/apache2/sites-available/FlorenceOkoli.conf creates a new empty file named FlorenceOkoli.conf in the /etc/apache2/sites-available/ directory.
This is the first step in setting up a new web page with Apache.

vii. Let's create a copy of the default Apache site configuration file and name it FlorenceOkoli.conf.
To do this, let's run the command below
sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/FlorenceOkoli

viii. Now that the FlorenceOkoli.conf file has been created, let's edit it to add the configuration of our new site.

sudo nano /etc/apache2/sites-available/FlorenceOkoli.conf

Your conf file should look exactly like the image below. Edit the DocumentRoot to be /var/www/name of your conf file

Save your file and exit.

ix. Enable the FlorenceOkoli.conf file and disable the 000-default.conf file

First, enable the FlorenceOkoli.conf file
sudo a2ensite FlorenceOkoli.conf

Then disable the 000-default.conf file
sudo a2dissite 000-default.conf

When these commands are run, it enables the site in the FlorenceOkoli.conf file and disables the site in 000-default.conf file.

To activate these new configurations in the conf file, run this command:

sudo systemctl reload apache2

Finally, on your web browser where you have the displayed Apache web page, reload it and you will see your custom web page displayed.
If you used my GitHub repo, the output of your web page should look like the image below:

As soon as you are done following this guide, please terminate your EC2 instances to avoid incurring costs from AWS. Let the images below guide you on how to terminate your instance.

Go back to your console where you have your instance ID. Expand the Instance state box, click on terminate instance and follow the prompt.

Once this is done, you will find a pop-up like the image below to show that your instance has been successfully terminated.

- Conclusion

Congratulations on successfully hosting your custom web page using Apache on AWS! In this guide, we covered the essential steps to set up an EC2 instance, install an Apache web server, and deploy a custom web page. By leveraging cloud infrastructure and open-source tools like Git and Apache, you've created a scalable and accessible platform for showcasing your web page.

Remember to terminate your EC2 instance to avoid unnecessary costs. Follow the provided steps to gracefully shut down your resources and manage your AWS environment efficiently.

I encourage you to explore further with Apache and AWS, experiment with different configurations, and customize your web hosting setup to meet your specific needs. Your feedback is valuable to me- please feel free to share your thoughts and experiences with this guide. I'm here to assist and improve based on your insights.

Thank you!

SMTP & mailutils: How to send your mails via the Linux terminal.

Florence Okoli — Sun, 28 Apr 2024 22:08:10 +0000

Table of Contents

Introduction
Prerequisite
Generate Google App password
Launch your EC2 Instance
Configuration of SSMTP
Write and send your mail
Conclusion

1. Introduction

Imagine being able to compose, attach files and send emails directly from your CLI using a few concise Linux commands. Well, the Linux terminal offers a streamlined and efficient alternative for sending emails using mailutils and the Simple Mail Transfer Protocol (SMTP).

What is SMTP?
SMTP stands for Simple Mail Transfer Protocol. It is a protocol used by email servers to send and receive email messages over the Internet. For instance, the email you send is transferred over the internet from one server to the other using SMTP.

What is mailutils?
The mailutils is a set of versatile utilities that manages emails directly from the CLI or Linux terminal using SMTP and other protocols. Some of the utilities include:
mail: This utility allows you to read and send emails interactively from the command line.
movemail: A utility that moves mail from one location to another.
frm: A utility to list the subject lines of email in a mailbox.
readmsg: A utility to read and print messages.

This article will provide a guide on how to send mail seamlessly via the Linux terminal using SMTP and mailutils.

Now, let's get started.

2. Prerequisite

For this article, you will need:
i. A Google account for your app password generation
ii. A Linux terminal. I used the AWS console. You can sign up for a free 1yr tier account here

3. Generate Google App Password

On your Google account, locate the settings icon and click on manage your Google account. Take a look at the image attached below:

Next, go to the security settings and turn on your 2-step verification.

Scroll down the 2-step verification page and click on the App passwords. Type a name for your app and a password will be generated automatically. Make sure to copy and save this password as we will need it later.
See the images attached below:

4. Launch EC2 Instance

Once you log in on your AWS console, in the search bar, type EC2 and click on EC2. Click on instance and choose a name for your instance. See image below

Select your AMI. For this article, we will use the Ubuntu AMI. So, go ahead and select your Ubuntu AMI.

Click on Launch instance.

Next, click on instance ID. See the image below

Then connect to the terminal

5. Configuration of SMTP

i. On your terminal, run sudo apt update

This command is run before installing new software with apt install to ensure you get the latest versions of packages and all their dependencies.

ii. Install mailutils
sudo apt update mailutils

Please note that while the installation is running, a postfix configuration will pop up, select the internet site option using your arrow keys and then click ok to finish up with the installation.

iii. Install SSMTP

Why install SSMTP?

SSMTP is a simple mail transfer agent (MTA) used to send emails from a Linux system. In other words, it forwards emails to another SMTP server for delivery.

To install SSMTP
sudo apt install ssmtp

iv. Configuration of SSMTP file
To configure the ssmtp file, sudo nano /etc/ssmtp/ssmtp.com

With the arrow keys, edit your ssmtp configuration file to look exactly like the images attached below

In this configuration file,
Your root should be your email address.
Your AuthUser should be your email address.
Your AuthPass should be the 16-character string generated from the app password in your Google account. When typing it in, remember not to include the spaces.
The rewriteDomain should be gmail.com, but if you are not using Gmail's SMTP server to send your email, replace gmail.com with your domain.
Lastly, uncomment the FromLineOverride as shown in the image above.
Save your file.

6. Write and send your mail

To send your mail, run the command below
echo "I'm a Cloud Engineer" | mail -s "Hello there!" your email address

Once this is done, check your Gmail to see the mail.

This is how to use SMTP and mailutils to send emails from the Ubuntu terminal.
As soon as you are done following this guide, please terminate your EC2 instances to avoid incurring costs from AWS. Let the images below guide you on how to terminate your instance.

Go back to your console where you have your instance ID. Expand the Instance state box and click on terminate instance

Once this is done, you will find a pop-up like the image image below

6. Conclusion

Congratulations on successfully setting up your Linux terminal to send emails using SMTP and mailutils! You've learned how to configure your environment step by step, from generating a Google App password to launching an EC2 instance and configuring SSMTP.

Sending emails from the command line can be a powerful and efficient way to handle communications, especially in automated scripts or remote environments. By following this guide, you've gained valuable insights into how SMTP works and how to leverage it within your Linux terminal.

Your feedback is important to me! If you encounter any issues or have suggestions for improvement, please don't hesitate to share your thoughts. Your insights can help refine this guide and make it even more helpful for others.