/
├── bin      → essential user command binaries (often symlinked to /usr/bin now)
├── boot      → bootloader files, kernel images
├── dev        → device files (e.g. /dev/sda for a disk)
├── etc         → system-wide configuration files
├── home         → personal directories for each user (/home/ec2-user)
├── lib            → shared libraries
├── opt              → optional/third-party software
├── proc               → virtual filesystem exposing running processes/kernel info
├── root                 → the root user's home directory (NOT the same as /)
├── tmp                    → temporary files, often cleared on reboot
├── usr                     → user programs, libraries, documentation
└── var                       → variable data: logs, caches, spool files

pwd                     # print working directory - "where am I?"
ls                        # list files in current directory
ls -la                       # list ALL files (including hidden dotfiles), long format (permissions, size, owner)
ls -lh                          # long format with human-readable sizes (K/M/G instead of raw bytes)

cd /var/log                        # change directory - absolute path
cd ..                                  # go up one level
cd ~                                      # go to your home directory
cd -                                         # go to the PREVIOUS directory you were in

mkdir my-folder                                 # create a directory
mkdir -p a/b/c                                     # create nested directories in one go (-p = parents)

touch notes.txt                                       # create an empty file (or update its timestamp if it exists)

cp notes.txt backup.txt                                  # copy a file
cp -r my-folder my-folder-copy                              # copy a directory recursively

mv backup.txt archive/backup.txt                                # move (or rename) a file
mv notes.txt final-notes.txt                                       # rename in place

rm final-notes.txt                                                    # remove a file
rm -r my-folder-copy                                                     # remove a directory and its contents
rm -rf a                                                                     # force remove, no confirmation - USE CAREFULLY, no undo

man ls              # full manual page for the ls command (press q to quit)
ls --help              # quick summary of flags, faster than man
whatis ls                 # one-line description of what a command does

mkdir -p ~/linux-practice/{projects,scripts,logs}
cd ~/linux-practice
ls -la

touch projects/app.py scripts/deploy.sh logs/app.log

# Explore what you just built
find ~/linux-practice -type f          # list all files
find ~/linux-practice -type d           # list all directories

# Practice moving around
cd scripts
pwd
cd ../logs
pwd
cd ~/linux-practice

-rwxr-xr-- 1 ec2-user developers 220 Sep  9 10:15 deploy.sh

-  rwx  r-x  r--
│   │    │    │
│   │    │    └── OTHER: read only
│   │    └─────── GROUP: read + execute
│   └──────────── OWNER: read + write + execute
└──────────────── file type (- = regular file, d = directory, l = symlink)

cd ~/linux-practice
touch script.sh
ls -l script.sh

chmod u+x script.sh        # add execute for the owner (user)
chmod g+w script.sh          # add write for the group
chmod o-r script.sh            # remove read for others
chmod a+x script.sh              # add execute for everyone (a = all)

chmod 755 script.sh    # owner: rwx (7) | group: r-x (5) | other: r-x (5)
chmod 644 script.sh     # owner: rw- (6) | group: r-- (4) | other: r-- (4)
chmod 700 script.sh      # owner: rwx (7) | group: --- (0) | other: --- (0)

echo '#!/bin/bash' > script.sh
echo 'echo "Hello!"' >> script.sh

./script.sh              # fails - "Permission denied" (no execute bit yet)
chmod +x script.sh          # add execute permission
./script.sh                    # now it runs

whoami                # who am I?
id                       # my user ID (UID), group ID (GID), and all groups I belong to
cat /etc/passwd            # every user on the system (one line per user)
cat /etc/group               # every group on the system
groups                          # groups the CURRENT user belongs to

sudo chown ec2-user script.sh              # change the owner
sudo chown ec2-user:developers script.sh      # change owner AND group in one command
sudo chgrp developers script.sh                  # change only the group

whoami           # e.g. ec2-user
sudo whoami         # root

sudo su                 # switch to a full root shell (use sparingly - easy to make sweeping mistakes)
exit                       # leave the root shell, back to your normal user

sudo visudo    # view/edit safely

ls -ld /tmp
# drwxrwxrwt  ← that trailing 't' is the sticky bit, exactly why /tmp is safe for multiple users to share

