Автоматическое резервное копирование MongoDB в Docker: от скрипта до админки

#!/bin/bash
# MongoDB backup script for blog
# Run via cron: 0 3 * * * /path/to/scripts/backup-mongo.sh >> /var/log/mongo-backup.log 2>&1

set -e

# Configuration
BACKUP_DIR="${BACKUP_DIR:-./backups}"
KEEP_DAYS="${KEEP_DAYS:-7}"
CONTAINER_NAME="${CONTAINER_NAME:-blog-mongo}"
DB_NAME="${MONGO_DB:-blog}"

# Generate filename with timestamp
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
FILENAME="blog_${TIMESTAMP}.gz"

echo "[$(date)] Starting backup..."

# Create backup directory if not exists
mkdir -p "$BACKUP_DIR"

# Create backup using mongodump
docker exec "$CONTAINER_NAME" mongodump \
  --db="$DB_NAME" \
  --archive=/tmp/backup.gz \
  --gzip \
  --quiet

# Copy backup from container
docker cp "$CONTAINER_NAME:/tmp/backup.gz" "$BACKUP_DIR/$FILENAME"

# Clean up temp file in container
docker exec "$CONTAINER_NAME" rm -f /tmp/backup.gz

# Get file size
SIZE=$(du -h "$BACKUP_DIR/$FILENAME" | cut -f1)
echo "[$(date)] Backup created: $FILENAME ($SIZE)"

# Remove old backups
DELETED=$(find "$BACKUP_DIR" -name "blog_*.gz" -mtime +"$KEEP_DAYS" -delete -print | wc -l)
if [ "$DELETED" -gt 0 ]; then
  echo "[$(date)] Deleted $DELETED old backup(s)"
fi

# Send Telegram notification if configured
if [ -n "$TELEGRAM_BOT_TOKEN" ] && [ -n "$TELEGRAM_CHAT_ID" ]; then
  COUNT=$(find "$BACKUP_DIR" -name "blog_*.gz" | wc -l | tr -d ' ')
  MESSAGE="✅ <b>Бэкап создан</b>%0A%0A📦 <b>Файл:</b> $FILENAME%0A💾 <b>Размер:</b> $SIZE%0A📁 <b>Всего копий:</b> $COUNT"

  curl -s "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
    -d "chat_id=${TELEGRAM_CHAT_ID}" \
    -d "text=${MESSAGE}" \
    -d "parse_mode=HTML" > /dev/null

  echo "[$(date)] Telegram notification sent"
fi

echo "[$(date)] Backup completed successfully"

services:
  app:
    image: ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA:-latest}
    container_name: blog-app
    restart: unless-stopped
    environment:
      - NUXT_MONGODB_URI=mongodb://mongo:27017
      - NUXT_MONGO_DB_NAME=${MONGO_DB}
      - NUXT_JWT_SECRET=${JWT_SECRET}
      - NUXT_JWT_REFRESH_SECRET=${JWT_REFRESH_SECRET}
      - NUXT_PUBLIC_SITE_URL=${SITE_URL}
      - NUXT_TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
      - NUXT_TELEGRAM_CHAT_ID=${TELEGRAM_CHAT_ID}
      - HOST=0.0.0.0
      - PORT=3000
      - BACKUP_DIR=/app/backups
    volumes:
      - uploads_data:/app/.output/public/uploads
      - ./backups:/app/backups:ro  # <-- Добавлено: read-only доступ к бэкапам
    # ... остальная конфигурация

import { readdir, stat } from 'fs/promises'
import { join } from 'path'
import { requireAdmin } from '../../../utils/auth'

const BACKUP_DIR = process.env.BACKUP_DIR || '/app/backups'

export default defineEventHandler(async (event) => {
  await requireAdmin(event)

  try {
    const files = await readdir(BACKUP_DIR)
    const backups = await Promise.all(
      files
        .filter(name => name.startsWith('blog_') && name.endsWith('.gz'))
        .map(async (name) => {
          const filePath = join(BACKUP_DIR, name)
          const stats = await stat(filePath)
          return {
            name,
            size: formatSize(stats.size),
            sizeBytes: stats.size,
            date: stats.mtime.toISOString()
          }
        })
    )

    // Sort by date descending (newest first)
    backups.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())

    return { backups }
  } catch (error: any) {
    if (error.code === 'ENOENT') {
      return { backups: [] }
    }
    throw createError({
      statusCode: 500,
      message: 'Failed to read backups directory'
    })
  }
})

