Linux Administration Guide [2026]: Commands to Mastery

Linux Runs the Infrastructure of the World

Linux powers 96% of the world's top web servers, all three major cloud platforms (AWS, Azure, GCP), every Android device, most embedded systems, and essentially every supercomputer on Earth. If you work in tech — development, DevOps, security, networking, data science — you will work with Linux. There's no path around it.

The good news: Linux skills compound. The command line patterns you learn on day one work on every Linux system, from a Raspberry Pi to a 64-core cloud server. It's worth the investment.

Essential Commands Every Linux Admin Must Know

Navigation and File Operations:

pwd                          # print working directory
ls -lah                      # list files (long, all, human-readable)
cd /var/log                  # change directory
mkdir -p /opt/app/config     # create directory tree
cp -r source/ dest/          # copy recursive
mv oldname newname           # move/rename
rm -rf dirname               # remove recursively (careful!)
find /etc -name "*.conf"     # find files by pattern
tar -czf backup.tar.gz dir/  # compress directory

Text Processing:

cat /etc/hosts               # view file
grep "error" /var/log/syslog # search in file
grep -r "pattern" /etc/      # recursive search
tail -f /var/log/auth.log    # follow log in real time
awk '{print $1}' access.log  # extract first column
sed 's/old/new/g' file.txt   # find and replace

Process Management:

ps aux                       # list all processes
top                          # interactive process viewer
htop                         # better top (install separately)
kill -9 PID                  # force kill process
killall nginx                # kill all processes by name
nice -n 10 command           # run with lower priority

Users, Groups, and Permissions

Linux uses a permission model built on users, groups, and three permission bits: read (r=4), write (w=2), execute (x=1) — applied to owner, group, and others.

useradd -m -s /bin/bash alice    # create user with home dir
passwd alice                      # set password
usermod -aG sudo alice            # add to sudo group
groups alice                      # list user's groups
chmod 755 script.sh               # rwxr-xr-x
chmod 640 /etc/secret             # rw-r-----
chown alice:devs /opt/app         # change owner and group
sudo -u alice command             # run command as alice

File permission breakdown: -rwxr-xr-x

• - = regular file (d=directory, l=symlink)
• rwx = owner can read, write, execute
• r-x = group can read and execute, not write
• r-x = others can read and execute, not write

Managing Services with systemd

Modern Linux systems use systemd as the init system and service manager. Nearly every daemon (nginx, sshd, postgresql, etc.) is a systemd unit.

systemctl status nginx           # show service status
systemctl start nginx            # start service
systemctl stop nginx             # stop service
systemctl restart nginx          # restart service
systemctl reload nginx           # reload config (no downtime)
systemctl enable nginx           # start on boot
systemctl disable nginx          # don't start on boot
journalctl -u nginx -f           # follow nginx logs
journalctl --since "1 hour ago"  # recent system logs

To write your own systemd unit:

# /etc/systemd/system/myapp.service
[Unit]
Description=My Application
After=network.target

[Service]
User=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/bin/myapp
Restart=always

[Install]
WantedBy=multi-user.target

Linux Networking Commands

ip addr show                     # show all interfaces/IPs
ip route show                    # show routing table
ip link set eth0 up              # bring interface up
ss -tlnp                         # show listening TCP ports with process
netstat -tlnp                    # older equivalent
ping 8.8.8.8                     # test connectivity
traceroute google.com            # trace route to host
dig google.com                   # DNS lookup
nslookup google.com              # DNS lookup (older)
curl -I https://example.com      # HTTP headers
wget https://example.com/file    # download file
ssh user@hostname                # SSH connect
scp file.txt user@host:/path/    # secure copy to remote
rsync -avz src/ user@host:dest/  # sync files over SSH

For firewall management on modern Ubuntu/Debian: ufw. On RHEL: firewalld.

ufw allow 22/tcp                 # allow SSH
ufw allow 443/tcp                # allow HTTPS
ufw enable                       # activate firewall
ufw status verbose               # show rules

Bash Scripting: Automate Everything

Bash scripting turns manual commands into repeatable automation. A simple backup script:

#!/bin/bash
# daily-backup.sh
set -e  # exit on error

BACKUP_DIR="/backups"
DATE=$(date +%Y-%m-%d)
SOURCE="/opt/app/data"

echo "Starting backup for $DATE"
mkdir -p "$BACKUP_DIR/$DATE"
tar -czf "$BACKUP_DIR/$DATE/data.tar.gz" "$SOURCE"
echo "Backup complete: $BACKUP_DIR/$DATE/data.tar.gz"

# Keep only last 7 days
find "$BACKUP_DIR" -maxdepth 1 -type d -mtime +7 -exec rm -rf {} \;
echo "Old backups cleaned"

Key bash concepts to know: variables, conditionals (if/elif/else), loops (for/while), functions, exit codes ($?), and command substitution ($(command)).

Linux Certifications Worth Pursuing

Certification	Level	Format	Best For
CompTIA Linux+	Entry	Multiple choice	Vendor-neutral foundation, validates basics
LFCS	Entry/Mid	Hands-on lab	Practical skills validation, cloud-focused environments
RHCSA	Mid	Hands-on lab	Enterprise sysadmin roles, Red Hat shops
RHCE	Advanced	Hands-on lab	Senior sysadmin, automation with Ansible
CKA (Kubernetes)	Advanced	Hands-on lab	DevOps/cloud-native engineering

Frequently Asked Questions

PA

Our Take

Linux administration is the hidden floor skill under cloud and AI infrastructure work.

Cloud abstraction has led a generation of infrastructure engineers to believe they can operate production systems without understanding Linux. That works until it does not. When an EC2 instance is behaving strangely, when a containerized service is consuming unexpectedly high memory, when a cron job is silently failing, or when a Node.js process is leaking file descriptors — at those moments, the engineer who can SSH in and read system logs, check process states with ps and top, trace file descriptor usage with lsof, and read network connections with ss or netstat is the engineer who resolves the issue in minutes instead of hours. These skills are genuinely uncommon at the application developer level in 2026, which means they are a real differentiator.

For AI infrastructure specifically, Linux administration skills compound with model serving and GPU management. NVIDIA GPU drivers on Linux have specific quirks, the nvidia-smi tool is the primary diagnostic for GPU utilization and temperature issues, and cuda toolkit versioning mismatches between the host system and containerized workloads are one of the most common sources of model serving failures. None of this is accessible to someone who treats Linux as a black box below their deployment layer. The engineers who are fastest at standing up and debugging GPU-accelerated inference environments are almost always the ones with strong Linux administration foundations.

The RHCSA or Linux Foundation LFCS certification provides a reasonable structured path for developers who want to formalize their Linux skills. The hands-on exam format (not multiple choice) makes it a reliable signal of actual capability to hiring managers.