เทคนิค Sync ไฟล์จำนวนมาก

# Sync ผ่าน SSH port 2222
rsync -avz -e 'ssh -p 2222' /data/ user@remote:/backup/

# Sync ผ่าน SSH พร้อม key file
rsync -avz -e 'ssh -i /path/to/key.pem -p 2222' \
  /data/ user@remote:/backup/

# ใช้ SSH config จากไฟล์
rsync -avz -e 'ssh -F /path/to/ssh_config' /data/ user@remote:/backup/

# 1. สร้าง SSH key บน Source Server
ssh-keygen -t rsa -b 4096 -f ~/.ssh/rsync_key -N ""

# 2. Copy public key ไปยัง Destination Server
ssh-copy-id -i ~/.ssh/rsync_key.pub user@destination-server

# หรือ manual copy
cat ~/.ssh/rsync_key.pub | ssh user@destination-server \
  "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

# 3. ทดสอบ connection
ssh -i ~/.ssh/rsync_key user@destination-server

# 4. ใช้ rsync กับ key
rsync -avz -e 'ssh -i ~/.ssh/rsync_key' /data/ user@destination:/backup/

# Ubuntu/Debian
sudo apt update
sudo apt install unison -y

# CentOS/RHEL
sudo yum install unison -y

# ตรวจสอบ version (ต้องเท่ากันทั้งสองฝั่ง)
unison -version

# สร้าง profile file
mkdir -p ~/.unison
nano ~/.unison/default.prf

# ติดตั้งด้วย script
curl https://rclone.org/install.sh | sudo bash

# หรือด้วย package manager
# Ubuntu/Debian
sudo apt update
sudo apt install rclone -y

# CentOS/RHEL
sudo yum install rclone -y

# ตรวจสอบ version
rclone version

# ~/.config/rclone/rclone.conf

[my-s3]
type = s3
provider = AWS
env_auth = false
access_key_id = YOUR_ACCESS_KEY
secret_access_key = YOUR_SECRET_KEY
region = ap-southeast-1
acl = private

[my-gdrive]
type = drive
client_id = YOUR_CLIENT_ID
client_secret = YOUR_CLIENT_SECRET
scope = drive
token = {"access_token":"...","token_type":"Bearer","refresh_token":"..."}

# Ubuntu/Debian
sudo apt update
sudo apt install lsyncd -y

# CentOS/RHEL
sudo yum install lsyncd -y

# สร้างโฟลเดอร์ config
sudo mkdir -p /etc/lsyncd

# ตรวจสอบ version
lsyncd --version

-- lsyncd configuration file

settings {
    logfile = "/var/log/lsyncd/lsyncd.log",
    statusFile = "/var/log/lsyncd/lsyncd.status",
    statusInterval = 20,
    nodaemon = false,
    maxProcesses = 4,
}

-- Sync ไปยัง remote server เดียว
sync {
    default.rsync,
    source = "/var/www/html/",
    target = "user@backup-server:/backup/www/",
    delete = true,
    delay = 5,
    rsync = {
        binary = "/usr/bin/rsync",
        archive = true,
        compress = true,
        verbose = true,
        _extra = {"--bwlimit=10240"}
    },
    exclude = {
        "*.log",
        "*.tmp",
        "cache/",
        ".git/"
    }
}

-- Sync ไปยังหลาย remote servers
sync {
    default.rsync,
    source = "/var/www/html/",
    target = "user@server1:/var/www/html/",
    -- ... options
}

sync {
    default.rsync,
    source = "/var/www/html/",
    target = "user@server2:/var/www/html/",
    -- ... options
}

#!/bin/bash
#
# Backup Sync Script
# Usage: ./backup-sync.sh [source] [destination]
#

set -e

# Configuration
SOURCE_DIR="${1:-/var/www/html/}"
DEST_USER="backup"
DEST_SERVER="backup.example.com"
DEST_DIR="${2:-/backup/www/}"
LOG_FILE="/var/log/backup-sync.log"
LOCK_FILE="/var/run/backup-sync.lock"
EMAIL="admin@example.com"

# Functions
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

send_alert() {
    local subject="$1"
    local message="$2"
    echo "$message" | mail -s "$subject" "$EMAIL"
}

