Forem: Amanda Igwe

AWS VPC PROJECT

Amanda Igwe — Sun, 28 Dec 2025 12:05:23 +0000

OVERVIEW OF THE AWS VPC PROJECT
You heard of cloud, but you do not understand what happens to your confidential data and how the system works. I will break down and explain the architecture that handles everything for you in the cloud.

The VPC (Your Private Network) A VPC is like your own private space on AWS. Nothing gets in or out unless you allow it.
Two Availability Zones (Backup Locations) Your setup runs in two separate data centers. If one goes down, the other keeps working. Your website stays online.
Public Subnets (The Front Door) These are the parts that connect to the internet. Two things live here:
NAT Gateway: Lets your servers download updates from the internet. Blocks unwanted traffic coming in.
Load Balancer: Spreads visitor traffic evenly across your servers. No single server gets overloaded.
Private Subnets (Where Your Servers Live) Your actual servers sit here, hidden from the internet. Visitors cannot reach them directly. They must go through the load balancer first.
Auto Scaling Group (Automatic Server Management) Adds more servers when traffic increases. Removes servers when traffic drops. You only pay for what you need.

How Traffic Moves

Visitor arrives at the load balancer
Load balancer sends them to a healthy server
Server handles the request
Response goes back to the visitor

S3 Gateway Endpoint (Fast File Access)
Your servers need files from S3 storage. This creates a direct private connection to S3. Faster and more secure than going through the internet.

BENEFIT
Servers are protected behind multiple layers. Traffic spreads evenly. If something breaks, backups take over automatically.

Now you understand this architecture, let’s begin with building it!

Step1: SET UP

Go to AWS Console
Search for VPC
Click on Create VPC
Select VPC and more
Give a name to your project - I used “aws-prod-demo”
Check the following
- Number of Availability Zones - 2
- Number of public Subnets - 2
- Number of private Subnets - 2
- Nat Gateways - choose zonal - 1 per AZ
- VPC endpoints - None
Click create vpc

Success! we have created our VPC

View your VPC .

Note: Give it few minutes to be available

Step 2: Create Auto Scaling Group

Auto scaling group helps to scale the servers to any number of ec2 instances automatically pending the traffic it receives. so it can automatically add extra 2 instances to our default 2 if the need arises.

Go to your AWS Console, search for EC2
Go to Auto Scaling Group
Create Auto Scaling Group

First create a launch template
Name your template and description

Select Ubuntu as the AMI

Select t2.micro as the instance type - this is for free tier AWS accounts

Create a key pair, if you have none.
I used aws_logins, maintained default settings and created it.
Save your key pair you will need it (automatically downloads when created)
Select that key pair ( I selected the aws_login)
Create security group
Name and describe it (I used aws-prod-demo-sg as the name, and “Allow ssh access” for description)

Click on the Inbound Security Group Rules to set up
We create this by selecting ssh and source type as anywhere
Add another rule for the app we are deploying
Select “custom TCP” and set the port as “8000” and source as “Anywhere”
Click launch template

We have successfully created the template

Now go back to creating the Auto Scaling group
Name your Auto scaling group and attach the template we created
Click next

Choose your VPC
Select the two private subnets as they are the ones with our application which needs the auto scaling

Keep desired capacity as 2 , minimum as 1 and maximum as 4 ( this maximum might come handy during peak seasons where demand is high, causing high traffic to the servers)
Click next

You can add SNS notification to send you an email when this happens but for now I skipped it ( I have other projects showcasing how to use SNS)
Review and create.
We have successfully created our Auto Scaling group

To confirm that our instances are created and running, let’s check our EC2 instances.

On your AWS Console, search for EC2
Go to instances to confirm

We can confirm our EC2 instances are running.

Step 3: Accessing the Private Subnet using Bastion Host

A bastion host is like the middleman for accessing our application in the private subnet. It simply means that as we are trying to secure unauthorised access to our private subnet, we need to mask the address to securely interact with the applications there and the internet. The Bastion host, as the middleman, says, " Alright, I can stand in as the public subnet to communicate with the private subnet.

Go to EC2
Click on instances
Click on Launch Instances
Name it - ”aws-prod-demo-bastion-host”
Select Ubuntu as the OS
Select the t2.micro
Select our key pair as aws_login

