Kurs NestJS · Moduł 9: Deployment i infrastruktura

Backup i Recovery - ratowanie tributów po katastrofie

4 min czytania ·
W tej lekcji4

Strażniku tributów! Pewnej nocy migracja z literówką kasuje kolumnę, a rano okazuje się, że ostatnia działająca kopia bazy ma trzy tygodnie, bo skrypt backupu od miesiąca kończył się błędem i nikt tego nie zauważył. Nawet najlepsze forty mogą lec w gruzach podczas oblężenia, dlatego każdy mądry legionista ma plan ratowania swoich tributów.

Dwie liczby, od których wszystko się zaczyna

Plan odtwarzania zaczyna się od dwóch celów. RTO (Recovery Time Objective) to maksymalny czas przywrócenia usługi po awarii. RPO (Recovery Point Objective) to dopuszczalna utrata danych, mierzona w czasie: backup raz na dobę oznacza, że stracisz do 24 godzin pracy. Chcesz mniej - potrzebujesz częstszych kopii albo ciągłego archiwizowania dziennika zmian.

Kopie trzymaj według zasady 3-2-1: trzy kopie, na dwóch różnych nośnikach, w tym jedna poza główną lokalizacją.

Database Backup Strategy

Skrypt dla PostgreSQL robi zrzut, sprawdza go, wysyła do S3 i sprząta stare kopie:

#!/bin/bash
# backup-database.sh
set -euo pipefail

# Bez adresu bazy skrypt kończy się błędem, zamiast zrzucić domyślną bazę
: "${DATABASE_URL:?Ustaw DATABASE_URL}"
BACKUP_DIR="${BACKUP_DIR:-/backups}"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="legionariusze_legion_backup_${DATE}.dump"

# Create backup (format custom jest już skompresowany)
echo "Creating database backup..."
pg_dump --format=custom --file="$BACKUP_DIR/$BACKUP_NAME" "$DATABASE_URL"

# Verify backup - pg_restore musi odczytać spis zawartości
pg_restore --list "$BACKUP_DIR/$BACKUP_NAME" > /dev/null

# Upload to S3
aws s3 cp "$BACKUP_DIR/$BACKUP_NAME" s3://legionariusze-legion-backups/

# Cleanup old backups (keep last 7 days)
find "$BACKUP_DIR" -name "*.dump" -mtime +7 -delete

echo "Backup completed: ${BACKUP_NAME}"

set -euo pipefail przerywa skrypt przy pierwszym błędzie, nieustawionej zmiennej albo awarii w potoku. Linijka z :? to poprawka: w pierwszej wersji puste DATABASE_URL sprawiało, że pg_dump po cichu łączył się z domyślną bazą lokalną. Format custom jest już skompresowany, więc osobny gzip zniknął, a pg_restore --list sprawdza, czy plik da się odczytać.

W MongoDB, na której stoi wiele aplikacji NestJS, ta sama strategia wygląda tak:

#!/bin/bash
# backup-mongo.sh - ta sama strategia dla MongoDB
set -euo pipefail

: "${MONGODB_URI:?Ustaw MONGODB_URI}"
BACKUP_DIR="${BACKUP_DIR:-/backups/mongo}"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
ARCHIVE="$BACKUP_DIR/imperium_$TIMESTAMP.archive.gz"

mkdir -p "$BACKUP_DIR"

# Zrzut bazy do jednego skompresowanego archiwum
mongodump --uri="$MONGODB_URI" --archive="$ARCHIVE" --gzip

# Weryfikacja: próbne odtworzenie bez zapisu danych
mongorestore --uri="$MONGODB_URI" --archive="$ARCHIVE" --gzip --dryRun

# Suma kontrolna do sprawdzenia kopii po przesłaniu
sha256sum "$ARCHIVE" > "$ARCHIVE.sha256"

# Rotacja: usuń kopie starsze niż 7 dni
find "$BACKUP_DIR" -name "imperium_*" -mtime +7 -delete

echo "Backup completed: $ARCHIVE"

mongodump zapisuje bazę do jednego skompresowanego archiwum, mongorestore --dryRun próbuje je odczytać bez zapisywania danych, a suma kontrolna pozwala sprawdzić kopię po przesłaniu. Próba na sucho to jednak nie test: kopia, której nigdy nie odtworzyłeś na osobnej bazie, jest tylko nadzieją.

Disaster Recovery Plan

Plan odtwarzania warto zapisać jako kod, żeby w stresie nikt nie pominął kroku:

// Recovery service
@Injectable()
export class RecoveryService {
  async restoreFromBackup(backupFile: string) {
    // 1. Download backup from S3
    const backup = await this.downloadBackup(backupFile);

    // 2. Create new database
    await this.createRecoveryDatabase();

    // 3. Restore data
    await this.restoreData(backup);

    // 4. Verify integrity
    await this.verifyDataIntegrity();

    // 5. Switch traffic
    await this.switchTraffic();
  }
}