# Check if already running
if [ -f "$LOCK_FILE" ]; then
    PID=$(cat "$LOCK_FILE")
    if ps -p "$PID" > /dev/null 2>&1; then
        log "ERROR: Script already running (PID: $PID)"
        exit 1
    else
        rm -f "$LOCK_FILE"
    fi
fi

# Create lock file
echo $$ > "$LOCK_FILE"

# Start sync
log "Starting backup sync from $SOURCE_DIR to $DEST_SERVER:$DEST_DIR"

START_TIME=$(date +%s)

rsync -avz \
    --delete \
    --progress \
    --stats \
    --log-file="$LOG_FILE" \
    --exclude='*.log' \
    --exclude='cache/' \
    --exclude='.git/' \
    --bwlimit=10240 \
    -e 'ssh -i /root/.ssh/backup_key -p 22 -o StrictHostKeyChecking=no' \
    "$SOURCE_DIR" \
    "${DEST_USER}@${DEST_SERVER}:${DEST_DIR}"

RSYNC_EXIT_CODE=$?

END_TIME=$(date +%s)
DURATION=$((END_TIME - START_TIME))

if [ $RSYNC_EXIT_CODE -eq 0 ]; then
    log "Backup sync completed successfully in ${DURATION} seconds"
    send_alert "Backup Sync Success" "Backup completed in ${DURATION} seconds"
else
    log "ERROR: Backup sync failed with exit code $RSYNC_EXIT_CODE"
    send_alert "Backup Sync FAILED" "Backup failed with exit code $RSYNC_EXIT_CODE"
fi

# Remove lock file
rm -f "$LOCK_FILE"

exit $RSYNC_EXIT_CODE

#!/bin/bash
#
# Bidirectional Sync Script using Unison
#

set -e

# Configuration
LOCAL_DIR="/data/shared"
REMOTE_USER="sync"
REMOTE_HOST="server-b.example.com"
REMOTE_DIR="/data/shared"
SSH_KEY="/root/.ssh/unison_key"
LOG_FILE="/var/log/bidirectional-sync.log"
PROFILE="shared-sync"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}

# Create temporary profile
TEMP_PROFILE="/tmp/${PROFILE}.prf"
cat > "$TEMP_PROFILE" <&1 | while read line; do
    log "$line"
done

UNISON_EXIT=$?

if [ $UNISON_EXIT -eq 0 ]; then
    log "Bidirectional sync completed successfully"
else
    log "ERROR: Bidirectional sync failed with exit code $UNISON_EXIT"
fi

# Cleanup
rm -f "$TEMP_PROFILE"

exit $UNISON_EXIT

#!/bin/bash
#
# Multi-Server Sync Script
# Sync ไปยังหลาย servers พร้อมกัน
#

set -e

SOURCE_DIR="/var/www/html/"
SSH_KEY="/root/.ssh/sync_key"
BWLIMIT="10240"
LOG_FILE="/var/log/multi-sync.log"

# Server list (user@host:destination)
SERVERS=(
    "deploy@web1.example.com:/var/www/html/"
    "deploy@web2.example.com:/var/www/html/"
    "deploy@web3.example.com:/var/www/html/"
    "backup@backup.example.com:/backup/www/"
)

# Parallel sync function
sync_to_server() {
    local server="$1"
    local start_time=$(date +%s)
    
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Starting sync to $server" >> "$LOG_FILE"
    
    if rsync -avz \
        --delete \
        --bwlimit="$BWLIMIT" \
        --exclude='*.log' \
        --exclude='cache/' \
        -e "ssh -i $SSH_KEY -o StrictHostKeyChecking=no -o ConnectTimeout=30" \
        "$SOURCE_DIR" \
        "$server" >> "$LOG_FILE" 2>&1; then
        
        local end_time=$(date +%s)
        local duration=$((end_time - start_time))
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] SUCCESS: $server (${duration}s)" >> "$LOG_FILE"
        return 0
    else
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] FAILED: $server" >> "$LOG_FILE"
        return 1
    fi
}

# Main
echo "========================================" >> "$LOG_FILE"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Starting multi-server sync" >> "$LOG_FILE"