function formatSize(bytes: number): string {
  if (bytes < 1024) return bytes + ' B'
  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB'
  if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB'
  return (bytes / (1024 * 1024 * 1024)).toFixed(1) + ' GB'
}

import { createReadStream } from 'fs'
import { stat } from 'fs/promises'
import { join, basename } from 'path'
import { requireAdmin } from '../../../utils/auth'

const BACKUP_DIR = process.env.BACKUP_DIR || '/app/backups'

export default defineEventHandler(async (event) => {
  await requireAdmin(event)

  const filename = getRouterParam(event, 'filename')

  if (!filename) {
    throw createError({
      statusCode: 400,
      message: 'Filename is required'
    })
  }

  // Validate filename format to prevent directory traversal
  const sanitizedName = basename(filename)
  if (!sanitizedName.startsWith('blog_') || !sanitizedName.endsWith('.gz')) {
    throw createError({
      statusCode: 400,
      message: 'Invalid backup filename'
    })
  }

  const filePath = join(BACKUP_DIR, sanitizedName)

  try {
    const stats = await stat(filePath)

    setHeader(event, 'Content-Type', 'application/gzip')
    setHeader(event, 'Content-Disposition', `attachment; filename="${sanitizedName}"`)
    setHeader(event, 'Content-Length', stats.size)

    return sendStream(event, createReadStream(filePath))
  } catch (error: any) {
    if (error.code === 'ENOENT') {
      throw createError({
        statusCode: 404,
        message: 'Backup file not found'
      })
    }
    throw createError({
      statusCode: 500,
      message: 'Failed to read backup file'
    })
  }
})

<script setup lang="ts">
definePageMeta({
  layout: 'admin',
  middleware: 'admin',
  title: 'Бэкапы'
})

interface Backup {
  name: string
  size: string
  sizeBytes: number
  date: string
}

const { getAuthHeaders } = useAuth()
const toast = useToast()

const { data, pending, refresh } = await useFetch<{ backups: Backup[] }>('/api/admin/backups', {
  headers: getAuthHeaders()
})

const downloadBackup = async (backup: Backup) => {
  try {
    const response = await $fetch(`/api/admin/backups/${backup.name}`, {
      headers: getAuthHeaders(),
      responseType: 'blob'
    })

    const url = window.URL.createObjectURL(response as Blob)
    const link = document.createElement('a')
    link.href = url
    link.download = backup.name
    document.body.appendChild(link)
    link.click()
    document.body.removeChild(link)
    window.URL.revokeObjectURL(url)

    toast.add({
      title: 'Загрузка началась',
      description: backup.name,
      color: 'success'
    })
  } catch (err: any) {
    toast.add({
      title: 'Ошибка загрузки',
      description: err.message,
      color: 'error'
    })
  }
}

const formatDate = (dateStr: string) => {
  const date = new Date(dateStr)
  return date.toLocaleString('ru-RU', {
    day: '2-digit',
    month: '2-digit',
    year: 'numeric',
    hour: '2-digit',
    minute: '2-digit'
  })
}

const getRelativeTime = (dateStr: string) => {
  const date = new Date(dateStr)
  const now = new Date()
  const diffMs = now.getTime() - date.getTime()
  const diffHours = Math.floor(diffMs / (1000 * 60 * 60))
  const diffDays = Math.floor(diffHours / 24)

  if (diffHours < 1) return 'только что'
  if (diffHours < 24) return `${diffHours} ч. назад`
  if (diffDays === 1) return 'вчера'
  return `${diffDays} дн. назад`
}

const totalSize = computed(() => {
  if (!data.value?.backups?.length) return '0 B'
  const total = data.value.backups.reduce((acc, b) => acc + b.sizeBytes, 0)
  if (total < 1024) return total + ' B'
  if (total < 1024 * 1024) return (total / 1024).toFixed(1) + ' KB'
  if (total < 1024 * 1024 * 1024) return (total / (1024 * 1024)).toFixed(1) + ' MB'
  return (total / (1024 * 1024 * 1024)).toFixed(1) + ' GB'
})

useSeoMeta({
  title: 'Бэкапы - Админ-панель'
})
</script>