In Network Settings, click edit
Select our own VPC that we created
By default, it will select the private 1 subnet; change this to the public 1 subnet. (The bastion host should be public as it masks our private subnet ip address by assigning a public ip address for public use.
Select Enable for Auto-assign public IP
Create security group
Name and put a description

Select launch Instance

We have successfully launched our bastion-host instance.

Step 4: SSH into the EC2 Instances

Now we have to ssh into the bastion host instance and also into our private instances. Let’s go on and communicate with these through our local machine.

We have to do this using our key value pair “aws_logins” we created (the one that automatically downloaded into our system, remember) it will serve as our login details to access these instances.

Go to EC2 instances , click on the bastion host instance
Copy the public IPv4 address
open your terminal to run the following commands

# check for where the .pem file aws_login is located at. Mine is at Downloads 

ls                                  ----# to find Downloads folder
cd Downloads                         ------- # to change into the folder

ls | grep aws_login                    ---------# to grab the .pem file

#securely copy the file and insert it into our bastion host.

 scp -i /Users/igweamanda/Downloads/aws_login.pem  /Users/igweamanda/Downloads/aws_login.pem ubuntu@34.207.137.190:/home/ubuntu
 Press Enter 
# Please change the 34.207.137.190 to your own IP address by copying the bastion host public subnet address

# Now you may experience an error based on public key. To fix this use the command below

/chmod 400 /Users/igweamanda/Downloads/aws_login.pem   ---#this change the mode and secure the key permissions

Press Enter
# recopy this previous command and paste again to copy the .pem file into the instance

 scp -i /Users/igweamanda/Downloads/aws_login.pem  /Users/igweamanda/Downloads/aws_login.pem ubuntu@34.207.137.190:/home/ubuntu
Press Enter

We have successfully copied the pem file into the bastion host.

Let’s ssh into the bastion host now

# use the command to ssh into the bastion host

ssh -i aws_login.pem ubuntu@34.207.137.190         #change to your bastion ip address

Press Enter

We have successfully ssh into the bastion host instance!

it is time to use this as our middleman to ssh or log in securely into our private subnets to access files.

Go back to EC2 instances
Open any of the private instances
Copy the Private IP address

Come back to the Terminal
SSH into it

ssh -i aws_login.pem ubuntu@10.0.128.198      #which is our private ip address we copied

From the image above, you can see that we are now logged into our private subnet via our bastion host as a middleman.

Let’s create a file and run it the server with python

# Create an index.html file 

ubuntu@ip-10-0-128-198:~$ vim index.html

# press i to insert your file and :wq! to save and exit

# run the server using python 

ubuntu@ip-10-0-128-198:~$ python3 -m http.server 8000

# our application is running on this private instance successfully 
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Step 5 : Application Load Balancer

We have our servers running and can communicate or securely log into them. As best practice, we need to consider balancing traffic across both instances. This is the duty of the Application Load Balancer.

Go to AWS Console
Open EC2
Go to Load Balancers
Select the Application Load Balancer

Name it — I used “aws-prod-demo-lb
Select Internet Facing > IPv4

Choose the VPC we created from the drop-down
In Availability Zones, Select the public subnets.

Select our vpc security group
Create Target group > instances
Name it - aws-prod-demo-tg
Put the protocol at HTTP and Port at 8000
Choose our VPC
Leave the default settings > next

Select the two private instances only (do not select the bastion-host)
Click include as pending
Click Create Target Group

Go back to the load balancer to continue creating it
Attach the target group we have created
Click on the refresh button close to it to see the target group we created
Create Load balancer

Give it few secs and refresh to see the active status

While this is successful, we have an error in the protocol port as “not reachable” remember we used http :80 so let’s fix this.

Go the security tab
Click on our already created security group
Click on Edit inbound rules
Add a new rule for port HTTP : 80
Source Anywhere : IPv4
Save
Come back to the load balancer, refresh it.
Error is fixed.

Step 6: Testing

Now that everything has been set, it is time to test the app in our private subnet and see it publicly after applying all security rules and features.

Copy the DNS address
Paste on your browser

Success!

ERRORS ENCOUNTERED

Well, I had a major roadblock while working on this project. I received a 502 Bad Gateway, and my instances were unhealthy after the health check.

SOLUTIONS

Make sure your index.html file was actually saved. I realised during the project implementation that my file wasn’t saved so nothing was outputting.
If you are like me who made this tiny mistake, refresh the instances again to correct the health checks
Give your load balancers time to provision and become active.

In my case, I also had to check my server from the terminal to make sure the ports were communicating. I received a 200 status, which means yes!

Then refreshed the target group. You can see that one of the instances is healthy as it is the instance where the server is running on.

This project was eye-opening and a lot of struggles reading and troubleshooting. I had my fair share of tears, haha!

If you try out this project, do let me know your experience too. Hopefully, my article makes it quite easier for you!

DELETE!

Please remember to delete all resources to avoid bearing costs enough to buy a Rolls-Royce! I have an article on my Medium page that helps you do this as well.

Before you can delete the VPC, you must delete the Auto Scaling group, terminate your instances, delete the NAT gateways, and delete the load balancer.

Day 30/ 30 Days of Linux Mastery: Mastering 'for', 'do', 'while', and 'case' Statements in Shell Scripts

Amanda Igwe — Sat, 24 May 2025 10:05:06 +0000

Introduction
What Are Loops and Case Statements?
Core Loops and Case Statements Syntax
Real-World Scenario: Loops and Case Statements
Conclusion
Let's Connect

Introduction

Welcome back to Day 30 of this practical Linux challenge! Part 4/4 of our beginner shell scripting series for RHEL 9.

If you have ever wanted your Linux system to repeat tasks, check conditions, or handle input differently based on options, then you are ready to meet three of the most powerful tools in shell scripting: for loops, do, while loops, and case statements.

What Are Loops and Case Statements?

Loops help you repeat commands without having to type them repeatedly.

Case statements help you respond to different inputs, like choosing a different action depending on the value a user gives.

In Bash, we use:

for loop: repeat something a certain number of times

do: Starts the loop block

while loop: repeat while something is true

case: handle multiple possible inputs

Core Loops and Case Statements Syntax

The for and do statement syntax;

for item in 1 2 3
do
   echo "Number: $item"
done

What they do;

for item in 1 2 3: This means we are looping through the numbers 1, 2, and 3.

do: This begins the block of code we want to repeat.

done: This ends the loop block. The loop knows to stop after this.

Think of do as “start the loop task” and done as “finish the loop task.

The while loop statement syntax;

count=1
while [ $count -le 3 ]
do
   echo "Count is $count"
   ((count++))
done

What they do;

while [ $count -le 3 ]: This checks if count is 3 or less.

do: Starts the loop block.

((count++)): Adds 1 to count each time.

done: This ends the loop block. The loop knows to stop after this.

So, the loop runs until count becomes 4.

The case statement syntax;

echo "Enter a fruit:"
read fruit

case $fruit in
   apple)
      echo "Apples are red or green.";;
   banana)
      echo "Bananas are yellow.";;
   *)
      echo "Unknown fruit.";;
