notebookvb

MongoDBBackup/mongodbbackup_with_gzip.sh

@@ -1,43 +1,86 @@
 #!/bin/bash
-set -x
+# ==============================================================================
+# MongoDBBackupWithGzip — záloha MongoDB databází na Tower
+# ==============================================================================
+#
+# CO DĚLÁ:
+#   Zálohuje vybrané MongoDB databáze pomocí mongodump --archive --gzip.
+#   Každá databáze dostane vlastní adresář s timestampem, výstup jde přímo
+#   ze stdout Docker kontejneru na disk hostitele (žádný volume mount).
+#
+# TECHNICKÉ DETAILY:
+#   - mongodump --archive: binární formát archivu (jeden soubor na DB)
+#   - --gzip: komprese přímo v mongodump, není třeba pipe přes gzip
+#   - --numParallelCollections=4: paralelní dump kolekcí = rychlejší záloha
+#   - Záloha zachovává: indexy, metadata, validátory, všechny kolekce
+#   - MongoDB na Tower nemá autentizaci — žádné heslo není potřeba
+#
+# SCHEDULE:
+#   Unraid User Script "MongoDBBackupWithGzip" — daily (4:40 ráno)
+#
+# STRUKTURA ZÁLOHY:
+#   /mnt/user/Backup/Critical/MongoDBBackup/tower/
+#     admin/
+#       YYYY-MM-DD_HHMM/
+#         admin.archive.gz    ← binární archiv databáze
+#         admin.err           ← dočasný soubor chyb (smazán při úspěchu)
+#     edc/
+#       YYYY-MM-DD_HHMM/
+#         edc.archive.gz
+#
+# ROTACE:
+#   Dvoustupňová — nejprve maž dle stáří (KEEP_DAYS), pak ořízni na KEEP_COUNT.
+#   To zaručí min. KEEP_COUNT záloh i pokud skript chvíli neběžel.
+#
+# RESTORE:
+#   Viz mongodbrestore_from_backup.sh — stream ze souboru přes docker exec -i
+# ==============================================================================
+set -x  # debug výstup — každý příkaz se vypíše před spuštěním (viditelné v logu Unraid)
 
-# ==========================================================
-# CONFIGURATION
-# ==========================================================
-CONTAINER_NAME="MongoDB"
-MONGO_HOST="localhost"
-MONGO_PORT="27017"
+# ==============================================================================
+# KONFIGURACE
+# ==============================================================================
+CONTAINER_NAME="MongoDB"    # název Docker kontejneru na Tower
+MONGO_HOST="localhost"       # MongoDB naslouchá uvnitř kontejneru na localhost
+MONGO_PORT="27017"           # výchozí MongoDB port
 
-UNRAID_NAME="tower"
-BASE_PATH="/mnt/user/Backup/Critical/MongoDBBackup"
+UNRAID_NAME="tower"          # název serveru — součást cesty zálohy (pro případ rozšíření na více serverů)
+BASE_PATH="/mnt/user/Backup/Critical/MongoDBBackup"  # kořenový adresář všech MongoDB záloh
 
-KEEP_DAYS=3
-KEEP_COUNT=3   # počet posledních záloh k udržení (mimo time-based)
+KEEP_DAYS=3    # zálohy starší než 3 dny se smažou v prvním průchodu rotace
+KEEP_COUNT=3   # z toho co zbyde, ponech vždy alespoň poslední 3 zálohy
 
-# Databases to back up (+ admin DB pro credentials a roles)
+# Databáze k zálohování:
+#   admin — systémová DB, obsahuje uživatele, role a credentials (i přes to, že auth je vypnutá)
+#   edc   — hlavní aplikační databáze
 WHAT_TO_BACKUP=("admin" "edc")
 
-# ==========================================================
+# ==============================================================================
 # START
-# ==========================================================
+# ==============================================================================
 echo "Starting scheduled backup for: ${WHAT_TO_BACKUP[*]}"
 START_TS=$(date '+%Y-%m-%d %H:%M:%S')
 
+# Iterujeme přes každou databázi zvlášť — každá dostane vlastní adresář a archiv.
+# Důvod: při obnovení lze vybrat konkrétní DB bez nutnosti rozpakovat celý dump.
 for DB_NAME in "${WHAT_TO_BACKUP[@]}"; do
     echo "------------------------------------------"
     echo "Processing database: $DB_NAME"
 
