7.6. Backup и restore

docker run --rm \
    -v myvol:/data:ro \
    -v "$PWD:/backup" \
    alpine:3.21 tar czf /backup/myvol.tar.gz -C /data .

docker compose exec -T db pg_dump -U postgres -Fc mydb > backup.dump

docker volume ls -f dangling=true

docker cp mycontainer:/app/report.csv ./report.csv
docker cp ./config.ini mycontainer:/app/config.ini

mkdir -p /tmp/vol-backup && cd /tmp/vol-backup

docker volume create source-vol > /dev/null
docker run --rm -v source-vol:/data alpine:3.21 sh -c '
    mkdir -p /data/nested
    echo "важные данные" > /data/main.txt
    echo "скрытый файл"  > /data/.hidden
    echo "вложенный"     > /data/nested/deep.txt
    chown 10001:10001 /data/main.txt
    chmod 600 /data/main.txt
'

echo "═══ исходное состояние ═══"
docker run --rm -v source-vol:/data alpine:3.21 sh -c 'ls -lan /data | tail -n +2'

echo
echo "═══ резервная копия ═══"
docker run --rm -v source-vol:/data:ro -v "$PWD:/backup" \
    alpine:3.21 tar czf /backup/source-vol.tar.gz --numeric-owner -C /data .
ls -lh source-vol.tar.gz | awk '{print "  архив: " $9 " (" $5 ")"}'

echo
echo "═══ содержимое архива ═══"
tar tzf source-vol.tar.gz | sort | sed 's/^/  /'

═══ исходное состояние ═══
drwxr-xr-x    3 0        0             4096 Jul 30 13:02 .
drwxr-xr-x    1 0        0             4096 Jul 30 13:02 ..
-rw-r--r--    1 0        0               25 Jul 30 13:02 .hidden
-rw-------    1 10001    10001           28 Jul 30 13:02 main.txt
drwxr-xr-x    2 0        0             4096 Jul 30 13:02 nested

═══ резервная копия ═══
  архив: source-vol.tar.gz (283)

═══ содержимое архива ═══
  ./
  ./.hidden
  ./main.txt
  ./nested/
  ./nested/deep.txt

docker run --rm -v source-vol:/data:ro -v "$PWD:/backup" \
    alpine:3.21 sh -c 'tar czf /backup/wrong.tar.gz /data/* 2>/dev/null'
echo "═══ архив по шаблону /data/* ═══"
tar tzf wrong.tar.gz | sort | sed 's/^/  /'
rm -f wrong.tar.gz

