10 Essential Linux Commands Every DevOps Engineer Should Know

Beyond the basic navigation commands like ls, cd, and pwd, there are powerful Linux commands that every DevOps engineer should master. These commands are essential for debugging, monitoring, and managing systems in production environments. Let's explore the 10 most useful commands that will make you more effective in your daily operations.

1. `tail -f` - Real-Time Log Monitoring

tail -f /var/log/nginx/error.log

What it does: Monitor log files in real time as new entries are written.

Why it's essential:

Debug issues as they happen
Monitor application behavior in production
Track system events in real-time

Use `tail -f` with multiple files: `tail -f /var/log/nginx/access.log /var/log/nginx/error.log` to monitor multiple logs simultaneously.

2. `grep` - Powerful Text Search

grep -i "timeout" /var/log/app.log

What it does: Search through files, logs, or command outputs for specific patterns.

Why it's essential:

Quickly isolate errors in logs
Filter command output
Search configuration files for specific settings

Common options:

-i: Case-insensitive search
-r: Recursive search through directories
-n: Show line numbers
-A 3: Show 3 lines after match
-B 3: Show 3 lines before match

3. `systemctl` - Service Management

systemctl restart nginx
systemctl status docker
systemctl enable nginx

What it does: Control system services using systemd.

Why it's essential:

Start, stop, and restart services
Check service status and health
Enable/disable services at boot
Manage service dependencies

`systemctl` is the modern replacement for older service management tools like `service` and `chkconfig`.

4. `journalctl` - System Logs

journalctl -u docker.service -f
journalctl --since "1 hour ago"

What it does: View logs for systemd-managed services and the system.

Why it's essential:

Debug service issues
Monitor system events
View logs with powerful filtering options
Track service startup and shutdown

Useful options:

-u service-name: Filter by service
-f: Follow logs in real-time
--since: Show logs since specific time
--until: Show logs until specific time

5. `ps aux | grep` - Process Management

ps aux | grep nginx
ps aux --sort=-%cpu | head -10

What it does: List running processes with detailed information.

Why it's essential:

Find rogue or resource-intensive processes
Monitor system resource usage
Identify processes by name or PID
Debug performance issues

Use `ps aux | grep -v grep` to exclude the grep process itself from results.

6. `df -h` / `du -sh` - Disk Space Management

df -h       # Check available disk space
du -sh *    # See folder sizes in current directory
du -sh /var/log/* | sort -hr

What it does: Monitor disk usage and available space.

Why it's essential:

Prevent disk space issues
Identify large files and directories
Plan storage capacity
Clean up unnecessary files

Pro tip: Use du -sh * | sort -hr to find the largest directories quickly.

7. `chmod` / `chown` - File Permissions

chmod +x deploy.sh
chown ubuntu:ubuntu script.sh
chmod 755 /opt/app

What it does: Manage file permissions and ownership.

Why it's essential:

Secure file access
Fix permission issues
Set up executable scripts
Manage user and group ownership

Use `chmod 755` for directories and `chmod 644` for files as a good starting point for web applications.

8. `find` - Advanced File Search

find /var/log -name "*.log" -mtime +7
find /home -type f -size +100M
find /etc -name "*.conf" -exec grep -l "nginx" {} \;

What it does: Locate files based on various criteria.

Why it's essential:

Automate cleanup tasks
Audit file systems
Find files by size, date, or type
Execute commands on found files

Common use cases:

Find old log files for cleanup
Locate large files
Search for configuration files
Find files modified recently

9. `curl` - HTTP Testing

curl -I http://localhost:8080
curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' http://api.example.com
curl -v https://example.com

What it does: Test web endpoints, APIs, and service availability.

Why it's essential:

Test API endpoints
Check service health
Debug HTTP issues
Verify SSL certificates

Useful options:

-I: Show only headers
-v: Verbose output
-X: Specify HTTP method
-H: Add custom headers

10. `rsync` - Efficient File Sync

rsync -avz /app/ user@server:/backup/
rsync -avz --delete /source/ /destination/

What it does: Efficient file synchronization and backup.

Why it's essential:

Fast file transfers
Incremental backups
Sync directories between servers
Resume interrupted transfers

`rsync` is much faster and more reliable than `scp` for large directories and regular backups.

Command Combinations and Tips

Monitor System Resources

# Top CPU processes
ps aux --sort=-%cpu | head -10

# Top memory processes
ps aux --sort=-%mem | head -10

# Disk usage by directory
du -sh /* | sort -hr

Log Analysis

# Find errors in logs
grep -i error /var/log/app.log | tail -20

# Monitor multiple logs
tail -f /var/log/nginx/access.log /var/log/nginx/error.log

# Search for specific patterns
journalctl -u nginx --since "1 hour ago" | grep -i error

Service Management

# Check service status
systemctl status nginx docker

# Restart multiple services
systemctl restart nginx && systemctl restart php-fpm

# Enable services at boot
systemctl enable nginx docker

Best Practices

Always use -h flag with df and du for human-readable output
Combine commands with pipes for powerful data processing
Use grep -v grep to exclude grep processes from results
Test commands in safe environments before using in production
Document complex command combinations for team knowledge sharing

Be careful with commands that modify files or services. Always test in non-production environments first.

Conclusion

Mastering these 10 Linux commands will significantly improve your efficiency as a DevOps engineer. They provide the foundation for:

System monitoring and debugging
Service management and automation
File system operations and maintenance
Network and API testing
Backup and synchronization tasks

Practice these commands regularly and combine them with pipes and other tools to create powerful automation scripts for your infrastructure management tasks.

Table of Contents