cd ~/linux-practice
mkdir shared-scripts
chmod 755 shared-scripts

cd shared-scripts
echo '#!/bin/bash' > backup.sh
echo 'echo "Backing up..."' >> backup.sh
chmod 750 backup.sh    # owner: rwx, group: r-x, other: no access

ls -l backup.sh

cat file.txt              # dump the entire file to the terminal
less file.txt                # page through it - use arrow keys, / to search, q to quit
head file.txt                   # first 10 lines
head -n 20 file.txt                # first 20 lines
tail file.txt                        # last 10 lines
tail -n 20 file.txt                     # last 20 lines
tail -f /var/log/messages                  # follow a file live as new lines are appended - critical for watching logs in real time

echo "line one" > notes.txt          # create/overwrite notes.txt with this line
echo "line two" >> notes.txt            # append a second line
cat notes.txt                              # confirm both lines are there

ls -la /etc > etc-listing.txt                 # save command output to a file
ls /nonexistent 2> errors.txt                    # save just the error message to a file

# Pipe example: list processes, filter for "ssh", count matching lines
ps aux | grep ssh | wc -l

grep "error" app.log                  # find lines containing "error"
grep -i "error" app.log                  # case-insensitive
grep -r "TODO" ~/linux-practice             # search recursively through a directory
grep -n "error" app.log                        # show line numbers
grep -v "debug" app.log                           # invert match - show lines that DON'T contain "debug"
grep -c "error" app.log                              # count matching lines instead of printing them
grep -E "error|warning" app.log                        # extended regex - match either word

cd ~/linux-practice
printf "INFO: starting up\nERROR: connection failed\nINFO: retrying\nERROR: timeout\n" > app.log

grep "ERROR" app.log
grep -c "ERROR" app.log
grep -v "ERROR" app.log

sed 's/ERROR/WARNING/' app.log            # replace first match per line (prints to terminal, doesn't modify file)
sed -i 's/ERROR/WARNING/g' app.log           # -i = edit the file IN PLACE, g = replace ALL matches per line, not just the first
sed -n '2,3p' app.log                           # print only lines 2-3

echo "alice 25 engineer" | awk '{print $1}'          # print the 1st field (fields split on whitespace by default)
echo "alice 25 engineer" | awk '{print $2, $3}'         # print the 2nd and 3rd fields

# real example: print just the usernames from `ls -l` output
ls -l ~/linux-practice | awk '{print $3}'

find ~/linux-practice -name "*.log"           # find files by name pattern
find ~/linux-practice -type d                    # find only directories
find ~/linux-practice -mtime -1                     # files modified in the last 1 day
find ~/linux-practice -size +1M                        # files larger than 1MB

which python3          # show the full path of a command (where it will actually run from)
whereis python3           # similar, also shows man page location if available

locate app.log               # fast filename search using a prebuilt index (may need `sudo updatedb` first, and may not be installed on minimal images)

nano notes.txt

vim notes.txt

i          → enter insert mode (start typing)
Esc        → back to normal mode
:w         → save
:q         → quit (fails if unsaved changes)
:wq        → save and quit
:q!        → quit WITHOUT saving (discard changes)
dd         → delete the current line (normal mode)
/searchterm → search forward for text
n          → jump to next search match

vim notes.txt

ps                  # processes in YOUR current terminal session
ps aux                 # ALL processes on the system, all users, full detail
ps aux | grep nginx        # find a specific process

USER   PID  %CPU %MEM  VSZ   RSS TTY  STAT START TIME COMMAND
root     1   0.0  0.1  1234  512 ?    Ss   09:00 0:01 /sbin/init
nginx  842   0.1  0.5  9876 2048 ?    S    09:05 0:00 nginx: worker

top          # built-in on virtually every Linux system
htop            # nicer interface, color, easier to navigate - may need: sudo yum install -y htop

kill <PID>              # sends SIGTERM - a polite "please stop" request the process can catch and clean up after
kill -9 <PID>               # sends SIGKILL - immediate, forceful termination, cannot be ignored or caught
killall nginx                  # kill ALL processes matching a name
pkill -f "python app.py"          # kill processes matching a pattern in their full command line

