# 가장 기본적인 백업 명령어
mysqldump -u username -p database_name > backup.sql

# 예시: myapp 데이터베이스를 백업
mysqldump -u root -p myapp > myapp_backup_20240115.sql

# 실무에서 권장하는 완전한 백업 명령어
mysqldump -u root -p \
  --single-transaction \
  --routines \
  --triggers \
  --events \
  --hex-blob \
  --default-character-set=utf8mb4 \
  myapp > myapp_full_backup.sql

# 여러 데이터베이스를 한 번에 백업
mysqldump -u root -p \
  --databases db1 db2 db3 \
  --single-transaction \
  --routines > multi_db_backup.sql

# 모든 데이터베이스 백업
mysqldump -u root -p \
  --all-databases \
  --single-transaction \
  --routines \
  --triggers \
  --events > all_databases_backup.sql

# 특정 테이블만 백업
mysqldump -u root -p myapp users orders > specific_tables.sql

# 특정 테이블 제외하고 백업
mysqldump -u root -p myapp \
  --ignore-table=myapp.logs \
  --ignore-table=myapp.temp_data > backup_without_logs.sql

# 테이블 구조만 백업 (데이터 제외)
mysqldump -u root -p --no-data myapp > schema_only.sql

# 데이터만 백업 (구조 제외)
mysqldump -u root -p --no-create-info myapp > data_only.sql

# gzip으로 압축하면서 백업
mysqldump -u root -p myapp | gzip > myapp_backup.sql.gz

# 압축 백업 복원
gunzip < myapp_backup.sql.gz | mysql -u root -p myapp

# 더 높은 압축률을 원한다면 bzip2
mysqldump -u root -p myapp | bzip2 > myapp_backup.sql.bz2

# bzip2 백업 복원
bunzip2 < myapp_backup.sql.bz2 | mysql -u root -p myapp

# 기본 복원
mysql -u root -p myapp < myapp_backup.sql

# 압축된 백업 복원
gunzip < myapp_backup.sql.gz | mysql -u root -p myapp

# 새로운 데이터베이스로 복원
mysql -u root -p -e "CREATE DATABASE myapp_restored;"
mysql -u root -p myapp_restored < myapp_backup.sql

# 복원 진행상황 확인하며 복원 (pv 도구 사용)
pv myapp_backup.sql | mysql -u root -p myapp

# 가장 기본적인 백업
pg_dump -U username database_name > backup.sql

# 예시: myapp 데이터베이스 백업
pg_dump -U postgres myapp > myapp_backup.sql

# 호스트와 포트 지정
pg_dump -h localhost -p 5432 -U postgres myapp > backup.sql

# 스키마만 백업
pg_dump -U postgres --schema-only myapp > schema.sql

# 데이터만 백업
pg_dump -U postgres --data-only myapp > data.sql

# 특정 스키마만 백업
pg_dump -U postgres -n public myapp > public_schema.sql

# 특정 테이블만 백업
pg_dump -U postgres -t users -t orders myapp > tables.sql

# 특정 테이블 제외
pg_dump -U postgres -T logs myapp > backup_without_logs.sql

# 병렬 백업 (4개 작업 동시 실행)
pg_dump -U postgres -Fd -j 4 myapp -f backup_dir

# 압축 레벨 지정 (0-9, 9가 최대 압축)
pg_dump -U postgres -Fc -Z 9 myapp > backup.dump

# 모든 데이터베이스 백업
pg_dumpall -U postgres > all_databases.sql

# 글로벌 객체만 백업 (역할, 테이블스페이스 등)
pg_dumpall -U postgres --globals-only > globals.sql

# 역할(사용자)만 백업
pg_dumpall -U postgres --roles-only > roles.sql

# Plain Text 복원
psql -U postgres myapp < backup.sql

# Custom Format 복원
pg_restore -U postgres -d myapp backup.dump

