DEV Community: methew smith

scripting

methew smith — Sun, 15 Mar 2026 01:54:39 +0000

File: systeminfo.sh

#!/bin/bash
# systeminfo.sh
# Purpose: Display system information including kernel, processor, OS, and editor info
# Usage: ./systeminfo.sh

echo "========================================="
echo "         SYSTEM INFORMATION REPORT       "
echo "========================================="

# Print kernel name (e.g., Linux)
echo "Kernel Name     : $(uname -s)"

# Print kernel release version (e.g., 5.15.0-91-generic)
echo "Kernel Release  : $(uname -r)"

# Print processor/hardware type (e.g., x86_64)
echo "Processor Type  : $(uname -p)"

# Print the installed operating system name and version
echo "Operating System: $(lsb_release -d | cut -f2)"

echo ""
echo "========================================="
echo "           FAVORITE EDITOR INFO          "
echo "========================================="

# Define favorite editor
EDITOR_NAME="nano"

# Display the name of the favorite editor
echo "Favorite Editor : $EDITOR_NAME"

# Show where the editor binary is located using 'which'
echo "Editor Location : $(which $EDITOR_NAME)"

# Show where the editor documentation/manual is located using 'whereis'
echo "Documentation   : $(whereis $EDITOR_NAME)"

echo "========================================="

Make executable and run:

chmod +x systeminfo.sh
./systeminfo.sh

Expected Output:

=========================================
         SYSTEM INFORMATION REPORT
=========================================
Kernel Name     : Linux
Kernel Release  : 5.15.0-91-generic
Processor Type  : x86_64
Operating System: Ubuntu 22.04.3 LTS
=========================================
           FAVORITE EDITOR INFO
=========================================
Favorite Editor : nano
Editor Location : /usr/bin/nano
Documentation   : nano: /usr/bin/nano /usr/share/man/man1/nano.1.gz
=========================================

User and Group Management
File: usergroup.sh

#!/bin/bash
# usergroup.sh
# Purpose: Create a user, a group, and add the user to the group
# Usage: ./usergroup.sh

echo "========================================="
echo "       USER AND GROUP MANAGEMENT         "
echo "========================================="

# Step 1: Create a new user named 'devopsuser'
# -m flag creates the home directory automatically
# -s sets the default shell to bash
if id "devopsuser" &>/dev/null; then
    # Check if user already exists to avoid errors
    echo "[INFO] User 'devopsuser' already exists. Skipping creation."
else
    sudo useradd -m -s /bin/bash devopsuser
    echo "[SUCCESS] User 'devopsuser' created successfully."
fi

# Step 2: Create a new group named 'devopsgroup'
if getent group devopsgroup &>/dev/null; then
    # Check if group already exists to avoid errors
    echo "[INFO] Group 'devopsgroup' already exists. Skipping creation."
else
    sudo groupadd devopsgroup
    echo "[SUCCESS] Group 'devopsgroup' created successfully."
fi

# Step 3: Add 'devopsuser' to 'devopsgroup'
# usermod -aG appends the user to the group without removing from other groups
sudo usermod -aG devopsgroup devopsuser
echo "[SUCCESS] User 'devopsuser' added to group 'devopsgroup'."

# Display verification — show the groups the user belongs to
echo ""
echo "--- Verification ---"
echo "Groups for devopsuser:"
groups devopsuser

echo "========================================="

Make executable and run:

chmod +x usergroup.sh
./usergroup.sh

Expected Output:

=========================================
       USER AND GROUP MANAGEMENT
=========================================
[SUCCESS] User 'devopsuser' created successfully.
[SUCCESS] Group 'devopsgroup' created successfully.
[SUCCESS] User 'devopsuser' added to group 'devopsgroup'.

--- Verification ---
Groups for devopsuser: devopsuser devopsgroup
=========================================

Question 3: SSH Configuration

File: sshconfig.sh

#!/bin/bash
# sshconfig.sh
# Purpose: Generate SSH key pair, configure passwordless login, and run non-interactive SSH tasks
# Usage: ./sshconfig.sh

echo "========================================="
echo "          SSH CONFIGURATION SCRIPT       "
echo "========================================="

# Define the target user and their home directory
TARGET_USER="devopsuser"
USER_HOME="/home/$TARGET_USER"
SSH_DIR="$USER_HOME/.ssh"

# -----------------------------------------------
# Step 1: Generate SSH key pair for devopsuser
# -----------------------------------------------
echo "[STEP 1] Generating SSH key pair for $TARGET_USER..."

# Create .ssh directory inside devopsuser's home if it doesn't exist
sudo mkdir -p $SSH_DIR

# Generate RSA key pair with no passphrase (-N "")
# -t rsa   → use RSA algorithm
# -b 2048  → 2048-bit key strength
# -f       → specify the output file path
# -N ""    → no passphrase (for automation)
sudo ssh-keygen -t rsa -b 2048 -f $SSH_DIR/id_rsa -N "" -C "$TARGET_USER@localhost"

# Copy public key to authorized_keys so the user can login with the private key
sudo cat $SSH_DIR/id_rsa.pub | sudo tee $SSH_DIR/authorized_keys > /dev/null

# Set correct permissions — SSH is strict about permissions
# 700 = only owner can access the .ssh folder
# 600 = only owner can read/write the key files
sudo chmod 700 $SSH_DIR
sudo chmod 600 $SSH_DIR/authorized_keys
sudo chmod 600 $SSH_DIR/id_rsa
sudo chmod 644 $SSH_DIR/id_rsa.pub

# Make devopsuser own all these files
sudo chown -R $TARGET_USER:$TARGET_USER $SSH_DIR

echo "[SUCCESS] SSH key pair generated and saved to $SSH_DIR"

# -----------------------------------------------
# Step 2: Disable password authentication in SSH config
# -----------------------------------------------
echo "[STEP 2] Disabling password authentication in /etc/ssh/sshd_config..."

# Edit SSH server config to disable password-based login
# This forces key-based authentication only
sudo sed -i 's/^#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
sudo sed -i 's/^PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config

# Also ensure PubkeyAuthentication is enabled
sudo sed -i 's/^#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config

# Restart SSH service to apply changes
sudo systemctl restart ssh
echo "[SUCCESS] Password authentication disabled. Key-based auth enabled."

# -----------------------------------------------
# Step 3: Set up SSH shortcut in ~/.ssh/config
# -----------------------------------------------
echo "[STEP 3] Setting up SSH config shortcut..."

# Create SSH client config file so user doesn't need to type full username and IP
# This allows: ssh devopsserver  instead of: ssh devopsuser@127.0.0.1
sudo tee $SSH_DIR/config << EOF
# SSH shortcut configuration for devopsuser
Host devopsserver
    HostName 127.0.0.1
    User $TARGET_USER
    Port 22
    IdentityFile $SSH_DIR/id_rsa
EOF

# Fix permissions on config file
sudo chmod 600 $SSH_DIR/config
sudo chown $TARGET_USER:$TARGET_USER $SSH_DIR/config

echo "[SUCCESS] SSH config shortcut created. Use: ssh devopsserver"

# -----------------------------------------------
# Step 3a: SSH in non-interactive mode and run tasks
# -----------------------------------------------
echo "[STEP 3a] Running tasks via non-interactive SSH..."

# Task b: Create a test directory inside home directory
# -o StrictHostKeyChecking=no → skip host fingerprint prompt (for automation)
sudo -u $TARGET_USER ssh -o StrictHostKeyChecking=no \
    -i $SSH_DIR/id_rsa \
    $TARGET_USER@127.0.0.1 \
    "mkdir -p ~/testdir"
echo "[SUCCESS] Test directory 'testdir' created inside $USER_HOME"

# Task c: Create file and write the required text into it
sudo -u $TARGET_USER ssh -o StrictHostKeyChecking=no \
    -i $SSH_DIR/id_rsa \
    $TARGET_USER@127.0.0.1 \
    "echo 'I am doing the task3.' > ~/testdir/filecreatedinnoninteractivemode.txt"
echo "[SUCCESS] File 'filecreatedinnoninteractivemode.txt' created with required content."

# Verify the file contents
echo ""
echo "--- Verification: File Contents ---"
sudo cat $USER_HOME/testdir/filecreatedinnoninteractivemode.txt

echo "========================================="
echo "     SSH CONFIGURATION COMPLETE          "
echo "========================================="

Make executable and run:

chmod +x sshconfig.sh
sudo ./sshconfig.sh

Question 4: File and Directory Manipulation

File: filedir.sh

#!/bin/bash
# filedir.sh
# Purpose: Create directory, file, write content, and set correct permissions
# Usage: ./filedir.sh

echo "========================================="
echo "     FILE AND DIRECTORY MANIPULATION     "
echo "========================================="

# Step 1: Create the directory /devopsdir
# -p flag prevents error if directory already exists
sudo mkdir -p /devopsdir
echo "[SUCCESS] Directory '/devopsdir' created."

# Step 2: Create file inside /devopsdir and write the required text
# Using tee with sudo so we can write to the protected /devopsdir
echo "AoA, Hello DevOps!" | sudo tee /devopsdir/devopsfile.txt > /dev/null
echo "[SUCCESS] File 'devopsfile.txt' created with content: 'AoA, Hello DevOps!'"

# Step 3: Set permissions for devopsuser and other users
# We need to set:
#   - devopsuser → rw- on the file (read + write) → 6
#   - devopsuser → rwx on the directory (read + write + execute) → 7
#   - Others     → r-- on the file (read only) → 4
#   - Others     → r-- on the directory (read only) → 4

# Change owner of /devopsdir and its contents to devopsuser
sudo chown -R devopsuser:devopsuser /devopsdir

# Set permissions on the directory: rwxr--r-- (744)
# devopsuser: rwx (7), group: r-- (4), others: r-- (4)
sudo chmod 744 /devopsdir

# Set permissions on the file: rw-r--r-- (644)
# devopsuser: rw- (6), group: r-- (4), others: r-- (4)
sudo chmod 644 /devopsdir/devopsfile.txt

echo "[SUCCESS] Permissions set:"
echo "  /devopsdir       → 744 (devopsuser: rwx, others: r--)"
echo "  devopsfile.txt   → 644 (devopsuser: rw-, others: r--)"

# Verify — display the final permissions
echo ""
echo "--- Verification ---"
ls -ld /devopsdir
ls -l /devopsdir/devopsfile.txt
echo ""
echo "--- File Content ---"
cat /devopsdir/devopsfile.txt

echo "========================================="

Make executable and run:

chmod +x filedir.sh
sudo ./filedir.sh

Expected Output:

=========================================
     FILE AND DIRECTORY MANIPULATION
=========================================
[SUCCESS] Directory '/devopsdir' created.
[SUCCESS] File 'devopsfile.txt' created with content: 'AoA, Hello DevOps!'
[SUCCESS] Permissions set:
  /devopsdir       → 744 (devopsuser: rwx, others: r--)
  devopsfile.txt   → 644 (devopsuser: rw-, others: r--)

--- Verification ---
drwxr--r-- 2 devopsuser devopsuser 4096 Mar 15 12:00 /devopsdir
-rw-r--r-- 1 devopsuser devopsuser   19 Mar 15 12:00 /devopsdir/devopsfile.txt

--- File Content ---
AoA, Hello DevOps!
=========================================

Question 5: Backup Script

File: backup.sh

#!/bin/bash
# backup.sh
# Purpose: Compress /devopsdir into a timestamped tarball and save to devopsuser's backup folder
# Usage: ./backup.sh
# Bonus: Also sets up a cron job to run this backup every 10 minutes