-    DATE=$(date +%Y-%m-%d_%H%M)
-    FINAL_PATH="$BASE_PATH/$UNRAID_NAME/$DB_NAME/$DATE"
+    DATE=$(date +%Y-%m-%d_%H%M)                          # timestamp v minutách — pro přehlednost v názvech adresářů
+    FINAL_PATH="$BASE_PATH/$UNRAID_NAME/$DB_NAME/$DATE"   # cílový adresář pro tuto zálohu
     mkdir -p "$FINAL_PATH"
 
-    DUMP_FILE="$FINAL_PATH/$DB_NAME.archive.gz"
-    ERR_FILE="$FINAL_PATH/$DB_NAME.err"
+    DUMP_FILE="$FINAL_PATH/$DB_NAME.archive.gz"  # výsledný archiv
+    ERR_FILE="$FINAL_PATH/$DB_NAME.err"          # sem jde stderr mongodump
 
-    # ======================================================
-    # DUMP + GZIP (streamuje přes stdout, nepotřebuje volume mount)
-    # Zachovává: indexy, metadata, validators, all collections
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # DUMP + GZIP
+    # docker exec spustí mongodump uvnitř kontejneru.
+    # stdout (archiv) přesměrujeme do souboru na hostiteli — žádný volume mount.
+    # stderr (logy mongodump) jde do .err souboru pro pozdější analýzu.
+    # --archive bez cílového souboru = stream na stdout
+    # --------------------------------------------------------------------------
     docker exec "$CONTAINER_NAME" mongodump \
         --host="$MONGO_HOST" \
         --port="$MONGO_PORT" \
@@ -49,9 +92,14 @@ for DB_NAME in "${WHAT_TO_BACKUP[@]}"; do
 
     EXIT_CODE=$?
 
-    # ======================================================
-    # VALIDATION
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # VALIDACE VÝSLEDKU
+    # Tři podmínky pro úspěch:
+    #   1. EXIT_CODE=0 — mongodump skončil bez chyby
+    #   2. -s "$DUMP_FILE" — archiv existuje a není prázdný
+    #   3. ! -s "$ERR_FILE" — .err soubor je prázdný (žádné chybové hlášky)
+    # Pokud všechny platí, .err smažeme. Jinak ho ponecháme pro diagnostiku.
+    # --------------------------------------------------------------------------
     if [ $EXIT_CODE -eq 0 ] && [ -s "$DUMP_FILE" ] && [ ! -s "$ERR_FILE" ]; then
         echo "SUCCESS: $DB_NAME backed up successfully"
         echo "Dump size: $(du -h "$DUMP_FILE" | cut -f1)"
@@ -65,17 +113,24 @@ for DB_NAME in "${WHAT_TO_BACKUP[@]}"; do
         [ -s "$ERR_FILE" ] && cat "$ERR_FILE" || echo "  (no stderr output)"
     fi
 
-    # ======================================================
-    # CLEANUP OLD BACKUPS
-    # 1. Smaž zálohy starší než KEEP_DAYS dnů
-    # 2. Z toho co zbyde, ponech jen posledních KEEP_COUNT
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # ROTACE STARÝCH ZÁLOH — dvoustupňová
+    #
+    # Krok 1: Smaž adresáře starší než KEEP_DAYS dní.
+    #   -mindepth 1 -maxdepth 1: jen přímé podadresáře (ne rekurzivně)
+    #   -type d: pouze adresáře
+    #   -mtime +N: starší než N dní
+    #
+    # Krok 2: Z toho co zbyde, ponech jen posledních KEEP_COUNT.
+    #   ls -td: seřadit adresáře dle času (nejnovější první)
+    #   tail -n +N: přeskoč prvních N-1 (to jsou ty které chceme ponechat)
+    #   xargs -r rm -rf: smaž zbytek (jen pokud existuje vstup — -r zabrání prázdnému xargs)
+    # --------------------------------------------------------------------------
     echo "Cleaning up old backups for $DB_NAME..."
     find "$BASE_PATH/$UNRAID_NAME/$DB_NAME" \
         -mindepth 1 -maxdepth 1 -type d -mtime +$KEEP_DAYS \
         -exec rm -rf {} \;
 