# 병렬 복원 (4개 작업 동시 실행)
pg_restore -U postgres -d myapp -j 4 backup.dump

# 특정 테이블만 복원
pg_restore -U postgres -d myapp -t users backup.dump

# 새 데이터베이스로 복원
createdb -U postgres myapp_restored
pg_restore -U postgres -d myapp_restored backup.dump

# 기존 데이터 삭제 후 복원
pg_restore -U postgres -d myapp --clean backup.dump

# 복원 전 DROP 명령 실행
pg_restore -U postgres -d myapp --clean --if-exists backup.dump

#!/bin/bash
# mysql_backup.sh

# 설정
DB_USER="root"
DB_PASS="your_password"
DB_NAME="myapp"
BACKUP_DIR="/backup/mysql"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${DB_NAME}_${DATE}.sql.gz"

# 백업 디렉토리 생성
mkdir -p $BACKUP_DIR

# 백업 실행
mysqldump -u $DB_USER -p$DB_PASS \
  --single-transaction \
  --routines \
  --triggers \
  --events \
  $DB_NAME | gzip > $BACKUP_FILE

# 7일 이상 된 백업 파일 삭제
find $BACKUP_DIR -name "*.sql.gz" -mtime +7 -delete

# 백업 결과 확인
if [ -f $BACKUP_FILE ]; then
    echo "Backup successful: $BACKUP_FILE"
    # 백업 파일 크기 확인
    ls -lh $BACKUP_FILE
else
    echo "Backup failed!"
    exit 1
fi

#!/bin/bash
# pg_backup.sh

# 설정
export PGPASSWORD="your_password"
DB_USER="postgres"
DB_NAME="myapp"
BACKUP_DIR="/backup/postgresql"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${DB_NAME}_${DATE}.dump"

# 백업 디렉토리 생성
mkdir -p $BACKUP_DIR

# 백업 실행 (Custom Format, 압축 레벨 9)
pg_dump -U $DB_USER -Fc -Z 9 $DB_NAME > $BACKUP_FILE

# 7일 이상 된 백업 파일 삭제
find $BACKUP_DIR -name "*.dump" -mtime +7 -delete

# 백업 결과 확인
if [ -f $BACKUP_FILE ]; then
    echo "Backup successful: $BACKUP_FILE"
    ls -lh $BACKUP_FILE
else
    echo "Backup failed!"
    exit 1
fi

# 환경변수 정리
unset PGPASSWORD

# crontab 편집
crontab -e

# 매일 새벽 2시에 백업 실행
0 2 * * * /path/to/mysql_backup.sh >> /var/log/mysql_backup.log 2>&1

# 매주 일요일 새벽 3시에 전체 백업
0 3 * * 0 /path/to/full_backup.sh >> /var/log/full_backup.log 2>&1

# 매시간 증분 백업
0 * * * * /path/to/incremental_backup.sh >> /var/log/incremental_backup.log 2>&1

# 매일 오전 9시와 오후 6시에 백업
0 9,18 * * * /path/to/pg_backup.sh >> /var/log/pg_backup.log 2>&1

#!/bin/bash
# verify_backup.sh

BACKUP_FILE=$1
TEST_DB="test_restore_db"

# MySQL 백업 검증
verify_mysql_backup() {
    echo "Verifying MySQL backup: $BACKUP_FILE"
    
    # 테스트 DB 생성
    mysql -u root -p -e "DROP DATABASE IF EXISTS $TEST_DB;"
    mysql -u root -p -e "CREATE DATABASE $TEST_DB;"
    
    # 백업 복원 시도
    if gunzip < $BACKUP_FILE | mysql -u root -p $TEST_DB; then
        echo "✅ Backup verification successful!"
        
        # 테이블 수 확인
        TABLE_COUNT=$(mysql -u root -p -N -e "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema='$TEST_DB';")
        echo "Restored tables: $TABLE_COUNT"
        
        # 테스트 DB 삭제
        mysql -u root -p -e "DROP DATABASE $TEST_DB;"
        return 0
    else
        echo "❌ Backup verification failed!"
        return 1
    fi
}