echo "========================================="
echo "            BACKUP SCRIPT                "
echo "========================================="

# Define variables
SOURCE_DIR="/devopsdir"                            # Directory to back up
BACKUP_DIR="/home/devopsuser/backup"               # Where to save backups
TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")            # Unique timestamp: e.g., 2026-03-15_14-30-00
BACKUP_FILE="$BACKUP_DIR/devopsdir_backup_$TIMESTAMP.tar.gz"  # Full backup filename

# Step 1: Create backup directory if it doesn't exist
mkdir -p $BACKUP_DIR
echo "[INFO] Backup directory: $BACKUP_DIR"

# Step 2: Check if source directory exists before backing up
if [ ! -d "$SOURCE_DIR" ]; then
    echo "[ERROR] Source directory '$SOURCE_DIR' does not exist. Exiting."
    exit 1
fi

# Step 3: Create compressed tarball of /devopsdir
# -c → create archive
# -z → compress with gzip
# -f → specify filename
# -v → verbose (show files being added)
tar -czf $BACKUP_FILE $SOURCE_DIR 2>/dev/null

# Step 4: Check if backup was created successfully using exit code $?
if [ $? -eq 0 ]; then
    echo "[SUCCESS] Backup created: $BACKUP_FILE"
    echo "[INFO] Backup size: $(du -sh $BACKUP_FILE | cut -f1)"
else
    echo "[ERROR] Backup failed!"
    exit 1
fi

# -----------------------------------------------
# BONUS: Set up cron job to run backup every 10 minutes
# -----------------------------------------------
echo ""
echo "[BONUS] Setting up cron job for automatic backup every 10 minutes..."

# Get the absolute path of this script
SCRIPT_PATH=$(realpath $0)

# Add cron job for devopsuser — run backup.sh every 10 minutes
# crontab -l lists existing cron jobs
# We check first to avoid duplicate entries
CRON_JOB="*/10 * * * * $SCRIPT_PATH"

# Check if cron job already exists
(crontab -l 2>/dev/null | grep -q "$SCRIPT_PATH") && \
    echo "[INFO] Cron job already exists. Skipping." || \
    (crontab -l 2>/dev/null; echo "$CRON_JOB") | crontab -

echo "[SUCCESS] Cron job set: backup runs every 10 minutes."
echo ""
echo "--- Current Cron Jobs ---"
crontab -l

echo "========================================="

Make executable and run:

chmod +x backup.sh
./backup.sh

Expected Output:

=========================================
            BACKUP SCRIPT
=========================================
[INFO] Backup directory: /home/devopsuser/backup
[SUCCESS] Backup created: /home/devopsuser/backup/devopsdir_backup_2026-03-15_14-30-00.tar.gz
[INFO] Backup size: 4.0K

[BONUS] Setting up cron job for automatic backup every 10 minutes...
[SUCCESS] Cron job set: backup runs every 10 minutes.

--- Current Cron Jobs ---
*/10 * * * * /path/to/backup.sh
=========================================

Question 6: System Health Report (40 Marks)

File: system_health.sh

#!/bin/bash
# system_health.sh
# Purpose: Collect system health info and generate an HTML report, then host it with nginx
# Usage: ./system_health.sh

OUTPUT_FILE="/var/www/html/system_health.html"

echo "========================================="
echo "        SYSTEM HEALTH REPORT             "
echo "========================================="

# -----------------------------------------------
# Collect: Current Date and Time
# -----------------------------------------------
CURRENT_DATE=$(date "+%A, %B %d %Y %I:%M %p")

# -----------------------------------------------
# Collect: Memory Information using free + awk
# -----------------------------------------------

# Total memory in MB
TOTAL_MEM=$(free -m | awk '/^Mem:/ {print $2}')

# Used memory in MB
USED_MEM=$(free -m | awk '/^Mem:/ {print $3}')

# Available memory in MB
AVAIL_MEM=$(free -m | awk '/^Mem:/ {print $7}')

# Used memory as percentage
USED_MEM_PCT=$(free | awk '/^Mem:/ {printf("%.1f", $3/$2 * 100)}')

# Available memory as percentage
AVAIL_MEM_PCT=$(free | awk '/^Mem:/ {printf("%.1f", $7/$2 * 100)}')

# Total swap memory in MB
TOTAL_SWAP=$(free -m | awk '/^Swap:/ {print $2}')

# Used swap in MB
USED_SWAP=$(free -m | awk '/^Swap:/ {print $3}')

# Used swap as percentage (avoid divide by zero if no swap)
USED_SWAP_PCT=$(free | awk '/^Swap:/ { if($2 > 0) printf("%.1f", $3/$2 * 100); else print "0.0" }')

# Available swap as percentage
AVAIL_SWAP_PCT=$(free | awk '/^Swap:/ { if($2 > 0) printf("%.1f", ($2-$3)/$2 * 100); else print "0.0" }')

# -----------------------------------------------
# Collect: Disk Information using df + awk
# -----------------------------------------------

# Total disk space (root partition)
TOTAL_DISK=$(df -h / | awk 'NR==2 {print $2}')

# Used disk space
USED_DISK=$(df -h / | awk 'NR==2 {print $3}')

# Available disk space
AVAIL_DISK=$(df -h / | awk 'NR==2 {print $4}')

# List partitioned disks — exclude tmpfs using awk regex
# ^ means starts with, ! negates the match — exclude lines starting with tmpfs
DISK_LIST=$(df -h | awk '!/^tmpfs/ && !/^Filesystem/ {print $1, $3, $4}')

# -----------------------------------------------
# Write everything into HTML using heredoc
# -----------------------------------------------
echo "[INFO] Writing HTML report..."

sudo tee $OUTPUT_FILE << EOF
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>System Health Report</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #1a1a2e;
            color: #e0e0e0;
            margin: 0;
            padding: 20px;
        }
        h1 {
            color: #00d4ff;
            text-align: center;
            border-bottom: 2px solid #00d4ff;
            padding-bottom: 10px;
        }
        h2 {
            color: #00d4ff;
            margin-top: 30px;
        }
        .section {
            background-color: #16213e;
            border-radius: 8px;
            padding: 20px;
            margin: 20px 0;
            border-left: 4px solid #00d4ff;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-top: 10px;
        }
        th {
            background-color: #0f3460;
            color: #00d4ff;
            padding: 10px;
            text-align: left;
        }
        td {
            padding: 8px 10px;
            border-bottom: 1px solid #0f3460;
        }
        tr:hover {
            background-color: #0f3460;
        }
        .date {
            text-align: center;
            font-size: 1.1em;
            color: #aaa;
            margin-bottom: 20px;
        }
    </style>
</head>
<body>

<h1>🖥️ System Health Report</h1>
<p class="date">Generated on: $CURRENT_DATE</p>

<!-- Memory Section -->
<div class="section">
    <h2>💾 Memory Usage</h2>
    <table>
        <tr>
            <th>Type</th>
            <th>Total</th>
            <th>Used</th>
            <th>Used %</th>
            <th>Available %</th>
        </tr>
        <tr>
            <td>RAM</td>
            <td>${TOTAL_MEM} MB</td>
            <td>${USED_MEM} MB</td>
            <td>${USED_MEM_PCT}%</td>
            <td>${AVAIL_MEM_PCT}%</td>
        </tr>
        <tr>
            <td>Swap</td>
            <td>${TOTAL_SWAP} MB</td>
            <td>${USED_SWAP} MB</td>
            <td>${USED_SWAP_PCT}%</td>
            <td>${AVAIL_SWAP_PCT}%</td>
        </tr>
    </table>
</div>

<!-- Disk Section -->
<div class="section">
    <h2>💿 Disk Usage</h2>
    <table>
        <tr>
            <th>Total Space</th>
            <th>Used</th>
            <th>Available</th>
        </tr>
        <tr>
            <td>$TOTAL_DISK</td>
            <td>$USED_DISK</td>
            <td>$AVAIL_DISK</td>
        </tr>
    </table>

    <h2>📂 Partitioned Disks (excluding tmpfs)</h2>
    <table>
        <tr>
            <th>Disk Name</th>
            <th>Used</th>
            <th>Available</th>
        </tr>
$(df -h | awk '!/^tmpfs/ && !/^Filesystem/ {print "<tr><td>"$1"</td><td>"$3"</td><td>"$4"</td></tr>"}')
    </table>
</div>

</body>
</html>
EOF

# -----------------------------------------------
# Host the HTML file using Nginx
# -----------------------------------------------
echo "[INFO] Setting up Nginx to host the report..."

# Install nginx if not already installed
if ! command -v nginx &>/dev/null; then
    sudo apt update -y && sudo apt install nginx -y
fi

# Copy report to nginx web root as index.html
sudo cp $OUTPUT_FILE /var/www/html/index.html

# Start and enable nginx
sudo systemctl start nginx
sudo systemctl enable nginx

# Check if nginx started successfully using exit code
if [ $? -eq 0 ]; then
    echo "[SUCCESS] System health report is live at: http://localhost"
else
    echo "[ERROR] Nginx failed to start."
    exit 1
fi

echo "========================================="

Make executable and run:

chmod +x system_health.sh
sudo ./system_health.sh

Question 7: LAMP Stack Automation

File: bsc-configuring-lamp-environment.sh

#!/bin/bash
# bsc-configuring-lamp-environment.sh
# Purpose: Automate installation and removal of full LAMP stack (Linux, Apache/Nginx, MySQL, PHP)
# Usage:
#   ./bsc-configuring-lamp-environment.sh -i           → install with default Apache
#   ./bsc-configuring-lamp-environment.sh -i -ws Apache → install with Apache
#   ./bsc-configuring-lamp-environment.sh -i -ws Nginx  → install with Nginx
#   ./bsc-configuring-lamp-environment.sh -d            → delete all LAMP services

# -----------------------------------------------
# LOG FILE SETUP
# -----------------------------------------------
# Create a log file with your registration number in the name
REG_NUMBER="YOUR_REG_NUMBER"      # ← Replace with your actual reg number
LOG_FILE="lamp-setup-${REG_NUMBER}.log"

# Function to write timestamped log entries
log() {
    # Each log entry gets a timestamp like: [2026-03-15 14:30:21] message
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

# -----------------------------------------------
# PARSE COMMAND LINE ARGUMENTS
# -----------------------------------------------
ACTION=""          # Will be 'install' or 'delete'
WEB_SERVER="Apache" # Default web server is Apache

# Loop through all arguments using getopts
while getopts ":idw:s:" opt; do
    case $opt in
        i) ACTION="install" ;;       # -i flag → install
        d) ACTION="delete" ;;        # -d flag → delete
        w) ;;                        # partial -ws handling
        s) WEB_SERVER="$OPTARG" ;;   # capture Apache or Nginx value
        ?) echo "[ERROR] Unknown option: -$OPTARG"; exit 1 ;;
    esac
done

# Handle -ws Apache or -ws Nginx as combined argument
for arg in "$@"; do
    if [[ "$arg" == "Apache" || "$arg" == "Nginx" ]]; then
        WEB_SERVER="$arg"
    fi
done

# Validate — must provide either -i or -d
if [ -z "$ACTION" ]; then
    echo "Usage: $0 -i [-ws Apache|Nginx]   → install LAMP"
    echo "       $0 -d                       → delete LAMP"
    exit 1
fi

