Создание резервных копий БД с шифрованием

Правильный подход к шифрованию БД, чтобы не оставлять персональные данные открытыми это: создать дамп → зашифровать его GPG → сохранить/отправить.

▪️ Подготовка GPG. На сервере, который будет создавать бэкапы, импортируйте публичный ключ:

gpg --import backup_public.key

Проверьте наличие ключа:

gpg --list-keys

Использовать будем шифрование public key → private key, так что дешифровать можно только на безопасном ПК/сервере.

🛠 Скрипт универсального бэкапа PostgreSQL/MySQL с шифрованием GPG

#!/usr/bin/env bash
set -euo pipefail

# === Настройки ===
BACKUP_DIR="/var/backups/db"
RETENTION_DAYS=7
GPG_RECIPIENT="[email protected]"   # email из публичного ключа
TS=$(date +"%F_%H-%M-%S")

DB_TYPE="$1"          # postgres | mysql
DB_NAME="$2"          # имя базы
DB_USER="$3"          # пользователь

mkdir -p "$BACKUP_DIR"

DUMP_FILE="$BACKUP_DIR/${DB_TYPE}_${DB_NAME}_${TS}.sql"
ENC_FILE="$DUMP_FILE.gpg"
LOG_FILE="$BACKUP_DIR/backup.log"

# === Логгер ===
log() {
    echo "[$(date +%F_%T)] $*" | tee -a "$LOG_FILE"
}

log "=== Старт резервного копирования $DB_TYPE:$DB_NAME ==="

# === Дамп базы ===
case "$DB_TYPE" in
    postgres)
        log "Выполняю pg_dump…"
        pg_dump -U "$DB_USER" "$DB_NAME" > "$DUMP_FILE"
        ;;
    mysql)
        log "Выполняю mysqldump…"
        mysqldump -u "$DB_USER" "$DB_NAME" > "$DUMP_FILE"
        ;;
    *)
        log "Неизвестный тип БД: $DB_TYPE"
        exit 1
        ;;
esac

log "Дамп создан: $DUMP_FILE"

# === Шифрование GPG ===
log "Шифрую дамп для получателя: $GPG_RECIPIENT"
gpg --yes --encrypt --recipient "$GPG_RECIPIENT" "$DUMP_FILE"

log "Шифрованный файл: $ENC_FILE"

# === Удаление оригинального дампа ===
rm -f "$DUMP_FILE"
log "Оригинальный файл удалён"

# === Очистка старых бэкапов ===
log "Удаление файлов старше $RETENTION_DAYS дней"
find "$BACKUP_DIR" -type f -name "*.gpg" -mtime "+$RETENTION_DAYS" -delete

log "Готово"

Скрипт:

делает бэкап PostgreSQL или MySQL;
шифрует его GPG-ключом;
сохраняет с датой;
удаляет старые копии.
логирует все происходящее

▪️ Запуск

PostgreSQL:

./backup.sh postgres mydb dbuser

MySQL/MariaDB:

./backup.sh mysql mydb root

▪️ Как восстановить?

gpg -d backup_postgres_mydb_2025-11-01_03-00-00.sql.gpg > restore.sql

PostgreSQL:

psql -U postgres mydb < restore.sql

MySQL:

mysql -u root mydb < restore.sql

BashTex 📱 #bash #utils

Использование printf -v для динамического формирования переменных

Бывает, что нужно создавать или заполнять переменные с динамическими именами: item_1, item_2, user_alice и т.д. Вместо eval попробуем использовать встроенный printf -v, который позволяет записать форматированный строковый результат прямо в переменную по имени.

Почему printf -v лучше, чем eval?

безопаснее (без спаивания и выполнения произвольного кода),
дает форматирование (числа, нули, float),
удобно в функциях (можно создавать глобальные переменные через declare -g).

▪️ Базовый пример: простая запись

name="user_alice"
printf -v "$name" "%s" "id=42"
echo "$user_alice"

id=42

Здесь мы записали строку в переменную user_alice без eval.

▪️ Нумерация с форматированием (zero-padding)

for i in {1..5}; do
  printf -v "item_%03d" "$i" "val_$i"
done

# показать созданные переменные
for i in {1..5}; do
  var="item_$(printf '%03d' "$i")"
  echo "$var = ${!var}"
done

item_001 = val_1
item_002 = val_2

