Forem: Muhammad Zulqernain Zahid

Linux Challenge #2: Real-World Log Cleanup with Command Line Automation

Muhammad Zulqernain Zahid — Sun, 11 May 2025 23:14:06 +0000

Welcome back, command-line champs!

In this challenge, we’re simulating a real-world task every sysadmin faces: managing and cleaning up system logs. This is where your rm, mv, cp, find, and echo commands come into play in a real scenario!

Challenge Brief

You’ve been asked to clean up a log directory on a RHEL 9 machine.

The logs are eating up space, and you need to:

📝 Task Overview

List all files in /var/logs/.
Delete all .log files except syslog and auth.log.
Move the remaining logs into an archive folder called /var/logs/archive/.
Create a cleanup report that lists all deleted and moved files with timestamps.

Full Script Solution

#!/bin/bash

# Step 1: List all files in /var/logs/
echo "Listing all files in /var/logs/"
ls /var/logs/

# Step 2: Delete unnecessary log files except syslog and auth.log
echo "Deleting unnecessary log files..."
find /var/logs/ -maxdepth 1 -type f -name "*.log" ! -name "syslog" ! -name "auth.log" -exec rm -v {} \;

# Step 3: Move remaining .log files to an archive folder
echo "Moving important logs to archive..."
mkdir -p /var/logs/archive
find /var/logs/ -maxdepth 1 -type f -name "*.log" -exec mv {} /var/logs/archive/ \;

# Step 4: Create a cleanup report
echo "Cleanup report - $(date)" > /var/logs/cleanup_report.txt
echo "Moved files:" >> /var/logs/cleanup_report.txt
ls /var/logs/archive/ >> /var/logs/cleanup_report.txt
echo "Remaining files in /var/logs/:" >> /var/logs/cleanup_report.txt
ls /var/logs/ >> /var/logs/cleanup_report.txt

What You Just Practiced