esac

What they do;

read fruit: User types a fruit name.

case $fruit in: Begins checking value.

apple), banana): These are the options.

*): Wildcard — matches anything else.

;;: Ends each option’s command

esac : simply means case spelt backward. Used to end a case statement.

Real-World Scenario: Loops and Case Statements

Let’s write a for loop script that checks for a file and let us know if it exists or not.

Open your terminal, create a file and add this line into it

vim forloop.sh   # note that script files end with a .sh

#!/bin/bash

# FOR LOOP EXAMPLE


echo "FOR loop - Print numbers 1 to 5:"
for i in {1..5}
do
  echo "Number: $i"
done

# Save and exit using:wq!

Now, give the script permission to run

chmod +x forloop.sh     # this enables it to be executable

Verify the file has the execute permissions

ls -ltr forloop.sh

Run the script on your terminal

./forloop.sh

Let's practice the while scenario
Create a script file, paste the code, or you can write your own now, then grant it the executable permissions.

#!/bin/bash


# While loop Example


echo " WHILE loop - Count down from 3:"
count=3
while [ $count -gt 0 ]
do
  echo "Countdown: $count"
  count=$((count - 1))
done


# Save and exit using:wq!

Let's practice the case scenario
Create a script file, paste the code, or you can write your own now, then grant it the executable permissions.

#!/bin/bash

echo "CASE statement - Choose an option:"
echo "Enter a fruit: apple, banana, or mango"
read fruit

case $fruit in
  apple)
    echo "You chose Apple"
    ;;
  banana)
    echo "You chose Banana"
    ;;
  mango)
    echo "You chose Mango"
    ;;
  *)
    echo "Unknown fruit. Please pick from apple, banana, or mango."
    ;;
esac

# Save and exit using:wq!

Conclusion

And that’s it!

You have now learned how to use for, do, while, and case statements in your shell scripts. These tools help you make your scripts smarter, more flexible, and powerful.

Take your time to practice each one, experiment on your terminal, and slowly build confidence. The more you use them, the easier it becomes.

Keep going, you are doing great!

If this is helpful to you, feel free to bookmark, comment, like and follow me!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 29/ 30 Days of Linux Mastery: if Statements in Shell Scripting for Beginners

Amanda Igwe — Fri, 23 May 2025 09:05:03 +0000

Introduction
What is an if statement?
Core if Statement Syntax
Real-World Scenario: if Statement
Conclusion
Let's Connect

Introduction

Welcome back to Day 29 of this practical Linux challenge! Part 3 of our beginner shell scripting series for RHEL 9.

We are looking at the Conditional statements like the if elif then else statements.

They allow your script to make decisions based on a condition.

What is an `if` statement?

Have you ever made a decision based on a condition? Let's say it is the weekend, and you are planning your rest. You decide that if it rains, then you will stay indoors and watch your Netflix, else you will go out to the cinema.

Now because you really don't want to go out you add more conditions like if it rains, then you will stay indoors and watch your Netflix, elif its cloudy, then you have to cancel leaving the house, else you have no choice but go out to the cinema.

Simple logic, right? But you have just written a script with conditional statements.

Core `if` Statement Syntax

The if and elif statement syntax;

# for if statement 

if [ CONDITION ]
then
    # do something
else
    # do something else
fi


# for elif statement

if [ CONDITION ]
then
    # do something
elif [ CONDITION ]
then
    # do something again
else
    # do something else
fi

Each part explained:

if [ CONDITION ]: We are checking if something is true

then: If it is true, do this...

elif [ CONDITION ]: We are checking if another condition is true

else: If it is not true, do this instead...

fi: This is just if spelt backwards, it tells bash that you're done with the condition.

Real-World Scenario: `if` Statement

Let’s write a conditional script that checks for a file and let us know if it exists or not.

Open your terminal, create a file and add this line into it

vim checkfile.sh   # note that script files end with a .sh

#!/bin/bash

if [ -f lines.txt ]; 
then
    echo "File exists."
else
    echo "File does not exist."
fi

# Save and exit using:wq!

Flags Meaning
-f : Is it a regular file?
-d : Is it a directory?
-e : Does it exist (file or dir)?
-z : Is the string empty?

Now, give the script permission to run

chmod +x checkfile.sh     # this enables it to be executable

Verify the file has the execute permissions

ls -ltr checkfile.sh

Run the script on your terminal

