Linux/Bash

Essential shell commands and utilities for file management, process control, system monitoring, and daily terminal workflows.

103 commands

Browse by Topic

Getting Started

Quick setup and installation

3commands

Files

File operations

20commands

Processes

Process management

17commands

Network

Network commands

19commands

Disk

Disk operations

11commands

Text

Text processing

14commands

SSH

SSH operations

9commands

Systemd

systemd analysis

6commands

Journal

systemd journal logs

4commands

Check kernel version

$ uname -r

Display the current Linux kernel version

Check distro info

$ cat /etc/os-release

Display distribution name, version, and release details

Update system packages

$ sudo apt update && sudo apt upgrade -y

Refresh package lists and upgrade all packages on Debian/Ubuntu

Disk usage by directory

$ du -sh */ | sort -hr | head -10

Show top 10 largest directories.

Check disk space

$ df -h

Show disk usage in human-readable format.

Find disk hogs

$ ncdu /

Interactive disk usage analyzer.

List block devices

$ lsblk -f

Show all block devices with filesystem type, label, and UUID.

Show block device IDs

$ blkid

Display UUID, type, and label of all partitions.

Mount a filesystem

$ sudo mount /dev/sdb1 /mnt/data

Mount a partition to a directory mount point.

Unmount a filesystem

$ sudo umount /mnt/data

Unmount a mounted filesystem safely.

Check filesystem integrity

$ sudo fsck /dev/sdb1

Run filesystem check and repair. Partition must be unmounted.

Format partition as ext4

$ sudo mkfs.ext4 /dev/sdb1

Create an ext4 filesystem on a partition. Destroys existing data.

Show inode usage

$ df -i

Display inode usage per filesystem. Running out of inodes prevents file creation.

Estimate file space usage

$ du -sh /var/log

Show the total size of a specific directory.

Recursive grep with context

$ grep -rn -B2 -A2 'pattern' .

Search recursively with context lines.

Replace text in multiple files

$ find . -type f -name '*.js' -exec sed -i 's/old/new/g' {} +

Find and replace text in all matching files.

Monitor file changes

$ tail -F /var/log/app.log | grep --line-buffered 'ERROR'

Follow log file and filter for errors.

Extract columns with awk

$ awk '{print $1, $3}' file.txt

Print the first and third columns from a file.

Stream edit with sed

$ sed -n '10,20p' file.txt

Print only lines 10 through 20 of a file.

Sort and deduplicate

$ sort file.txt | uniq -c | sort -rn | head -20

Count occurrences of each line, sorted by frequency.

Count words, lines, chars

$ wc -lwc file.txt

Count lines, words, and characters in a file.

Extract specific fields

$ cut -d',' -f1,3 data.csv

Extract the first and third columns from a CSV file.

Translate or delete characters

$ echo 'Hello World' | tr '[:upper:]' '[:lower:]'

Convert uppercase to lowercase characters.

Tee output to file and screen

$ make 2>&1 | tee build.log

Write command output to both stdout and a file simultaneously.

Compare two files

$ diff -u file1.txt file2.txt

Show unified diff between two files.

Show first N lines

$ head -n 50 file.txt

Display the first 50 lines of a file.

Show last N lines

$ tail -n 100 /var/log/syslog

Display the last 100 lines of a log file.

Grep with regex pattern

$ grep -E '^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' access.log

Search for lines matching an IP address pattern using extended regex.

SSH tunnel (local port forward)

$ ssh -L 8080:localhost:80 user@remote

Forward local port 8080 to remote's localhost:80.

SSH with key file

$ ssh -i ~/.ssh/key.pem user@host

Connect using a specific private key.

Copy SSH key to server

$ ssh-copy-id user@host

Install your public key on a remote server.

Generate SSH key pair

$ ssh-keygen -t ed25519 -C 'your@email.com'

Generate a modern Ed25519 SSH key pair.

Remote port forward

$ ssh -R 9090:localhost:3000 user@remote

Expose local port 3000 on the remote server as port 9090.

SOCKS proxy via SSH

$ ssh -D 1080 user@remote

Create a SOCKS5 proxy tunnel through the remote server.

Copy file via SCP

$ scp -r /local/dir user@remote:/remote/dir

Securely copy a directory to a remote server.

Run remote command

$ ssh user@host 'df -h && free -m'

Execute commands on a remote server without interactive session.

SSH with agent forwarding

$ ssh -A user@bastion

Forward local SSH agent to the remote host for key-based access to other servers.

Show boot time breakdown

$ systemd-analyze

Display total boot time and time spent in kernel vs userspace.

List services by startup time

$ systemd-analyze blame

Show which services took the longest to start during boot.

Show critical startup path

$ systemd-analyze critical-chain

Display the critical chain of units that delayed boot the most.

Generate boot timeline graph

$ systemd-analyze plot > boot.svg

Create an SVG visualization of the boot process timeline.

Validate unit file syntax

$ systemd-analyze verify <unit>

Check a systemd unit file for syntax errors and configuration issues.

Security analysis of service

$ systemd-analyze security <service>

Analyze security and sandboxing settings of a systemd service unit.

Follow service logs

$ journalctl -u nginx.service -f

Stream logs for a specific systemd service in real-time.

Time-based log query

$ journalctl --since '2 hours ago' --until '1 hour ago'

Display logs from a specific time range using natural language.

Show errors from current boot

$ journalctl -p err -b

Display all error-level messages since the last system boot.

Show journal disk usage

$ journalctl --disk-usage

Display total disk space used by systemd journal logs.

Discussion

Loading comments...