-    # Nech jen posledních KEEP_COUNT záloh
     ls -td "$BASE_PATH/$UNRAID_NAME/$DB_NAME"/*/ 2>/dev/null \
         | tail -n +$((KEEP_COUNT + 1)) \
         | xargs -r rm -rf

MongoDBBackup/mongodbrestore_from_backup.sh

@@ -1,20 +1,47 @@
 #!/bin/bash
+# ==============================================================================
+# MongoDBRestore — obnovení MongoDB databází ze zálohy
+# ==============================================================================
+#
+# CO DĚLÁ:
+#   Pro každou databázi v zadané zálohovací složce najde nejnovější archiv
+#   a obnoví ho do MongoDB pomocí mongorestore.
+#
+# POUŽITÍ:
+#   bash mongodbrestore_from_backup.sh <cesta_k_záloze>
+#   Příklad:
+#     bash mongodbrestore_from_backup.sh /mnt/user/Backup/Critical/MongoDBBackup/tower
+#
+#   Skript sám najde nejnovější zálohu pro každou DB v zadaném adresáři.
+#   Struktura: <base_path>/<DB_NAME>/YYYY-MM-DD_HHMM/<DB_NAME>.archive.gz
+#
+# TECHNICKÉ DETAILY:
+#   - mongorestore --archive --gzip: čte binární archiv ze stdin
+#   - docker exec -i: interaktivní stdin = stream ze souboru na hostiteli
+#   - --drop: před obnovením smaže existující kolekce (čistý restore)
+#   - --numParallelCollections=4: rychlejší restore přes paralelní zpracování
+#   - Obnovuje: indexy, metadata, validátory, všechny kolekce
+#
+# POZOR:
+#   --drop smaže data v cílové DB před obnovením!
+#   Používat jen při vědomém restore, ne jako test konzistence.
+# ==============================================================================
 set -x
 
-# ==========================================================
-# CONFIGURATION
-# ==========================================================
-CONTAINER_NAME="MongoDB"
+# ==============================================================================
+# KONFIGURACE
+# ==============================================================================
+CONTAINER_NAME="MongoDB"  # název Docker kontejneru na Tower
 MONGO_HOST="localhost"
 MONGO_PORT="27017"
 
-# Cesta k záloze kterou chceš obnovit
-# Např: /mnt/user/Backup/Critical/MongoDBBackup/tower
+# Cesta k záloze — předávána jako první argument skriptu.
+# Může být bud přímo adresář konkrétní zálohy, nebo základní cesta s DB podsložkami.
 BACKUP_BASE_PATH="$1"
 
-# ==========================================================
-# VALIDATION
-# ==========================================================
+# ==============================================================================
+# VALIDACE VSTUPŮ
+# ==============================================================================
 if [ -z "$BACKUP_BASE_PATH" ]; then
     echo "Usage: $0 <backup_base_path>"
     echo "Example: $0 /mnt/user/Backup/Critical/MongoDBBackup/tower"
@@ -29,23 +56,24 @@ fi
 echo "Starting MongoDB restore from: $BACKUP_BASE_PATH"
 START_TS=$(date '+%Y-%m-%d %H:%M:%S')
 
-# ==========================================================
+# ==============================================================================
 # RESTORE PROCESS
-# ==========================================================
-
-# Najdi nejnovější backupy pro každou DB
+# ==============================================================================
+# Iterujeme přes podadresáře base_path — každý podadresář = jedna databáze.
 # Struktura: $BACKUP_BASE_PATH/DB_NAME/YYYY-MM-DD_HHMM/DB_NAME.archive.gz
 
 for DB_DIR in "$BACKUP_BASE_PATH"/*; do
     if [ ! -d "$DB_DIR" ]; then
-        continue
+        continue  # přeskoč soubory (pokud by nějaké byly)
     fi
 
     DB_NAME=$(basename "$DB_DIR")
     echo "------------------------------------------"
     echo "Processing database: $DB_NAME"
 
-    # Najdi nejnovější backup pro tuto DB
+    # Najdi nejnovější zálohu pro tuto DB.
+    # ls -td: vypíše adresáře seřazené dle času, nejnovější první.
+    # head -1: vezmeme jen první = nejnovější.
     LATEST_BACKUP=$(ls -td "$DB_DIR"/*/ 2>/dev/null | head -1)
 
     if [ -z "$LATEST_BACKUP" ]; then