<template>
  <div>
    <div class="flex justify-between items-center mb-6">
      <h1 class="text-2xl font-bold text-gray-900 dark:text-white">
        Резервные копии базы данных
      </h1>
      <UButton
        icon="i-heroicons-arrow-path"
        variant="ghost"
        :loading="pending"
        @click="refresh()"
      >
        Обновить
      </UButton>
    </div>

    <!-- Stats -->
    <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
      <UCard>
        <div class="flex items-center gap-3">
          <div class="p-2 bg-primary-100 dark:bg-primary-900/30 rounded-lg">
            <UIcon name="i-heroicons-circle-stack" class="w-6 h-6 text-primary-500" />
          </div>
          <div>
            <p class="text-sm text-gray-500 dark:text-gray-400">Всего копий</p>
            <p class="text-2xl font-bold text-gray-900 dark:text-white">
              {{ data?.backups?.length || 0 }}
            </p>
          </div>
        </div>
      </UCard>

      <UCard>
        <div class="flex items-center gap-3">
          <div class="p-2 bg-success-100 dark:bg-success-900/30 rounded-lg">
            <UIcon name="i-heroicons-server" class="w-6 h-6 text-success-500" />
          </div>
          <div>
            <p class="text-sm text-gray-500 dark:text-gray-400">Занято места</p>
            <p class="text-2xl font-bold text-gray-900 dark:text-white">
              {{ totalSize }}
            </p>
          </div>
        </div>
      </UCard>

      <UCard>
        <div class="flex items-center gap-3">
          <div class="p-2 bg-warning-100 dark:bg-warning-900/30 rounded-lg">
            <UIcon name="i-heroicons-clock" class="w-6 h-6 text-warning-500" />
          </div>
          <div>
            <p class="text-sm text-gray-500 dark:text-gray-400">Последний бэкап</p>
            <p class="text-2xl font-bold text-gray-900 dark:text-white">
              {{ data?.backups?.[0] ? getRelativeTime(data.backups[0].date) : '—' }}
            </p>
          </div>
        </div>
      </UCard>
    </div>

    <!-- Backups list -->
    <UCard>
      <template #header>
        <div class="flex items-center justify-between">
          <h2 class="font-semibold text-gray-900 dark:text-white">Список бэкапов</h2>
          <UBadge color="neutral" variant="subtle">
            Хранятся 7 дней
          </UBadge>
        </div>
      </template>

      <div v-if="pending" class="flex justify-center py-8">
        <UIcon name="i-heroicons-arrow-path" class="w-8 h-8 animate-spin text-gray-400" />
      </div>

      <div v-else-if="!data?.backups?.length" class="text-center py-12">
        <UIcon name="i-heroicons-circle-stack" class="w-12 h-12 text-gray-300 mx-auto mb-4" />
        <p class="text-gray-500 dark:text-gray-400 mb-2">Бэкапов пока нет</p>
        <p class="text-sm text-gray-400 dark:text-gray-500">
          Они появятся после первого запуска скрипта резервного копирования
        </p>
      </div>

      <div v-else class="divide-y divide-gray-200 dark:divide-gray-700">
        <div
          v-for="backup in data.backups"
          :key="backup.name"
          class="flex items-center justify-between py-4 first:pt-0 last:pb-0"
        >
          <div class="flex items-center gap-4">
            <div class="p-2 bg-gray-100 dark:bg-gray-700 rounded-lg">
              <UIcon name="i-heroicons-document-arrow-down" class="w-5 h-5 text-gray-500" />
            </div>
            <div>
              <p class="font-medium text-gray-900 dark:text-white">
                {{ backup.name }}
              </p>
              <p class="text-sm text-gray-500 dark:text-gray-400">
                {{ formatDate(backup.date) }} · {{ backup.size }}
              </p>
            </div>
          </div>

          <UButton
            icon="i-heroicons-arrow-down-tray"
            color="primary"
            variant="soft"
            @click="downloadBackup(backup)"
          >
            Скачать
          </UButton>
        </div>
      </div>
    </UCard>

    <!-- Info -->
    <UCard class="mt-6">
      <template #header>
        <h2 class="font-semibold text-gray-900 dark:text-white">Восстановление из бэкапа</h2>
      </template>

      <div class="prose prose-sm dark:prose-invert max-w-none">
        <p>Для восстановления базы данных из бэкапа:</p>
        <ol>
          <li>Скачайте нужный файл бэкапа</li>
          <li>Скопируйте файл на сервер</li>
          <li>Выполните команды:</li>
        </ol>
        <pre><code>docker cp backup.gz blog-mongo:/tmp/
docker exec blog-mongo mongorestore \
  --db=blog \
  --archive=/tmp/backup.gz \
  --gzip \
  --drop</code></pre>
      </div>
    </UCard>
  </div>
</template>