💡

“Learning Linux: breaking things, fixing them, and growing every day.”

Learning Linux — A Fresher’s Practical Journey

When I started learning DevOps, I quickly understood one thing 👇
👉 Linux is the base of everything in DevOps

✍️ Introduction (Why I Started Linux)

As a fresher stepping into IT and DevOps, I quickly realized one thing:
👉 Linux is everywhere — servers, cloud, DevOps tools, containers, and automation.

At first, the terminal looked scary. Black screen, strange commands, no mouse 😅
But once I started practicing, Linux became logical, powerful, and even fun.

This blog is written from a fresher’s perspective, explaining Linux simply with examples .

🧠 What is Linux (In Simple Words)?

Linux is an open-source operating system used to run:

• Servers

• Cloud platforms (AWS, Azure, GCP)

• DevOps tools (Docker, Kubernetes, Jenkins)

• Databases and backend systems

💡 Think of Linux as the engine behind most of the internet.

So instead of just reading theory, I decided to practice real tasks.
Here’s what I worked on and what I learned from it.

📁 Understanding the Linux File System

Unlike Windows (C: drive), Linux has one root:

/

Common directories:

• /home → user files

• /etc → configuration files

• /var → logs & variable data

• /bin → essential commands

• /tmp → temporary files

📌 Everything in Linux is treated as a file.

💻 Basic Linux Commands (With Examples)

📍 Check where you are

pwd

➡ Shows current directory

📍 List files and folders

ls
ls -l

➡ Shows files (with permissions & details)

📍 Move between directories

cd /var/log
cd ..

📍 Create and delete files/folders

mkdir devops
touch file.txt
rm file.txt

💡 Practice tip: Create → View → Delete to understand commands better.

🔐 File Permissions (Very Important!)

When you run:

ls -l

You’ll see something like:

-rwxr-xr--

Meaning:

• r → read

• w → write

• x → execute

Change permissions

chmod 755 script.sh

📌 Permissions are critical for security and servers.

⚙️ Process Management (Watching Running Tasks)

Linux allows you to see what is running in the background.

View running processes

ps aux

Live monitoring

top

Better view (if installed)

htop

Stop a process

kill PID

💡 DevOps engineers constantly monitor processes on servers.

🌐 Networking Basics in Linux

Check connectivity:

ping google.com

Make HTTP requests:

curl https://example.com

Check open ports:

ss -tuln

📌 Networking knowledge + Linux = strong DevOps foundation.

⏰ Automation with Cron (Beginner Intro)

Linux can run commands automatically using cron.

Edit cron jobs:

crontab -e

Example:

0 9 * * * /home/user/backup.sh

➡ Runs script every day at 9 AM

💡 Automation is where Linux truly shines.

📍Task’s i did to improve Linux (Hands on) :

1️⃣ User & Group Management (Real Admin Work)

Every company has multiple users. So learning users & groups is important.

🔹 What I did

• Created a new user & password

    sudo useradd devops_user
    sudo passwd devops_user
  

• Created a group & add user in the group

    sudo groupadd devops_team
    sudo usermod -aG devops_team devops_user
  

• Gave sudo access

  
    sudo usermod -aG sudo devops_user
  

✅ Check sudo group

groups username

Example:

groups devops_user

👉 If you see sudo in the output, the user has sudo access.

🔒 Restrict SSH Login

Edit SSH config:

sudo nano /etc/ssh/sshd_config

Add:

AllowUsers devops_user

Restart SSH:

sudo systemctl restart ssh

📌 Learning:
Users + groups = access control
SSH restriction = security 🔐

2️⃣ File & Directory Permissions (Who Can Do What?)

Permissions decide who can read, write, or access files.

🔹 Task

• Create workspace

• Create file

• Set proper permissions

sudo mkdir /devops_workspace
sudo touch /devops_workspace/project_notes.txt

Set permissions:

sudo chmod 640 /devops_workspace/project_notes.txt

Check permissions:

ls -l /devops_workspace

📊 Permission Meaning:

-rw-r-----
Owner → read & write  
Group → read  
Others → no access

📌 Learning:
Permissions are simple once you practice them 👍

3️⃣ Log File Analysis (This Felt Like Real DevOps 😄)

Example :

Logs are everywhere in DevOps.

🔹 Download log file

wget https://raw.githubusercontent.com/logpai/loghub/master/Linux/Linux_2k.log

🔍 Find errors

grep -i "error" Linux_2k.log

⏱ Extract timestamp & log level

awk '{print $1, $2, $3}' Linux_2k.log

🔐 Hide IP addresses

sed -E 's/[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/[REDACTED]/g' Linux_2k.log

⭐ Bonus – Most frequent logs

sort Linux_2k.log | uniq -c | sort -nr | head -10

📌 Learning:
Logs tell stories.
We just need the right commands to read them 📖

4️⃣ Disk & Volume Management

Understanding storage is important when servers grow.

🔹 Create mount point

sudo mkdir /mnt/devops_data

Verify:

df -h
mount | grep devops_data

📌 Learning:
df -h is your best friend for disk usage 📊

5️⃣ Process Management (Watching Running Tasks)

🔹 Start background process

ping google.com > ping_test.log &

🔍 Monitor

ps aux | grep ping
top
htop

❌ Kill process

kill <PID>

📌 Learning:
Always monitor running processes to avoid overload ⚙️

6️⃣ Automate Backups with Shell Script

Automation = heart of DevOps ❤️

🔹 Backup script

# Set source and target locations
DATE=$(date "+%F-%H-%M")
BACKUP_FILE="backup_${DATE}.tar.gz"

# Create compressed backup
echo -e "\e[32mStarting backup creation...\e[0m"
tar -czf "${2}/${BACKUP_FILE}" "$1" 2>/dev/null

Make executable:

chmod +x backup.sh

⏰ Schedule using cron

crontab -e

Example (daily at 1 AM):

0 1 * * * /path/to/backup.sh

📌 Learning:
Once automation starts, manual work reduces 🔁

🧠 Fresher Tips (Important!)

✔ You don’t need to remember all commands
✔ Practice daily in terminal
✔ Read man pages → man ls
✔ Break things → fix them → learn faster
✔ Linux confidence comes with usage

🔑 Key discoveries — What a fresher learns after doing these tasks

1. Practice beats theory. Commands stick when you type them.

2. Small mistakes teach a lot. Broke SSH or perms? Fixing it is a big learning step.

3. Permissions are safety. chmod + chown avoid accidental leaks.

4. Logs are your detective notebook. grep, awk, sed help you read problems.

5. Automation wins time. A simple cron job saves you repeated work.

6. Monitoring is normal. top, ps, df -h are your daily friends.

7. Be careful with root. Use sudo only when needed and test changes in a second session.

8. Document what you do. Your future self will thank you.

Cheat-Sheet :

🚀Final Thought :

“As a fresher, Linux showed me that progress happens one command at a time—and this is only the beginning.”

📌 GitHub (All My Week 2 Tasks)

Click Here To See : My Week-2 Tasks