ls -lah               # list with permissions, human sizes, hidden files
chmod 755 file        # rwxr-xr-x
chmod -R 750 /app     # recursive
chown user:group file
chown -R appuser:app /app

# Typical production pattern
chown -R appuser:app /app
chmod -R 750 /app        # owner=rwx, group=r-x, others=none

groups                    # what groups your user is in
umask                     # view default permission mask
umask 022                 # new files = 644, dirs = 755
chmod g+s /shared-dir     # setgid: new files inherit group

ps aux                    # all processes, full detail
ps aux | grep appname     # filter for specific app
top                       # live view, press q to quit
htop                      # better top (if installed)

kill PID          # SIGTERM (15) — graceful, app can clean up
kill -9 PID       # SIGKILL — force kill, no cleanup
killall appname   # kill by name

sleep 100 &       # run in background
jobs              # list background jobs
fg                # bring last job to foreground
fg %2             # bring job #2 to foreground
bg                # resume stopped job in background
nohup python app.py &   # survive terminal close (use systemd instead in production)

ping google.com           # basic reachability
traceroute google.com     # hop-by-hop path

ss -tuln          # listening ports (no process names)
ss -tulnp         # listening ports WITH process names (use this)

curl -I https://example.com              # headers only
curl -v https://example.com              # verbose (debug TLS etc.)
curl -X POST -d '{"key":"val"}' \
     -H "Content-Type: application/json" \
     http://localhost:8080/api
curl -o /dev/null -s -w "%{http_code}" url  # just the status code

dig google.com            # full DNS lookup
dig google.com +short     # just the IP
nslookup google.com       # alternative
cat /etc/hosts            # local overrides (check here first!)
cat /etc/resolv.conf      # which DNS servers are configured

nmap localhost            # scan local ports
nmap -p 8080 hostname     # check specific port on remote host

command > file.txt          # stdout → file (overwrite)
command >> file.txt         # stdout → file (append)
command 2> error.txt        # stderr → file
command 2>&1                # merge stderr into stdout
command > all.txt 2>&1      # stdout + stderr → file
command 2>/dev/null         # suppress errors
command > /dev/null 2>&1    # suppress everything

ps aux | grep nginx         # pipe stdout of ps into grep
cat file | sort | uniq      # chain commands
command | tee file.txt      # write to file AND show on screen

grep "error" app.log                  # find lines with "error"
grep -i "error" app.log               # case insensitive
grep -n "error" app.log               # show line numbers
grep -r "TODO" ./src                  # recursive search in directory
grep -v "debug" app.log               # exclude lines matching
grep -A 3 "error" app.log             # show 3 lines AFTER match
grep -B 3 "error" app.log             # show 3 lines BEFORE match
grep -E "error|warn" app.log          # regex OR

awk '{print $1}' file          # print first column
awk '{print $1, $3}' file      # print columns 1 and 3
awk -F: '{print $1}' /etc/passwd   # use : as delimiter
awk '/error/ {print $0}' file  # print lines matching pattern
 
# Real example: get PIDs from ps
ps aux | awk '{print $2}'

sed 's/old/new/' file             # replace first occurrence per line
sed 's/old/new/g' file            # replace all occurrences
sed -i 's/old/new/g' file         # in-place edit (modifies file)
sed -n '10,20p' file              # print lines 10–20
sed '/pattern/d' file             # delete lines matching pattern

# Count errors per minute from a log
grep "ERROR" app.log | awk '{print $1, $2}' | sort | uniq -c

0 * * * *        # every hour at :00
*/15 * * * *     # every 15 minutes
0 2 * * *        # daily at 2:00 AM
0 2 * * 0        # weekly Sunday at 2 AM
0 0 1 * *        # monthly on 1st at midnight

crontab -e        # edit your crontab
crontab -l        # list your crontabs
crontab -r        # remove all (careful!)
sudo crontab -e   # edit root's crontab

# Always redirect output or it emails you (annoying)
0 2 * * * /path/to/script.sh >> /var/log/myjob.log 2>&1
 
# Use absolute paths — cron has minimal $PATH
0 2 * * * /usr/bin/python3 /home/user/script.py

ssh user@hostname              # connect
ssh -p 2222 user@hostname      # non-default port
ssh -i ~/.ssh/mykey user@host  # specific key

# Generate a key pair (do this once)
ssh-keygen -t ed25519 -C "your@email.com"
 
# Copy public key to server
ssh-copy-id user@hostname
# or manually:
cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys  # on server

scp file.txt user@host:/path/        # copy file to server
scp user@host:/path/file.txt .       # copy file from server
scp -r dir/ user@host:/path/         # copy directory
rsync -avz ./local/ user@host:/path/ # sync (better than scp for dirs)

# Local: access remote service locally
ssh -L 8080:localhost:5432 user@host
# Now: localhost:8080 → host:5432 (postgres on remote)
 
