Introduction

Many beginners getting into Linux are often scared off by the thousands of available commands: complex parameters, the lack of a graphical interface, and the constant “Permission denied” errors.

But here is the truth: as a developer or DevOps engineer, we effectively only use about 20% of the core content in our daily work. Once you master this core, you will have built the skeleton of your Linux knowledge; the rest is just filling in the flesh by reading documentation.

This article strips away the non-essentials to guide you through the 6 core pillars of learning the Linux system.

🌏 Pillar 1: The Worldview: Understanding the Philosophy

Before memorizing commands, you must understand the two core “worldviews” of Linux. This will determine the height of your learning potential.

Everything is a File

In Windows, you are used to clicking hardware icons; but in Linux, hard drives, keyboards, mice, and even running processes are abstracted as files.

• Need to modify system configurations? Find the file.
• Need to check hardware status? Find the file.

Pipes and Composition (|)

Linux believes that “Small is Beautiful.” Every command does one thing and does it well. Through the Pipe (|), we can turn the output of one command into the input of another, building complex tasks like assembling LEGO blocks.

1
2

# Example: Find logs containing "error" and count how many lines there are
cat app.log | grep "error" | wc -l

🛡️ Pillar 2: Survival Basics: File Systems & Permissions

You cannot move an inch in Linux without understanding permissions.

Directory Structure (FHS)

Don’t scatter files randomly. Linux has a strict hierarchy standard:

Permission Management (The Gatekeeper)

When using ls -l, you will see codes like -rwxr-xr--.

Three Identities: Owner (User), Group, Others.

Core Commands:

• chmod: Change mode/permissions (e.g., chmod 755 script.sh or chmod +x script.sh)
• chown: Change owner (e.g., chown user:group file)

⚔️ Pillar 3: The Weapons: Text Processing

Linux servers usually lack a GUI (Graphical User Interface). Efficient text processing is your core productivity tool.

The Editor of Gods: Vim

You don’t need to master all the magic of Vim, but you must master the basic skills to “survive”:

The Text Processing Trio (Grep, Awk, Sed)

These are artifacts for handling logs and data:

Real-world Scenario: Log Analysis

Find all “404 Not Found” errors in the Nginx log and count the top 5 IPs:

1
2

# Pipe chain: Read -> Filter -> Extract IP -> Sort -> Count -> Sort again -> Limit
cat access.log | grep "404" | awk '{print $1}' | sort | uniq -c | sort -nr | head -n 5

⚡ Pillar 4: God Mode: Processes & Services

You need to know what is running on the system and how to control it.

Process Management

System slowing down? CPU spiking?

Real-world Scenario: Java Process Cleanup

Find the PID of a stuck Java application and kill it:

1
2
3
4
5
6

# Step 1: Find the Process ID (PID)
ps -ef | grep java
# Output example: root  1234  1  0 10:00 ?  00:00:20 java -jar app.jar

# Step 2: Kill it forcefully
kill -9 1234

Service Management (Systemd)

Modern Linux distributions mostly use systemd to manage background services.

🌐 Pillar 5: Connecting the World: Network Basics

Linux servers are usually managed remotely, so networking skills are essential.

SSH: The standard for remote login. Learn to configure Passwordless Login (SSH Keys) to boost efficiency.

Troubleshooting Commands:

🤖 Pillar 6: Advanced: Automation (Shell Scripting)

When you find yourself typing the same commands repeatedly, it’s time to write a script. Shell scripting involves saving the above commands into a .sh file and adding logic (if/else) and loops. This is the crucial step to evolving from a “User” to an “Engineer.”

Real-world Scenario: Daily Log Backup

Here is a simple script to verify if you are a “User” or an “Engineer”:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#!/bin/bash
# backup_logs.sh - A simple script to archive logs

LOG_DIR="/var/log/nginx"
BACKUP_DIR="/backup/logs"
DATE=$(date +%Y%m%d)

echo "Starting backup for $DATE..."

# Check if log directory exists
if [ -d "$LOG_DIR" ]; then
    # Create backup directory if not exists
    mkdir -p "$BACKUP_DIR"
    
    # Compress logs
    tar -czf "$BACKUP_DIR/nginx_logs_$DATE.tar.gz" "$LOG_DIR"/*.log
    
    echo "Backup success! File: nginx_logs_$DATE.tar.gz"
else
    echo "Error: Log directory not found!"
fi

Conclusion

The learning curve of Linux is steep, but as long as you hold these 6 core positions, you possess the ability to solve most problems.

Appendix: Linux Common Commands Cheat Sheet

File & Directory Operations (Basic)

Text Viewing & Processing (Log Tools)

System Status & Processes (DevOps Core)

Permissions & Users (Security)

Network Operations (Connectivity)

Compression & Archiving