# -----------------------------------------------
# FUNCTION: Install Web Server (Apache or Nginx)
# -----------------------------------------------
install_webserver() {
    log "Starting Web Server installation: $WEB_SERVER"

    if [ "$WEB_SERVER" == "Apache" ]; then
        # Check if Apache is already installed
        if dpkg -l | grep -q apache2; then
            echo "[INFO] Apache web server is already installed."
            read -p "Do you want to remove it and reinstall? (Y/n): " CONFIRM
            if [[ "$CONFIRM" == "Y" || "$CONFIRM" == "y" ]]; then
                log "Removing existing Apache installation..."
                sudo apt remove --purge apache2 -y
                log "Apache removed."
            else
                log "Skipping Apache reinstall. Continuing..."
                return
            fi
        fi
        # Install Apache without user interaction
        log "Installing Apache Web Server..."
        sudo apt update -y
        sudo DEBIAN_FRONTEND=noninteractive apt install apache2 -y
        sudo systemctl start apache2
        sudo systemctl enable apache2
        log "Apache Web Server installed and started successfully."
        echo "[SUCCESS] Apache installed. Visit http://localhost"

    elif [ "$WEB_SERVER" == "Nginx" ]; then
        # Check if Nginx is already installed
        if dpkg -l | grep -q nginx; then
            echo "[INFO] Nginx web server is already installed."
            read -p "Do you want to remove it and reinstall? (Y/n): " CONFIRM
            if [[ "$CONFIRM" == "Y" || "$CONFIRM" == "y" ]]; then
                log "Removing existing Nginx installation..."
                sudo apt remove --purge nginx -y
                log "Nginx removed."
            else
                log "Skipping Nginx reinstall. Continuing..."
                return
            fi
        fi
        # Install Nginx without user interaction
        log "Installing Nginx Web Server..."
        sudo apt update -y
        sudo DEBIAN_FRONTEND=noninteractive apt install nginx -y
        sudo systemctl start nginx
        sudo systemctl enable nginx
        log "Nginx Web Server installed and started successfully."
        echo "[SUCCESS] Nginx installed. Visit http://localhost"
    else
        log "[ERROR] Invalid web server: $WEB_SERVER. Choose Apache or Nginx."
        exit 1
    fi
}

# -----------------------------------------------
# FUNCTION: Install PHP and required modules
# -----------------------------------------------
install_php() {
    log "Starting PHP installation..."

    # Check if PHP is already installed
    if command -v php &>/dev/null; then
        PHP_VERSION=$(php -r "echo PHP_VERSION;")
        echo "[INFO] PHP is already installed. Version: $PHP_VERSION"
        log "PHP already installed. Version: $PHP_VERSION"
        return
    fi

    # Install PHP with common modules needed for a basic PHP application
    # php-mysql     → MySQL support
    # php-curl      → HTTP requests
    # php-xml       → XML processing
    # php-mbstring  → Multibyte string handling
    # php-zip       → ZIP file support
    log "Installing PHP and required modules..."
    sudo DEBIAN_FRONTEND=noninteractive apt install php libapache2-mod-php \
        php-mysql php-curl php-xml php-mbstring php-zip php-gd -y

    log "PHP installed successfully. Version: $(php -r 'echo PHP_VERSION;')"
    echo "[SUCCESS] PHP installed. Version: $(php --version | head -1)"
}

# -----------------------------------------------
# FUNCTION: Install MySQL and generate root password
# -----------------------------------------------
install_mysql() {
    log "Starting MySQL installation..."

    # Check if MySQL is already installed
    if command -v mysql &>/dev/null; then
        echo "[INFO] MySQL is already installed."
        log "MySQL already installed. Skipping."
        return
    fi

    # Generate a random root password (16 characters)
    MYSQL_ROOT_PASS=$(openssl rand -base64 16)

    log "Installing MySQL Server..."
    # Set root password non-interactively using debconf
    sudo debconf-set-selections <<< "mysql-server mysql-server/root_password password $MYSQL_ROOT_PASS"
    sudo debconf-set-selections <<< "mysql-server mysql-server/root_password_again password $MYSQL_ROOT_PASS"

    sudo DEBIAN_FRONTEND=noninteractive apt install mysql-server -y

    # Start and enable MySQL
    sudo systemctl start mysql
    sudo systemctl enable mysql

    log "MySQL installed successfully."

    # Display the generated password to the user
    echo ""
    echo "========================================"
    echo "  ⚠️  IMPORTANT: SAVE THIS PASSWORD!"
    echo "  MySQL Root Password: $MYSQL_ROOT_PASS"
    echo "========================================"
    echo ""
    log "MySQL root password generated and displayed to user."
}

# -----------------------------------------------
# FUNCTION: Delete all LAMP services
# -----------------------------------------------
delete_lamp() {
    log "LAMP stack deletion requested."

    # Show serious warning before deleting
    echo ""
    echo "=========================================================="
    echo "  ⚠️  WARNING: You are about to DELETE the LAMP stack!"
    echo "  This will remove Apache/Nginx, PHP, and MySQL."
    echo "  ALL DATA WILL BE LOST. Please take a backup first!"
    echo "=========================================================="
    echo ""

    # Ask user to confirm — double confirmation for safety
    read -p "Have you taken a backup? Are you sure you want to continue? (Y/n): " CONFIRM

    if [[ "$CONFIRM" != "Y" && "$CONFIRM" != "y" ]]; then
        echo "[INFO] Deletion cancelled. No changes made."
        log "Deletion cancelled by user."
        exit 0
    fi

    log "User confirmed deletion. Proceeding to remove LAMP stack..."

    # Remove Apache if installed
    if dpkg -l | grep -q apache2; then
        log "Removing Apache..."
        sudo apt remove --purge apache2 apache2-utils -y
        sudo apt autoremove -y
        log "Apache removed."
        echo "[SUCCESS] Apache removed."
    fi

    # Remove Nginx if installed
    if dpkg -l | grep -q nginx; then
        log "Removing Nginx..."
        sudo apt remove --purge nginx nginx-common -y
        sudo apt autoremove -y
        log "Nginx removed."
        echo "[SUCCESS] Nginx removed."
    fi

    # Remove PHP and all modules
    if command -v php &>/dev/null; then
        log "Removing PHP..."
        sudo apt remove --purge php* -y
        sudo apt autoremove -y
        log "PHP removed."
        echo "[SUCCESS] PHP removed."
    fi

    # Remove MySQL
    if command -v mysql &>/dev/null; then
        log "Removing MySQL..."
        sudo apt remove --purge mysql-server mysql-client mysql-common -y
        sudo apt autoremove -y
        sudo rm -rf /var/lib/mysql /etc/mysql
        log "MySQL removed."
        echo "[SUCCESS] MySQL removed."
    fi

    log "LAMP stack deletion complete."
    echo ""
    echo "[SUCCESS] All LAMP services have been removed."
}

# -----------------------------------------------
# MAIN: Execute based on action flag
# -----------------------------------------------
log "========= Script started ========="
log "Action: $ACTION | Web Server: $WEB_SERVER"

if [ "$ACTION" == "install" ]; then
    echo "[INFO] Starting LAMP stack installation..."
    install_webserver
    install_php
    install_mysql
    log "========= LAMP installation complete ========="
    echo ""
    echo "[SUCCESS] LAMP stack fully installed!"
    echo "  Web Server : $WEB_SERVER → http://localhost"
    echo "  PHP        : $(php -r 'echo PHP_VERSION;')"
    echo "  MySQL      : Running"
    echo "  Log file   : $LOG_FILE"

elif [ "$ACTION" == "delete" ]; then
    delete_lamp
    log "========= Script ended ========="
fi

Make executable and run:

chmod +x bsc-configuring-lamp-environment.sh

# Install with Apache (default)
sudo ./bsc-configuring-lamp-environment.sh -i

# Install with Nginx
sudo ./bsc-configuring-lamp-environment.sh -i -ws Nginx

# Delete everything
sudo ./bsc-configuring-lamp-environment.sh -d

Question 8: Submit Script (10 Marks)

File: submit.sh

#!/bin/bash
# submit.sh
# Purpose: Bundle all bash scripts from this assignment into a compressed tarball for submission
# Usage: ./submit.sh

echo "========================================="
echo "         ASSIGNMENT SUBMISSION SCRIPT    "
echo "========================================="

# Define your registration number — change this to your actual reg number
REG_NUMBER="YOUR_REG_NUMBER"

# Define the output tarball name using reg number
TARBALL_NAME="${REG_NUMBER}.tar.gz"

# -----------------------------------------------
# Step 1: Find all bash scripts in current directory
# -----------------------------------------------
# Use *.sh pattern to match ALL bash scripts automatically
# This handles any number of scripts without naming them manually
echo "[INFO] Finding all bash scripts..."
SCRIPTS=$(ls *.sh 2>/dev/null)

# Check if any scripts exist
if [ -z "$SCRIPTS" ]; then
    echo "[ERROR] No .sh files found in current directory!"
    exit 1
fi

echo "[INFO] Scripts found:"
for script in $SCRIPTS; do
    echo "  - $script"
done

# -----------------------------------------------
# Step 2: Create compressed tarball of all scripts
# -----------------------------------------------
# -c → create
# -z → compress with gzip
# -v → verbose (show files being added)
# -f → output filename
# *.sh → pattern matches all shell scripts (no need to name each one!)
echo ""
echo "[INFO] Creating tarball: $TARBALL_NAME"
tar -czvf $TARBALL_NAME *.sh

# Step 3: Check if tarball was created successfully
if [ $? -eq 0 ]; then
    echo ""
    echo "[SUCCESS] Tarball created: $TARBALL_NAME"
    echo "[INFO] Size: $(du -sh $TARBALL_NAME | cut -f1)"
    echo "[INFO] Contents:"
    # List what's inside the tarball to verify
    tar -tzvf $TARBALL_NAME
else
    echo "[ERROR] Failed to create tarball!"
    exit 1
fi

# -----------------------------------------------
# Step 3: Reminder to upload
# -----------------------------------------------
echo ""
echo "========================================="
echo "  ✅ Done! Now upload '$TARBALL_NAME'"
echo "     to Microsoft Teams for submission."
echo "========================================="

Make executable and run:

chmod +x submit.sh
./submit.sh

Expected Output:

=========================================
         ASSIGNMENT SUBMISSION SCRIPT
=========================================
[INFO] Finding all bash scripts...
[INFO] Scripts found:
  - systeminfo.sh
  - usergroup.sh
  - sshconfig.sh
  - filedir.sh
  - backup.sh
  - system_health.sh
  - bsc-configuring-lamp-environment.sh
  - submit.sh

[INFO] Creating tarball: YOUR_REG_NUMBER.tar.gz
systeminfo.sh
usergroup.sh
...

[SUCCESS] Tarball created: .tar.gz
[INFO] Size: 12K

=========================================

Make all scripts executable at once

chmod +x *.sh

Run in order:

sudo ./systeminfo.sh
sudo ./usergroup.sh
sudo ./sshconfig.sh
sudo ./filedir.sh
./backup.sh
sudo ./system_health.sh
sudo ./bsc-configuring-lamp-environment.sh -i -ws Apache
./submit.sh


---

## 🔑 Key Commands Used — Quick Reference

bash
uname -s # kernel name
uname -r # kernel release
uname -p # processor type
lsb_release -d # OS name
which # location of command
whereis # location + docs of command

useradd -m -s /bin/bash username # create user
groupadd groupname # create group
usermod -aG groupname username # add user to group