# Remote: expose local port on remote server
ssh -R 9090:localhost:8080 user@host

# ~/.ssh/config
Host myserver
    HostName 192.168.1.100
    User ubuntu
    Port 2222
    IdentityFile ~/.ssh/mykey
 
# Now just:
ssh myserver

echo $HOME              # print a variable
echo $PATH              # where shell looks for commands
env                     # list all env vars
printenv VAR_NAME       # print specific var
 
export MY_VAR="value"   # set for current session + child processes
MY_VAR="value" command  # set only for this one command

# Add to ~/.bashrc (user shell sessions)
echo 'export MY_VAR="value"' >> ~/.bashrc
source ~/.bashrc         # reload without restarting terminal
 
# System-wide
/etc/environment         # simple KEY=VALUE, no export needed
/etc/profile.d/*.sh      # scripts loaded at login

# .env file format
DB_HOST=localhost
DB_PORT=5432
DB_PASS=secret
 
# Load in bash
set -a; source .env; set +a
 
# Pass to docker
docker run --env-file .env myapp

[Service]
Environment="DB_HOST=localhost"
EnvironmentFile=/etc/myapp/.env

df -h                   # disk usage per filesystem (human-readable)
df -h /                 # just root partition
du -sh /var/log         # size of a directory
du -sh * | sort -rh     # size of all items, sorted largest first
du -sh * | sort -rh | head -10   # top 10 largest

du -sh /var/* | sort -rh | head    # what's in /var?
du -sh /var/log/* | sort -rh       # drilling into logs
find / -size +500M 2>/dev/null     # files larger than 500MB

free -h                 # RAM + swap (human-readable)
free -m                 # in megabytes

# Top memory consumers
ps aux --sort=-%mem | head -10
 
# Top CPU consumers
ps aux --sort=-%cpu | head -10

# Create archives
tar -czf archive.tar.gz  dir/      # gzip compressed
tar -cjf archive.tar.bz2 dir/      # bzip2 compressed
tar -cf  archive.tar     dir/       # no compression
 
# Extract
tar -xzf archive.tar.gz            # extract gzip
tar -xjf archive.tar.bz2           # extract bzip2
tar -xf  archive.tar               # extract uncompressed
 
# List contents without extracting
tar -tzf archive.tar.gz
 
# Extract to specific location
tar -xzf archive.tar.gz -C /target/dir/

#!/bin/bash
set -euo pipefail   # e=exit on error, u=error on undefined var, o pipefail=pipe failures
 
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

name="test"
echo "$name"          # always quote variables
echo "${name}_suffix" # use braces when needed

if [ "$name" = "test" ]; then
    echo "match"
elif [ "$name" = "other" ]; then
    echo "other"
else
    echo "no match"
fi
 
# File checks
[ -f file ]    # file exists
[ -d dir ]     # directory exists
[ -z "$var" ]  # variable is empty
[ -n "$var" ]  # variable is not empty

for i in 1 2 3; do echo "$i"; done
 
for file in *.log; do
    echo "Processing $file"
done
 
while read -r line; do
    echo "$line"
done < input.txt

greet() {
    local name="$1"    # local = scoped to function
    echo "Hello, $name"
}
greet "Nishanth"

command
echo $?         # 0 = success, anything else = failure
 
command || echo "command failed"     # run on failure
command && echo "command succeeded"  # run on success

systemctl start app
systemctl stop app
systemctl restart app
systemctl reload app        # reload config without restart (if supported)
systemctl status app        # current state + recent logs

systemctl enable app        # start at boot
systemctl disable app       # don't start at boot
systemctl is-enabled app    # check if enabled

journalctl -u app           # all logs for service
journalctl -u app -f        # follow (live tail)
journalctl -u app -n 100    # last 100 lines
journalctl -u app --since "1 hour ago"
journalctl -u app --since "2024-01-01" --until "2024-01-02"

[Unit]
Description=My App
After=network.target       # start after network is up
 
[Service]
Type=simple
ExecStart=/usr/bin/python3 /app/main.py
WorkingDirectory=/app
User=appuser
Group=app
Restart=always
RestartSec=5               # wait 5s before restarting
Environment=PORT=8080
EnvironmentFile=/app/.env
 
# Output to journal
StandardOutput=journal
StandardError=journal
 
[Install]
WantedBy=multi-user.target

# After creating/editing a service file:
systemctl daemon-reload     # always do this first
systemctl enable --now app  # enable + start in one command

# 1. Service status
systemctl status app
 
# 2. Logs (most important step)
journalctl -u app -f
 
# 3. Process running?
ps aux | grep app
 
# 4. Port listening?
ss -tulnp | grep 8080
 
# 5. HTTP responding?
curl -v localhost:8080
 
# 6. Disk full? Memory?
df -h && free -h
 
# 7. Permissions?
ls -lah /app/