# Start something long-running in the background to practice on
sleep 300 &
jobs                    # show background jobs in this shell
ps aux | grep sleep

kill %1                  # kill background job #1 (referenced by job number)
# or, using the PID directly:
# kill <PID>

sleep 100                  # runs in the FOREGROUND - blocks your terminal until it finishes
sleep 100 &                   # runs in the BACKGROUND - you get your terminal back immediately

jobs                             # list background jobs in the current shell
fg %1                               # bring job 1 back to the foreground
Ctrl+Z                                 # suspend (pause) the current foreground job
bg %1                                     # resume a suspended job, but in the background

nohup python app.py &
# output goes to nohup.out by default unless redirected elsewhere

tmux new -s mysession        # start a new named session
# ...do your work...
# press Ctrl+B then D to detach (session keeps running)

tmux ls                          # list active sessions
tmux attach -t mysession            # reattach later, from the same or a different SSH connection

sudo systemctl status jenkins        # is it running? recent log lines? enabled at boot?
sudo systemctl start jenkins            # start it now
sudo systemctl stop jenkins                # stop it now
sudo systemctl restart jenkins                # stop then start
sudo systemctl enable jenkins                    # start automatically on boot
sudo systemctl disable jenkins                      # don't start automatically on boot
sudo systemctl is-enabled jenkins                       # check if it's set to start on boot

sudo tee /etc/systemd/system/mytool.service > /dev/null << 'EOF'
[Unit]
Description=My Practice Tool
After=network.target

[Service]
ExecStart=/usr/bin/sleep infinity
Restart=on-failure
User=ec2-user

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload      # tell systemd to notice the new unit file
sudo systemctl start mytool
sudo systemctl status mytool
sudo systemctl enable mytool

sudo systemctl stop mytool
sudo systemctl disable mytool
sudo rm /etc/systemd/system/mytool.service
sudo systemctl daemon-reload