ssh-keygen -t rsa -b 2048 # generate RSA key pair
chmod 700 ~/.ssh # fix ssh dir permissions
chmod 600 ~/.ssh/authorized_keys # fix key file permissions

tar -czf backup.tar.gz /folder # create compressed backup
tar -tzvf backup.tar.gz # list contents of tarball
crontab -e # edit cron jobs

free -m # memory in MB
df -h # disk usage human readable
awk '/^Mem:/ {print $3/$2 * 100}' # calculate memory percent

---

Docker commands

methew smith — Sun, 15 Mar 2026 01:20:58 +0000

A practical, terminal-focused guide covering everything you need to know about web server deployment, Docker containers, GitHub-based hosting, and Bash automation.

📌 Table of Contents

Hosting Apache2 — Traditional Way
Hosting Nginx — Traditional Way
Multiple Static Sites — Virtual Hosts & Server Blocks
Hosting via Docker
Clone from GitHub & Host via Docker
Bash Scripting — Automate Everything
Docker Cheatsheet
Key Concepts & Golden Rules

1. Hosting Apache2 — Traditional Way

Install Apache2

sudo apt update
sudo apt install apache2 -y

Start, Enable & Check Status

sudo systemctl start apache2
sudo systemctl enable apache2      # auto-start on reboot
sudo systemctl status apache2      # check if running

Web Root — where your files go

/var/www/html/

Deploy your page

echo "<h1>My Apache Site</h1>" | sudo tee /var/www/html/index.html

Fix Permissions (always do this!)

sudo chown -R www-data:www-data /var/www/html/
sudo chmod -R 755 /var/www/html/

Test config & Reload

sudo apache2ctl -t          # test for syntax errors → should say: Syntax OK
sudo systemctl reload apache2

Visit: http://localhost ✅

2. Hosting Nginx — Traditional Way

Install Nginx

sudo apt update
sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

Deploy your page

echo "<h1>My Nginx Site</h1>" | sudo tee /var/www/html/index.html

Test config & Reload

sudo nginx -t               # should say: syntax is ok
sudo systemctl reload nginx

Port Conflict — Apache & Nginx both want port 80

sudo lsof -i :80            # see who owns port 80
sudo systemctl stop apache2 # free port 80
sudo systemctl start nginx  # now nginx can start

3. Multiple Static Sites

Apache — Virtual Hosts

Each site gets its own folder and config file.

# Step 1 — Create site folders
sudo mkdir -p /var/www/site1
sudo mkdir -p /var/www/site2

# Step 2 — Create HTML pages
echo "<h1>Site 1</h1>" | sudo tee /var/www/site1/index.html
echo "<h1>Site 2</h1>" | sudo tee /var/www/site2/index.html

# Step 3 — Fix permissions
sudo chown -R www-data:www-data /var/www/site1 /var/www/site2
sudo chmod -R 755 /var/www/site1 /var/www/site2

Create config file for Site 1:

sudo nano /etc/apache2/sites-available/site1.conf

<VirtualHost *:80>
    ServerName site1.local
    DocumentRoot /var/www/site1
    ErrorLog ${APACHE_LOG_DIR}/site1_error.log
    CustomLog ${APACHE_LOG_DIR}/site1_access.log combined
</VirtualHost>

Create config file for Site 2:

sudo nano /etc/apache2/sites-available/site2.conf

<VirtualHost *:80>
    ServerName site2.local
    DocumentRoot /var/www/site2
</VirtualHost>

Enable both sites:

sudo a2ensite site1.conf
sudo a2ensite site2.conf
sudo a2dissite 000-default.conf    # disable default site
sudo systemctl reload apache2

Add fake DNS to /etc/hosts:

sudo nano /etc/hosts
# Add these lines:
127.0.0.1   site1.local
127.0.0.1   site2.local

Visit http://site1.local and http://site2.local ✅

Nginx — Server Blocks

sudo mkdir -p /var/www/site1 /var/www/site2
echo "<h1>Nginx Site 1</h1>" | sudo tee /var/www/site1/index.html
echo "<h1>Nginx Site 2</h1>" | sudo tee /var/www/site2/index.html
sudo chown -R www-data:www-data /var/www/site1 /var/www/site2
sudo chmod -R 755 /var/www/site1 /var/www/site2

Create config for Site 1:

sudo nano /etc/nginx/sites-available/site1

server {
    listen 80;
    server_name site1.local;
    root /var/www/site1;
    index index.html;
}

Enable sites using symlinks (no a2ensite in Nginx!):

sudo ln -s /etc/nginx/sites-available/site1 /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/site2 /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Key Difference: Apache uses a2ensite command. Nginx uses manual ln -s symlinks.

4. Hosting via Docker

Nginx via Docker — Single Site

# Pull image
docker pull nginx

# Run with port mapping
docker run -d -p 8080:80 --name mysite nginx

Visit http://localhost:8080 ✅

Host your own HTML file inside Docker

echo "<h1>Hello Docker!</h1>" > index.html

docker run -d -p 8080:80 \
  --name mysite \
  -v $(pwd)/index.html:/usr/share/nginx/html/index.html \
  nginx

Important: Nginx's web root inside Docker is /usr/share/nginx/html/ — NOT /var/www/html/

Apache via Docker

docker pull ubuntu/apache2
docker run -d --name webserver -p 8081:80 ubuntu/apache2

Multiple Sites via Docker (different ports)

mkdir site1 site2
echo "<h1>Site 1</h1>" > site1/index.html
echo "<h1>Site 2</h1>" > site2/index.html

docker run -d --name site1 -p 8081:80 \
  -v $(pwd)/site1/index.html:/usr/share/nginx/html/index.html nginx

docker run -d --name site2 -p 8082:80 \
  -v $(pwd)/site2/index.html:/usr/share/nginx/html/index.html nginx

docker ps    # verify both running

Visit http://localhost:8081 and http://localhost:8082 ✅

5. Clone from GitHub & Host via Docker

This is the real-world DevOps workflow — pull code from GitHub, host it instantly with Docker.

Method 1 — Clone & Mount with Docker

# Step 1 — Clone your static site from GitHub
git clone https://github.com/yourusername/your-static-site.git
cd your-static-site

# Step 2 — Run Nginx container with your cloned folder mounted
docker run -d \
  --name myapp \
  -p 8080:80 \
  -v $(pwd):/usr/share/nginx/html \
  nginx

# Step 3 — Verify
docker ps

Visit http://localhost:8080 — your GitHub site is live! ✅

Method 2 — Clone & Host with Apache

git clone https://github.com/yourusername/your-static-site.git
cd your-static-site

docker run -d \
  --name apacheapp \
  -p 8081:80 \
  -v $(pwd):/var/www/html \
  ubuntu/apache2

Key difference: Apache Docker container uses /var/www/html as web root, Nginx uses /usr/share/nginx/html

Method 3 — Clone & Host Normally (Without Docker)

# Clone repo
git clone https://github.com/yourusername/your-site.git