@@ -53,8 +81,8 @@ for DB_DIR in "$BACKUP_BASE_PATH"/*; do
         continue
     fi
 
-    BACKUP_FILE="$LATEST_BACKUP/${DB_NAME}.archive.gz"
-    ERR_FILE="$LATEST_BACKUP/${DB_NAME}.restore.err"
+    BACKUP_FILE="$LATEST_BACKUP/${DB_NAME}.archive.gz"  # archiv pro tuto DB
+    ERR_FILE="$LATEST_BACKUP/${DB_NAME}.restore.err"    # sem jde stderr mongorestore
 
     if [ ! -f "$BACKUP_FILE" ]; then
         echo "ERROR: Backup archive not found: $BACKUP_FILE"
@@ -65,10 +93,13 @@ for DB_DIR in "$BACKUP_BASE_PATH"/*; do
     echo "Backup date: $(stat -c %y "$BACKUP_FILE" | cut -d' ' -f1-2)"
     echo "Backup size: $(du -h "$BACKUP_FILE" | cut -f1)"
 
-    # ======================================================
-    # RESTORE TO MONGODB (streamuje přes stdin z hosta)
-    # Restores: indexy, metadata, validators, all collections
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # RESTORE DO MONGODB
+    # Archiv streamujeme ze souboru na hostiteli do stdin kontejneru.
+    # docker exec -i: umožňuje stdin stream (bez -i by stdin byl /dev/null)
+    # < "$BACKUP_FILE": přesměrujeme obsah archivu na stdin mongorestore
+    # 2> "$ERR_FILE": stderr mongorestore jde do .restore.err pro diagnostiku
+    # --------------------------------------------------------------------------
     echo "Restoring $DB_NAME to MongoDB..."
     docker exec -i "$CONTAINER_NAME" mongorestore \
         --host="$MONGO_HOST" \
@@ -82,12 +113,12 @@ for DB_DIR in "$BACKUP_BASE_PATH"/*; do
 
     RESTORE_EXIT=$?
 
-    # ======================================================
-    # VALIDATION
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # VALIDACE VÝSLEDKU
+    # --------------------------------------------------------------------------
     if [ $RESTORE_EXIT -eq 0 ]; then
         echo "SUCCESS: $DB_NAME restored successfully"
-        rm -f "$ERR_FILE"
+        rm -f "$ERR_FILE"  # .err soubor je prázdný — uklidíme
     else
         echo "ERROR: Restore failed for database: $DB_NAME"
         echo "Exit code: $RESTORE_EXIT"

MongoDBBackup/verify_backup_integrity.sh

@@ -1,32 +1,53 @@
 #!/bin/bash
+# ==============================================================================
+# MongoDB Verify Backup Integrity — ověření konzistence po restore
+# ==============================================================================
+#
+# CO DĚLÁ:
+#   Připojí se k MongoDB a pro každou databázi zkontroluje:
+#     1. Existence databáze
+#     2. Počet a seznam kolekcí
+#     3. Indexy na každé kolekci
+#     4. Statistiky (počet dokumentů, velikost)
+#     5. Pro admin DB: počet systémových uživatelů a rolí
+#
+# KDY POUŽÍT:
+#   Po provedení mongodbrestore_from_backup.sh — ověří, že data jsou v pořádku.
+#   Spouštět ručně, není součástí automatizovaného schedule.
+#
+# VÝSTUP:
+#   ✅ / ❌ indikátory pro každý krok.
+#   Skript vrátí exit code 1 pokud cokoliv selže.
+# ==============================================================================
 set -x
 
-# ==========================================================
-# VERIFY BACKUP INTEGRITY
-# Kontroluje že se indexy, metadata, a všechny kolekce
-# správně obnovily
-# ==========================================================
-
+# ==============================================================================
+# KONFIGURACE
+# ==============================================================================
 CONTAINER_NAME="MongoDB"
 MONGO_HOST="localhost"
 MONGO_PORT="27017"
 
-# Databases to verify
+# Databáze ke kontrole — zahrnuje i MySQL databáze zrcadlené do MongoDB,
+# protože verify kontroluje aktuální stav MongoDB, ne zálohu.
 WHAT_TO_VERIFY=("admin" "fio" "torrents" "OrdinaceDropBoxBackup" "medevio" "kanboard" "medicus" "studie" "puzzle")
 
 echo "Starting backup integrity verification..."
 echo "=========================================="
 
-ALL_OK=true
+ALL_OK=true  # flag — pokud jakákoliv kontrola selže, nastaví se na false
 
 for DB_NAME in "${WHAT_TO_VERIFY[@]}"; do
     echo ""
     echo "Verifying database: $DB_NAME"
     echo "------------------------------------------"
 
-    # ======================================================
-    # 1. CHECK IF DB EXISTS
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # 1. EXISTENCE DATABÁZE
+    # adminCommand('listDatabases') vrátí seznam všech DB.
+    # Filtrujeme podle jména — pokud filter nic nevrátí (length=0), DB neexistuje.
+    # mongosh --quiet potlačí uvítací banner, --eval vykoná JS výraz.
+    # --------------------------------------------------------------------------
     DB_EXISTS=$(docker exec "$CONTAINER_NAME" mongosh \
         --host="$MONGO_HOST" \
         --port="$MONGO_PORT" \
@@ -36,13 +57,15 @@ for DB_NAME in "${WHAT_TO_VERIFY[@]}"; do
     if [ "$DB_EXISTS" != "true" ]; then
         echo "❌ ERROR: Database $DB_NAME does not exist!"
         ALL_OK=false
-        continue
+        continue  # bez DB nemá smysl kontrolovat dál
     fi
     echo "✅ Database exists: $DB_NAME"
 
-    # ======================================================
-    # 2. COUNT COLLECTIONS
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # 2. POČET KOLEKCÍ
+    # getCollectionNames() vrátí pole názvů všech kolekcí v DB.
+    # .length dá číslo — slouží jako rychlá sanity check (0 by bylo podezřelé).
+    # --------------------------------------------------------------------------
     COLLECTION_COUNT=$(docker exec "$CONTAINER_NAME" mongosh \
         --host="$MONGO_HOST" \
         --port="$MONGO_PORT" \
@@ -51,9 +74,10 @@ for DB_NAME in "${WHAT_TO_VERIFY[@]}"; do
 
     echo "✅ Collections count: $COLLECTION_COUNT"
 
-    # ======================================================
-    # 3. LIST ALL COLLECTIONS
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # 3. SEZNAM KOLEKCÍ
+    # Vypíše název každé kolekce — pro vizuální kontrolu po restore.
+    # --------------------------------------------------------------------------
     echo "   Collections:"
     docker exec "$CONTAINER_NAME" mongosh \
         --host="$MONGO_HOST" \
@@ -61,9 +85,11 @@ for DB_NAME in "${WHAT_TO_VERIFY[@]}"; do
         --quiet \
         --eval "use $DB_NAME; db.getCollectionNames().forEach(c => print('     - ' + c))"
 
-    # ======================================================
-    # 4. CHECK INDEXES FOR EACH COLLECTION
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # 4. INDEXY NA KAŽDÉ KOLEKCI
+    # getIndexes() vrátí pole index definic. Každý index má field "key" (JSON).
+    # Výpis indexů ověří, že mongorestore správně obnovil i indexy (ne jen data).
+    # --------------------------------------------------------------------------
     echo "   Indexes per collection:"
     docker exec "$CONTAINER_NAME" mongosh \
         --host="$MONGO_HOST" \
@@ -80,9 +106,12 @@ db.getCollectionNames().forEach(collName => {
 });
 "
 
-    # ======================================================
-    # 5. CHECK COLLECTION STATS (document count, size)
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # 5. STATISTIKY KOLEKCÍ (počet dokumentů, velikost)
+    # db[collName].stats() vrátí objekt se statistikami kolekce.
+    # .count = počet dokumentů, .size = velikost v bytech → převádíme na MB.
+    # Nulový count může signalizovat problém (záloha prázdné DB nebo selhání restore).
+    # --------------------------------------------------------------------------
     echo "   Collection stats:"
     docker exec "$CONTAINER_NAME" mongosh \
         --host="$MONGO_HOST" \
@@ -98,9 +127,11 @@ db.getCollectionNames().forEach(collName => {
 });
 "
 
-    # ======================================================
-    # 6. VERIFY USERS/ROLES (if admin DB)
-    # ======================================================
+    # --------------------------------------------------------------------------
+    # 6. UŽIVATELÉ A ROLE (pouze admin DB)
+    # admin DB obsahuje systémové uživatele a role — i bez auth jsou zálohovány.
+    # Ověřujeme, že restore je správně obnovil.
+    # --------------------------------------------------------------------------
     if [ "$DB_NAME" = "admin" ]; then
         echo "   Users and Roles:"
         USER_COUNT=$(docker exec "$CONTAINER_NAME" mongosh \