═══ архив по шаблону /data/* ═══
  data/main.txt
  data/nested/
  data/nested/deep.txt

docker volume create restored-vol > /dev/null
docker run --rm -v restored-vol:/data -v "$PWD:/backup" \
    alpine:3.21 tar xzf /backup/source-vol.tar.gz --numeric-owner -C /data

echo "═══ восстановлено ═══"
docker run --rm -v restored-vol:/data alpine:3.21 sh -c 'ls -lan /data | tail -n +2'

═══ восстановлено ═══
drwxr-xr-x    3 0        0             4096 Jul 30 13:02 .
drwxr-xr-x    1 0        0             4096 Jul 30 13:05 ..
-rw-r--r--    1 0        0               25 Jul 30 13:02 .hidden
-rw-------    1 10001    10001           28 Jul 30 13:02 main.txt
drwxr-xr-x    2 0        0             4096 Jul 30 13:02 nested

cd /tmp/vol-backup
cat > verify.sh <<'SH'
#!/usr/bin/env bash
# Сравнивает два volume по содержимому, правам и владельцам.
set -uo pipefail
A="${1:?volume 1}"; B="${2:?volume 2}"

snapshot() {
    docker run --rm -v "$1:/v:ro" alpine:3.21 sh -c '
        cd /v && find . -type f -exec sha256sum {} \; | sort
        cd /v && find . -printf "%p %m %U:%G\n" 2>/dev/null | sort || \
            find . -exec stat -c "%n %a %u:%g" {} \; | sort
    '
}

if diff <(snapshot "$A") <(snapshot "$B") > /tmp/verify.diff 2>&1; then
    echo "  ✓ volumes идентичны: содержимое, права, владельцы"
    exit 0
fi
echo "  ✗ РАСХОЖДЕНИЕ:"
head -10 /tmp/verify.diff | sed 's/^/    /'
exit 1
SH
chmod +x verify.sh

echo "═══ сравнение оригинала и восстановленного ═══"
./verify.sh source-vol restored-vol

═══ сравнение оригинала и восстановленного ═══
  ✓ volumes идентичны: содержимое, права, владельцы

docker run --rm -v restored-vol:/data alpine:3.21 sh -c 'echo испорчено > /data/main.txt'
./verify.sh source-vol restored-vol | head -4

  ✗ РАСХОЖДЕНИЕ:
    2c2
    < 8f3a2b1c...  ./main.txt
    ---
    > 1d4e7f9a...  ./main.txt

docker volume rm source-vol restored-vol > /dev/null

mkdir -p /tmp/db-backup && cd /tmp/db-backup

cat > compose.yaml <<'EOF'
services:
  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: appdb
    volumes:
      - db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d appdb"]
      interval: 3s
      timeout: 3s
      retries: 15

volumes:
  db-data:
EOF

docker compose up -d > /dev/null 2>&1
until [ "$(docker compose ps --format '{{.Health}}' db)" = "healthy" ]; do sleep 2; done

# Наполняем и создаём постоянную нагрузку на запись
docker compose exec -T db psql -U postgres -d appdb -q <<'SQL'
CREATE TABLE records (id serial PRIMARY KEY, payload text, created timestamptz DEFAULT now());
INSERT INTO records (payload) SELECT md5(g::text) FROM generate_series(1, 50000) g;
SQL

echo "═══ записей в базе ═══"
docker compose exec -T db psql -U postgres -d appdb -tAc 'SELECT count(*) FROM records' | sed 's/^/  /'

# Нагрузка на запись во время копирования
docker compose exec -d db sh -c '
    for i in $(seq 1 200); do
        psql -U postgres -d appdb -q -c "INSERT INTO records (payload) SELECT md5(random()::text) FROM generate_series(1,500)"
    done
' 2>/dev/null

echo
echo "═══ копируем файлы данных на ходу (так делать нельзя) ═══"
docker run --rm -v db-backup_db-data:/data:ro -v "$PWD:/backup" \
    alpine:3.21 tar czf /backup/hot-copy.tar.gz --numeric-owner -C /data . 2>/dev/null
ls -lh hot-copy.tar.gz | awk '{print "  архив создан без ошибок: " $5}'

═══ записей в базе ═══
  50000

═══ копируем файлы данных на ходу (так делать нельзя) ═══
  архив создан без ошибок: 12.4M

cd /tmp/db-backup
docker volume create hot-restore > /dev/null
docker run --rm -v hot-restore:/data -v "$PWD:/backup" \
    alpine:3.21 tar xzf /backup/hot-copy.tar.gz --numeric-owner -C /data

echo "═══ запускаем PostgreSQL на восстановленных файлах ═══"
docker run -d --name hot-test -e POSTGRES_PASSWORD=secret \
    -v hot-restore:/var/lib/postgresql/data postgres:17-alpine > /dev/null
sleep 15
printf '  статус: %s\n' "$(docker inspect hot-test --format '{{.State.Status}}')"
echo "  логи:"
docker logs hot-test 2>&1 | grep -iE 'recover|redo|invalid|corrupt|LOG:|FATAL' | head -6 | sed 's/^/    /'
docker rm -f hot-test > /dev/null
docker volume rm hot-restore > /dev/null

═══ запускаем PostgreSQL на восстановленных файлах ═══
  статус: running
  логи:
    LOG:  database system was interrupted; last known up at 2026-07-30 13:10:22 UTC
    LOG:  database system was not properly shut down; automatic recovery in progress
    LOG:  redo starts at 0/1A2B3C4
    LOG:  invalid record length at 0/1D4E5F6: wanted 24, got 0
    LOG:  redo done at 0/1D4E5F0
    LOG:  database system is ready to accept connections

cd /tmp/db-backup
sleep 5   # даём нагрузке завершиться

before="$(docker compose exec -T db psql -U postgres -d appdb -tAc 'SELECT count(*) FROM records' | tr -d ' \r')"
echo "═══ записей до копирования: $before ═══"

echo "═══ pg_dump на работающей базе ═══"
docker compose exec -T db pg_dump -U postgres -Fc appdb > appdb.dump
ls -lh appdb.dump | awk '{print "  дамп: " $5}'

echo
echo "═══ восстановление в чистую базу ═══"
docker compose exec -T db psql -U postgres -q -c 'DROP DATABASE IF EXISTS restored;' -c 'CREATE DATABASE restored;'
docker compose exec -T db pg_restore -U postgres -d restored --no-owner < appdb.dump 2>&1 | tail -2

after="$(docker compose exec -T db psql -U postgres -d restored -tAc 'SELECT count(*) FROM records' | tr -d ' \r')"
echo "  записей после восстановления: $after"
[ "$before" = "$after" ] && echo "  ✓ совпадает" || echo "  ✗ расхождение: было $before, стало $after"

echo
echo "═══ контрольная сумма данных ═══"
sum_src="$(docker compose exec -T db psql -U postgres -d appdb -tAc \
    'SELECT md5(string_agg(payload, E"\n" ORDER BY id)) FROM records' | tr -d ' \r')"
sum_dst="$(docker compose exec -T db psql -U postgres -d restored -tAc \
    'SELECT md5(string_agg(payload, E"\n" ORDER BY id)) FROM records' | tr -d ' \r')"
printf '  оригинал:     %s\n' "$sum_src"
printf '  восстановлено: %s\n' "$sum_dst"
[ "$sum_src" = "$sum_dst" ] && echo "  ✓ данные идентичны" || echo "  ✗ данные различаются"

═══ записей до копирования: 150000 ═══
═══ pg_dump на работающей базе ═══
  дамп: 3.8M
═══ восстановление в чистую базу ═══
  записей после восстановления: 150000
  ✓ совпадает
═══ контрольная сумма данных ═══
  оригинал:     4b1f8e2c9d3a7f605e8b1c2d3a4f5e6b
  восстановлено: 4b1f8e2c9d3a7f605e8b1c2d3a4f5e6b
  ✓ данные идентичны

cd /tmp/db-backup
echo "═══ корректная физическая копия: с остановкой ═══"
docker compose stop db > /dev/null
docker run --rm -v db-backup_db-data:/data:ro -v "$PWD:/backup" \
    alpine:3.21 tar czf /backup/cold-copy.tar.gz --numeric-owner -C /data .
docker compose start db > /dev/null
until [ "$(docker compose ps --format '{{.Health}}' db)" = "healthy" ]; do sleep 2; done
ls -lh cold-copy.tar.gz | awk '{print "  архив: " $5}'

docker volume create cold-restore > /dev/null
docker run --rm -v cold-restore:/data -v "$PWD:/backup" \
    alpine:3.21 tar xzf /backup/cold-copy.tar.gz --numeric-owner -C /data
docker run -d --name cold-test -e POSTGRES_PASSWORD=secret \
    -v cold-restore:/var/lib/postgresql/data postgres:17-alpine > /dev/null
sleep 12
echo "  логи запуска:"
docker logs cold-test 2>&1 | grep -iE 'not properly shut down|ready to accept' | head -2 | sed 's/^/    /'
printf '  записей: %s\n' \
    "$(docker exec cold-test psql -U postgres -d appdb -tAc 'SELECT count(*) FROM records' 2>/dev/null | tr -d ' \r')"
docker rm -f cold-test > /dev/null
docker volume rm cold-restore > /dev/null

═══ корректная физическая копия: с остановкой ═══
  архив: 12.6M
  логи запуска:
    LOG:  database system is ready to accept connections
  записей: 150000

cd /tmp/db-backup && docker compose down -v > /dev/null 2>&1
cd /tmp && rm -rf /tmp/db-backup /tmp/vol-backup

echo "═══ сколько занимают volumes ═══"
docker system df -v 2>/dev/null | sed -n '/VOLUME NAME/,/^$/p' | head -12

═══ сколько занимают volumes ═══
VOLUME NAME                                                        LINKS     SIZE
app-data                                                           1         124MB
3f8a91c2e7d45b6a09fe1c3d8b27a4e5f60c9d1e2a3b4c5d6e7f8091a2b3c4d5    0         2.1GB
prod-cache                                                         0         340MB

cat > /tmp/safe-prune.sh <<'SH'
#!/usr/bin/env bash
# Показывает неиспользуемые volumes с содержимым — БЕЗ удаления.
set -uo pipefail

mapfile -t vols < <(docker volume ls -qf dangling=true)
if [ "${#vols[@]}" -eq 0 ]; then
    echo "  неиспользуемых volumes нет"
    exit 0
fi

for v in "${vols[@]}"; do
    size="$(docker run --rm -v "$v:/v:ro" alpine:3.21 du -sh /v 2>/dev/null | cut -f1)"
    printf '\n  %s  (%s)\n' "$v" "${size:-?}"
    docker run --rm -v "$v:/v:ro" alpine:3.21 \
        sh -c 'ls -A /v 2>/dev/null | head -5' | sed 's/^/      /'
done

echo
echo "  Ничего не удалено. Для удаления выбранного:"
echo "    docker volume rm <имя>"
SH
chmod +x /tmp/safe-prune.sh
/tmp/safe-prune.sh

  3f8a91c2e7d45b6a09fe1c3d8b27a4e5f60c9d1e2a3b4c5d6e7f8091a2b3c4d5  (2.1G)
      base
      pg_wal
      postgresql.conf

  prod-cache  (340M)
      index.db
      thumbnails

  Ничего не удалено. Для удаления выбранного:
    docker volume rm <имя>

rm -f /tmp/safe-prune.sh

docker volume create bk-src > /dev/null
docker run --rm -v bk-src:/d alpine:3.21 sh -c 'echo данные > /d/f.txt; echo скрытый > /d/.h'
docker run --rm -v bk-src:/d:ro -v "$PWD:/b" alpine:3.21 tar czf /b/t.tar.gz -C /d .
docker volume create bk-dst > /dev/null
docker run --rm -v bk-dst:/d -v "$PWD:/b" alpine:3.21 tar xzf /b/t.tar.gz -C /d
docker run --rm -v bk-dst:/d alpine:3.21 ls -A /d
docker volume rm bk-src bk-dst > /dev/null; rm -f t.tar.gz