Metody serwisu to szkielet do uzupełnienia pod Twoją infrastrukturę. Kolejność ma znaczenie: nową bazę tworzysz obok uszkodzonej, a nie na niej, żeby zachować ślady do analizy, a integralność sprawdzasz liczbą rekordów, sumą kontrolną i testem dymnym aplikacji, zanim przełączysz ruch. Cały proces disaster recovery przebiega tak:

  1. wykrycie i ocena incydentu,
  2. aktywacja planu disaster recovery,
  3. przywrócenie serwisów z backupów,
  4. walidacja integralności i wznowienie operacji.

Infrastruktura jako kod

Dane to połowa odtwarzania - drugą jest infrastruktura. Infrastructure as Code (IaC), np. Terraform albo Pulumi, opisuje serwery, sieci i bazy w plikach trzymanych w repozytorium. Daje wersjonowanie, powtarzalność i automatyzację: po katastrofie odtwarzasz środowisko jednym poleceniem, także w innym regionie, zamiast klikać w konsoli z pamięci.

Tak samo pewny musi być obraz aplikacji. Bezpieczny pipeline budowania obrazów Docker ma etapy:

  1. zoptymalizowany Dockerfile z multi-stage build,
  2. skanowanie bezpieczeństwa i podatności, np. Trivy,
  3. tagowanie obrazu i wypchnięcie do rejestru,
  4. podpis obrazu i atestacja, np. przez cosign.

Podpis powstaje po wypchnięciu, bo dotyczy konkretnego skrótu obrazu w rejestrze; przy odtwarzaniu wdrażasz tylko obrazy z ważnym podpisem.

Polecam Ci raz w miesiącu ćwiczyć pełne odtworzenie na świeżym środowisku i mierzyć, ile trwa - to jedyny uczciwy sprawdzian RTO. W projekcie kończącym moduł połączysz backup z całym wdrożeniem.

Pamiętaj: fort odbudujesz z planów, ale tributów nie odtworzysz bez kopii, którą ktoś naprawdę sprawdził.

Kod do tej lekcji: scripts/backup.sh
#!/bin/bash
# Backup i Recovery - Ratowanie Tributyw po Katastrofie

# === KONFIGURACJA ===
BACKUP_DIR="/backups/roman-empire"
DB_NAME="roman_empire"
DB_HOST="localhost"
DB_PORT="27017"
RETENTION_DAYS=7
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_PATH="$BACKUP_DIR/$TIMESTAMP"

echo "=== Roman Empire Database Backup ==="
echo "Timestamp: $TIMESTAMP"
echo "Database: $DB_NAME"

# === 1. MONGODUMP ===
mkdir -p "$BACKUP_PATH"

echo "Starting mongodump..."
mongodump \
  --host "$DB_HOST" \
  --port "$DB_PORT" \
  --db "$DB_NAME" \
  --out "$BACKUP_PATH"

# Sprawdz czy backup sie powiodl
if [ $? -eq 0 ]; then
  echo "Backup successful!"
else
  echo "ERROR: Backup FAILED!"
  exit 1
fi

# === 2. KOMPRESJA ===
echo "Compressing backup..."
tar -czf "$BACKUP_PATH.tar.gz" -C "$BACKUP_DIR" "$TIMESTAMP"
rm -rf "$BACKUP_PATH"
echo "Compressed: $BACKUP_PATH.tar.gz"

# === 3. ROTACJA (usun stare backupy) ===
echo "Removing backups older than $RETENTION_DAYS days..."
find "$BACKUP_DIR" -name "*.tar.gz" \
  -mtime +$RETENTION_DAYS -delete

# === 4. RESTORE (odtwarzanie) ===
# mongorestore \
#   --host "$DB_HOST" \
#   --port "$DB_PORT" \
#   --db "$DB_NAME" \
#   --drop \
#   "$BACKUP_PATH/$DB_NAME"

# === 5. CRON - automatyczne backupy ===
# Dodaj do crontab:
# 0 2 * * * /scripts/backup.sh >> /var/log/backup.log 2>&1
# (codziennie o 2:00 w nocy)

# === 6. STRATEGIA BACKUPOW ===
# - Daily: pelny backup co 24h
# - Incremental: zmiany co 6h
# - Offsite: kopia na zewnetrznym serwerze
# - Test restore: co miesiac testuj odtwarzanie!

echo "=== Backup Complete ==="
echo "File: $BACKUP_PATH.tar.gz"
echo "Size: $(du -h "$BACKUP_PATH.tar.gz" | cut -f1)"

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Infrastructure as Code (IaC) pozwala na:

  2. 2. RTO (Recovery Time Objective) i RPO (Recovery Point Objective) określają:

Zadania praktyczne w grze

  • Edytor kodu

    Napisz skrypt backup z mongodump, rotacją i weryfikacją integralności

  • Układanie w pionie

    Uporządkuj kroki procesu disaster recovery:

  • Układanie w pionie

    Ułóż etapy bezpiecznego pipeline budowania obrazów Docker:

  1. PytanieInfrastructure as Code
  2. PytanieDisaster recovery
  3. Zadanie z kodemPraktyka: Backup strategy
  4. Ułóż w kolejnościDisaster recovery process
  5. Ułóż w kolejnościPipeline bezpiecznego budowania obrazów

Przydatne artykuły