Backup Database: Strategie e Tool

L'Importanza del Backup Database

Perdere i dati del database è uno degli scenari peggiori per qualsiasi applicazione. Un backup robusto non è opzionale—è una necessità critica per business continuity, disaster recovery e compliance. Questa guida copre strategie, strumenti e best practice per proteggere i tuoi dati in modo professionale.

Tipi di Backup

Backup Completo (Full)

Copia completa di tutto il database inclusi schema, dati, indici e configurazioni. È la base per qualsiasi strategia di backup.

# PostgreSQL - pg_dump
pg_dump -h localhost -U postgres -d mydb -F c -f backup_full.dump

# -F c: formato custom (compresso, parallelizzabile)
# -F d: formato directory (per parallelismo)
# -F p: formato plain SQL

# MySQL - mysqldump
mysqldump -u root -p --all-databases > backup_full.sql
mysqldump -u root -p --single-transaction mydb > mydb.sql

# MongoDB - mongodump
mongodump --uri="mongodb://localhost:27017" --db=mydb --out=/backup/full

Backup Incrementale

Solo le modifiche dall'ultimo backup. Veloce ma richiede la catena completa per il ripristino.

# PostgreSQL - WAL archiving
# postgresql.conf
archive_mode = on
archive_command = 'cp %p /backup/wal/%f'
wal_level = replica

# pg_basebackup per backup base
pg_basebackup -D /backup/base -Ft -Xs -P

# MySQL - binary logs
# my.cnf
log_bin = /var/log/mysql/mysql-bin.log
expire_logs_days = 7

# Estrai modifiche incrementali
mysqlbinlog --start-datetime="2025-01-01 00:00:00" mysql-bin.000001 > incremental.sql

Backup Differenziale

Tutte le modifiche dall'ultimo backup completo. Compromesso tra velocità di backup e semplicità di ripristino.

Confronto Strategie

Tipo	Velocità Backup	Velocità Restore	Storage
Full	Lento	Veloce	Alto
Incrementale	Veloce	Lento	Basso
Differenziale	Medio	Medio	Medio

Strategie di Backup

Regola 3-2-1

La regola d'oro per la protezione dei dati:

3 copie dei dati (originale + 2 backup)
2 tipi diversi di storage (locale + cloud)
1 copia offsite (geograficamente separata)

Retention Policy

# Esempio policy aziendale:
# GFS (Grandfather-Father-Son)

Daily (Son):    Ultimi 7 giorni
Weekly (Father): Ultime 4 settimane (ogni domenica)
Monthly (Grandfather): Ultimi 12 mesi (primo del mese)
Yearly:         Ultimi 5 anni (1 gennaio)

# Script di pulizia
find /backup/daily -mtime +7 -delete
find /backup/weekly -mtime +28 -delete
find /backup/monthly -mtime +365 -delete

RPO e RTO

RPO (Recovery Point Objective): Quanti dati puoi permetterti di perdere? (es. max 1 ora)
RTO (Recovery Time Objective): Quanto tempo puoi stare offline? (es. max 4 ore)

# Relazione tra RPO e frequenza backup:
RPO 24 ore → Backup giornaliero
RPO 1 ora  → Backup orario o WAL archiving
RPO 0      → Replica sincrona (High Availability)

PostgreSQL Backup

pg_dump per Backup Logici

# Backup completo con compressione
pg_dump -h localhost -U postgres -d mydb -F c -Z 9 -f backup.dump

# Opzioni utili:
-F c        # Formato custom (raccomandato)
-Z 9        # Compressione massima
-j 4        # Parallelismo (solo con -F d)
--no-owner  # Ignora ownership
--no-acl    # Ignora permessi

# Solo schema (per migrazioni)
pg_dump --schema-only mydb > schema.sql

# Solo dati
pg_dump --data-only mydb > data.sql

# Escludere tabelle specifiche
pg_dump --exclude-table='logs*' mydb > backup.sql

# Ripristino
pg_restore -d mydb -j 4 backup.dump

# Oppure con psql per plain SQL
psql mydb < backup.sql

pg_basebackup per Backup Fisici

# Backup fisico completo (per PITR)
pg_basebackup -D /backup/base -Ft -Xs -P -U replicator

# Opzioni:
-D      # Directory destinazione
-Ft     # Formato tar
-Xs     # Include WAL tramite streaming
-P      # Progress bar

# Point-in-Time Recovery (PITR)
# 1. Ripristina backup base
# 2. Configura recovery.conf
# 3. Replay WAL fino al punto desiderato

# recovery.conf
restore_command = 'cp /backup/wal/%f %p'
recovery_target_time = '2025-01-15 14:30:00'

MySQL Backup

mysqldump

# Tutti i database
mysqldump -u root -p --all-databases > all_dbs.sql

# Singolo database con transazioni consistenti
mysqldump -u root -p --single-transaction --routines --triggers mydb > mydb.sql

