30 Linux Command Combinations: Solve 95% of Daily Operations Needs, Ready to Use!

Core Idea: The Power of Command Combinations

The philosophy of Linux is that a program should do one thing and do it well. Combining multiple commands through pipes |, redirection >, and logical operators && and || is key to solving complex problems.

1. System Status and Monitoring

Real-time Monitoring of Core Metrics (Top Integrated Tool)
```
htop
```

Scenario: Replaces top, providing a more intuitive view of CPU, memory, and process load, supporting color, graphical display, and mouse operations.

Quickly View System Load and Uptime

uptime && free -h && df -h

Scenario: Get a one-click overview of the system’s overall health.
uptime: View uptime, number of users, and average load over 1/5/15 minutes.
free -h: View memory usage in a human-readable format (G/M).
df -h: View disk space usage in a human-readable format.

Monitor Disk I/O Activity

iostat -dx 2

Scenario: Determine if the disk is a performance bottleneck. -d shows device reports, -x shows extended statistics, and 2 indicates refresh every 2 seconds. Focus on %util (utilization, close to 100% indicates saturation) and await (average wait time for I/O).

Monitor Network Traffic and Connections

iftop -P

Scenario: View in real-time which network connections are consuming a lot of bandwidth, similar to top for processes. -P shows port numbers.

Find the Most CPU-Intensive Processes

ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%cpu | head -n 10

Scenario: Quickly locate the top 10 processes consuming the most CPU. --sort=-%cpu sorts by CPU usage in descending order.

Find the Most Memory-Intensive Processes

ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%mem | head -n 10

Scenario: Quickly locate the top 10 processes consuming the most memory.

2. Log Analysis “Killer Tricks”

Real-time Tracking of Log Files (Most Common)
```
tail -f /var/log/nginx/access.log
```

Scenario: View the latest log content in real-time, essential for debugging web requests. -f (follow) parameter is key.

Filter Log Lines with the Keyword “error”

grep -i "error" /var/log/syslog

Scenario: Quickly locate errors in a sea of logs.-i ignores case.

Dynamic Log Tracking (Advanced Version of tail -f + grep)

tail -f /var/log/your_app.log | grep --line-buffered "keyword"

Scenario: Only display logs in real-time that match specific keywords you care about. --line-buffered ensures immediate output after each line matches.

View the Last 100 Lines of Logs and Filter by Keyword

tail -n 100 /var/log/nginx/access.log | grep "POST"

Count Access Times of Different IPs in Logs

awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -nr | head -n 10

Scenario: Quickly find the top 10 most frequently accessed IPs for security or traffic analysis.
awk '{print $1}': The first column of the default nginx log is the IP, extract it.
sort: Sort to prepare for deduplication.
uniq -c: Count occurrences of duplicate lines.
sort -nr: Sort in reverse numerical order (from largest to smallest).
head -n 10: Display the top 10 lines.

Analyze Logs for “504 Gateway Time-out” Errors

grep "504" /var/log/nginx/access.log | awk '{print $7}' | sort | uniq -c | sort -nr

Scenario: Identify which request URLs most frequently cause 504 timeout errors.

3. File and Directory Operations

Recursively Find Files Containing Specific Content
```
grep -r "config_value" /etc/
```

Scenario: Forgot which file a configuration item is in? This is the solution.-r indicates recursive search.

Find Files by Filename

find /home -name "*.log"

Scenario: Search for all files ending with .log in the /home directory.

Find and Delete Log Files Older than 7 Days

find /var/log -name "*.log" -mtime +7 -exec rm -f {} \;

Scenario: Log cleanup, regular archiving. Very dangerous, confirm the path and conditions before executing!
-mtime +7: Modified time older than 7 days.
-exec ... \;: Execute the following command on each found file.

Quickly Calculate Directory Size

du -sh /var/log/

Scenario: View the total size of a directory.-s shows the total, -h displays in a human-readable format (G/M/K).

Find the 10 Largest Files in the System

find / -type f -exec du -Sh {} + 2>/dev/null | sort -rh | head -n 10

Scenario: When disk space is low, quickly locate the “culprits”.
2>/dev/null: Ignore permission denied and other error messages.
sort -rh: Sort in reverse order by human-readable numbers.

Compare Differences Between Two Directories

diff -rq dir1/ dir2/

Scenario: After deploying code, confirm whether files are synchronized successfully.-r compares recursively, -q reports only which files differ.

4. Network Troubleshooting and Debugging

Check Port Connectivity (Most Common)
```
nc -zv example.com 443
```

Scenario: Quickly determine if a remote server’s port is open and reachable. More concise than telnet.

View Route Traces

traceroute -w 2 google.com

Scenario: When the network is down, determine where the fault occurs at which hop.-w 2 sets the wait time to 2 seconds to avoid long waits.

View All Listening Ports and Corresponding Processes

ss -tulnp

Scenario: Replaces netstat, faster and more efficient. View which services are open on the local machine.
-t: TCP, -u: UDP, -l: Listening, -n: Do not resolve service names, -p: Show process information.

View All Current Network Connections

ss -tan | awk '{print $NF}' | grep -v 'Address\|^$' | sort | uniq -c | sort -nr

Scenario: Count connections in various states to determine if there are issues like SYN Flood or excessive TIME_WAIT.

Download Files (Supports Resuming)

wget -c http://example.com/bigfile.iso

Scenario: Download large files. -c parameter indicates resuming downloads.

5. Process Management

Gracefully Terminate a Process
```
kill -TERM 
```

Scenario: First send a TERM signal, allowing the process to clean up before exiting, which is a more friendly way to end.

Forcefully Kill a Process

kill -9

Scenario: When kill -TERM is ineffective, use the ultimate measure -9 (SIGKILL). Last resort.

Kill a Process by Name

pkill -f "python my_script.py"

Scenario: No need to check PID first, directly kill the process by matching its name. -f matches the entire command line.

Run a Process Reliably in the Background

nohup ./long_running_script.sh > script.log 2>&1 &

Scenario: The process will not be terminated even after closing the terminal.
nohup: Ignores hangup signals.
> script.log: Redirect standard output to a file.
2>&1: Redirect standard error to standard output (i.e., the same file).
&: Run in the background.

6. Data Processing and Backup

One-click Package and Compress Directory

tar -czvf backup.tar.gz /path/to/directory/

Scenario: Archive and compress logs, code, data, etc. -c creates, -z compresses with gzip, -v shows progress, -f specifies filename.

Extract Compressed Package

tar -xzvf backup.tar.gz

Scenario: Extract common .tar.gz files. -x indicates extraction.

View Command Output in Real-time and Write to File Simultaneously

./my_script.sh | tee output.log

Scenario: Want to see real-time output on the screen while saving a log for later analysis. tee command solves this perfectly.

Summary and Reminders

Use rm -rf with caution: Always double-check the path you want to delete. You can set alias rm='rm -i' to prompt before each deletion.
Make Good Use of man: man <command> is your best teacher, showing all parameters and detailed descriptions of commands.
Understand the Principles: Memorizing is not as good as understanding the meaning of each parameter and combination, so you can use them flexibly.

By mastering these 30 combinations, you can indeed solve most daily operational issues, greatly enhancing your work efficiency.