Command	Purpose
`find`	Searches for files matching specific criteria
`rm -v`	Deletes files with verbose output
`mv`	Moves files to another directory
`mkdir -p`	Creates a directory (and parents if they don't exist)
`echo >`	Outputs text to a file
`ls`	Lists files for logging/reporting

Bonus Challenge

Make this script interactive:

Prompt the user for the log folder path.
Confirm before deleting files.
Add a log rotation option that backs up .log files with today’s date appended.

Want help building that version? Drop a comment and we’ll go there together.

Why This Matters

This type of script is gold in production. Automating file cleanup prevents your system from getting bloated and shows real command over Linux fundamentals. Try tweaking this to work for different folders or file types.

Next up? We’re jumping into file permissions and ownership. But for now—clean up, document your moves, and show that terminal who’s boss!

Tags:

#linux #redhat #rhcsa #techwithengineers #techtransition #learnlinux #devops #linuxlab #cloudwhistler #30daychallenge #opensource #techjourney

Linux Challenge #1: The Power of Basics – Can You Automate This?

Muhammad Zulqernain Zahid — Thu, 08 May 2025 18:28:23 +0000

Hey there, Terminal Warriors!

You've made it through the core commands: mkdir, touch, cat, rm, cp, and mv. Now it’s time to apply them all together in a practical challenge that'll push your command-line confidence to the next level.

This challenge is meant for RHEL 9 learners following my series — but anyone who loves some good terminal automation fun can jump in!

Challenge Brief

You're asked to quickly organize a project workspace for a small dev team.

Here’s what needs to be done:

📝 Task Overview

Create a project directory named team_alpha.
Inside it, create the following structure:

   team_alpha/
   ├── docs/
   ├── src/
   │   ├── frontend/
   │   └── backend/
   ├── tests/

Inside docs/, create 3 files: README.md, CONTRIBUTING.md, and LICENSE.
Inside src/frontend/, create files: index.html, style.css.
Inside src/backend/, create files: app.py, requirements.txt.
Append a line of dummy content to README.md and app.py.
Rename README.md to README_MAIN.md.
Copy requirements.txt to the main team_alpha/ directory.
Delete the tests/ directory.

Full Solution Walkthrough

# Step 1: Create the base project directory
mkdir team_alpha

# Step 2: Create nested structure with -p (recursive flag)
mkdir -p team_alpha/docs team_alpha/src/frontend team_alpha/src/backend team_alpha/tests

# Step 3: Create files in docs/
touch team_alpha/docs/README.md team_alpha/docs/CONTRIBUTING.md team_alpha/docs/LICENSE

# Step 4: Create files in frontend
touch team_alpha/src/frontend/index.html team_alpha/src/frontend/style.css

# Step 5: Create files in backend
touch team_alpha/src/backend/app.py team_alpha/src/backend/requirements.txt

# Step 6: Add dummy text to README.md and app.py
echo "This is the README file." > team_alpha/docs/README.md
echo "# Python App" > team_alpha/src/backend/app.py

# Step 7: Rename README.md
mv team_alpha/docs/README.md team_alpha/docs/README_MAIN.md

# Step 8: Copy requirements.txt to the root of the project
cp team_alpha/src/backend/requirements.txt team_alpha/

# Step 9: Delete the tests folder
rm -rvf team_alpha/tests

🧠 What You Just Practiced

Command	Purpose
`mkdir -p`	Creates nested directory structure
`touch`	Creates empty files
`echo >`	Writes dummy content to files
`mv`	Renames a file or moves it
`cp`	Copies a file
`rm -rvf`	Deletes a folder and everything inside, recursively

Mini Challenge

Take it up a notch! Add a script that automates the above setup, but accepts the project name as an argument.

Hint:

#!/bin/bash
project_name=$1

# Use "$project_name" in place of team_alpha above

Want me to help you with the script version? Let me know in the comments 👇

Keep Practicing

Every time you build something small like this, you're building muscle memory. Try modifying this structure to suit different projects — and see how fast you get with automation!

Tags:

#linux #redhat #rhcsa #techwithengineers #techtransition #learnlinux #devops #linuxlab #cloudwhistler #30daychallenge #opensource #techjourney

File & Directory Management – Command Your Files with Power! (30-Day RHCSA + Ansible Journey)

Muhammad Zulqernain Zahid — Wed, 07 May 2025 13:28:11 +0000

Hey there, Linux explorers! Welcome to Day 3 — today we’re diving deep into the magic of file and directory management. Creating, deleting, copying, and moving files might sound simple, but trust me — when you master these, you’ll save time, stay organized, and look like a pro. Let’s unlock the secret sauce behind commands like mkdir, touch, cat, rm, cp, and mv. Ready to level up? Let’s get to it!

Part 1: Building Your File Empire

It’s time to set up your file kingdom. Grab your tools and let’s create those files and directories like a boss!

1. mkdir – Build Your Directories Like a Pro!

Want to create directories? mkdir is your go-to command. Whether it’s one directory or multiple, mkdir will get it done in seconds.

Create a single directory:
```
mkdir new_project
```
✅ Creates a folder called "new_project".
Create multiple directories:
```
mkdir dir1 dir2 dir3
```
✅ Creates three directories at once — fast and efficient!
Create nested directories (directories inside directories):
```
mkdir -p parent/child/subchild
```
✅ The -p option means "parent" directory will be created first if it doesn’t exist. Recursive creation, nice!
Create a sequence of directories:
```
mkdir project_{1..5}
```
✅ Creates directories with names like project_1, project_2, and so on.

Explanation of options:

-p: Recursive creation — Automatically creates parent directories.
{1..5}: Creates directories in a sequence (like project_1, project_2).

2. touch – Your File-Making Wizard

The touch command creates empty files quickly. But it doesn’t just create files — it touches them into existence.

Create a single file:
```
touch readme.txt
```
✅ Creates an empty file called readme.txt.
Create multiple files:
```
touch file1.txt file2.txt file3.txt
```
✅ Creates three files, just like that!
Create a sequence of files:
```
touch file_{1..10}.txt
```
✅ Creates file_1.txt through file_10.txt. Magic!

Explanation of options:

No options needed: Simply creates an empty file! You can use it to initialize files for your project.

3. cat – More Than Just a File Reader

Want to create, read, and append content to your files? cat is your go-to.

Create and write to a file:
```
cat > newfile.txt
```
🔥 Start typing, hit Ctrl+D to save and exit.
Read a file:
```
cat newfile.txt
```
✅ Displays the content of newfile.txt.
Append to a file:
```
cat >> newfile.txt
```
🔥 Start typing, hit Ctrl+D to append more content.

Explanation of options:

>: Creates a new file (or overwrites an existing one).
<: Read the content of a file.
>>: Appends content to the end of a file.

Part 2: The Real Power: Deleting, Copying, and Moving Files Like a Boss

We’re diving into file management that goes beyond just creating files. Now, it’s time to delete, copy, and move like a real Linux pro.

4. rm – Delete Files and Directories Like a Cleanup Pro

Need to clean up? rm gets the job done, but use with caution — it’s unforgiving! So, let’s make sure you understand every option and how to use them safely.

Delete a specific file:
```
rm unwantedfile.txt
```
✅ Deletes a specific file.
Delete a directory (and all its contents):
```
rm -r mydir
```
✅ The -r option means "recursive" — deletes the directory and everything inside it.
Force delete without confirmation:
```
rm -rf mydir
```
⚠️ Be careful! The -f option **forces* deletion without asking for confirmation.*
Delete all files matching a pattern:
```
rm *.log
```
✅ Deletes all files with the .log extension.
Delete all files in the current directory:
```
rm *
```
✅ Deletes everything in the current directory.

Explanation of options:

-r: Recursive — Deletes directories and their contents, including subdirectories.
-f: Force — Skips confirmation prompts (use with care!).
-v: Verbose — Gives a detailed output of what's being deleted.

Pro Tip: Always double-check when using -rf. It’s easy to accidentally delete more than intended. Proceed with caution!

5. cp – Copy Files and Directories with Ease

Need a backup or want to duplicate files? cp is the command for that. Whether you're copying a file or a directory, this tool makes it seamless.

Copy a single file:
```
cp myfile.txt backupfile.txt
```
✅ Copies myfile.txt to backupfile.txt.
Copy a directory and its contents:
```
cp -r mydir backupdir
```
✅ The -r flag ensures that the entire directory (and its contents) are copied.
Copy files matching a pattern:
```
cp *.txt backupdir
```
✅ Copies all .txt files to backupdir.

Explanation of options:

-r: Recursive — Copies directories and their contents.
-v: Verbose — Shows detailed information about what’s being copied.
-f: Force — Overwrites files without asking for confirmation.

6. mv – Move and Rename Files with Precision

mv is your ultimate file mover. Whether you're shifting files around or renaming them, it’s essential.

Move a file to another directory:
```
mv myfile.txt /path/to/destination/
```
✅ Moves myfile.txt into the specified directory.
Rename a file:
```
mv oldname.txt newname.txt
```
✅ Renames oldname.txt to newname.txt.
Move multiple files:
```
mv *.txt /new/folder/
```
✅ Moves all .txt files to a new folder.

Explanation of options:

No options: Moves files from one location to another or renames them.
-v: Verbose — Shows details of what’s being moved or renamed.

Let’s Wrap This Up – Time to Practice!

🎉 You've just learned to create, delete, copy, and move files and directories! These are your foundation commands that will serve you daily. Practice these, and you’ll start seeing how powerful Linux can be when you’re in control of your files.

🔥 Mini Challenges:

Create a folder structure for a new project. Use mkdir and experiment with the -p option to make nested directories.
Write a few lines of code in a file using cat, then try appending to that file. See how easily you can update your work!
Move a file into a new directory and rename it using mv. Clean up old files with rm.
Copy a bunch of files with cp and organize them into proper folders. Copy data matching a specific pattern!

Keep up the momentum! You’ve unlocked powerful file management skills. Up next, we’ll be diving into VIM. Stay tuned for more and keep exploring!

Tags:

#linux #redhat #rhcsa #techwithengineers #techtransition #learnlinux #devops #linuxlab #cloudwhistler #30daychallenge #opensource #techjourney

Nerds Go to War: Why Linux and Red Hat Certified Heroes Matter

Muhammad Zulqernain Zahid — Mon, 28 Apr 2025 03:36:21 +0000

⚡ CODE. CONFIGURE. CONQUER.

— The Red Hat Way

The Battlegrounds We Face
Why RHEL 9 is Our Weapon of Choice
Nerds: The Unsung Heroes
This is Why We Train
- Final Word: Rise, Nerds, Rise

In a world fueled by data and chaos, the silent warriors aren't clad in armor — they're armed with keyboards and commands. Welcome to the real battleground: Infrastructure.

The modern world runs not on magic, but on infrastructure — messy, sprawling networks of machines that need to talk to each other, scale overnight, heal themselves, and withstand attacks from every direction.

The generals of this new world? Sysadmins. Automation Engineers. Linux Wizards.

The frontline weapon? RHEL 9 — Red Hat Enterprise Linux, the battle-tested OS that powers critical systems across governments, banks, tech giants, hospitals, and beyond.

Learning Linux isn't a hobby anymore. It's a survival skill.

Mastering RHEL 9 and earning that Red Hat certification isn’t just a flex — it’s an act of war preparedness.

The Battlegrounds We Face

Without rock-solid Linux skills:

Infrastructure collapses at scale.
Downtime costs millions.
Security holes get exploited faster than you can say sudo su -.
Chaos reigns when automation breaks.

The problem?

Modern infrastructure is too complex for manual babysitting.

The solution?

Linux, automation, and certified professionals who know how to fight smart.

Why RHEL 9 is Our Weapon of Choice

Red Hat Enterprise Linux 9 isn't just another OS. It’s engineered for the realities of modern infrastructure:

Security-first architecture — because breaches are not a matter of if, but when.
Performance tuning at scale — your cloud, containers, and bare-metal servers all optimized to the teeth.
Automation baked in — no more fragile shell scripts duct-taped to servers; real automation with Ansible.
Stability and support — 10+ years of rock-solid updates. In the battlefield, you don't want surprises.

This is why industries trust RHEL 9 to run their mission-critical environments.

And why they trust Red Hat Certified Engineers (RHCEs) to wield it.

Nerds: The Unsung Heroes

When you earn that RHCSA or RHCE, you're not just passing a test — you're proving that:

You can configure systems securely and efficiently.
You can automate deployments faster than manual setups could even finish.
You can troubleshoot when the pressure is high and time is short.
You can lead infrastructure projects, migrations, and disaster recoveries.

You become the nerd that companies pray for when the servers start crying at 2AM.

You become the calm in the storm. The tech medic. The strategist. The last line of defense.

This is Why We Train

Every chmod, every systemctl, every Ansible playbook...

It's not just a command. It's training for battle.

When you learn Linux, when you pursue that RHCSA or RHCE, you’re preparing for real-world warzones:

Securing healthcare data from cyber threats.
Keeping financial systems running when millions depend on them.
Scaling global applications overnight during product launches.
Resurrecting critical systems after natural disasters.

The world may never know your name.

But your servers will sing your praises.

And somewhere out there, a whole company will keep standing because of you.

Final Word: Rise, Nerds, Rise

This journey isn't for the faint of heart.

But if you feel that fire — that itch to know more, to build stronger, to protect and optimize — then welcome to the frontlines.

Linux isn't just another skill. It's the weapon of choice.

Red Hat Certified Professionals aren't just employees. They are warriors.

So gear up. Train hard. Automate smart.

The world needs us.

The battle for better infrastructure has just begun.

Follow my RHCSA + Ansible training series and join the Red Hat warriors in mastering RHEL 9!

Have war stories, tips, or questions? Sound off in the comments — let’s forge stronger systems together!

Tags:

#linux #redhat #rhcsa #techwithengineers #techtransition #learnlinux #devops #linuxlab #cloudwhistler #30daychallenge #opensource #techjourney

Leveling Up — Linux Commands You’ll Actually Use (30-Day RHCSA + Ansible Journey)

Muhammad Zulqernain Zahid — Mon, 28 Apr 2025 00:51:49 +0000

You survived your first Linux commands? Congratulations, you’re officially dangerous!

Now let’s add some serious power moves to your toolbox — still beginner-friendly, but with enough spice to impress.

Commands That Make Life Easier

1. `uname -r` — Know Your Kernel Like You Know Your Coffee

uname -r

Purpose: Displays your Linux kernel version.

Use it when: You're troubleshooting or bragging about running the latest and greatest.

2. `whoami` — Existential Crisis, Solved

whoami

Purpose: Tells you which user you're currently logged in as.

Use it when: You forgot who you are (at least digitally).

3. `df -h` — How Much Room Left for Bad Decisions?

df -h

Purpose: Shows disk space usage in a human-readable format.

Use it when: You want to check if you’re running out of space before downloading more cat memes.

4. `top` — The Pulse of Your Machine

top

Purpose: Live view of running processes and system resource usage.

Use it when: You hear the fans spinning like a jet engine.

5. `cat` — Fastest Way to Peek at a File

cat filename.txt

Purpose: Displays the contents of a file.

Use it when: You need a quick look without opening an editor.

6. `chmod` — Because Permissions Matter

chmod 755 myscript.sh

Purpose: Changes file permissions.

Use it when: Your script refuses to run because it's "not executable."

7. `man` — The Book of Secrets

man ls

Purpose: Opens the manual for a command.

Use it when: You want to dive deeper into how a command works.

🏆 Mini Challenge: Become the Command Ninja

Open your terminal.
Find out your kernel version with uname -r.
Check your user with whoami.
See your disk usage with df -h.
Peek into any file using cat.
Explore man chmod and learn about file permissions.

Bonus Points:

Use top and identify which process is hogging your CPU!

Pro Tip:

Practice every day. Linux rewards curiosity. The more you try, the faster you level up.

🔥 Ready to flex? Drop your favorite command in the comments!

Tags:

#linux #redhat #rhcsa #techwithengineers #techtransition #learnlinux #devops #linuxlab #cloudwhistler #30daychallenge #opensource #techjourney

Getting Comfortable with the Command Line (30-Day RHCSA + Ansible Journey)

Muhammad Zulqernain Zahid — Sun, 27 Apr 2025 01:10:30 +0000

Today we finally opened the terminal — and this is where Linux begins to feel like Linux.

No more clicking around folders like in Windows. Here, you take control using the shell.

It might initially feel intimidating, but these are the basics that build your confidence.

💻 Understanding the Shell Prompt

When you launch a terminal in Linux, you’ll see something like this:

[root@vbox ~]#

Here’s what that means:

root — This is the user (we’re logged in as the superuser here).
@vbox — The hostname of the machine. In this case, it’s called vbox.
~ — This symbol refers to the home directory of the current user.
# — Indicates that you're using a root shell. Regular users see a $.

📁 Exploring the Linux File System

Everything starts from / (the root directory), and the system branches out from there:

Directory	Purpose
`/`	Root of the file system
`/home`	Home directories for users
`/root`	Home for the root user
`/bin`	Essential user binaries (commands like `ls`, `cp`, `mv`)
`/sbin`	System binaries (commands used for system admin tasks)
`/usr`	User-installed software and libraries
`/etc`	Configuration files
`/var`	Variable files like logs, mail, spool
`/tmp`	Temporary files (cleared on reboot)
`/mnt`	Mount point for temporarily mounted filesystems
`/media`	Mount point for removable media (USB, CD-ROM)
`/dev`	Device files (like disks, USBs, etc.)
`/proc`	Virtual filesystem providing process info
`/sys`	Virtual filesystem with system device info
`/opt`	Optional or third-party software packages
`/lib`	Essential shared libraries
`/boot`	Boot loader files and kernel

Each folder has its own critical purpose — it keeps Linux organized and powerful.

🔧 Basic Linux Commands We Practiced

Here are the basic commands we explored — with examples:

💻 System Info & Utilities

uname        # Print system info
uname -r     # Show kernel version
date         # Show current date and time
cal          # Display calendar
uptime       # How long the system has been running
whoami       # Shows currently logged-in user

📂 Navigation

cd           # Change directory
cd /         # Go to root directory
cd ..        # Go one directory up
pwd          # Print current working directory

🧱 Directory & File Handling

mkdir myfolder       # Create a new directory
ls                   # List contents of directory
ls -l                # List in long format (details)
ls -a                # Include hidden files
touch myfile.txt     # Create a blank file
rm myfile.txt        # Delete a file
rmdir myfolder       # Remove an empty directory

👤 User and Permissions

su                  # Switch user
history             # Show recently used commands
clear               # Clear the terminal screen

💡 Troubleshooting Tip

If you try a command and see "command not found", check:

If you’re spelling it correctly
Whether the command is installed
If your $PATH variable includes the correct directories

#LinuxBasics #RHCSA #CommandLineTools #LearnLinux #RedHat #DevToCommunity #TechPivot #Techwithengineers #CloudWhistler #RHCSAChallenge #30daysRHCSA+Ansiblechallenge

Setting Up My Linux Lab with RHEL 9 (30-Day RHCSA + Ansible Journey)

Muhammad Zulqernain Zahid — Thu, 24 Apr 2025 16:36:57 +0000

Day 1 of the RHCSA + Ansible Fast Track Training with the CloudWhistler Community was all about setting up the lab environment. This isn’t just busy work — this is the groundwork for everything we’ll build from here.

And honestly? It felt like a real moment. Because setting up your own lab makes it real.

What We Did:

Installed VirtualBox to create our virtual environment
Downloaded Red Hat Enterprise Linux 9 (RHEL 9) ISO
Created a VM from scratch and installed RHEL 9 on it
Got our first look at the Linux CLI (Command Line Interface) — even if we didn't dive in yet

This is where it starts. Your machine becomes your personal lab — a safe place to break things, fix things, and get hands-on with Linux.

🧰 Troubleshooting During Installation

Like many of us in the session, I hit a few bumps. If you're doing this solo, here are some common issues and how to solve them:

🔹 VirtualBox not detecting RHEL ISO?

Make sure you’ve selected the ISO under "Storage" → Controller: IDE → and checked "Live CD/DVD". Also, verify that the ISO isn’t corrupted.

🔹 VM crashes or stuck during boot?

Check your allocated memory (at least 2 GB recommended) and CPU settings. Also, enable Virtualization Technology (VT-x) from your BIOS if you haven’t.

💡 Pro Tip from the Training:

Even setting up your lab teaches you a lot. Things like:

The importance of resource allocation (RAM, CPU)
Understanding ISO images, boot orders, and disk partitions
Getting comfortable with errors — and learning to solve them one step at a time

This is the part that builds muscle memory.

🧭 Reflection:

Before this, I never thought of myself as someone who could “set up a system.” Now, I’ve got a fully functioning Linux machine on my own hardware. And yes, I needed guidance, but I made it happen.

That’s a win. And it’s only Day 1.

If you're thinking about learning Linux or preparing for RHCSA — don’t wait until you feel “ready.”

Set up the lab. Press the buttons. Hit a few errors. That’s where it starts.

Let me know if you're setting yours up too, or if you get stuck — I’ll share whatever I can from my own setup.

Tags:

#linux #redhat #rhcsa #techwithengineers #techtransition #learnlinux #devops #linuxlab #cloudwhistler #30daychallenge #opensource #techjourney

Why Linux? Why Now? (30-Day RHCSA + Ansible Journey)

Muhammad Zulqernain Zahid — Tue, 22 Apr 2025 22:23:54 +0000

I'm officially kicking off my 30-day RHCSA + Ansible Fast Track Training with the CloudWhistler Community, and I want to bring you along — not just to document my journey, but to share what I’m learning in real-time with those of you walking the same path.

On Day 0, we didn't touch the command line. Instead, we went back — way back — to understand the roots of Linux, where it came from, and why it still matters so much today.

What We Covered:

How Linux evolved from Unix — and why open-source changed everything
Why Linux powers everything from supercomputers to smartphones
Its presence in cloud infrastructure, cybersecurity, DevOps, and more
And why mastering Linux is foundational — not optional — if you're serious about building a future in tech

For someone like me — transitioning into tech from a completely non-technical background — this hit hard. I’ve always worked on tech systems, never inside them. So understanding why Linux is so deeply embedded in everything modern gave me the “why” I didn’t even know I needed.

It’s not just about learning to type commands in a terminal.

It’s about building a mental model of how systems work — so you can troubleshoot, automate, and eventually, lead.

If you’ve ever felt behind because you didn’t come from a computer science background, or wondered whether you’re cut out for this — I get it. I’m figuring it out as I go. And I’ll be sharing it all here.

Let’s do this. One day at a time.

Tags:

#RedHat #linux #RHCSA #careertransition #techwithengineers #cloudwhistler #opensource #techjourney #learnlinux #30daychallenge #devops

Forem: Muhammad Zulqernain Zahid

Linux Challenge #2: Real-World Log Cleanup with Command Line Automation

Challenge Brief

📝 Task Overview

Full Script Solution

What You Just Practiced

Bonus Challenge

Why This Matters

Linux Challenge #1: The Power of Basics – Can You Automate This?

Challenge Brief

📝 Task Overview

Full Solution Walkthrough

🧠 What You Just Practiced

Mini Challenge

Keep Practicing

File & Directory Management – Command Your Files with Power! (30-Day RHCSA + Ansible Journey)

Part 1: Building Your File Empire

1. mkdir – Build Your Directories Like a Pro!

2. touch – Your File-Making Wizard

3. cat – More Than Just a File Reader

Part 2: The Real Power: Deleting, Copying, and Moving Files Like a Boss

4. rm – Delete Files and Directories Like a Cleanup Pro

5. cp – Copy Files and Directories with Ease

6. mv – Move and Rename Files with Precision

Let’s Wrap This Up – Time to Practice!

🔥 Mini Challenges:

Nerds Go to War: Why Linux and Red Hat Certified Heroes Matter

The Battlegrounds We Face

Why RHEL 9 is Our Weapon of Choice

Nerds: The Unsung Heroes

This is Why We Train

Final Word: Rise, Nerds, Rise

Leveling Up — Linux Commands You’ll Actually Use (30-Day RHCSA + Ansible Journey)

Commands That Make Life Easier

1. uname -r — Know Your Kernel Like You Know Your Coffee

2. whoami — Existential Crisis, Solved

3. df -h — How Much Room Left for Bad Decisions?

4. top — The Pulse of Your Machine

5. cat — Fastest Way to Peek at a File

6. chmod — Because Permissions Matter

7. man — The Book of Secrets

🏆 Mini Challenge: Become the Command Ninja

Getting Comfortable with the Command Line (30-Day RHCSA + Ansible Journey)

💻 Understanding the Shell Prompt

📁 Exploring the Linux File System

🔧 Basic Linux Commands We Practiced

💻 System Info & Utilities

📂 Navigation

🧱 Directory & File Handling

👤 User and Permissions

💡 Troubleshooting Tip

Setting Up My Linux Lab with RHEL 9 (30-Day RHCSA + Ansible Journey)

What We Did:

🧰 Troubleshooting During Installation

💡 Pro Tip from the Training:

🧭 Reflection:

Why Linux? Why Now? (30-Day RHCSA + Ansible Journey)

What We Covered:

1. `uname -r` — Know Your Kernel Like You Know Your Coffee

2. `whoami` — Existential Crisis, Solved

3. `df -h` — How Much Room Left for Bad Decisions?

4. `top` — The Pulse of Your Machine

5. `cat` — Fastest Way to Peek at a File

6. `chmod` — Because Permissions Matter

7. `man` — The Book of Secrets