# Opzioni importanti:
--single-transaction  # Consistenza senza lock (InnoDB)
--routines           # Include stored procedures
--triggers           # Include trigger
--events             # Include scheduled events
--quick              # Per tabelle grandi

# Ripristino
mysql -u root -p mydb < mydb.sql

# Con progress
pv mydb.sql | mysql -u root -p mydb

XtraBackup (Percona)

# Backup completo hot (senza lock)
xtrabackup --backup --target-dir=/backup/full

# Backup incrementale
xtrabackup --backup --target-dir=/backup/inc1 \
  --incremental-basedir=/backup/full

# Preparazione per ripristino
xtrabackup --prepare --target-dir=/backup/full
xtrabackup --prepare --target-dir=/backup/full \
  --incremental-dir=/backup/inc1

# Ripristino
systemctl stop mysql
xtrabackup --copy-back --target-dir=/backup/full
chown -R mysql:mysql /var/lib/mysql
systemctl start mysql

MongoDB Backup

# mongodump
mongodump --uri="mongodb://localhost:27017" --db=mydb --out=/backup

# Con compressione
mongodump --archive=/backup/mydb.gz --gzip --db=mydb

# Oplog per point-in-time recovery
mongodump --oplog --out=/backup

# Ripristino
mongorestore --uri="mongodb://localhost:27017" /backup/mydb

# Da archivio
mongorestore --gzip --archive=/backup/mydb.gz

Automazione

Script Bash Completo

#!/bin/bash
# backup.sh - Script di backup automatico

set -e  # Exit on error

# Configurazione
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/backup/postgres"
DB_NAME="mydb"
S3_BUCKET="s3://my-backups/postgres"
RETENTION_DAYS=7

# Crea backup
echo "Starting backup: $DATE"
pg_dump -Fc $DB_NAME > "$BACKUP_DIR/${DB_NAME}_${DATE}.dump"

# Comprimi
gzip "$BACKUP_DIR/${DB_NAME}_${DATE}.dump"

# Upload su S3
aws s3 cp "$BACKUP_DIR/${DB_NAME}_${DATE}.dump.gz" "$S3_BUCKET/"

# Elimina backup locali vecchi
find $BACKUP_DIR -name "*.gz" -mtime +$RETENTION_DAYS -delete

# Notifica successo
echo "Backup completed: ${DB_NAME}_${DATE}.dump.gz"

Cron Job

# crontab -e

# Backup giornaliero alle 3:00
0 3 * * * /scripts/backup.sh >> /var/log/backup.log 2>&1

# Backup ogni 6 ore per database critici
0 */6 * * * /scripts/backup-critical.sh >> /var/log/backup-critical.log 2>&1

# Backup settimanale completo (domenica)
0 2 * * 0 /scripts/backup-weekly.sh >> /var/log/backup-weekly.log 2>&1

GitHub Actions

name: Database Backup

on:
  schedule:
    - cron: '0 3 * * *'  # Daily at 3 AM UTC
  workflow_dispatch:      # Manual trigger

jobs:
  backup:
    runs-on: ubuntu-latest
    steps:
      - name: Install PostgreSQL client
        run: sudo apt-get install -y postgresql-client

      - name: Backup PostgreSQL
        env:
          PGPASSWORD: ${{ secrets.DB_PASSWORD }}
        run: |
          pg_dump -h ${{ secrets.DB_HOST }} -U postgres -d mydb \
            -F c -f backup.dump

      - name: Configure AWS
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_KEY }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET }}
          aws-region: eu-west-1

      - name: Upload to S3
        run: |
          aws s3 cp backup.dump \
            s3://backups/$(date +%Y%m%d).dump

Verifica dei Backup

# REGOLA D'ORO: Un backup non testato non è un backup!

# Test di ripristino periodico
createdb test_restore
pg_restore -d test_restore backup.dump

# Verifica integrità
pg_restore --list backup.dump

# Verifica checksum file
sha256sum backup.dump > backup.dump.sha256
sha256sum -c backup.dump.sha256

# Monitora dimensioni (anomalie = problemi)
ls -lh /backup/

# Alert su fallimenti
if [ $? -ne 0 ]; then
  curl -X POST https://hooks.slack.com/... \
    -d '{"text":"Backup failed!"}'
fi

Strumenti Correlati

Per gestire backup e database:

JSON Formatter - Formatta dati esportati
Cron Builder - Configura schedule backup
Hash Generator - Verifica integrità file

Conclusione

Un backup efficace richiede:

Automazione: Mai backup manuali per produzione
Test regolari: Verifica restore almeno mensilmente
Offsite: Copie geograficamente separate
Monitoraggio: Alert immediati su fallimenti
Documentazione: Procedure di restore chiare

Ricorda: un backup che non hai mai testato potrebbe non funzionare quando serve.

Per altri strumenti utili, esplora i nostri tool online gratuiti. Per approfondimenti, consulta PostgreSQL Backup Documentation.