# Copy files to Apache/Nginx web root
sudo cp -r your-site/* /var/www/html/

# Fix permissions
sudo chown -R www-data:www-data /var/www/html/
sudo chmod -R 755 /var/www/html/

# Reload server
sudo systemctl reload apache2
# OR
sudo systemctl reload nginx

6. Bash Scripting — Automate Everything

Script Skeleton (always start with this)

#!/bin/bash
# Description: What this script does
# Usage: ./script.sh <argument>

# your code here

Make it executable and run:

chmod +x script.sh
./script.sh

Variables & User Input

#!/bin/bash
NAME="Daniyal"             # variable — NO spaces around =
echo "Hello $NAME"

read -p "Enter site name: " SITE    # get input from user
echo "You entered: $SITE"

Special Variables

Variable	Meaning
`$1`	First argument passed to script
`$2`	Second argument
`$#`	Total number of arguments
`$@`	All arguments as list
`$?`	Exit code of last command (0=success)

./deploy.sh site1 8080
# $1 = site1, $2 = 8080, $# = 2

If / Else

#!/bin/bash
if [ -z "$1" ]; then
    echo "Error: No argument given"
    echo "Usage: ./script.sh <sitename>"
    exit 1
fi

if [ -f "$1" ]; then
    echo "File exists"
elif [ -d "$1" ]; then
    echo "It is a directory"
else
    echo "Not found"
fi

Case Statement — Handle Flags

#!/bin/bash
case $1 in
  --install)
    echo "Installing..."
    sudo apt install nginx -y
    ;;
  --remove)
    echo "Removing..."
    sudo apt remove nginx -y
    ;;
  --status)
    sudo systemctl status nginx
    ;;
  *)
    echo "Usage: ./script.sh --install | --remove | --status"
    exit 1
    ;;
esac

For Loop

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

# Loop over sites and create folders
for site in site1 site2 site3; do
    sudo mkdir -p /var/www/$site
    echo "<h1>Welcome to $site</h1>" | sudo tee /var/www/$site/index.html
    echo "Created $site"
done

Heredoc — Write Multi-line Files

# Normal folder (no sudo needed)
cat > index.html << EOF
<html>
<body>
<h1>Hello World</h1>
</body>
</html>
EOF

# Protected folder — use sudo tee
sudo tee /var/www/html/index.html << EOF
<html>
<body>
<h1>Hello World</h1>
</body>
</html>
EOF

Redirect Operators

echo "hello" > file.txt       # write (overwrite)
echo "hello" >> file.txt      # append
command | sudo tee file.txt   # pipe to tee (for protected files)
./script.sh > output.log 2>&1 # redirect stdout AND stderr to file

Full Script — Auto Deploy Site from GitHub

#!/bin/bash
# deploy.sh — Clone from GitHub and host with Docker

REPO=$1
PORT=${2:-8080}      # default port 8080 if not given
NAME=${3:-mysite}    # default name mysite if not given

# Validate input
if [ -z "$REPO" ]; then
    echo "Usage: ./deploy.sh <github-repo-url> [port] [container-name]"
    exit 1
fi

echo "==> Cloning repo..."
git clone $REPO site_files

echo "==> Starting Docker container on port $PORT..."
docker run -d \
    --name $NAME \
    -p $PORT:80 \
    -v $(pwd)/site_files:/usr/share/nginx/html \
    nginx

echo "==> Done! Visit http://localhost:$PORT"
docker ps | grep $NAME

Run it:

chmod +x deploy.sh
./deploy.sh https://github.com/user/mysite.git 8081 coolsite

Full Script — Setup Apache Virtual Host

#!/bin/bash
# setup_vhost.sh — Create Apache virtual host

SITE=$1

if [ -z "$SITE" ]; then
    echo "Usage: ./setup_vhost.sh <sitename>"
    exit 1
fi

echo "==> Creating directory..."
sudo mkdir -p /var/www/$SITE

echo "==> Creating HTML page..."
sudo tee /var/www/$SITE/index.html << EOF
<html>
<body>
<h1>Welcome to $SITE</h1>
</body>
</html>
EOF

echo "==> Setting permissions..."
sudo chown -R www-data:www-data /var/www/$SITE
sudo chmod -R 755 /var/www/$SITE

echo "==> Creating Virtual Host config..."
sudo tee /etc/apache2/sites-available/$SITE.conf << EOF
<VirtualHost *:80>
    ServerName $SITE.local
    DocumentRoot /var/www/$SITE
    ErrorLog \${APACHE_LOG_DIR}/${SITE}_error.log
    CustomLog \${APACHE_LOG_DIR}/${SITE}_access.log combined
</VirtualHost>
EOF

echo "==> Enabling site..."
sudo a2ensite $SITE.conf
sudo systemctl reload apache2

echo "==> Adding to /etc/hosts..."
echo "127.0.0.1   $SITE.local" | sudo tee -a /etc/hosts

echo "==> Done! Visit http://$SITE.local"

7. Docker Cheatsheet

Images

docker pull nginx              # download image
docker pull ubuntu:22.04       # specific version/tag
docker images                  # list all downloaded images
docker rmi nginx               # remove image

Containers — Run

docker run nginx                          # basic run
docker run -d nginx                       # detached (background)
docker run -it ubuntu bash                # interactive shell
docker run --name mysite nginx            # with custom name
docker run -p 8080:80 nginx               # port mapping HOST:CONTAINER
docker run -d -p 8080:80 --name s nginx   # all combined
docker run --rm nginx                     # auto-remove when stopped

Volume Mount

# Mount a single file
docker run -d -p 8080:80 \
  -v $(pwd)/index.html:/usr/share/nginx/html/index.html \
  nginx

# Mount entire folder
docker run -d -p 8080:80 \
  -v $(pwd)/mysite:/usr/share/nginx/html \
  nginx

Containers — Manage

docker ps                      # running containers
docker ps -a                   # all containers (including stopped)
docker stop mysite             # stop container
docker start mysite            # start stopped container
docker rm mysite               # remove container
docker logs mysite             # view logs
docker inspect mysite          # detailed info

Enter a Running Container

docker exec -it mysite bash    # open NEW shell (safe — exit won't stop container)
docker attach mysite           # attach to main process (exit WILL stop container)
                               # safe detach: CTRL+P+Q

Cleanup — All at Once

docker stop $(docker ps -q)    # stop ALL running containers
docker rm $(docker ps -aq)     # remove ALL containers
docker rmi $(docker images -q) # remove ALL images

Useful Flags Reference

Flag	Meaning
`-d`	Detached — run in background
`-it`	Interactive + TTY — go inside container
`-p 8080:80`	Port map host:container
`-v path:path`	Volume mount local:container
`--name`	Give container a name
`--rm`	Auto-remove container when it exits

8. Key Concepts & Golden Rules

File Locations — Never Forget

What	Path
Apache web root	`/var/www/html/`
Nginx web root	`/var/www/html/`
Nginx Docker web root	`/usr/share/nginx/html/`
Apache sites config	`/etc/apache2/sites-available/`
Nginx sites config	`/etc/nginx/sites-available/`
Apache enabled sites	`/etc/apache2/sites-enabled/`
Nginx enabled sites	`/etc/nginx/sites-enabled/`
SSH config file	`/etc/ssh/sshd_config`
SSH keys folder	`~/.ssh/`
Public key destination	`~/.ssh/authorized_keys`
Fake DNS file	`/etc/hosts`

Permissions — The Rules

755   # directories  → owner:rwx  group:r-x  others:r-x
644   # files        → owner:rw-  group:r--  others:r--
600   # private keys → owner:rw-  group:---  others:---
777   # ❌ NEVER USE — anyone can write/execute = security risk

sudo chown -R www-data:www-data /var/www/html/   # fix ownership
sudo chmod -R 755 /var/www/html/                 # fix permissions

systemctl Commands

sudo systemctl start apache2      # start now
sudo systemctl stop apache2       # stop now
sudo systemctl restart apache2    # stop + start (brief downtime)
sudo systemctl reload apache2     # apply config changes gracefully (no downtime)
sudo systemctl enable apache2     # auto-start on reboot
sudo systemctl status apache2     # check if running

Apache vs Nginx — Quick Comparison

Feature	Apache	Nginx
Install	`apt install apache2`	`apt install nginx`
Enable site	`a2ensite site.conf`	`ln -s sites-available/x sites-enabled/`
Disable site	`a2dissite site.conf`	`rm /etc/nginx/sites-enabled/x`
Test config	`apache2ctl -t`	`nginx -t`
Config folder	`/etc/apache2/`	`/etc/nginx/`
Default port	80	80
Docker image	`ubuntu/apache2`	`nginx`

Pipe vs Redirect — Common Mistakes

# WRONG ❌ — >> is for files, not commands
echo "hello" >> sudo tee /var/www/html/index.html

# CORRECT ✅ — use pipe | before sudo tee
echo "hello" | sudo tee /var/www/html/index.html

# CORRECT ✅ — append mode with sudo tee -a
echo "hello" | sudo tee -a /var/www/html/index.html

Docker: attach vs exec

# attach — connects to main process
# ⚠️  typing "exit" STOPS the container
docker attach mycontainer
# Safe way to leave: CTRL+P+Q

# exec — opens a NEW shell
# ✅ typing "exit" is completely safe, container keeps running
docker exec -it mycontainer bash

GitHub + Docker — The DevOps Workflow

GitHub Repo  →  git clone  →  Docker container  →  Live website

git clone https://github.com/user/repo.git
cd repo
docker run -d -p 8080:80 -v $(pwd):/usr/share/nginx/html nginx

That's it. 3 commands. Site is live. ✅

🎯 Quick Reference Card

# Apache — install, start, deploy
sudo apt install apache2 -y && sudo systemctl start apache2 && sudo systemctl enable apache2
echo "<h1>Hello</h1>" | sudo tee /var/www/html/index.html
sudo chown -R www-data:www-data /var/www/html/ && sudo chmod -R 755 /var/www/html/

# Nginx — install, start, deploy
sudo apt install nginx -y && sudo systemctl start nginx && sudo systemctl enable nginx

# Docker — nginx with your file
docker run -d -p 8080:80 -v $(pwd)/index.html:/usr/share/nginx/html/index.html nginx

# Docker — clone from github and host
git clone <repo-url> site && docker run -d -p 8080:80 -v $(pwd)/site:/usr/share/nginx/html nginx

# Docker — cleanup everything
docker stop $(docker ps -q) && docker rm $(docker ps -aq)

Written for CS316 DevOps — Practical Lab Reference Guide
Topics: Apache2 | Nginx | Docker | Bash Scripting | GitHub Deployment

basic OS commands

methew smith — Sat, 14 Mar 2026 22:12:18 +0000

Focus: Terminal-first, step-by-step command explanations for practical exam prep

Linux Basics & File System
Linux Commands & Navigation
File Permissions & Ownership
Users & Groups Management
SSH (Secure Shell)
Apache Web Server
Nginx Web Server
Port Debugging & Troubleshooting
Bash Scripting
Docker Containers
Lab Exercises Summary
Quick Reference Cheat Sheet

1. Linux Basics & File System

What is Linux?

Linux is an open-source operating system kernel. A Linux Distribution (distro) is a collection of software built around the Linux kernel, all licensed under open-source or GPL. 90% of all cloud infrastructure is powered by Linux, making it the foundation of DevOps.

Linux Distributions

Debian-based: Ubuntu, Debian — use .deb packages and apt package manager
Red Hat-based: CentOS, Fedora, RHEL — use .rpm packages and yum/dnf package manager
Technical differences are mainly about package management, software versions, and file locations
Once you grasp those differences, switching between distros becomes painless

Choosing a Distribution — Key Questions

What is the main function? (Server or Desktop?)
What packages are important? (web server, database, etc.)
How much disk space is available?
How often are packages updated?
How long is the support cycle? (LTS = Long Term Support)
Do you need long-term stability or cutting-edge software?

Package Management (apt — Debian/Ubuntu)

apt update                    # Update the package index (local DB of available repos)
apt upgrade                   # Upgrade installed packages to latest versions
apt install <pkg_name>        # Install a package
apt remove <pkg_name>         # Remove a package
apt search <pkg_name>         # Search for a package
apt show <pkg_name>           # Show package details
apt list --installed          # List all installed packages

🔥 EXAM TIP: Always run apt update BEFORE apt install. Update refreshes the package list, upgrade actually updates the software.

Linux File System Hierarchy

Linux organizes everything in a tree structure starting from / (root):

Directory	Purpose
`/`	Root — top of the entire filesystem tree
`/home`	User home directories (e.g., `/home/daniyal`)
`/etc`	System configuration files (ssh config, apache config, etc.)
`/var`	Variable data — logs (`/var/log`), web files (`/var/www`)
`/usr`	User programs and utilities (`/usr/bin`, `/usr/lib`)
`/bin`	Essential command binaries (`ls`, `cp`, `mv`, `cat`)
`/sbin`	System binaries (`systemctl`, `fdisk`) — need root
`/tmp`	Temporary files — cleared on reboot
`/opt`	Optional/third-party software
`/root`	Home directory of the root user
`/dev`	Device files (hardware represented as files)
`/proc`	Virtual filesystem — running process info

🔥 EXAM TIP: Know these paths by heart: /etc/ssh/sshd_config, /var/www/html, /var/log/apache2/, /etc/apache2/sites-available/

OS and Kernel Information

uname -a              # Full system info (kernel name, version, architecture)
lsb_release -a        # Distribution-specific info
cat /etc/os-release   # OS release details

2. Linux Commands & Navigation

Command Structure

A Linux command has three parts: command [options] [arguments]

wc -l devops_course_outline.txt
#  ^    ^    ^
#  |    |    +-- argument (what to operate on)
#  |    +------- option (modifies behavior, starts with - or --)
#  +------------ command (program to execute)

The sudo Command

sudo (superuser do) lets you run commands with root (administrator) privileges:

sudo ls -la /root      # List root's home directory with elevated privileges
sudo apt install nginx  # Install software (needs root)

Directory Navigation

Command	What It Does	Example
`pwd`	Print current working directory	`pwd` → `/home/daniyal`
`cd`	Change directory	`cd /var/www/html`
`cd ~` or `cd`	Go to home directory	`cd ~`
`cd ..`	Go up one level (parent dir)	`cd ..`
`cd -`	Go to previous directory	`cd -`
`ls`	List directory contents	`ls /etc`
`ls -la`	List ALL files (hidden + details)	`ls -la`
`tree`	Show directory tree structure	`tree /var/www`
`mkdir`	Create a directory	`mkdir myproject`
`mkdir -p`	Create nested directories	`mkdir -p a/b/c`
`rmdir`	Remove empty directory	`rmdir myproject`
`rm -r`	Remove directory and contents	`rm -r myproject`

Absolute vs Relative Paths

Absolute path: Starts from root /. Example: /usr/bin/python3
Relative path: Starts from current directory. Example: ../usr/bin

cd /usr/bin     # Absolute path
cd ../usr/bin   # Relative path

Viewing Files

Command	Purpose
`cat file.txt`	Display entire file at once (not ideal for large files)
`cat -n file.txt`	Display with line numbers
`tac file.txt`	Display file in reverse (last line first)
`less file.txt`	Page through large files (scroll up/down, search with `/`)
`head file.txt`	Show first 10 lines (use `-n 20` for first 20)
`tail file.txt`	Show last 10 lines (use `-n 20` for last 20)
`tail -f file.txt`	Follow file in real-time (great for logs!)
`wc file.txt`	Count lines, words, characters
`wc -l file.txt`	Count only lines

Creating & Manipulating Files

touch newfile.txt                    # Create empty file (or update timestamp)
touch -t 12091600 file.txt           # Set specific timestamp (Dec 9, 4PM)
echo "hello" > file.txt              # Write to file (OVERWRITES!)
echo "world" >> file.txt             # Append to file
cp source.txt dest.txt               # Copy file
mv old.txt new.txt                   # Rename/move file
rm file.txt                          # Delete file
rm -rf directory/                    # Force delete directory and contents

Searching for Files

The `find` Command

The find command searches the filesystem in real-time. Extremely useful in DevOps for automation, cleanup, backups, and CI/CD scripts.

find /var/log -name "*.log"           # Find all .log files in /var/log
find /usr -name gcc                   # Find files/dirs named gcc
find /usr -type d -name gcc           # Find only DIRECTORIES named gcc
find /usr -type f -name gcc           # Find only regular FILES named gcc
find / -size +10M                     # Find files larger than 10MB
find / -size 0                        # Find empty files
find / -mtime 3                       # Files modified 3 days ago
find / -user root                     # Files owned by root
find -name "*.jpg" -exec rm {} ';'   # Find and DELETE all .jpg files
find / -size +10M -exec command {} ';'  # Find large files and run command

Key find Options:

Option	Purpose
`-name`	Match filename (case-sensitive)
`-iname`	Match filename (case-insensitive)
`-type f`	Regular files only
`-type d`	Directories only
`-size`	File size (`+100M` = over 100MB, `-10k` = under 10KB)
`-mtime`	Modified time in days
`-exec`	Execute a command on each result
`-user`	Files owned by specific user

📝 NOTE: The {} is a placeholder filled with each file found. The ';' or \; terminates the -exec command.

The `locate` Command

locate zip         # Fast search using pre-built database
# Database is updated by 'updatedb' (runs daily automatically)

`which` & `whereis`

which python3      # Shows path of executable: /usr/bin/python3
whereis python3    # Shows binary, source, and man page locations

I/O Redirection & Pipes

echo "hello" > file.txt       # Redirect stdout to file (overwrite)
echo "world" >> file.txt      # Redirect stdout to file (append)
command < input.txt           # Feed file as stdin to command
command 2> errors.txt         # Redirect stderr to file
command > out.txt 2>&1        # Redirect BOTH stdout AND stderr to file
cat /etc/passwd | wc -l       # Pipe: send output of cat as input to wc
cat /etc/passwd | cut -d: -f1 | sort | uniq  # Chain multiple pipes

🔥 EXAM TIP: > overwrites, >> appends. 2>&1 redirects errors to same place as stdout. The pipe | chains commands together.

Process Management

kill -SIGKILL <PID>       # Force kill a process (same as kill -9)
kill -9 <PID>             # Force kill by PID
node server.js &          # Run process in background (& suffix)
lsof -i :80              # Find what process is using port 80

📝 NOTE: You can only kill your own processes (unless you are root).

Getting Help

man apache2       # Full manual page for a command
man -k compress   # Search man pages by keyword
info make         # GNU Info documentation (alternative to man)
command --help    # Quick help/usage summary (fastest option)

3. File Permissions & Ownership

Three Types of Owners

User (u): The owner of the file. When you create a file, you become the owner.
Group (g): A collection of users. Useful in multi-user environments.
Other (o): Everyone else on the system.

Three Types of Permissions

Permission	Symbol	Number	On Files	On Directories
Read	`r`	4	View/copy file contents	List directory contents (`ls`)
Write	`w`	2	Modify file contents	Create/delete files inside
Execute	`x`	1	Run the file as program	Enter the directory (`cd`)

Octal Permission Table (MEMORIZE THIS!)

Number	0	1	2	3	4	5	6	7
Permission	`---`	`--x`	`-w-`	`-wx`	`r--`	`r-x`	`rw-`	`rwx`
Meaning	None	Exec only	Write only	Write+Exec	Read only	Read+Exec	Read+Write	ALL

Reading Permission Strings

-rw-r--r-- 1 sajid devops_students 13 2022-05-11 08:29 lecture.txt
 ^^^^^^^^^   ^     ^
 |           |     +-- group owner
 |           +-------- file owner (user)
 +-------------------- permission string

First char: - = file, d = directory, l = symlink
Next 9 chars: rwx for user | rwx for group | rwx for others

Example: -rw-r--r-- means:
  User:  rw-  (read + write)      = 4+2+0 = 6
  Group: r--  (read only)          = 4+0+0 = 4
  Other: r--  (read only)          = 4+0+0 = 4
  Octal: 644

`chmod` — Change Permissions

chmod 644 file.txt         # rw-r--r-- (standard file permission)
chmod 755 directory/       # rwxr-xr-x (standard directory permission)
chmod 700 secret.txt       # rwx------ (owner only, full access)
chmod 666 file.txt         # rw-rw-rw- (everyone can read/write)
chmod +x script.sh         # Add execute permission for everyone
chmod u+x script.sh        # Add execute for user only
chmod g-w file.txt         # Remove write from group
chmod o-rwx file.txt       # Remove all permissions from others

`chown` — Change Ownership

sudo chown root:root file.txt           # Change owner AND group to root
sudo chown daniyal file.txt             # Change owner only
sudo chown daniyal:www-data file.txt    # Change owner to daniyal, group to www-data
sudo chown -R www-data:www-data /var/www/html/  # Recursive (all files inside)

⭐ DevOps Golden Rules for Permissions

Rule	Permission	Why
Directories	`755` (rwxr-xr-x)	Owner full access, others can read/enter
Regular files	`644` (rw-r--r--)	Owner read/write, others read only
Scripts (.sh)	`755` (rwxr-xr-x)	Must be executable
SSH private key	`600` (rw-------)	ONLY owner can read (SSH refuses otherwise)
~/.ssh/ directory	`700` (rwx------)	ONLY owner can access
authorized_keys	`600` (rw-------)	ONLY owner can read/write
Web files owner	`www-data:www-data`	Web server user must be able to read
NEVER use	`777`	SECURITY RISK — everyone has full access!

🔥 EXAM TIP: If a web page shows '403 Forbidden', first check permissions and ownership! Owner should be www-data, dirs 755, files 644.

4. Users & Groups Management

User Management Commands

cat /etc/passwd                    # List ALL users on the system
sudo adduser newuser               # Create new user (interactive - sets password)
sudo useradd newuser               # Create user (non-interactive - no password set)
sudo usermod -aG sudo newuser      # Add user to sudo group (give admin rights)
sudo userdel newuser               # Delete a user
sudo userdel -r newuser            # Delete user AND their home directory
su - newuser                       # Switch to another user
whoami                             # Show current username
id                                 # Show user ID, group ID, and groups

Group Management Commands

cat /etc/group                     # List all groups
sudo groupadd devopsgroup          # Create a new group
sudo usermod -aG devopsgroup user1 # Add user1 to devopsgroup
sudo groupdel devopsgroup          # Delete a group
groups username                    # Show which groups a user belongs to

📝 NOTE: The -aG flag is critical! Without -a, the user gets REMOVED from all other groups. Always use -aG together.

Important Files

/etc/passwd — Contains user account info (username:x:UID:GID:info:home:shell)
/etc/shadow — Contains encrypted passwords (only root can read)
/etc/group — Contains group definitions

5. SSH (Secure Shell)

What is SSH?

SSH (Secure Shell) allows you to connect and log into remote systems securely. It encrypts ALL communication between client and server. SSH runs on port 22 by default. The server must have sshd (SSH daemon) installed and running.

Basic SSH Connection

ssh username@remote_server_ip       # Connect to remote machine
ssh daniyal@192.168.1.100           # Example with IP
whoami                               # Verify you are logged in
hostname                             # Verify which machine you are on
exit                                 # Disconnect from remote

SSH Service Control

sudo systemctl status ssh          # Check if SSH is running
sudo systemctl start ssh           # Start SSH service
sudo systemctl stop ssh            # Stop SSH service
sudo systemctl restart ssh         # Restart (apply config changes)
sudo systemctl enable ssh          # Start automatically on boot
sudo systemctl disable ssh         # Don't start on boot

🔥 EXAM TIP: systemctl enable makes service start on boot. systemctl start starts it NOW. They are different! You often need BOTH.

SSH Configuration File

The main SSH server config file is: /etc/ssh/sshd_config

sudo nano /etc/ssh/sshd_config     # Edit SSH server configuration

# Key settings to know:
Port 22                            # Default SSH port
PermitRootLogin yes/no             # Allow/block root login via SSH
PasswordAuthentication yes/no      # Allow/block password-based login
PubkeyAuthentication yes           # Allow key-based authentication

# IMPORTANT: After ANY change, restart SSH!
sudo systemctl restart ssh

SSH Key-Based Authentication

Key-based auth is more secure than passwords. It uses a pair of keys:

Private key (~/.ssh/id_rsa): Stays on YOUR machine. NEVER share this!
Public key (~/.ssh/id_rsa.pub): Goes to the REMOTE server.

Step-by-step setup:

# STEP 1: Generate key pair on YOUR machine (client)
ssh-keygen -t rsa
# Press Enter for default location (~/.ssh/id_rsa)
# Press Enter for no passphrase (or set one for extra security)
# Creates: ~/.ssh/id_rsa (private) and ~/.ssh/id_rsa.pub (public)

# STEP 2: Copy public key to the REMOTE server
ssh-copy-id username@remote_server
# OR manually:
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys  # On the remote server

# STEP 3: Set correct permissions (CRITICAL!)
chmod 700 ~/.ssh                   # Directory: owner only
chmod 600 ~/.ssh/id_rsa            # Private key: owner only
chmod 600 ~/.ssh/authorized_keys   # Auth keys: owner only

# STEP 4: Now you can login without password!
ssh username@remote_server

📝 NOTE: The remote server stores public keys in ~/.ssh/authorized_keys (one key per line). If permissions on this file are wrong, SSH will REFUSE the key and fall back to password auth.

SSH Config File (Client Side)

Create ~/.ssh/config to avoid typing username and IP every time:

# File: ~/.ssh/config
Host myserver
    HostName 192.168.1.100
    User daniyal
    IdentityFile ~/.ssh/id_rsa

# Now you can just type:
ssh myserver
# Instead of: ssh daniyal@192.168.1.100

Non-Interactive SSH Commands

Run commands on a remote server without opening a full session:

ssh user@server "whoami"                    # Run whoami on remote
ssh user@server "mkdir ~/test_dir"          # Create dir on remote
ssh user@server "cat /etc/hostname"         # Read remote file
ssh user@server "systemctl restart apache2" # Restart service remotely

🔥 EXAM TIP: Non-interactive SSH is key for scripting — you can loop over servers: for server in list; do ssh server "command"; done

Disabling Root Login & Password Auth

# Edit /etc/ssh/sshd_config:
PermitRootLogin no              # Block root from logging in via SSH
PasswordAuthentication no       # Force key-based auth only

# Restart to apply:
sudo systemctl restart ssh

# Test: trying ssh root@server should now be DENIED

6. Apache Web Server

Installation & Service Management

sudo apt update
sudo apt install apache2           # Install Apache

sudo systemctl start apache2       # Start the service
sudo systemctl stop apache2        # Stop the service
sudo systemctl restart apache2     # Restart (apply changes)
sudo systemctl reload apache2      # Reload config without downtime
sudo systemctl status apache2      # Check if running
sudo systemctl enable apache2      # Start on boot

curl localhost                     # Test: should show Apache default page

Apache runs on Port 80 (HTTP) or Port 443 (HTTPS)

Apache Default Paths

Path	Purpose
`/var/www/html/`	Default web root (put your website files here)
`/etc/apache2/`	Main configuration directory
`/etc/apache2/sites-available/`	Virtual host config files (available)
`/etc/apache2/sites-enabled/`	Symlinks to active virtual hosts
`/etc/apache2/apache2.conf`	Main Apache configuration file
`/etc/apache2/ports.conf`	Which ports Apache listens on
`/var/log/apache2/error.log`	Error log file
`/var/log/apache2/access.log`	Access log file

Deploying a Static Website

# Step 1: Clone or copy your website files
sudo git clone https://github.com/user/repo.git /var/www/html/mysite

# Step 2: Set correct ownership
sudo chown -R www-data:www-data /var/www/html/mysite

# Step 3: Set correct permissions
sudo chmod -R 755 /var/www/html/mysite/                        # Directories
sudo find /var/www/html/mysite -type f -exec chmod 644 {} \;   # Files

# Step 4: Verify
curl localhost

Virtual Hosts (Multiple Websites)

Virtual hosts let you run MULTIPLE websites on one server, each on a different port or domain.

# Step 1: Create config file in sites-available
sudo nano /etc/apache2/sites-available/mysite.conf

Content of mysite.conf:

<VirtualHost *:8080>
    ServerName mysite.local
    DocumentRoot /var/www/mysite
    ErrorLog /var/log/apache2/mysite-error.log
    CustomLog /var/log/apache2/mysite-access.log combined
</VirtualHost>

# Step 2: Add Listen directive for new port
# Edit /etc/apache2/ports.conf and add: Listen 8080

# Step 3: Enable the site
sudo a2ensite mysite.conf

# Step 4: Test config and reload
sudo apache2ctl configtest         # Check for syntax errors
sudo systemctl reload apache2

# Step 5: Verify
curl localhost:8080

🔥 EXAM TIP: sites-available = config files stored here. sites-enabled = symlinks to active configs. Use a2ensite/a2dissite to enable/disable.

7. Nginx Web Server

Installation & Service Management

sudo apt update
sudo apt install nginx

sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl status nginx
sudo systemctl enable nginx

curl localhost                     # Test

Nginx Key Paths

Default web root: /var/www/html/ (same as Apache)
Config files: /etc/nginx/sites-available/ and /etc/nginx/sites-enabled/
Main config: /etc/nginx/nginx.conf
Default site config: /etc/nginx/sites-available/default

Nginx Virtual Host (Server Block)

# File: /etc/nginx/sites-available/mysite
server {
    listen 80;
    server_name mysite.local;
    root /var/www/mysite;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

# Enable the site by creating a symlink:
sudo ln -s /etc/nginx/sites-available/mysite /etc/nginx/sites-enabled/

# Test config:
sudo nginx -t

# Reload:
sudo systemctl reload nginx

📝 NOTE: Both Apache and Nginx use port 80 by default. They CANNOT run on the same port at the same time!

8. Port Debugging & Troubleshooting

Common Scenario: Port Conflict

If Apache fails to start with "Address already in use" error, another process (like Nginx) is already using port 80.

Debugging Commands

# Check what's using a specific port
sudo lsof -i :80                   # Show process using port 80

# Production-friendly command (all open network connections)
sudo lsof -i -P -n
# -i = open network connections
# -P = show port numbers (not service names)
# -n = don't resolve hostnames

# Check service logs for errors
sudo journalctl -xe                # Show recent system logs with details
sudo journalctl -u apache2         # Show only Apache logs

# Monitor log files in real-time
sudo tail -f /var/log/apache2/error.log
sudo tail -f /var/log/nginx/error.log

Fixing Port Conflicts Step by Step

# Step 1: Check which service is using port 80
sudo lsof -i :80
# Output shows: nginx (PID 1234)

# Step 2: Stop the conflicting service
sudo systemctl stop nginx

# Step 3: Start the service you want
sudo systemctl start apache2

# Step 4: Verify
sudo systemctl status apache2
curl localhost

Common Web Server Errors & Fixes

Error	Likely Cause	Fix
403 Forbidden	Wrong permissions/ownership	`chown www-data:www-data`, `chmod 755`/`644`
404 Not Found	Wrong DocumentRoot path	Check config file, verify path exists
Address in use	Port conflict	`lsof -i :80`, stop conflicting service
Service won't start	Config syntax error	`apache2ctl configtest` or `nginx -t`
Connection refused	Service not running	`systemctl start apache2/nginx`

9. Bash Scripting

Script Basics

#!/bin/bash
# The first line is the SHEBANG — tells the system to use bash
# Every script MUST start with #!/bin/bash

# Make script executable:
chmod +x script.sh

# Run script:
./script.sh
# OR
bash script.sh

Variables

#!/bin/bash
NAME="Daniyal"                     # Assign (NO spaces around =)
echo "Hello $NAME"                 # Use variable with $
echo "Hello ${NAME}"               # Curly braces version (safer)

# Read user input
echo "Enter your name:"
read USERNAME                      # Stores input in USERNAME
echo "Welcome $USERNAME"

# Command substitution — store command output in variable
TODAY=$(date)                      # Run date command, store result
echo "Today is: $TODAY"

HOSTNAME=$(hostname)
echo "Machine: $HOSTNAME"

🔥 EXAM TIP: NO SPACES around = when assigning variables! NAME='value' is correct. NAME = 'value' is WRONG and will cause an error.

Command Line Arguments

Variable	Meaning
`$0`	Script name itself
`$1`, `$2`, `$3`...	First, second, third argument...
`$#`	Total number of arguments passed
`$@`	All arguments as separate words
`$?`	Exit code of the LAST command (0=success, non-0=failure)

#!/bin/bash
# Example: ./myscript.sh hello world
echo "Script name: $0"            # ./myscript.sh
echo "First arg: $1"              # hello
echo "Second arg: $2"             # world
echo "Total args: $#"             # 2
echo "All args: $@"               # hello world

Exit Codes

#!/bin/bash
# Every command returns an exit code
# 0 = SUCCESS, anything else = FAILURE

ls /tmp
echo $?    # 0 (success — /tmp exists)

ls /nonexistent
echo $?    # 2 (failure — directory doesn't exist)

# Set your own exit code
exit 0     # Exit script with success
exit 1     # Exit script with failure

Conditionals (if/else)

#!/bin/bash
# Basic if/else
if [ -d "/var/www/html" ]; then
    echo "Directory exists"
else
    echo "Directory does NOT exist"
fi

# Check if file exists
if [ -f "/etc/ssh/sshd_config" ]; then
    echo "SSH config found"
fi

# Compare strings
if [ "$1" == "install" ]; then
    echo "Installing..."
elif [ "$1" == "remove" ]; then
    echo "Removing..."
else
    echo "Usage: $0 install|remove"
    exit 1
fi

# Check if command succeeded
apt install nginx -y
if [ $? -eq 0 ]; then
    echo "Installation successful"
else
    echo "Installation FAILED"
    exit 1
fi

Common test operators:

Operator	Meaning
`-f file`	File exists and is a regular file
`-d dir`	Directory exists
`-e path`	Path exists (file or directory)
`-z string`	String is empty (zero length)
`-n string`	String is NOT empty
`str1 == str2`	Strings are equal
`str1 != str2`	Strings are NOT equal
`num1 -eq num2`	Numbers are equal
`num1 -ne num2`	Numbers are NOT equal
`num1 -gt num2`	Greater than
`num1 -lt num2`	Less than

Case Statement (for Flags)

#!/bin/bash
# Great for handling command-line flags like -i, -r, -h
case "$1" in
    -i|--install)
        echo "Installing..."
        ;;
    -r|--remove)
        echo "Removing..."
        ;;
    -h|--help)
        echo "Usage: $0 [-i install] [-r remove] [-h help]"
        ;;
    *)
        echo "Invalid option: $1"
        echo "Use -h for help"
        exit 1
        ;;
esac

For Loops

#!/bin/bash
# Loop through a list
for server in server1 server2 server3; do
    echo "Restarting $server..."
    ssh $server "systemctl restart apache2"
done

# Loop through files
for file in *.sh; do
    echo "Found script: $file"
done

# Loop with numbers
for i in 1 2 3 4 5; do
    echo "Number: $i"
done

# C-style loop
for ((i=1; i<=5; i++)); do
    echo "Count: $i"
done

The `tar` Command (Archives/Backups)

# Create a compressed archive
tar -czf backup.tar.gz /path/to/directory
# -c = create
# -z = compress with gzip
# -f = filename follows

# Create with timestamp in name
tar -czf backup_$(date +%Y%m%d_%H%M%S).tar.gz /var/www/html/

# Extract an archive
tar -xzf backup.tar.gz
# -x = extract

# List contents without extracting
tar -tzf backup.tar.gz

The `awk` Command

# awk processes text line by line, splitting into fields
# Default field separator is whitespace

# Print second column of output
df -h | awk '{print $2}'

# Print specific fields with custom format
free -m | awk '/Mem:/ {print "Total: "$2" MB, Used: "$3" MB"}'

# Use custom field separator
cat /etc/passwd | awk -F: '{print $1}'   # Print usernames (field 1, : separator)

# Filter lines matching a pattern
df -h | awk '!/tmpfs/ {print $0}'        # Exclude lines containing tmpfs

Heredoc (Writing Multi-line Content)

#!/bin/bash
# Heredoc writes multi-line content to a file
cat << EOF > /var/www/html/index.html
<!DOCTYPE html>
<html>
<head><title>System Report</title></head>
<body>
    <h1>Server: $(hostname)</h1>
    <p>Date: $(date)</p>
</body>
</html>
EOF
# Variables inside heredoc get expanded!
# Use << 'EOF' (with quotes) to PREVENT variable expansion

Redirection in Scripts

#!/bin/bash
# Redirect command output to log file
apt install nginx -y > nginx.log 2>&1
# > nginx.log    = redirect stdout to file
# 2>&1           = redirect stderr (2) to same place as stdout (1)
# Combined: ALL output (normal + errors) goes to nginx.log

# Append to log
echo "$(date) - Installation complete" >> nginx.log

Lab Script Examples

Script 1: `backup.sh` — Automated Directory Backup

#!/bin/bash
echo "Enter directory path to backup:"
read DIR_PATH

if [ ! -d "$DIR_PATH" ]; then
    echo "ERROR: Directory $DIR_PATH does not exist!"
    exit 1
fi

TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_${TIMESTAMP}.tar.gz"

tar -czf "$BACKUP_FILE" "$DIR_PATH"

if [ $? -eq 0 ]; then
    echo "SUCCESS: Backup created: $BACKUP_FILE"
    echo "$(date) - SUCCESS - $BACKUP_FILE" >> backup.log
else
    echo "FAILED: Backup failed!"
    echo "$(date) - FAILED" >> backup.log
    exit 1
fi

Script 2: Virtual Host Automator

#!/bin/bash
echo "Enter domain/directory name:"
read DOMAIN

sudo mkdir -p /var/www/$DOMAIN

sudo cat << EOF > /var/www/$DOMAIN/index.html
<html><body><h1>Welcome to $DOMAIN</h1></body></html>
EOF

sudo cat << EOF > /etc/apache2/sites-available/$DOMAIN.conf
<VirtualHost *:80>
    ServerName $DOMAIN
    DocumentRoot /var/www/$DOMAIN
    ErrorLog /var/log/apache2/${DOMAIN}-error.log
    CustomLog /var/log/apache2/${DOMAIN}-access.log combined
</VirtualHost>
EOF

sudo chown -R www-data:www-data /var/www/$DOMAIN
sudo chmod -R 755 /var/www/$DOMAIN
sudo a2ensite $DOMAIN.conf
sudo systemctl reload apache2
echo "Website $DOMAIN deployed successfully!"

Script 3: `wserver.sh` — Nginx Install/Remove with Flags

#!/bin/bash
case "$1" in
    -i)
        if dpkg -l | grep -q nginx; then
            echo "Nginx is already installed."
            exit 0
        fi
        sudo apt install nginx -y > nginx.log 2>&1
        if [ $? -eq 0 ]; then
            echo "Nginx installed successfully."
        else
            echo "ERROR: Installation failed. Check nginx.log"
            exit 1
        fi
        ;;
    -r)
        if ! dpkg -l | grep -q nginx; then
            echo "Nginx is not installed."
            exit 0
        fi
        sudo apt remove nginx -y > nginx.log 2>&1
        if [ $? -eq 0 ]; then
            echo "Nginx removed successfully."
        else
            echo "ERROR: Removal failed. Check nginx.log"
            exit 1
        fi
        ;;
    *)
        echo "Usage: $0 [-i install] [-r remove]"
        exit 1
        ;;
esac

Script 4: `system_health.sh` — HTML Report

#!/bin/bash
TOTAL_MEM=$(free -m | awk '/Mem:/ {print $2}')
USED_MEM=$(free -m | awk '/Mem:/ {print $3}')
AVAIL_MEM=$(free -m | awk '/Mem:/ {print $7}')
TOTAL_SWAP=$(free -m | awk '/Swap:/ {print $2}')
USED_SWAP=$(free -m | awk '/Swap:/ {print $3}')

DISK_TOTAL=$(df -h --total --exclude-type=tmpfs | awk '/total/ {print $2}')
DISK_USED=$(df -h --total --exclude-type=tmpfs | awk '/total/ {print $3}')
DISK_AVAIL=$(df -h --total --exclude-type=tmpfs | awk '/total/ {print $4}')

cat << EOF > system_health.html
<!DOCTYPE html>
<html>
<head><title>System Health Report</title></head>
<body>
<h1>System Health Report</h1>
<p>Date: $(date)</p>
<h2>Memory Usage</h2>
<p>Total: ${TOTAL_MEM}MB | Used: ${USED_MEM}MB | Available: ${AVAIL_MEM}MB</p>
<h2>Disk Usage</h2>
<p>Total: $DISK_TOTAL | Used: $DISK_USED | Available: $DISK_AVAIL</p>
</body>
</html>
EOF

sudo cp system_health.html /var/www/html/index.html
if [ $? -eq 0 ]; then
    echo "SUCCESS: Report hosted at http://localhost"
else
    echo "ERROR: Failed to deploy report"
    exit 1
fi

Script 5: `systeminfo.sh`

#!/bin/bash
echo "Kernel Name: $(uname -s)"
echo "Kernel Release: $(uname -r)"
echo "Processor: $(uname -p)"
echo "OS: $(cat /etc/os-release | grep PRETTY_NAME | cut -d= -f2)"

EDITOR="nano"
echo "Favorite Editor: $EDITOR"
echo "Editor Location: $(which $EDITOR)"
echo "Documentation: $(whereis $EDITOR)"

10. Docker Containers

What is Docker?

Docker is a platform that lets you package, ship, and run applications in isolated environments called containers. A container is like a lightweight virtual machine that shares the host OS kernel. Think of it as: your app + all its dependencies, packaged together so it runs the same everywhere.

Key Concepts

Image: A blueprint/template for a container (like a class in OOP). Downloaded from Docker Hub.
Container: A running instance of an image (like an object). You can run multiple from one image.
Docker Hub: Online registry of Docker images (like GitHub for images).
Tag: Version of an image. Example: ubuntu:22.04 vs ubuntu:latest

Verify Docker Installation

docker --version           # Check Docker version
docker version             # Detailed client + server version
docker run hello-world     # Test Docker works

Docker Container Lifecycle

# PULL an image from Docker Hub
docker pull ubuntu                 # Download ubuntu image (latest)
docker pull ubuntu:22.04           # Download specific version
docker pull nginx                  # Download nginx image

# RUN a container from an image
docker run ubuntu                  # Runs and exits immediately (no process)
docker run ubuntu sleep 5          # Runs, sleeps 5 seconds, then exits

# RUN in interactive mode (get a shell inside container)
docker run -it ubuntu bash         # -i=interactive, -t=terminal
# You are now INSIDE the container!
echo "Hello Docker"
ls
exit                               # Exit container (container stops)

# RUN with a custom name
docker run --name myubuntu ubuntu sleep 30

# RUN in detached mode (background)
docker run -d ubuntu sleep 300     # -d = detached (runs in background)
docker run -dit --name test ubuntu bash  # Detached + interactive

Managing Containers

# LIST containers
docker ps                          # Show RUNNING containers only
docker ps -a                       # Show ALL containers (running + stopped)

# STOP a container
docker stop <container_id>         # Graceful stop
docker stop myubuntu               # Stop by name

# REMOVE a container
docker rm <container_id>           # Remove stopped container
docker rm myubuntu                 # Remove by name

# STOP ALL containers at once
docker stop $(docker ps -q)        # -q = quiet (only IDs)

# REMOVE ALL containers
docker rm $(docker ps -aq)         # Remove all (running + stopped)

🔥 EXAM TIP: docker run ubuntu exits immediately because there is no long-running process. Use sleep, -it bash, or -d to keep it alive.

Managing Images

# LIST downloaded images
docker images

# REMOVE an image
docker rmi ubuntu                  # Remove ubuntu image
docker rmi <image_id>              # Remove by ID
# Note: Must remove all containers using that image first!

Attach vs Exec (IMPORTANT DIFFERENCE!)

# ATTACH to a running container (connects to main process)
docker attach test
# CTRL+P then CTRL+Q = detach WITHOUT stopping container
# If you type 'exit', container STOPS

# EXEC runs a NEW process inside a running container
docker exec -it test bash
# If you type 'exit', only the exec process ends
# The container keeps running!

📝 NOTE: Use exec when you want to inspect a running container without affecting it. Use attach to reconnect to the main process.

Container Logs & Inspect

docker logs <container_id>                          # View container logs
docker logs myubuntu

docker inspect test                                  # Full container details (JSON)
docker inspect --format='{{.State.Status}}' test     # Get specific info

Port Mapping (`-p`)

Port mapping connects a port on your HOST machine to a port inside the container.

# Map host port 8081 to container port 80
docker run -d -p 8081:80 nginx
#                ^     ^
#                |     +-- container port (nginx listens on 80)
#                +-------- host port (access via localhost:8081)

# Run multiple web servers on different ports
docker run -d --name web1 -p 8081:80 ubuntu/apache2
docker run -d --name web2 -p 8082:80 ubuntu/apache2

# Access in browser:
# http://localhost:8081  -->  web1
# http://localhost:8082  -->  web2

🔥 EXAM TIP: Format is -p HOST_PORT:CONTAINER_PORT. The HOST port is what you type in the browser. The CONTAINER port is what the app listens on inside.

Volume Mounts (`-v`) / Bind Mounts

Volumes let you share files between your host machine and the container.

# Mount current directory into container
docker run -it -v $(pwd):/scripts ubuntu bash
# $(pwd) = your current directory on host
# /scripts = path inside the container

# Mount a specific file into nginx
echo '<h1>Hello Docker!</h1>' > index.html
docker run -d -p 8081:80 -v $(pwd)/index.html:/usr/share/nginx/html/index.html nginx
# You have just hosted a simple web app!

# Mount a Python script
echo 'print("Hello, world!")' > hello.py
docker run -it --rm -v $(pwd)/hello.py:/hello.py python:3.10-slim bash
# Then inside: python hello.py

📝 NOTE: The --rm flag automatically removes the container when it exits. Great for temporary containers.

Complete Docker Command Reference

Command	Purpose
`docker version`	Check Docker client and server version
`docker run <image>`	Start a container from an image
`docker run --name <n> <img>`	Run with a custom name
`docker run <img>:<tag>`	Run a specific version
`docker run -it <img> bash`	Run interactively with terminal
`docker run -d <img>`	Run in detached (background) mode
`docker run -p H:C <img>`	Map host port H to container port C
`docker run -v H:C <img>`	Mount host path H to container path C
`docker run --rm <img>`	Auto-remove container on exit
`docker ps`	List running containers
`docker ps -a`	List ALL containers
`docker stop <id/name>`	Stop a running container
`docker rm <id/name>`	Remove a stopped container
`docker images`	List downloaded images
`docker rmi <image>`	Remove an image
`docker pull <image>`	Download image from Docker Hub
`docker exec -it <id> bash`	Open shell in running container
`docker attach <id>`	Attach to main process of container
`docker logs <id>`	View container output logs
`docker inspect <id>`	Detailed container info (JSON)
`docker stop $(docker ps -q)`	Stop ALL running containers
`docker rm $(docker ps -aq)`	Remove ALL containers

— list, create, add to sudo, switch user, create group

12. Quick Reference Cheat Sheet

systemctl Commands

systemctl start <service>     # Start a service NOW
systemctl stop <service>      # Stop a service NOW
systemctl restart <service>   # Restart a service
systemctl reload <service>    # Reload config without stopping
systemctl status <service>    # Check if service is running
systemctl enable <service>    # Start on boot
systemctl disable <service>   # Don't start on boot

Key File Paths

Path	What
`/etc/ssh/sshd_config`	SSH server configuration
`~/.ssh/id_rsa`	Your SSH private key
`~/.ssh/id_rsa.pub`	Your SSH public key
`~/.ssh/authorized_keys`	Public keys allowed to login
`~/.ssh/config`	Client SSH shortcuts
`/var/www/html/`	Default web root (Apache + Nginx)
`/etc/apache2/sites-available/`	Apache virtual host configs
`/etc/apache2/sites-enabled/`	Active Apache sites (symlinks)
`/etc/nginx/sites-available/`	Nginx server block configs
`/etc/nginx/sites-enabled/`	Active Nginx sites (symlinks)
`/var/log/apache2/error.log`	Apache error log
`/var/log/nginx/error.log`	Nginx error log
`/etc/passwd`	User account information
`/etc/group`	Group definitions
`/etc/shadow`	Encrypted passwords (root only)

Permission Quick Reference

644 = rw-r--r--   # Standard file permission
755 = rwxr-xr-x   # Standard directory / script permission
700 = rwx------   # Private (owner only)
600 = rw-------   # SSH keys
777 = rwxrwxrwx   # NEVER USE (security risk)

Docker Quick Reference

docker run -it ubuntu bash        # Interactive shell
docker run -d -p 8080:80 nginx    # Background + port map
docker run -v $(pwd):/app ubuntu  # Volume mount
docker ps -a                      # List all containers
docker stop $(docker ps -q)       # Stop all running
docker rm $(docker ps -aq)        # Remove all containers
docker exec -it <id> bash         # Shell into running container
CTRL+P then CTRL+Q               # Detach without stopping

Bash Scripting Quick Reference

#!/bin/bash                        # Shebang (always first line)
$1 $2 $# $@ $?                    # Args, count, all, exit code
read VAR                           # Read user input
if [ condition ]; then ... fi      # Conditional
case "$1" in pattern) ... ;; esac  # Flag handling
for item in list; do ... done      # Loop
tar -czf name.tar.gz dir/         # Create archive
awk '{print $1}' file             # Text processing
cat << EOF > file ... EOF          # Heredoc
command > file 2>&1               # Redirect all output

Good luck on your exam! Practice these commands in the terminal — reading is not enough, you need muscle memory! 🚀