Linux Command Line Basics: Essential Commands for Beginners

ls: List directory contents

ls is the first tool you’ll use to inspect directories. Useful flags you should know:

• -l: long listing (permissions, owner, size, timestamp)
• -a: show hidden files (dotfiles)
• -h: human-readable sizes (with -l)
• --color=auto: colorize output (common in GNU coreutils)

Examples:

# detailed listing with human-readable sizes
ls -lah --color=auto

# view a specific directory sorted by modification time
ls -lt /var/log | head -n 20

Practical DevOps tip: when inspecting a package deploy folder (e.g., /var/www/html), combine ls -lt to find the most recently modified files and detect unexpected changes after deployment.

Navigating the filesystem: pwd and cd

pwd

Use pwd (print working directory) to confirm where you are before running commands that can change or delete files.

pwd
# /home/ubuntu/myproject

cd

Common patterns:

• cd /path/to/dir — go to absolute path
• cd ../ — move up one level
• cd - — switch to previous directory
• cd ~ or cd — home directory

cd /etc/nginx
pwd
cd -  # go back to previous dir

Tip: Use tab completion and cd - to move safely between deployment and staging directories without retyping long paths.

mkdir: Create directories

mkdir creates directories. Common options:

• -p — create parent directories as needed

# create nested directories in one command
mkdir -p /srv/backups/daily/2025-12-01

DevOps use-case: create structured backup paths and ensure scripts don't fail when parent folders are missing.

Managing files: cp, mv, rm, rmdir

cp (copy)

Common flags:

• -r — recursive (directories)
• -a — archive; preserves attributes and is equivalent to -dR --preserve=all in GNU cp
• -v — verbose

# copy a directory preserving metadata
cp -a /etc/nginx /backup/nginx-$(date +%F)

Tip: use cp -a when backing up configuration files to keep permissions intact.

mv (move / rename)

Common flags:

• -i — interactive prompt before overwrite

# rename a file or move it into a directory
mv -i release.tar.gz /srv/releases/

Use -i in scripts run interactively to avoid accidental overwrites.

rm and rmdir (remove)

Be cautious: rm is destructive. Useful options:

• -r — recursive
• -f — force (no prompts)
• --preserve-root — (GNU rm default behavior) protects /

# remove an empty directory
rmdir tmpdir

# remove a directory tree interactively
rm -rI build/

Security tip: avoid running sudo rm -rf unless you’ve double-checked the path. In automation, prefer safe deletion patterns (move to a quarantine directory first, then delete after verification).

Viewing and editing files: cat, less, and editors

cat and less

cat prints file contents; less is for paging large files. Combine with grep and tailing tools:

# quick view
cat /etc/hostname

# interactive paging
less /var/log/syslog

# follow a log file and highlight matches
tail -F /var/log/nginx/error.log | grep --line-buffered "ERROR"

Editing: vim, nano

Common editors on servers are vim and nano. If you must modify config files in production, use vim -R for read-only preview, then update with proper backups and reload services (e.g., systemctl reload nginx).

grep: Searching and filtering

grep is essential for finding text in files and pipelines. Useful flags:

• -R — recursive
• -n — show line numbers
• --color=auto — highlight matches
• -E — extended regular expressions

# find occurrences of ERROR in logs recursively
grep -R --color=auto -n "ERROR" /var/log/

# search inside a git repo for TODO comments
grep -R --line-number -E "TODO|FIXME" src/

DevOps example: when a deployment fails, search recent logs across multiple services to find the root cause quickly. Combine grep with xargs or find -exec for powerful automated searches.

File permissions: chmod and chown (practical guide)

Understanding permissions prevents accidental exposure of secrets and avoids permission-related outages.

Permission basics

Three classes: user (u), group (g), others (o). Three permissions: read (r), write (w), execute (x).

# human-readable view
ls -l /etc/nginx/nginx.conf
# -rw-r----- 1 root www-data 1234 Jan  1 12:00 nginx.conf

In this example, owner is root, group www-data. Only owner and group have read access.

chmod numeric examples

# give owner read/write, group read, others none
chmod 640 /etc/nginx/nginx.conf

# make a script executable by owner
chmod 700 /usr/local/bin/deploy.sh

chown usage

# change owner to deploy user and group to deploy
chown deploy:deploy /srv/releases/current
# change ownership recursively
chown -R deploy:deploy /srv/releases/

Best practice for sensitive config files: set ownership to a dedicated user (not root when possible), restrict mode to 640 or 600, and keep secrets out of world-readable files. In CI/CD pipelines, avoid committing credentials; instead use secret managers (e.g., Vault, AWS Secrets Manager) and mount them at runtime.

man pages and inline help

Use man to read manual pages; many commands also support --help for a quick summary.

# full manual
man ls

# quick help
ls --help

When you need authoritative documentation for shell builtins, refer to the Bash manual or project pages for tools (search the project root domain such as https://www.gnu.org/ or https://www.linux.org/).

System info & process management: top, ps, htop

top

top shows live resource usage. Use it to spot CPU or memory hogs quickly.

top
# press M to sort by memory, P to sort by CPU

ps + grep

Use ps with grep to locate processes in automation or scripts.

# find Java processes
ps aux | grep java | grep -v grep

htop

htop provides a friendlier UI (if available). On minimal servers you may prefer ps and top to avoid installing extra packages.

Troubleshooting example

When a service consumes excessive memory, inspect running processes, note the PID, and collect a stack or logs. Example workflow:

# identify top memory consumer
ps aux --sort=-%mem | head -n 10

# sample logs for that service
journalctl -u my-service -n 200 --no-pager

Tips for mastering the command line: shortcuts & resources

Shortcuts that save time

• Ctrl + R — reverse-i-search through history
• Ctrl + A / Ctrl + E — move to start/end of line
• Tab — autocomplete filenames/commands
• !! — repeat last command; sudo !! runs last command with sudo

# edit crontab for current user
crontab -e
# sample daily backup at 02:00
0 2 * * * /usr/local/bin/daily-backup.sh

Recommended resources

• Interactive learning platforms (e.g., Codecademy) for foundational practice
• Project and reference pages: https://www.gnu.org/ and https://www.linux.org/
• Cheat sheets (local copies in your dotfiles) — keep one for quick reference in servers