PIDS=()
SUCCESS=0
FAILED=0

# Start parallel syncs
for server in "${SERVERS[@]}"; do
    sync_to_server "$server" &
    PIDS+=($!)
done

# Wait for all syncs to complete
for pid in "${PIDS[@]}"; do
    if wait $pid; then
        ((SUCCESS++))
    else
        ((FAILED++))
    fi
done

# Summary
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Multi-server sync completed" >> "$LOG_FILE"
echo "  Success: $SUCCESS" >> "$LOG_FILE"
echo "  Failed: $FAILED" >> "$LOG_FILE"

if [ $FAILED -gt 0 ]; then
    exit 1
fi

exit 0

#!/bin/bash
#
# Incremental Backup with Rotation
# ใช้ hardlinks เพื่อประหยัดพื้นที่
#

set -e

# Configuration
SOURCE_DIR="/var/www/html/"
BACKUP_BASE="/backup/www"
REMOTE_USER="backup"
REMOTE_HOST="backup.example.com"
KEEP_DAILY=7
KEEP_WEEKLY=4
KEEP_MONTHLY=12

# Date variables
DATE=$(date +%Y-%m-%d)
DAY_OF_WEEK=$(date +%u)
DAY_OF_MONTH=$(date +%d)

# Backup directories
DAILY_DIR="${BACKUP_BASE}/daily"
WEEKLY_DIR="${BACKUP_BASE}/weekly"
MONTHLY_DIR="${BACKUP_BASE}/monthly"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

# Create directories
mkdir -p "$DAILY_DIR" "$WEEKLY_DIR" "$MONTHLY_DIR"

# Find latest backup for hardlink reference
LATEST_BACKUP=$(ls -1d "${DAILY_DIR}"/*/ 2>/dev/null | tail -1)

# Create new backup using hardlinks
NEW_BACKUP="${DAILY_DIR}/${DATE}"
log "Creating incremental backup: $NEW_BACKUP"

if [ -n "$LATEST_BACKUP" ]; then
    # Use rsync with link-dest for incremental backup
    rsync -avz \
        --delete \
        --link-dest="$LATEST_BACKUP" \
        --exclude='*.log' \
        --exclude='cache/' \
        -e 'ssh -i /root/.ssh/backup_key' \
        "${REMOTE_USER}@${REMOTE_HOST}:${SOURCE_DIR}" \
        "$NEW_BACKUP/"
else
    # First backup - full copy
    rsync -avz \
        --delete \
        --exclude='*.log' \
        --exclude='cache/' \
        -e 'ssh -i /root/.ssh/backup_key' \
        "${REMOTE_USER}@${REMOTE_HOST}:${SOURCE_DIR}" \
        "$NEW_BACKUP/"
fi

log "Backup created successfully"

# Weekly backup (Sunday)
if [ "$DAY_OF_WEEK" -eq 7 ]; then
    log "Creating weekly backup"
    cp -al "$NEW_BACKUP" "${WEEKLY_DIR}/${DATE}"
fi

# Monthly backup (1st of month)
if [ "$DAY_OF_MONTH" -eq 01 ]; then
    log "Creating monthly backup"
    cp -al "$NEW_BACKUP" "${MONTHLY_DIR}/${DATE}"
fi

# Rotation - delete old backups
log "Rotating old backups..."

# Daily rotation
find "$DAILY_DIR" -maxdepth 1 -type d -mtime +$KEEP_DAILY -exec rm -rf {} \; 2>/dev/null || true

# Weekly rotation
find "$WEEKLY_DIR" -maxdepth 1 -type d -mtime +$((KEEP_WEEKLY * 7)) -exec rm -rf {} \; 2>/dev/null || true

# Monthly rotation
find "$MONTHLY_DIR" -maxdepth 1 -type d -mtime +$((KEEP_MONTHLY * 30)) -exec rm -rf {} \; 2>/dev/null || true

log "Backup rotation completed"

# Calculate backup sizes
DAILY_SIZE=$(du -sh "$DAILY_DIR" | cut -f1)
log "Daily backup size: $DAILY_SIZE"

# Send summary
echo "Backup completed successfully on $(date)" | mail -s "Backup Summary - $(hostname)" admin@example.com

exit 0