./checkfile.sh

# Now edit the file and alter the name of the file to a file that doesn't exist.

Let's practice the elif scenario
Create a script file, paste the code, or you can write your own now, then grant it the executable permissions.

#!/bin/bash

echo "Enter a number:"
read num

if [ "$num" -gt 100 ]; 
then
    echo "That's a big number!"
elif [ "$num" -gt 50 ]; 
then
    echo "That's a medium number."
else
    echo "That's a small number."
fi

# Save and exit using:wq!

Note;

-gt: means greater than
-lt: means less than

Conclusion

Congratulations!
You just learned how to make your bash scripts smart with if, then, else, and elif. You can now write scripts that react based on conditions.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 30!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 28/ 30 Days of Linux Mastery: Variables and Inputs in Shell Scripting

Amanda Igwe — Thu, 22 May 2025 13:21:29 +0000

Introduction
What are Variables?
How to Use Variables
Real-World Scenario: Shell Scripting
Conclusion
Let's Connect

Introduction

Welcome back to Day 28 of this practical Linux challenge! Part 2 of our beginner shell scripting series for RHEL 9.

Shell scripts become truly useful when they can store data, accept user input, and respond accordingly.

In the previous article, you wrote your first script. Now, let’s make that script interactive by using variables and user inputs.

What are Variables?

A variable is like a labeled box where you can store information for your script to use later.

name="Amanda Igwe"

Here, name is the variable, and "Alex" is the value stored in it.
No spaces between variable name, =, and value!

How to Use Variables

To create a variable

greeting="Hello!"   - # remember no spaces

To use the variable, add a $ before it

echo "$greeting"   # echo means print the variable in greeting

# Output:

Hello!

We have two types of variables;

Local Variables - This refers to the variables that run in your current shell. If you open another shell, it won't work. For example the variable greeting="Hello!" will only work in our current terminal no where else.

# local variable example

myname="Amanda"

echo $myname

Environment Variables - This refers to the variables that is inherited by any child processes or scripts you run from your current session. It can only stop running if the system is rebooted or terminal is closed. (This can also be made permanent by adding it to your .bashrc or .bash_profile file)

# Environment variable example

export myname="Amanda"

echo $myname 

# to check the environment variables 
env

Taking Input from Users with read

Now that you have created your variables, your script will in one way or the other request details or information from your user like their name, age, phone number, home address, etc. To get this input we use read.

echo "What is your name?"    # this prints the question
read name                    # this collects the user's responses
echo "Hello, $name!"         # this prints the user's response inside the variable name

Real-World Scenario: Shell Scripting

Let’s write a script that asks for your name and greets you with the date.

Open your terminal, create a file and this line into it

vim greet.sh   # note that script files end with a .sh

#!/bin/bash

echo "What is your name?"
read username

echo "Hello, $username! Welcome to Amanda's 30 Days Linux Challenge"

echo "Today is: $(date)"

# Save and exit using:wq!

Now, give the script permission to run

chmod +x greet.sh     # this enables it to be executable

Verify the file has the execute permissions

ls -ltr greet.sh

Run the script on your terminal

./greet.sh

Conclusion

By learning how to use variables, collect user input with read, and understand the difference between local and environment variables, you are no longer just running commands; you are interacting with your scripts and making them smarter.

In the next article, we will explore logic-making decisions using if, else, and conditions inside your script.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 29!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 27/ 30 Days of Linux Mastery: Introduction to Shell Scripting

Amanda Igwe — Wed, 21 May 2025 12:08:07 +0000

Introduction
What is Shell Scripting?
Types of Shells
Real-World Scenario: Shell Scripting
Conclusion
Let's Connect

Introduction

Welcome back to Day 27 of this practical Linux challenge!

If you have been following my articles and practicing your commands on RHEL 9, then you are already using the shell!

Now, imagine having the shell perform multiple tasks for you automatically. That is what shell scripting is all about.

What is Shell Scripting?

A shell is a command-line interpreter that lets you interact with the operating system. Shell scripting is the process of writing a series of shell (command-line) instructions in a file that can be executed like a program.

Think of it like creating your own little tool to automate boring or repetitive tasks!

With it, you can:

Automate backups
Monitor system performance
Create users
Set scheduled tasks
Parse logs
Deploy services

Types of Shells

Linux systems support several types of shells. The most commonly used ones include:

Shell	Description
`sh`	The original Bourne shell. Simple, but limited.
`bash`	Bourne Again Shell – the most widely used and powerful shell on Linux (and the default on RHEL).
`zsh`	Z shell – known for features like auto-completion and customization.
`ksh`	Korn shell – used in enterprise environments.
`fish`	Friendly interactive shell – user-friendly and great for beginners.

For this tutorial, we will use bash, as it is the default on RHEL 9.

Real-World Scenario: Shell Scripting

Let's create and run our first shell script.

Open your terminal, create a file and this line into it

vim hello.sh   # note that script files end with a .sh

#!/bin/bash    # this is called shebang /bin/bash must always start the line in every script you are writing


echo "Hello, world! This is Amanda's first shell script in RHEL 9!"    # echo prints the message as an output on your terminal.

# Save and exit using:wq!

Now, give the script permission to run

chmod +x hello.sh     # this enables it to be executable