df -h              # disk space usage, human-readable, per filesystem/mount
du -sh /var/log        # total size of a specific directory
du -sh /var/log/*         # size of each item inside, individually

free -h                      # memory usage: total, used, free, available (human-readable)

uptime                          # how long the system has been running, plus load average

vmstat 2 5                         # system performance snapshot, repeated every 2 seconds, 5 times

              total    used    free   shared  buff/cache  available
Mem:          7.8Gi   2.1Gi   3.2Gi   120Mi    2.5Gi        5.4Gi

10:32:01 up 5 days, 3:14, 2 users, load average: 0.15, 0.22, 0.18

ip addr                 # show network interfaces and their IP addresses (modern replacement for old `ifconfig`)
ip a                        # shorthand for the same thing

ping google.com                # test basic connectivity - sends packets, waits for replies (Ctrl+C to stop)
ping -c 4 google.com               # send exactly 4 pings then stop

curl https://api.github.com           # fetch a URL and print the response body
curl -I https://api.github.com           # fetch just the HEADERS (useful to check status codes quickly)
curl -o output.json https://api.github.com/users/octocat   # save the response to a file

wget https://example.com/file.zip        # download a file directly to disk

ss -tulpn                                    # show listening ports and the process using each (modern replacement for `netstat`)
netstat -tulpn                                  # older equivalent, still common in tutorials/muscle memory

Netid  State   Local Address:Port   Process
tcp    LISTEN  0.0.0.0:8080         users:(("java",pid=1234,fd=6))

nslookup google.com          # basic DNS lookup
dig google.com                  # more detailed DNS lookup, standard tool for DNS debugging

sudo yum update                 # update the package index and upgrade all installed packages
sudo yum install -y htop           # install a package (-y = auto-confirm)
sudo yum remove -y htop               # uninstall a package
yum search "text editor"                 # search for packages by keyword
yum list installed                          # list everything currently installed
yum info htop                                  # detailed info about a specific package

sudo apt update                  # refresh the package index (does NOT upgrade anything yet)
sudo apt upgrade -y                 # actually upgrade installed packages
sudo apt install -y htop               # install a package
sudo apt remove -y htop                   # uninstall a package
apt search "text editor"                     # search for packages
apt list --installed                            # list installed packages

# Generate a new key pair (if you don't already have one for this purpose)
ssh-keygen -t ed25519 -C "your_email@example.com"
# Follow the prompts - default location is fine for most cases

# The public key is what you'd add to a server's authorized_keys
cat ~/.ssh/id_ed25519.pub

ssh -i mykey.pem ec2-user@<public-ip>          # connect using a specific private key file

Host myserver
    HostName 54.123.45.67
    User ec2-user
    IdentityFile ~/.ssh/mykey.pem

ssh myserver

# scp - simple, one-shot copy
scp -i mykey.pem localfile.txt ec2-user@<ip>:/home/ec2-user/          # upload
scp -i mykey.pem ec2-user@<ip>:/home/ec2-user/remotefile.txt .            # download

# rsync - smarter, only transfers what changed, can resume interrupted transfers
rsync -avz -e "ssh -i mykey.pem" ./local-folder/ ec2-user@<ip>:/home/ec2-user/remote-folder/

sudo systemctl status firewalld

sudo firewall-cmd --list-all                          # see current rules
sudo firewall-cmd --add-port=8080/tcp --permanent         # allow a port, persist across reboots
sudo firewall-cmd --reload                                   # apply changes
sudo firewall-cmd --remove-port=8080/tcp --permanent            # remove a rule

sudo ufw status
sudo ufw allow 8080/tcp
sudo ufw deny 23
sudo ufw enable

mkdir -p ~/linux-practice/scripts
cd ~/linux-practice/scripts

#!/bin/bash
echo "Hello from a shell script!"
echo "Today is $(date)"

chmod +x hello.sh
./hello.sh

./hello.sh           # requires execute permission (chmod +x) - uses the shebang to pick the interpreter
bash hello.sh            # explicitly runs it with bash - doesn't need execute permission
source hello.sh              # runs it in your CURRENT shell session, not a new one - variables it sets persist after

#!/bin/bash

name="Anup"
echo "Hello, $name"

# Command substitution - capture a command's output into a variable
current_dir=$(pwd)
echo "You are in: $current_dir"

file_count=$(ls | wc -l)
echo "Files here: $file_count"

#!/bin/bash
echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "All arguments: $@"
echo "Number of arguments: $#"

chmod +x greet.sh
./greet.sh Anup Kumar

#!/bin/bash
read -p "Enter your name: " user_name
echo "Hello, $user_name!"

#!/bin/bash

read -p "Enter a number: " num

if [ "$num" -gt 10 ]; then
    echo "That's greater than 10"
elif [ "$num" -eq 10 ]; then
    echo "That's exactly 10"
else
    echo "That's less than 10"
fi

#!/bin/bash
if [ -f "/etc/hosts" ]; then
    echo "hosts file exists"
fi

if [ ! -d "/tmp/mydir" ]; then
    echo "mydir doesn't exist yet, creating it"
    mkdir /tmp/mydir
fi

#!/bin/bash
for i in 1 2 3 4 5; do
    echo "Number: $i"
done

# Loop over files
for file in ~/linux-practice/*.txt; do
    echo "Found: $file"
done

# Numeric range
for i in {1..5}; do
    echo "Count: $i"
done

#!/bin/bash
count=1
while [ $count -le 5 ]; do
    echo "Attempt $count"
    count=$((count + 1))
done

#!/bin/bash
servers=("google.com" "github.com" "does-not-exist-xyz.com")

for server in "${servers[@]}"; do
    if ping -c 1 -W 2 "$server" > /dev/null 2>&1; then
        echo "$server is UP"
    else
        echo "$server is DOWN"
    fi
done

#!/bin/bash

greet() {
    local name=$1
    echo "Hello, $name!"
}

check_disk_space() {
    local threshold=$1
    local usage=$(df / | tail -1 | awk '{print $5}' | tr -d '%')
    if [ "$usage" -gt "$threshold" ]; then
        echo "WARNING: disk usage is at ${usage}%, above threshold of ${threshold}%"
    else
        echo "OK: disk usage is at ${usage}%"
    fi
}

greet "Anup"
check_disk_space 80

ls /etc > /dev/null
echo $?          # prints 0 - success

ls /nonexistent > /dev/null 2>&1
echo $?              # prints a non-zero code - failure

#!/bin/bash

if ! ping -c 1 google.com > /dev/null 2>&1; then
    echo "No internet connection - aborting"
    exit 1
fi

echo "Connection confirmed, continuing..."

#!/bin/bash
set -e     # exit immediately if any command fails

mkdir /tmp/mydeploy
cd /tmp/mydeploy
cp important-file.txt .    # if this fails (e.g. file doesn't exist), the script stops here instead of continuing blindly
echo "Deploy complete"

#!/bin/bash
set -u    # error out if you reference an undefined variable (catches typos like $nmae instead of $name)

#!/bin/bash
set -euo pipefail

SOURCE_DIR="$HOME/linux-practice"
BACKUP_DIR="$HOME/backups"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
BACKUP_FILE="$BACKUP_DIR/backup-$TIMESTAMP.tar.gz"

mkdir -p "$BACKUP_DIR"

echo "Backing up $SOURCE_DIR..."
tar -czf "$BACKUP_FILE" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")"
echo "Backup created: $BACKUP_FILE"

echo "Removing backups older than 7 days..."
find "$BACKUP_DIR" -name "backup-*.tar.gz" -mtime +7 -delete

echo "Current backups:"
ls -lh "$BACKUP_DIR"

chmod +x backup.sh
./backup.sh

ls -l /var/log

sudo tail -f /var/log/messages          # Amazon Linux / RHEL - general system log
sudo tail -f /var/log/syslog                # Ubuntu/Debian equivalent
sudo tail -f /var/log/secure                   # RHEL - authentication/sudo log
sudo tail -f /var/log/auth.log                    # Ubuntu equivalent

journalctl                      # all logs, oldest first
journalctl -r                       # reverse - newest first
journalctl -u jenkins                   # logs for a SPECIFIC service (you'll recognize this from debugging Jenkins)
journalctl -u jenkins -f                   # follow a specific service's logs live
journalctl --since "1 hour ago"                # time-filtered
journalctl --since "2024-01-01" --until "2024-01-02"
journalctl -p err                                  # only error-priority and above

cat /etc/logrotate.conf              # global config
ls /etc/logrotate.d/                     # per-application configs (e.g., one for nginx, one for a custom app)

/var/log/myapp/*.log {
    daily
    rotate 7
    compress
    missingok
    notifempty
}

crontab -l              # list your current scheduled jobs
crontab -e                 # edit your scheduled jobs (opens in your default editor)

 ┌───────────── minute (0–59)
 │ ┌───────────── hour (0–23)
 │ │ ┌───────────── day of month (1–31)
 │ │ │ ┌───────────── month (1–12)
 │ │ │ │ ┌───────────── day of week (0–6, Sunday=0)
 │ │ │ │ │
 * * * * *  command-to-run

0 2 * * *        /home/ec2-user/linux-practice/scripts/backup.sh          # every day at 2:00 AM
*/15 * * * *      /home/ec2-user/scripts/healthcheck.sh                      # every 15 minutes
0 9 * * 1-5        /home/ec2-user/scripts/daily-report.sh                       # 9 AM, weekdays only
0 0 1 * *            /home/ec2-user/scripts/monthly-cleanup.sh                    # midnight, first day of every month

crontab -e

0 2 * * * /home/ec2-user/linux-practice/scripts/backup.sh >> /home/ec2-user/backups/cron.log 2>&1

grep CRON /var/log/cron                # RHEL/Amazon Linux
grep CRON /var/log/syslog                  # Ubuntu
cat ~/backups/cron.log                        # your own redirected output, from the example above

sudo nano /etc/ssh/sshd_config

PermitRootLogin no

sudo systemctl restart sshd

PasswordAuthentication no

sudo yum install -y epel-release fail2ban     # Amazon Linux/RHEL (needs the EPEL repo first)
sudo systemctl enable --now fail2ban

sudo fail2ban-client status                      # see active "jails" (protection rules)
sudo fail2ban-client status sshd                    # see banned IPs for the SSH jail specifically

sudo yum update -y            # RHEL/Amazon Linux
sudo apt update && sudo apt upgrade -y    # Ubuntu/Debian