printf -v "item_%03d" "$i" "val" - формат имени и значение удобно комбинировать.

▪️ Создаем набор конфигов из CSV (пример)

while IFS=, read -r key value; do
  # нормализовать имя (латиница, цифры, _)
  safe_key=$(echo "$key" | tr -c '[:alnum:]_' '_')
  printf -v "cfg_%s" "$safe_key" "%s" "$value"
done <<'CSV'
db.host,localhost
db.port,5432
feature.enable,true
CSV

echo "Host: $cfg_db_host"
echo "Port: $cfg_db_port"
echo "Feature: $cfg_feature_enable"

▪️ Инспекция созданных переменных

# показать все переменные с префиксом cfg_
for v in ${!cfg_*}; do
  echo "$v = ${!v}"
done

(indirect expansion) позволяет получить значение переменной по имени.

▪️ Комбинация с declare -n (nameref)

printf -v "user_alice" "%s" "[email protected]"
ref_var="user_alice"
declare -n userref="$ref_var"
echo "Email via nameref: $userref"

declare -n дает ссылку на переменную, это удобнее, чем постоянно подставлять ${!name}.

▪️ Как избежать проблем с именами переменных. Переменная должна соответствовать правилам имени в bash. Можно валидировать:

sanitize() {
  printf '%s' "$1" | sed 's/[^a-zA-Z0-9_]/_/g'
}

raw="user-name@host"
safe=$(sanitize "$raw")
printf -v "$safe" "%s" "value"

Если допустить в имени пробелы или символы ; - printf -v либо даст ошибку, либо поведет себя непредсказуемо.

BashTex 📱 #bash #utils

Контроль размера логов и архивация быстро растущих файлов

Неловко будет если кто-то включил дебаг, забыл про него и оставил так, даже на выходные. Покажу скрипт который будет: мониторить размер файлов в директории логов, сравнивать с предыдущим значением, при подозрительном росте - архивировать лог и обнулять его, сохраняя копию.

🛠 Скрипт

#!/usr/bin/env bash
set -euo pipefail

LOG_DIR="/var/log/myapp"
STATE_FILE="/tmp/log_sizes.db"
THRESHOLD_MB=50   # если лог вырос более чем на 50 MB - архивируем
ARCHIVE_DIR="/var/log/archive"

mkdir -p "$ARCHIVE_DIR"
touch "$STATE_FILE"

# читаем прошлые размеры
declare -A old_sizes
while IFS=":" read -r file size; do
    old_sizes["$file"]="$size"
done < "$STATE_FILE"

> "$STATE_FILE"  # перезапишем свежим состоянием

for log in "$LOG_DIR"/*.log; do
    [[ -f "$log" ]] || continue
    size=$(stat -c %s "$log")
    echo "$log:$size" >> "$STATE_FILE"

    old_size=${old_sizes["$log"]:-0}
    diff=$(( (size - old_size) / 1024 / 1024 ))

    if (( diff > THRESHOLD_MB )); then
        ts=$(date +%F_%H-%M-%S)
        archive="$ARCHIVE_DIR/$(basename "$log").$ts.gz"

        echo "$log вырос на ${diff}MB - архивируем в $archive"
        cp "$log" "$archive"
        gzip "$archive"
        : > "$log"   # обнуляем лог
    fi
done

▪️ Пояснение:

хранит состояние предыдущих размеров в log_sizes.db,
если файл вырос больше порога, делает копию с timestamp, архивирует и очищает,
работает для всех *.log в выбранной директории.

▪️ Применение. Добавь в cron для регулярной проверки:

*/10 * * * * /usr/local/bin/log_watch.sh

BashTex 📱 #bash

Оптимизация скриптов: меньше внешних команд - выше скорость

Одна из самых недооцененных идей - это избегать лишних вызовов внешних утилит. Каждый grep, sed, awk, cut, wc - это новый процесс. Даже если он работает миллисекунды, то в большом цикле таких вызовов может быть сотни, и производительность падает кратно.

▪️ Примеры оптимизации

➖ Было:

count=$(grep "error" logfile | wc -l)

➕ Стало:

count=$(awk '/error/{c++} END{print c}' logfile)

или вообще без внешних утилит:

count=0
while IFS= read -r line; do
  [[ $line == *error* ]] && ((count++))
done < logfile

➖ Было:

name=$(echo "$filename" | cut -d. -f1)

➕ Стало:

name=${filename%%.*}

расширение строк - это встроенная возможность bash, без cut

➖ Было:

for f in $(ls *.log); do
  grep "fatal" "$f" >/dev/null && echo "$f"
done

➕ Стало:

for f in *.log; do
  grep -q "fatal" "$f" && echo "$f"
done

не вызываем ls, здесь glob уже делает свою работу

▪️ Фичи встроенного bash

${var,,} и ${var^^} - lowercase / uppercase без tr
${var//foo/bar} - замена без sed
${#array[@]} - длина массива без wc
[[ $var == pattern* ]] - шаблоны без grep
((expr)) - арифметика без expr или bc
mapfile -t lines < file - чтение файлов без cat

BashTex 📱 #bash

Кто тормозит твой скрипт

Когда скрипт вырастает, то понять, где он тратит время, становится сложно. Можно, конечно, запускать time ./script.sh, но это покажет лишь общую длительность.

А если внутри десятки функций, то какая из них проседает? Решается просто: встроенным профилированием на чистом bash.

▪️ Идея

Оборачиваем каждую функцию в таймер, считаем суммарное время вызовов и количество запусков.
В конце - печатаем красивые итоги.

🛠 Минимальный пример

#!/usr/bin/env bash
declare -A FN_CALLS FN_TIME

# Обертка для функции
trace() {
    local fn=$1
    eval "
    $fn() {
        local start=\$(date +%s.%N)
        __${fn}_impl \"\$@\"
        local end=\$(date +%s.%N)
        local delta=\$(awk -v s=\$start -v e=\$end 'BEGIN{print e-s}')
        ((FN_CALLS[$fn]++))
        FN_TIME[$fn]=\$(awk -v a=\${FN_TIME[$fn]:-0} -v d=\$delta 'BEGIN{print a+d}')
    }
    "
}

# Пример функций
__work_impl() { sleep 0.2; }
__fast_impl() { echo ok >/dev/null; }

trace work
trace fast

# Нагрузочный сценарий
for i in {1..5}; do
  work
  fast
done

# Вывод статистики
echo -e "\nFunction Stats:"
for fn in "${!FN_CALLS[@]}"; do
    avg=$(awk -v t=${FN_TIME[$fn]} -v c=${FN_CALLS[$fn]} 'BEGIN{printf "%.4f", t/c}')
    printf "%-10s calls=%-3s total=%.4fs avg=%.4fs\n" "$fn" "${FN_CALLS[$fn]}" "${FN_TIME[$fn]}" "$avg"
done

▪️ Пример вывода:

Function Stats:
work       calls=5   total=1.0012s avg=0.2002s
fast       calls=5   total=0.0003s avg=0.0001s

▪️ Как это работает

Каждая реальная функция хранится как __name_impl.
Обернутый вариант считает время (date +%s.%N) до и после вызова.
Сохраняет статистику в ассоциативных массивах.

BashTex 📱 #bash

Условное выполнение: && vs ; vs || vs !

У bash есть несколько операторов, которые управляют выполнением команд в зависимости от их кода возврата (0 - успех, ≠0 - ошибка). Разница кажется простой, но на практике часто приводит к тому, что люди не совсем понимают, что они используют.

▪️ ; - просто последовательность. Команды выполняются всегда, независимо от успеха/ошибки.

echo "start"; false; echo "end"
# => выведет start, потом end, даже если false упала

Используется, когда важно выполнить все подряд.

▪️ && - только при успехе. Выполнится вторая команда, если первая завершилась успешно (exit code 0).

mkdir data && echo "Папка создана"

Если mkdir упадет (например, папка уже есть), то echo не выполнится.

Полезно для цепочек успеха:

make build && make test && make deploy

▪️ || - только при ошибке. Выполнится, если первая команда завершилась с ошибкой.

ping -c1 host || echo "Хост недоступен"

Удобно для fallback-сценариев.

▪️ Комбинация && … || … Классический паттерн if-else в одну строку:

command && echo "OK" || echo "FAIL"

Подводный камень: если echo "OK" упадет, то выполнится и "FAIL".
Безопасный вариант - скобки:

command && { echo "OK"; } || { echo "FAIL"; }

▪️ ! - инверсия результата. Меняет код возврата команды на противоположный.

! true   # вернет 1
! false  # вернет 0

Часто встречается в условиях:

if ! grep -q "needle" file.txt; then
    echo "Нет совпадений"
fi

Результаты:

; → всегда выполнить
&& → выполнить при успехе
|| → выполнить при ошибке
! → инвертировать результат
&& … || … → if-else, но лучше со скобками для надежности

BashTex 📱 #bash #utils

Меньше if и больше логики в одну строку

Когда вы пишете:

if command; then
    echo "OK"
else
    echo "Fail"
fi

В мире плачет один котенок…🥺 Ведь есть куда более лаконичная альтернатива:

command && echo "OK" || echo "Fail"

Это логические цепочки (&& и ||), которые позволяют писать коротко и эффективно.

▪️ Принцип short-circuit логики

Bash, как и многие языки, останавливает выполнение цепочки, если уже ясно, что дальше не нужно:

cmd1 && cmd2 - cmd2 выполняется только если cmd1 завершилась успешно (exit 0).
cmd1 || cmd2 - cmd2 выполняется только если cmd1 завершилась с ошибкой (exit ≠ 0).

▪️ Примеры таких условий

📍 Минимизация if:

mkdir newdir && cd newdir

создаст и сразу перейдёт, только если каталог успешно создан.

📍 Команда с fallback:

cp file.txt backup/ || echo "Не удалось скопировать!"

Если cp не удался - сработает echo.

📍 Успех или откат:

make build && echo "Успешно" || echo "Ошибка"

Если echo "Успешно" завершится с ошибкой (что редко, но возможно), то сработает и ||.
Чтобы избежать этого, оберните в скобки:

make build && { echo "Успешно"; } || { echo "Ошибка"; }

📍 Цепочка нескольких условий:

[ -d logs ] && cd logs && ls || echo "Нет каталога logs"

Проверяем наличие каталога
Если есть - заходим и выводим содержимое
Если нет - сообщение

📍 Проверка переменной:

[[ -n $API_KEY ]] && echo "Ключ найден" || echo "Нет ключа"

▪️Более сложные варианты использования

📍 Комбинирование условий:

[[ -f $file && -s $file ]] && echo "Файл существует и не пуст"

📍 Логическая цепочка до первой ошибки:

do_step1 && do_step2 && do_step3 || echo "Ошибка на одном из этапов"

📍 Псевдо-транзакции:

backup && update && restart || rollback

Если что-то пошло не так - rollback.

BashTex 📱 #bash #utils

Автоматическое масштабирование ресурсов контейнеров

Казалось бы, нетривиальная задача - нужно, чтобы контейнер автоматически подстраивался под нагрузку: добавлял CPU/memory, когда процесс задыхается, и освобождал ресурсы при простое. Все это без kubernetes, без swarm, просто bash + docker API. Попробуем реализовать.

▪️ План скрипта:

Скрипт опрашивает docker stats --no-stream
Сравнивает текущую загрузку CPU/памяти с порогами
При превышении - обновляет лимиты контейнера через docker update
При простое - возвращает лимиты назад
Все это циклически, с логированием и защитой от дребезга (частых переключений)

🛠 Пример скрипта (называться пусть будет auto-scale.sh)

#!/usr/bin/env bash

CONTAINER="webapp"
CPU_MAX=200000       # 200% CPU
CPU_MIN=50000        # 50% CPU
MEM_MAX="1g"
MEM_MIN="256m"

LOGFILE="/var/log/docker_autoscale.log"
INTERVAL=30
STABILITY=3          # сколько циклов подряд должна держаться нагрузка

cpu_high=0
cpu_low=0

log() { echo "$(date '+%F %T') $*" >> "$LOGFILE"; }

while true; do
  read cpu mem <<<$(docker stats --no-stream --format "{{.CPUPerc}} {{.MemUsage}}" "$CONTAINER" \
    | awk -F'[ %/]' '{printf "%d %d", $1, $2}')

  if (( cpu > 80 )); then
    ((cpu_high++))
    cpu_low=0
  elif (( cpu < 30 )); then
    ((cpu_low++))
    cpu_high=0
  fi

  if (( cpu_high >= STABILITY )); then
    log "High load detected ($cpu%). Increasing limits..."
    docker update --cpus="2.0" --memory="$MEM_MAX" "$CONTAINER" >/dev/null
    cpu_high=0
  elif (( cpu_low >= STABILITY )); then
    log "Low load detected ($cpu%). Decreasing limits..."
    docker update --cpus="0.5" --memory="$MEM_MIN" "$CONTAINER" >/dev/null
    cpu_low=0
  fi

  sleep "$INTERVAL"
done

BashTex 📱 #bash

Генерация таблиц прогресса

Реализация живой таблицы прогресса выполнения сприпта, обновляемой прямо в терминале - без внешних тулз, только tput, trap. Звучит заманчиво.


🛠 Скрипт:

#!/usr/bin/env bash

tasks=("Backup" "Sync configs" "Rebuild cache" "Restart services" "Cleanup")
total=${#tasks[@]}
done=0

# Убираем курсор
tput civis

# При выходе вернуть курсор
trap 'tput cnorm; echo' EXIT

# Заголовок таблицы
printf "%-20s | %-10s | %-10s\n" "Task" "Status" "Progress"
printf -- "---------------------------------------------\n"

# Печатаем пустые строки под таблицу
for ((i=0; i<total; i++)); do
  printf "%-20s | %-10s | %-10s\n" "${tasks[i]}" "Pending" "0%"
done

# Запоминаем позицию курсора для обновлений
start_row=$(tput lines)
start_row=$((start_row - total))

# Функция обновления строки
update_row() {
  local idx=$1
  local status=$2
  local progress=$3
  tput cup $((start_row + idx)) 0
  printf "%-20s | %-10s | %-10s\n" "${tasks[idx]}" "$status" "$progress"
}

# Основной цикл выполнения
for i in "${!tasks[@]}"; do
  for p in {10..100..10}; do
    update_row "$i" "Running" "${p}%"
    sleep 0.1
  done
  update_row "$i" "Done" "100%"
done

tput cnorm
echo -e "\nВсе задачи завершены!"

▪️ Пояснения:

tput civis / cnorm - скрывает и возвращает курсор.
tput cup row col - перемещает курсор для перерисовки конкретной строки.
trap '...' EXIT - гарантирует возврат нормального состояния терминала даже при Ctrl+C.
printf с фиксированной шириной (%-20s) создает выровненную таблицу.

BashTex 📱 #bash #utils

Создание песочницы для экспериментов

Иногда нужно проверить какую-то команду, поиграться с конфигами или собрать пакет - но без риска сломать систему. Для этого в linux можно сделать свою мини-песочницу, используя старое доброе chroot и немного bash.

chroot - это механизм, который меняет корень файловой системы для процесса. Все, что он видит, находится внутри изолированного каталога, и даже rm -rf / не затронет настоящую систему (если, конечно, настроено правильно 🤓).

🛠 Скрипт создающий песочницу:

#!/usr/bin/env bash

SANDBOX="/opt/sandbox"
DEBIAN_MIRROR="https://deb.debian.org/debian"
ARCH=$(dpkg --print-architecture)

# Проверка зависимостей
for cmd in debootstrap chroot mount umount; do
  command -v $cmd >/dev/null || { echo "$cmd not found"; exit 1; }
done

# Создание окружения, если нет
if [[ ! -d "$SANDBOX" ]]; then
  echo "Создаю минимальную систему Debian..."
  sudo debootstrap --arch="$ARCH" stable "$SANDBOX" "$DEBIAN_MIRROR"
fi

# Монтируем системные точки
sudo mount -t proc /proc "$SANDBOX/proc"
sudo mount --rbind /sys "$SANDBOX/sys"
sudo mount --rbind /dev "$SANDBOX/dev"

# Добавим базовые бинари для экспериментов
sudo cp /bin/bash "$SANDBOX/bin/"
sudo cp /usr/bin/ls "$SANDBOX/usr/bin/"

echo "Входим в песочницу!"
sudo chroot "$SANDBOX" /bin/bash

# После выхода - очистка
echo "Отмонтирую ресурсы..."
sudo umount -l "$SANDBOX/proc" "$SANDBOX/sys" "$SANDBOX/dev"

Здесь:

debootstrap ставит минимальный Debian прямо в каталог (/opt/sandbox)
mount подключает системные псевдофайловые системы (/proc, /sys, /dev)
chroot запускает bash внутри нового корня
После выхода - все отмонтируется, и можно просто удалить /opt/sandbox

BashTex 📱 #bash #utils