Verify the file has the execute permissions

ls -ltr hello.sh

Run the script on your terminal

./hello.sh

Conclusion

Shell scripting might sound scary at first, but once you try it, you will wonder why you didn’t start sooner. Even with just 3 commands, you can automate tasks that make your life easier.

In RHEL 9, this is one of the most useful beginner skills. Just remember: start simple, run often, and break things (on purpose lol).

See you in the next article, where we dive deeper into shell scripting!

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 28!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 26/ 30 Days of Linux Mastery: Storage Management in RHEL 9

Amanda Igwe — Tue, 20 May 2025 14:52:04 +0000

Introduction
What is Storage Management?
Core Storage Management Commands
Real-World Scenario: Storage Management Commands
Conclusion
Let's Connect

Introduction

Welcome back to Day 26 of this practical Linux challenge!

In this post, we will cover Storage Management in RHEL 9, how to handle new storage devices, partition them, format, mount, and make them persistent.

If you are working with servers or cloud VMs, storage is something you will definitely encounter, whether it is adding more space or organizing existing disks.

What is Storage Management?

Store management comes handy whether you are:

Adding an EBS volume on AWS,
Attaching a new disk to a VM,
Or just learning how Linux handles storage.

You will need to understand how to identify new disks, partition them, format, mount, and persist them in your system.

Core Storage Management Commands

More commonly used Core Storage Management Commands options are listed in the table below.

Storage Command	Use
`lsblk`	Lists all block devices
`fdisk`	Create or manage partitions (for MBR disks)
`parted`	Create or manage partitions (especially GPT disks)
`mkfs.ext4`	Format partition with ext4 filesystem
`mkfs.xfs`	Format partition with XFS filesystem
`mount`	Mount a file system
`umount`	Unmount a file system
`blkid`	Displays UUID and type of block devices
`df -h`	Show mounted disk usage in human-readable format
`vi /etc/fstab`	File to make mounts persistent

Real-World Scenario: Storage Management Commands

You are a Junior Linux SysAdmin and your team adds a new virtual disk /dev/sdb to your RHEL 9 server. You have been asked to format and mount it to /mnt/backups.

Check Existing Disks

lsblk

Mine is already partitioned and mounted. but if yours isn't then follow these steps.

Now, create a partition

fdisk /dev/sdb      - # you can do this only using root, add sudo before the command if you are not

# type n to create a new partition, accept defaults and w to write changes

lsblk    - # to see the new disk created

Format the Partition

mkfs.ext4 /dev/sdb1    # depending on the file extension you want, you do .xfs as well

You can go ahead and create the Mount Directory

mkdir /mnt/backups

We go on to mount the partition we created earlier

mount /dev/sdb1 /mnt/backups

df -h   - # to verify it mounted

Let's make Mount persistent.

When you manually mount a disk using the mount command, it works only until the system reboots. After a restart, the OS forgets about your mount, and your disk won't be accessible from that mount point anymore.

So we say that the mount is temporary, not persistent.

To make sure your disk stays mounted even after a reboot, you need to tell Linux to mount it automatically every time the system starts.
That’s what we mean by making the mount persistent.

We will first get the UUID of the partition.

blkid /dev/sdb1

Open the fstab file in a text editor like vim

vim /etc/fstab

Scroll down and add this line at the end of the file

UUID=abcd-1234   /mnt/data   ext4   defaults   0   2

What they mean:

UUID=abcd-1234: uniquely identifies your disk (this won’t change across reboots)

/mnt/data: where you want the disk mounted

ext4: the file system type

defaults: standard mount options

0: skip dump (a legacy backup thing)

2: run fsck (filesystem check) after boot, after root file system

Test it before rebooting

mount -a

If no errors, it is successful. After this, even if you restart your system, your disk will stay mounted at /mnt/data.

Before making any changes to /etc/fstab, always back it up. This simple step can save you from system boot issues due to a misconfiguration.

cp /etc/fstab /etc/fstab.bak - # to backup

cp /etc/fstab.bak /etc/fstab  - # to restore if system breaks
mount -a  # to remount

Conclusion

Understanding how Linux handles disks is essential whether you are working with physical servers or managing virtual machines in the cloud.

Feel free to try it out on your own server or VM.

See you in the next article!

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 27!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 25/ 30 Days of Linux Mastery: Disk Management on RHEL 9

Amanda Igwe — Mon, 19 May 2025 14:25:25 +0000

Introduction
What is Disk Management?
Core Disk Management Commands
Real-World Scenario: Disk Management Commands
Conclusion
Let's Connect

Introduction

Welcome back to Day 25 of this practical Linux challenge!

Disk running out of space? Don't panic. Today, we dive into basic disk management using simple and practical Linux commands.

If you have ever seen the dreaded "disk full" error or wondered, "Where did all my space go?" then today’s lesson is for you.

As you grow in your journey as a Cloud System Admin or DevOps engineer, being able to know how to inspect, clean, and manage disk space becomes a **core skill.

What is Disk Management?

Disk space issues are one of the most common problems you will face in production environments. Whether it is logs filling up, unused packages, or large files forgotten, knowing how to find and fix space issues keeps your server healthy and running.

Managing disk space is crucial for:

Keeping your servers running smoothly
Avoiding outages due to full volumes
Debugging space-hungry apps
Mounting extra storage in cloud environments

Core Disk Management Commands

More commonly used Core Disk Management Commands options are listed in the table below.

Disk Management Command	What it Does
`df -h`	Shows available disk space (human-readable)
`du -sh *`	Shows folder sizes in current directory
`lsblk`	Lists block devices like disks and partitions
`mount`	Mounts a filesystem
`umount`	Unmounts a mounted filesystem
`journalctl --disk-usage`	Check journal log size
`journalctl --vacuum-size=100M`	Clear logs down to a specific size
`rm -rf <path>`	Remove unwanted files/directories (use with caution)
`blkid`	Shows UUID and type of a block device

Real-World Scenario: Disk Management Commands

You are running a small RHEL 9 web server, and suddenly you get an alert:

Disk usage at 90%. Clean up space immediately.

Let’s walk through what to do:

First Check Disk Usage.

df -h

Now check what's using the disk space

du -sh /*    - # you can do this only using root, add sudo before the command if you are not

Now you have seen what's eating your space you can open that folder

du -sh /var/*

You can go ahead to delete

rm -rf <directory path>

# or clear caches using 

dnf clean all

Conclusion

Disk management is not just for advanced users; even as a beginner on RHEL 9, you can confidently check, manage, and free up space on your system. These small actions make a huge difference in production environments.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 26!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 24/ 30 Days of Linux Mastery: Networking Commands in RHEL 9

Amanda Igwe — Sat, 17 May 2025 18:27:07 +0000

Introduction
What is Networking in Linux?
Core Networking Commands
Real-World Scenario: Networking Command
Conclusion
Let's Connect

Introduction

Welcome back to Day 24 of this practical Linux challenge! Today, we are diving into networking commands.

Networking is at the heart of everything in Linux, from connecting to the internet, reaching APIs, to managing remote servers.

What is Networking in Linux?

Networking in Linux enables systems to communicate with each other over a LAN, WAN, or the internet by configuring interfaces, IP addresses, routes, DNS, and other related settings.

Imagine you are setting up a cloud server on AWS or managing a VM. You will need to check its IP, confirm connectivity, troubleshoot DNS, or even check which ports are open. These tasks all rely on basic but powerful networking tools.

Core Networking Commands

More commonly used Networking command options are listed in the table below.

Networking Command	Description
`ip a`	Shows all IP addresses assigned to interfaces
`ip r`	Displays the routing table
`ping <host>`	Sends test packets to a host to check connectivity
`nmcli`	Manages Network Manager settings (create, modify, check connections)
`nmcli connection show`	List network connections)
`nmcli device status`	Show status of devices
`nmcli con up <connection-name>`	Activate a connection
`curl <URL>`	Makes requests to a web server and returns response
`ss -tuln`	Shows open TCP/UDP ports and listening services
`hostname`	Show system's hostname
`hostnamectl`	Manage system hostname
`hostname -I`	Displays the IP address(es) of your system
`dig <domain>`	Fetches DNS information for a domain
`traceroute <host>`	Traces the path packets take to reach a host
`ifdown` / `ifup`	Brings network interfaces down/up (used in some RHEL setups)

Real-World Scenario: Networking Command

You just launched your very first RHEL 9 virtual machine (VM) on a cloud platform like AWS, Azure, or GCP. You are supposed to install some packages and set up a web server. But… nothing is loading. You can’t even install updates.

Let's diagnose the problem.

First check the network interface has an ip address .

ip a        # you should see an output like 192.168 .....

Now check your if you have internet access

ping 8.8.8.8  

# If this fails then there is no internet. You can also try 

ip r    # to check the default route

# You should see something like "default via 192.168.1.1 dev eth0" if this does not show then you have your answer to the ping failure

Check Status

nmcli device status     # checks the status 
nmcli device connect eth0   # to connect to internet
ip a   - # to confirm it has connected and active

Let's test a DNS (Domain name server like Google)

ping google.com

# always use Ctrl + C to stop the commands from running

Now test outbound access. If it loads HTML content, your network is up and DNS works!

curl https://www.google.com

Conclusion

Understanding and using networking tools like ip, ping, ss, curl, and nmcli gives you control over your Linux system’s connectivity. You will be able to diagnose problems faster, automate network tasks, and support your team more confidently, especially in cloud environments.

Keep practicing. And remember: The terminal is your friend.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 25!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 23/ 30 Days of Linux Mastery: 'tar' Command

Amanda Igwe — Fri, 16 May 2025 15:09:59 +0000

Introduction
What is the tar Command?
Core tar Commands
Real-World Scenario: tar Command
Conclusion
Let's Connect

Introduction

Welcome back to Day 23 of this practical Linux challenge! Today, we are diving into one of the most useful Linux commands: tar.

When you think of archiving and backing up files, think of tar

What is the `tar` Command?

tar stands for Tape Archive. It is a powerful utility used to create, extract, compress, and archive files or directories into a single file, usually with .tar, .tar.gz, or .tgz extensions.

Core `tar` Commands

More commonly used tar command options are listed in the table below.

`tar` Command	What It Does	Explanation
`tar -cvf myarchive.tar myfolder/`	Creates an archive	`-c` = create, `-v` = show progress (verbose), `-f` = name the archive file
`tar -xvf myarchive.tar`	Extracts an archive	`-x` = extract files from the archive
`tar -czvf myarchive.tar.gz myfolder/`	Creates a compressed archive using gzip	`-z` = compress with gzip
`tar -xzvf myarchive.tar.gz`	Extracts a `.tar.gz` archive	`-x` = extract, `-z` = unzip gzip file
`tar -tvf myarchive.tar`	Lists archive contents	`-t` = list files inside the archive
`tar -xvf myarchive.tar file.txt`	Extracts a specific file	Only pulls out `file.txt` from the archive
`tar -C /target/folder -xvf myarchive.tar`	Extracts to a specific directory	`-C` = change to target directory before extracting
`tar --delete -f myarchive.tar file.txt`	Deletes a file from the archive (non-compressed only)	Removes file.txt from the `.tar` file (Does not work on `.tar.gz`)

Real-World Scenario: `tar` Command

Select a file you wish to archive. Add .tar to the filename.

tar -cvf demologs.txt.tar
ls -lh   # to confirm it compressed

Verify the file is created

 tar -tvf demologs.txt.tar

Restore the tar file.

mkdir demoarchives     - # we create a separate folder to move our archives 

tar -xvf demologs.txt.tar.gz -C demoarchives  - # restores the .tar to original file format 
ls -lh   # to confirm both the original and compressed file are there

Conclusion

By now, you have seen how to create, extract, compress, and manage archives with tar. You also understand the most useful options (-c, -x, -v, -f, -z, -t, --delete) and how to combine them based on what you are trying to achieve.

Keep experimenting in your terminal. Start by archiving test directories and extracting them to specific locations. The more hands-on you get, the more confident you will become. Stay curious. Stay hands-on.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 24!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 22/ 30 Days of Linux Mastery: 'gzip' Command

Amanda Igwe — Thu, 15 May 2025 15:33:04 +0000

Introduction
What is the gzip Command?
Core gzip Commands
Real-World Scenario: gzip Command
Conclusion
Let's Connect

Introduction

Welcome back to Day 22 of this practical Linux challenge! Today, we are diving into one of the most useful Linux commands: gzip.

When you think of compressing any file, think of gzip

What is the `gzip` Command?

gzip stands for GNU zip, a tool used to compress files, making them smaller and easier to store or transfer.

Core `gzip` Commands

More commonly used gzip command options are listed in the table below.

`gzip` Command	Description
`gzip filename`	Compress the file (creates `filename.gz`)
`gunzip filename.gz`	Decompress `.gz` file back to original
`gzip -k filename`	Compress file and keep original
`gzip -r folder/`	Recursively compress all files in a folder
`gzip -d filename.gz`	Same as `gunzip`, decompress file
`gzip -v filename`	Verbose mode – shows compression info

Worthy to note that this command works only for files, not folders.

Real-World Scenario: `gzip` Command

Select a file you wish to compress. Compress using the gzip command. It ends with .gz

gzip demologs.txt

ls -lh   # to confirm it compressed

Now you have seen how it works, let's decompress that .gz file back to the original format.

gunzip demologs.txt.gz

If you notice when we compressed, it did not keep the original file. Now, let's keep the original file and the compressed file.

gzip -k demologs.txt

ls -lh   # to confirm both the original and compressed file are there

Conclusion

Learning gzip might seem simple, but it is a crucial skill in Linux.

Mastering it helps you maintain lean storage and improve transfer speeds.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 23!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 21/ 30 Days of Linux Mastery: 'diff' Command

Amanda Igwe — Wed, 14 May 2025 13:35:15 +0000

Introduction
What is the diff Command?
Core diff Commands
Real-World Scenario: diff Command
Conclusion
Let's Connect

Introduction

Welcome back to Day 21 of this practical Linux challenge! Today, we are diving into one of the most useful Linux commands: diff.

Knowing how to compare files is a core skill that shows attention to detail and debugging awareness.

What is the `diff` Command?

The diff command helps you compare the contents of two files line by line. It’s essential for:

Verifying configuration changes
Reviewing file versions
Debugging or troubleshooting mismatches
Pre-deployment audits

This is especially useful in production environments where systems grow large and messy fast.

Core `diff` Commands

Basic Syntax for diff is

diff [options] file1 file2

More commonly used diff commands options are listed in the table below.

`diff` Options	Description
`-y`	Displays output side by side
`-c`	Produces a context diff (shows surrounding lines)
`-u`	Unified diff format (commonly used for patches)
`--color`	Adds color to differences in output
`-r`	Recursively compares directories
`--suppress-common-lines`	Used with `-y`, hides lines that are the same

Real-World Scenario: `diff` Command

We will create a file, then copy it as a backup and modify it by adding more words inside.

Compare the files using diff

diff demologs.txt demologsbackup.txt

Let's use side-by-side comparison to view the files easily

diff -y demologs.txt demologsbackup.txt

you can see the last line that was included.

Use Unified Format for Patching

diff -u demologs.txt demologsbackup.txt > patch.diff

This creates a .diff file that can be used to patch another demolog file using patch. Shows you the modification and versions of both files.

Conclusion

Whenever you need to check a file and compare with older versions to see changes or modifications, always think of using the diff command!

The diff command is not flashy, but it is one of those must-know tools that gets real work done. Whether you are reviewing configs, debugging a deployment, or managing drift in production, diff helps you stay in control.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 22!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Day 20/ 30 Days of Linux Mastery: Recover/Rescue Root Password in RHEL9

Amanda Igwe — Tue, 13 May 2025 13:51:13 +0000

Introduction
Step-by-Step Guide on Recovering the Root Password
Conclusion
Let's Connect

Introduction

Welcome back to day 20!. Today’s focus is on how to recover or rescue the forgotten root password in RHEL 9.

Yes, it happens that one might wake up one day and you can no longer remember your system root password. So, what do you do as the Linux System Administrator?

Let’s get into it!

Step-by-Step Guide on Recovering the Root Password

Start your virtual machine (I am using VirtualBox) or type reboot in your console.

Once it is about to boot, quickly use the up and down arrow keys to select the option with 'rescue' in it.

Hit the letter 'e' on your keyboard quickly on the GRUB boot entry screen to enter edit mode. (This is for editing the parameters)
Look for the line starting with linux or linux16. Now, at the end of that line, add the following inside.

rd.break console=tty1 selinux=0

With this we do not need to do the 'touch /.autorelabel' that is creating the autorelabel file in the root directory anymore.

Click Ctrl+X to start (Press Enter for maintenance if prompted, to see the shell)

Now you on the shell, you need to remount and give it read/write mode. Type this prompt

mount -o remount,rw /sysroot    - # press enter
chroot /sysroot               - # The root we want to reset password for. Now press enter.

passwd    -                # Type this and press Enter, you will be prompted to enter the new password and retype it again to confirm it.

Now type exit
Type exit again
The system will boot and request you to login. Now login as the root and the new password.

That's it! We have successfully recovered our root password. No more panics!

Conclusion

Recovering root password is a must-know skill and very important for every Cloud, Linux or DevOps Engineer.

If this is helpful to you, feel free to bookmark, comment, like and follow me for Day 21!

Let's Connect!

If you want to connect or share your journey, feel free to reach out on LinkedIn.
I am always happy to learn and build with others in the tech space.

#30DaysLinuxChallenge #Redhat#RHCSA #RHCE #CloudWhistler #Linux #Rhel #Ansible #Vim #CloudComputing #DevOps #LinuxAutomation #IaC #SysAdmin#CloudEngineer

Forem: Amanda Igwe

AWS VPC PROJECT

Step1: SET UP

Step 2: Create Auto Scaling Group

Step 3: Accessing the Private Subnet using Bastion Host

Step 4: SSH into the EC2 Instances

Step 5 : Application Load Balancer

Step 6: Testing

ERRORS ENCOUNTERED

SOLUTIONS

DELETE!

Day 30/ 30 Days of Linux Mastery: Mastering 'for', 'do', 'while', and 'case' Statements in Shell Scripts

Table of Contents

Introduction

What Are Loops and Case Statements?

Core Loops and Case Statements Syntax

Real-World Scenario: Loops and Case Statements

Conclusion

Let's Connect!

Day 29/ 30 Days of Linux Mastery: if Statements in Shell Scripting for Beginners

Table of Contents

Introduction

What is an if statement?

Core if Statement Syntax

Real-World Scenario: if Statement

Conclusion

Let's Connect!

Day 28/ 30 Days of Linux Mastery: Variables and Inputs in Shell Scripting

Table of Contents

Introduction

What are Variables?

How to Use Variables

Taking Input from Users with read

Real-World Scenario: Shell Scripting

Conclusion

Let's Connect!

Day 27/ 30 Days of Linux Mastery: Introduction to Shell Scripting

Table of Contents

Introduction

What is Shell Scripting?

Types of Shells

Real-World Scenario: Shell Scripting

Conclusion

Let's Connect!

Day 26/ 30 Days of Linux Mastery: Storage Management in RHEL 9

Table of Contents

Introduction

What is Storage Management?

Core Storage Management Commands

Real-World Scenario: Storage Management Commands

Conclusion

Let's Connect!

Day 25/ 30 Days of Linux Mastery: Disk Management on RHEL 9

Table of Contents

Introduction

What is Disk Management?

Core Disk Management Commands

Real-World Scenario: Disk Management Commands

Conclusion

Let's Connect!

Day 24/ 30 Days of Linux Mastery: Networking Commands in RHEL 9

Table of Contents

Introduction

What is Networking in Linux?

Core Networking Commands

Real-World Scenario: Networking Command

Conclusion

Let's Connect!

Day 23/ 30 Days of Linux Mastery: 'tar' Command

Table of Contents

Introduction

What is the tar Command?

Core tar Commands

Real-World Scenario: tar Command

Conclusion

Let's Connect!

Day 22/ 30 Days of Linux Mastery: 'gzip' Command

Table of Contents

Introduction

What is the gzip Command?

What is an `if` statement?

Core `if` Statement Syntax

Real-World Scenario: `if` Statement

What is the `tar` Command?

Core `tar` Commands

Real-World Scenario: `tar` Command

What is the `gzip` Command?

Core `gzip` Commands

Real-World Scenario: `gzip` Command

What is the `diff` Command?

Core `diff` Commands

Real-World Scenario: `diff` Command