# PostgreSQL 백업 검증
verify_pg_backup() {
    echo "Verifying PostgreSQL backup: $BACKUP_FILE"
    
    # 테스트 DB 생성
    dropdb -U postgres --if-exists $TEST_DB
    createdb -U postgres $TEST_DB
    
    # 백업 복원 시도
    if pg_restore -U postgres -d $TEST_DB $BACKUP_FILE; then
        echo "✅ Backup verification successful!"
        
        # 테이블 수 확인
        TABLE_COUNT=$(psql -U postgres -d $TEST_DB -t -c "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema='public';")
        echo "Restored tables: $TABLE_COUNT"
        
        # 테스트 DB 삭제
        dropdb -U postgres $TEST_DB
        return 0
    else
        echo "❌ Backup verification failed!"
        return 1
    fi
}

# 실행
if [[ $BACKUP_FILE == *.sql.gz ]]; then
    verify_mysql_backup
elif [[ $BACKUP_FILE == *.dump ]]; then
    verify_pg_backup
else
    echo "Unknown backup format"
    exit 1
fi

#!/bin/bash
# backup_to_s3.sh

# AWS CLI 설치 필요: apt-get install awscli

S3_BUCKET="my-database-backups"
BACKUP_FILE=$1

# S3로 업로드
aws s3 cp $BACKUP_FILE s3://$S3_BUCKET/mysql/ \
    --storage-class STANDARD_IA

# 업로드 확인
if [ $? -eq 0 ]; then
    echo "✅ Uploaded to S3: $BACKUP_FILE"
    
    # 로컬 백업 파일 삭제 (선택사항)
    # rm $BACKUP_FILE
else
    echo "❌ S3 upload failed!"
    exit 1
fi

# S3에서 30일 이상 된 백업 삭제
aws s3 ls s3://$S3_BUCKET/mysql/ | while read -r line; do
    createDate=$(echo $line | awk '{print $1" "$2}')
    createDate=$(date -d "$createDate" +%s)
    olderThan=$(date -d "30 days ago" +%s)
    
    if [[ $createDate -lt $olderThan ]]; then
        fileName=$(echo $line | awk '{print $4}')
        if [[ $fileName != "" ]]; then
            aws s3 rm s3://$S3_BUCKET/mysql/$fileName
            echo "Deleted old backup: $fileName"
        fi
    fi
done

#!/bin/bash
# backup_to_gcs.sh

# gcloud CLI 설치 필요

GCS_BUCKET="my-database-backups"
BACKUP_FILE=$1

# GCS로 업로드
gsutil cp $BACKUP_FILE gs://$GCS_BUCKET/postgresql/

# 업로드 확인
if [ $? -eq 0 ]; then
    echo "✅ Uploaded to GCS: $BACKUP_FILE"
else
    echo "❌ GCS upload failed!"
    exit 1
fi

# 30일 이상 된 백업 자동 삭제 설정 (Lifecycle 정책)
cat > lifecycle.json << EOF
{
  "lifecycle": {
    "rule": [
      {
        "action": {"type": "Delete"},
        "condition": {"age": 30}
      }
    ]
  }
}
EOF

gsutil lifecycle set lifecycle.json gs://$GCS_BUCKET

# 마스터 서버 설정 (my.cnf)
[mysqld]
server-id = 1
log-bin = mysql-bin
binlog-format = ROW

# 슬레이브 서버 설정 (my.cnf)
[mysqld]
server-id = 2
relay-log = mysql-relay-bin
read-only = 1

# 마스터에서 복제 사용자 생성
CREATE USER 'repl'@'%' IDENTIFIED BY 'password';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';

# 슬레이브에서 복제 시작
CHANGE MASTER TO
    MASTER_HOST='master_ip',
    MASTER_USER='repl',
    MASTER_PASSWORD='password',
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;

START SLAVE;

# 마스터 서버 설정 (postgresql.conf)
wal_level = replica
max_wal_senders = 3
wal_keep_size = 1GB

# 마스터 서버 접근 설정 (pg_hba.conf)
host replication repl 192.168.1.0/24 md5

# 슬레이브 서버에서 베이스 백업 생성
pg_basebackup -h master_ip -D /var/lib/postgresql/data -U repl -P -v -R

# 슬레이브 서버 시작
pg_ctl start

#!/bin/bash
# monitor_backup.sh

BACKUP_DIR="/backup/mysql"
ALERT_EMAIL="admin@example.com"
MAX_AGE_HOURS=25  # 백업이 25시간 이상 오래되면 알림

# 최신 백업 파일 찾기
LATEST_BACKUP=$(ls -t $BACKUP_DIR/*.sql.gz 2>/dev/null | head -1)

if [ -z "$LATEST_BACKUP" ]; then
    echo "❌ No backup files found!"
    echo "No backup files in $BACKUP_DIR" | mail -s "BACKUP ALERT: No backups found" $ALERT_EMAIL
    exit 1
fi

# 백업 파일 나이 확인
BACKUP_AGE=$(( ($(date +%s) - $(stat -c %Y "$LATEST_BACKUP")) / 3600 ))

if [ $BACKUP_AGE -gt $MAX_AGE_HOURS ]; then
    echo "❌ Backup is too old: $BACKUP_AGE hours"
    echo "Latest backup is $BACKUP_AGE hours old: $LATEST_BACKUP" | \
        mail -s "BACKUP ALERT: Backup too old" $ALERT_EMAIL
    exit 1
fi

# 백업 파일 크기 확인
BACKUP_SIZE=$(stat -c %s "$LATEST_BACKUP")
MIN_SIZE=1048576  # 1MB

if [ $BACKUP_SIZE -lt $MIN_SIZE ]; then
    echo "❌ Backup file is too small: $BACKUP_SIZE bytes"
    echo "Backup file is suspiciously small: $LATEST_BACKUP ($BACKUP_SIZE bytes)" | \
        mail -s "BACKUP ALERT: Backup too small" $ALERT_EMAIL
    exit 1
fi

# 백업 파일 무결성 확인
if ! gunzip -t "$LATEST_BACKUP" 2>/dev/null; then
    echo "❌ Backup file is corrupted!"
    echo "Backup file is corrupted: $LATEST_BACKUP" | \
        mail -s "BACKUP ALERT: Corrupted backup" $ALERT_EMAIL
    exit 1
fi

echo "✅ Backup is healthy"
echo "Latest backup: $LATEST_BACKUP"
echo "Age: $BACKUP_AGE hours"
echo "Size: $(numfmt --to=iec-i --suffix=B $BACKUP_SIZE)"

#!/bin/bash
# slack_notify.sh

SLACK_WEBHOOK="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"

send_slack_notification() {
    local message=$1
    local color=$2  # good, warning, danger
    
    curl -X POST $SLACK_WEBHOOK \
        -H 'Content-Type: application/json' \
        -d "{
            \"attachments\": [{
                \"color\": \"$color\",
                \"title\": \"Database Backup Status\",
                \"text\": \"$message\",
                \"footer\": \"Backup Monitor\",
                \"ts\": $(date +%s)
            }]
        }"
}

# 백업 성공 알림
send_slack_notification "✅ Backup completed successfully\nFile: myapp_20240115.sql.gz\nSize: 2.3GB" "good"

# 백업 실패 알림
send_slack_notification "❌ Backup failed!\nError: Disk space full" "danger"

# 백업 경고 알림
send_slack_notification "⚠️ Backup is older than 24 hours" "warning"

# Percona XtraBackup 설치 (Ubuntu/Debian)
wget https://repo.percona.com/apt/percona-release_latest.generic_all.deb
sudo dpkg -i percona-release_latest.generic_all.deb
sudo apt-get update
sudo apt-get install percona-xtrabackup-80

# 전체 백업
xtrabackup --backup --target-dir=/backup/full

# 증분 백업
xtrabackup --backup --target-dir=/backup/inc1 \
    --incremental-basedir=/backup/full

# 백업 준비 (복원 전 필수)
xtrabackup --prepare --target-dir=/backup/full

# 증분 백업 적용
xtrabackup --prepare --target-dir=/backup/full \
    --incremental-dir=/backup/inc1

# 복원
xtrabackup --copy-back --target-dir=/backup/full
chown -R mysql:mysql /var/lib/mysql

# pgBackRest 설치 (Ubuntu/Debian)
sudo apt-get install pgbackrest

# 설정 파일 (/etc/pgbackrest/pgbackrest.conf)
[global]
repo1-path=/var/lib/pgbackrest
repo1-retention-full=2
repo1-retention-diff=4
log-level-console=info
log-level-file=debug

[myapp]
pg1-path=/var/lib/postgresql/14/main
pg1-port=5432

# 전체 백업
pgbackrest --stanza=myapp --type=full backup

# 차등 백업
pgbackrest --stanza=myapp --type=diff backup

# 증분 백업
pgbackrest --stanza=myapp --type=incr backup

# 복원
pgbackrest --stanza=myapp restore

# 특정 시점으로 복원 (PITR)
pgbackrest --stanza=myapp --type=time \
    "--target=2024-01-15 14:30:00" restore

# MySQL 백업을 암호화하여 저장
mysqldump -u root -p myapp | \
    gzip | \
    openssl enc -aes-256-cbc -salt -out backup_encrypted.sql.gz.enc

# 암호화된 백업 복원
openssl enc -aes-256-cbc -d -in backup_encrypted.sql.gz.enc | \
    gunzip | \
    mysql -u root -p myapp

# GPG를 사용한 암호화 (공개키 암호화)
mysqldump -u root -p myapp | \
    gzip | \
    gpg --encrypt --recipient admin@example.com > backup.sql.gz.gpg

# GPG 암호화된 백업 복원
gpg --decrypt backup.sql.gz.gpg | \
    gunzip | \
    mysql -u root -p myapp

# 백업 디렉토리 권한 설정
chmod 700 /backup
chown mysql:mysql /backup

# 백업 파일 권한 설정
chmod 600 /backup/*.sql.gz

# SELinux 컨텍스트 설정 (RHEL/CentOS)
semanage fcontext -a -t mysqld_db_t "/backup(/.*)?"
restorecon -R /backup

# 백업 파일 소유자 확인
ls -la /backup/

# PostgreSQL 병렬 백업 (4개 작업 동시 실행)
pg_dump -U postgres -Fd -j 4 myapp -f backup_dir

# mydumper를 사용한 MySQL 병렬 백업
mydumper -u root -p password -B myapp -o /backup -t 4

# 테이블별로 병렬 백업 (스크립트)
#!/bin/bash
TABLES=$(mysql -u root -p -N -e "SHOW TABLES FROM myapp")

for table in $TABLES; do
    mysqldump -u root -p myapp $table | gzip > ${table}.sql.gz &
done

wait  # 모든 백업이 완료될 때까지 대기

# 압축을 사용한 원격 백업
mysqldump -u root -p myapp | \
    gzip | \
    ssh user@backup-server "cat > /backup/myapp.sql.gz"

# pigz를 사용한 병렬 압축 (더 빠름)
mysqldump -u root -p myapp | \
    pigz -p 4 > backup.sql.gz

# 네트워크 대역폭 제한 (다른 서비스에 영향 최소화)
mysqldump -u root -p myapp | \
    gzip | \
    pv -L 10m | \  # 10MB/s로 제한
    ssh user@backup-server "cat > /backup/myapp.sql.gz"