Copias de seguridad básicas de sistema

La explicación de las copias de seguridad a nivel usuario, estan en: Copia de seguridad (Usuarios)

Consideraciones generales2

  • Las copias se almacenan en subdirectorios en /mnt/backup_interno/
  • En algunos chismes y a la conexión de un disco duro se ejecuta una copia local
  • Para scripts de copia de seguridad adhoc, se siguen los criterios de ejecucion en cron. Ver ApuntesLinux.ProgramacionTareas

Enlace a host backup2, donde se centralizan las copias antes de volcarlas a un dispositivo externo

BROCOLI: @pool_brocoli (y plantilla para otros)

Esquema **pull** desde guisante hacia /mnt/backup_externo

El destino es el WD 8TB conectado a guisante (firebat negro).

La copia la inicia guisante con usuario backuplechuga y la entrega brocoli (captado con usuario local backuplechuga.

En backups (destino del dato)

# Instalación de rsync
apt-get update && apt-get install --yes rsync

# Generar sin clave:
ssh-keygen -t ed25519 -f /root/.ssh/ed25519_brocoli_a_guisante-pool_brocoli
chmod 400 /root/.ssh/ed25519_brocoli_a_guisante-pool_brocoli
cat /root/.ssh/ed25519_brocoli_a_guisante-pool_brocoli.pub

Script de copia a ejecutar en destino de datos

Uno por cada trabajo de copia en directorio /opt/scripts_backups/


# Generamos el directorio de destino
mkdir -p /mnt/pool_backups/pool_brocoli/@root/


# Volcado del script
cat > "/opt/scripts_backups/$NOMBRE_COPIA.sh" << 'EOF'
#!/usr/bin/env bash
set -euo pipefail

# Este script se lanza a través de *** lanzamiento_backups_lechuga.service ***
# Nombre de la copia
NOMBRE_COPIA=guisante_a_backups-root

SSH_KEY="/root/.ssh/ed25519_$NOMBRE_COPIA"
SRC="backuplechuga@192.168.1.140:."
DST="/mnt/pool_backups/pool_brocoli/@root/"
LOG="${DST}log_backup.txt"

echo "Inicio de copia: $(date '+%Y-%m-%d %H:%M:%S')" > "$LOG"

# --dry-run

rsync \
        --verbose \
        --archive \
        --hard-links \
        --acls \
        --xattrs \
        --delete \
        --numeric-ids \
        --compress \
        --human-readable \
        --one-file-system \
        --stats \
        --exclude "MMedia_R/" \
        --exclude "log_backup.txt" \
        -e "ssh -i $SSH_KEY" \
        "$SRC" \
        "$DST" | tee -a "$LOG"

echo "Fin de copia: $(date '+%Y-%m-%d %H:%M:%S')" >> "$LOG"
EOF


chmod u+rwx "/opt/scripts_backups/$NOMBRE_COPIA.sh"
 

Service de systemd

Uno para todos los trabajos de copia

cat > "/etc/systemd/system/lanzamiento_backups_lechuga.service" << EOF
[Unit]
Description=Lanzamiento de los backups de lechuga en guisante
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot

ExecStart=/root/script_backups_brocoli_a_guisante-pool_brocoli.sh
#ExecStart= ... Otros scripts de copia

User=root
StandardOutput=journal
StandardError=journal
TimeoutStartSec=6h
EOF


chmod a+r /etc/systemd/system/lanzamiento_backups_lechuga.service

Timer de systemd

Este timer lanza el service con la secuencia de todos los trabajos de copia

cat > "/etc/systemd/system/lanzamiento_backups_lechuga.timer" << EOF
[Unit]
Description=Timer diario de backups rsync


[Timer]
OnCalendar=*-*-* 03:00:00
RandomizedDelaySec=5min
Persistent=false
Unit=lanzamiento_backups_lechuga.service

[Install]
WantedBy=timers.target
EOF


chmod a+r /etc/systemd/system/lanzamiento_backups_lechuga.timer

Activación del timer y servicio


systemctl daemon-reload

systemctl enable "lanzamiento_backups_lechuga.timer"

systemctl status "lanzamiento_backups_lechuga.timer" --no-pager

systemctl list-timers "lanzamiento_backups_lechuga.timer" --no-pager

systemctl status "lanzamiento_backups_lechuga.service" --no-pager
 

En Brocoli como root (origen del dato):

Generar usuario y grupo dedicado backuplechuga, con uid 2009:

  • Con sudo puede acceder a todo el sistema (limitado por command en authorized_keys).

useradd --create-home backuplechuga --uid 2009
passwd -l backuplechuga

apt-get update && apt-get install rsync -y
apt-get install python3 --yes --no-install-recommends # Para el wrapper rrsync

visudo -f /etc/sudoers.d/backuplechuga
# Añadir:
#    Defaults:backuplechuga env_keep += "SSH_ORIGINAL_COMMAND"
#    backuplechuga ALL=(root) NOPASSWD: /usr/bin/rrsync *


mkdir -p /home/backuplechuga/.ssh
chmod 600 /home/backuplechuga/.ssh

vim /home/backuplechuga/.ssh/authorized_keys
# Añadir: command="sudo /usr/bin/rrsync -ro /mnt/pool_brocoli/",restrict ssh-ed25519 AAAA....

chown backuplechuga:backuplechuga /home/backuplechuga/.ssh/authorized_keys
chown backuplechuga:backuplechuga /home/backuplechuga/.ssh
chmod 700 /home/backuplechuga/.ssh
chmod 600 /home/backuplechuga/.ssh/authorized_keys

 
Añadir a /etc/ssh/sshd_config:

AllowUsers ... backuplechuga ...

Match User backuplechuga
    PasswordAuthentication no
    PermitEmptyPasswords no

y ejecutar systemctl restart sshd

BROCOLI: Clonezilla de sistema (y plantilla para otros)

Se utiliza el KVM-PCI de gestión.

Apagado de brocoli

Con un poweroff basta

Conexión a interfaz de gestión y arranque ISO.

Con un navegador web al KVM http://192.1681.110/

Volcado de imagen a share de pepino

Nuevar version, a desarrollar

  • Montar con sshfs el directorio /home/partimag del origen de la imagen. Usar partimag@192.168.1.155
  • Ejemplo de ruta de destino del montaje: /mnt/pool_backups/lenteja/clonezilla
  • Comando clonezilla una vez montado: /usr/sbin/ocs-sr -q1 -c -j2 -z9p -i 0 -sfsck -senc -plu -p choose savedisk $(date +"mHS")-clonezilladd sda

Volcado del disco a un fichero gzip

# en linux live arrancado

sudo bash

# Orígenes y destinos
disco_origen="/dev/disk/by-id/ata-KINGSTON_SA400S37120G_50026B77823FFE2B"
path_destino_dd="/mnt/cifs_pepino"

# Montar el share samba de pepino en el linux live arrancado
mkdir -p /mnt/cifs_pepino
mount -t cifs .... /mnt/cifs_pepino

dd if=$disco_origen conv=sync,noerror bs=64K | gzip -c  > $path_destino_dd/$(date +"%Y%m%d_%H%M%S")_backup_root_brocoli.img.gz

Restauración de la copia

Proceder al apagado de brocoli, conexión a la interfaz web del pci y montar share de pepino

restauración del fichero gzip a un disco

# en linux live arrancado

sudo bash
dev_destino="/dev/disk/by-id/ata-KINGSTON_SA400S37120G_50026B77823FFE2B"

mount -t cifs .... /mnt/cifs_pepino

gunzip -c /mnt/cifs_pepino/backupXXXX.img.gz | dd of=$dev_destino

INCUS: backups de contenedores

Se hace un snapshot de cada container, luego un publish y finalmente se lleva a un tar. Siguiendo https://superadmin.es/blog/devops/backup-contenedores-lxd/

implementar en cron, meter comprovaciones, usar el logger para advertencias y avisos.

código en https://git.lechuga.eu/git/incus-backup

WIKI_LECHUGA: Copia de seguridad a boniato

Se usa clave privada ssh para publicar en boniato: srv-internet:/root/.ssh/srv-internet_a_pool_boniato-pmwiki

En boniato está el usuario pool_boniato con esta línea en authorized_keys: no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,command="rsync --server -avz . /var/www/html/wiki_lechuga_backup/" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOW6OF+SnsgfsdfsdbscvbspqBbHE7XFpyO7 root@srv-internet.lechuga.eu

Se realizan desde el host srv-internet.lechuga.eu

Se ejecuta la unidad systemd actualiza_backup_wiki.service con el timer con el mismo nombre

El código fuente está en https://git.lechuga.eu/git/mirror-wiki

Actualmente la versión en boniato es accesible en la dirección http://boniato.lechuga.eu/wiki_lechuga, con el mismo usuario que la copia local.

Copia de seguridad de la web nuestras fotos

El blog es un wordpress, el cual cuelga de una base de datos MySQL.

el script de copia está en /usr/local/bin/nuestrasFotos y hay un link a él en el cron.weekly

Se hace una copia de la base de datos mediante mysqldump, siguiendo un script modificado de https://simon-davies.name/bash/backing-up-mysql-databases

La copia de seguridad de la base de datos la realiza el propio servidor srv.lechuga.eu para evitar dar acceso desde el exterior a la bbdd.

Las copias se depositan en el directorio nuestrasFotos dentro del pool de backups genérico.

Copia de seguridad de recursos brocoli (hosts incluidos)

Introducción

cada host ejecuta un rsync (bajo script nuestro) contra backups2.lechuga.eu, que ejecuta rrsync mediante ssh.

Estas copias se almacenan en backups2.lechuga.eu/mnt/backup_interno/rsyncs.

Posteriormente, backups2.lechuga.eu tiene un proceso que hace rsnapshot de los recursos.

Copias cíclicas se guardan en backups2.lechuga.eu/mnt/backup_interno/rsnapshots.

en backups2 hay un cron creando un archivo haciendo touch en /mnt/backup_interno/rsyncs/watchdog.README, que se utilizará luego para ver si se van actualizando las copias de seguridad:

  • Se envia un correo a hugo@hugo.cat si la copia tiene más de dos dias de antiguedad
  • En cualquier caso, se envía mensaje a la consola/log con la antiguedad del archivo comprobado

Añadir un nuevo recurso del cual hacer copia

en el host que tiene el recurso:

  • recuperar del git rsync-backup-lechuga y guardarlo en /opt/rsync-backup-lechuga (si no está ya copiado):
cd /opt
git clone https://srv.lechuga.eu/git/rsync-backup-lechuga
  • generar una pareja publico privada i y guardarla en /root/.ssh/id_rsa_rsync_[nombre_recurso](.pub):

# ejecutar como root
# en el host del que queremos hacer copia
NOMBRE_RECURSO=pool_crit

ssh-keygen -C "rsync-$NOMBRE_RECURSO" -f "/home/backuplechuga/.ssh/id_rsa_rsync_$NOMBRE_RECURSO"

copiar el contenido del fichero .pub en un notepad++.

  • añadir en /etc/crontab del host el siguiente comando, cambiando [nombre_recurso] por el nombre del recurso:
# copia de seguridad del recurso
* */6 * * * /opt/rsync-backup-lechuga/lanza-rsync-lechuga -s 7200 -f id_rsa_rsync_[NOMBRE_RECURSO] -d [directorio base recurso] -c

en el host backups2:

  • añadir la parte pública de la clave generada en el host origen al archivo /home/backuplechuga/.ssh/authorized_keys según el modelo de las otras:

vim /home/backuplechuga/.ssh/authorized_keys

Ha de comenzar por:
command="/opt/rrsync/rrsync /mnt/backup_interno/rsyncs/[NOMBRE_RECURSO]",no-agent-forwarding,no-port-forwarding,no-pty,no-user-rc,no-X11-forwarding [contenido de la parte pública]

Ha de acabar por:
rsync-[NOMBRE_RECURSO]

  • generar un directorio /mnt/backup_interno/rsyncs/[NOMBRE_RECURSO]
NOMBRE_RECURSO=pool_crit

mkdir /mnt/backup_interno/rsyncs/$NOMBRE_RECURSO
chown backuplechuga.backuplechuga /mnt/backup_interno/rsyncs/$NOMBRE_RECURSO
chmod 755 /mnt/backup_interno/rsyncs/$NOMBRE_RECURSO

DESACTIVADO Copia externa en disco duro (on-site, encriptado dmcrypt)

Actualmente: Disco duro de 2,5 pulgadas directo a USB 3

Indicación general

  • Guía utilizada: https://wiki.archlinux.org/title/Dm-crypt
  • La unidad está encriptada completa, debajo tiene un ext4.
  • La clave de encriptación está en el archivo de claves y se llama "dmcrypt backup_onsite"
  • El disco se monta a través del host directamente al arrancar (configuración en systemd)
  • Hay dos scripts, en /opt/backup-onite para el montaje y desmontaje llamados mediante la unidad backups-onsite.service
  • El disco los actualiza el host backups2 (se ha añadido a backups2 el punto encriptado) mediante un rsync en cron /opt/rsync-backup-externo/rsync-backup-externo
  • Sólo se hace copia del directorio de nubes
[Unit]
Description=Gestión Backup Onsite

[Service]
Type=oneshot
ExecStart=/opt/backup-onsite/mount-backup-onsite.sh
RemainAfterExit=yes
ExecStop=/opt/backup-onsite/umount-backup-onsite.sh

[Install]
WantedBy=multi-user.target

Verificaciones

Verificación del servicio de montaje
systemctl status backup-onsite.service

Verificación del montaje en el momento actual
lsblk -o NAME,FSTYPE,SIZE,MOUNTPOINT,LABEL,UUID

Última ejecución
sudo stat /mnt/backup_externo/nubes/centinela_realizado.txt

Pendientes

  • etiquetar correctamente el disco

Se configura un servicio de systemd para montarlo al principio

https://askubuntu.com/questions/1371186/how-to-start-my-own-script-at-the-end-of-boot

Copia externa en disco duro (off-site, encriptado ecryptfs)

Actualmente: WD GREEN 3TB (etiquetado "COPIA SEGURIDAD ENCRIPT")

1. Para montar y también para extraer la información (en linux), ejecutar el script sudo /opt/backup-offsite/01-mount.sh:

# El UUID corresponde a la particion que se usa del disco duro
UUID_BACKUP_OFFSITE="35d6b970-be40-4062-8b6e-b6e354370dda"
PUNTOMONT="/mnt/backup_offsite/"

cd /mnt

sudo mount /dev/disk/by-uuid/$UUID_BACKUP_OFFSITE $PUNTOMONT
sudo mount -t ecryptfs $PUNTOMONT"secure" $PUNTOMONT"secure" -o ecryptfs_passthrough=no,ecryptfs_cipher=aes,ecryptfs_key_bytes=16,ecryptfs_enable_filename_crypto=no

# El punto de montaje desencriptado es $PUNTOMONT"unsecure"

2. La actualización del backup ejecutar el script sudo /opt/backup-offsite/02-copia.sh

#!/bin/bash

ORIGEN="/mnt/backup_interno/"
PUNTOMONT="/mnt/backup_offsite/"

# rsync --archive --hard-links --progress --one-file-system --delete --exclude="rsyncs" $ORIGEN $PUNTOMONT"secure/"

rsync --verbose --archive --hard-links --progress --one-file-system --delete --exclude="rsnapshots" --exclude="repo_gestion_manual" /mnt/backup_interno/ $PUNTOMONT"secure/"
 

3. Para desmontar, ejecutar el script sudo /opt/backup-offsite/03-umount.sh:

cd /mnt  # Salimos del directorio de trabajo
sudo umount $PUNTOMONT"secure"
sudo umount $PUNTOMONT

DESACTIVADO Copia externa a nube (encriptación y subida)

  • Encargado al host backups
  • Script ejecutado con cron /etc/periodic/daily: /usr/local/bin/pool_crit_a_nube.sh
  • Se utiliza el directorio /mnt/backups/temp/ como buffer para la subida a la nube.
  • Se copian datos críticos.
  • Los respaldos son atómicos e independientes entre sí. No se hacen respaldos ni incrementales no diferenciales.
  • La encriptación se hace mediante llave pública.
  • La desencriptación se hace adhoc, mediante la parte privada de la clave.
  • Por eso se trata de un último recurso, cuando el resto de copias fallan.
  • El respaldo es siempre sobre datos que cuelgan desde el repositorio global de backups.

Generalizar el script de copia de seguridad a nube utilizado para los datos personales y extenderlo a cualquier copia, de cualquier directorio.

  • Debe aceptar un directorio arbitrario a respaldar
  • Debe aceptar la indicacion de un tamaño maximo de archivo. Hacer split mas alla de ese tamaño.
  • El formato de salida debe ser, en este orden:
    1. tar
    2. bzip2 (el incorporado en gpg)
    3. pgp
    4. split

Donde va a parar -> nube proveedor externo

A la cuenta brocoli@lechuga.eu de google drive. La clave está en el archivo de claves.

Donde va a parar -> boniato

A la cuenta backups_lechuga de boniato.lechuga.eu La clave está en el archivo de claves.

¿Cómo extraerlo?

El archivo se encripta en clave pública, siendo el destinatario hugo@hugo.cat

Descargar el archivo pool_nocrit.tar.bz2.gpg

  • Si es desde Google Drive, descargar a una carpeta donde poder usar el gnupg
  • Si es desde boniato, hacer un lftp para descargar lftp -u backups_lechuga,[clave_de_acceso] -p 990 boniato.lechuga.eu

El comando para desencriptar es:

gpg --decrypt pool_nocrit.tar.bz2.gpg > pool_nocrit.tar.bz2
tar xvf pool_nocrit.tar.bz2

Más información en Firma y encriptado GPG

De correos electrónicos

El host backups2 se dedica a descargar periodicamente los correos de las cuentas indicadas en el script /opt/backups-correos/backupscorreos

La configuración de cada cuenta está en /mnt/backup_interno/correos/getmailrc.[cuenta_de_correo]

Los correos electrónicos quedan /mnt/backup_interno/correos

Esta descarga se realiza diariamente según indicado en crontab

Para la copia se utiliza el programa getmail

Copia de seguridad hosts windows

TODO Configurar a guisante

Consideración general

  • Ejecutan rsync contra backups2
  • El repo está en /mnt/backup_interno/rsyncs

Configuración de un repo nuevo

En brocoli:

  1. Generar un directorio nuevo en /mnt/backup_interno/rsyncs
  2. Igualar el permisos y propiedad a los ya existentes (no hay ACL)
  3. dentro del nuevo directorio, añadir otro (no queremos poder modificar el raiz del nuevo repo). Por ejemplo, la letra de la unidad

En backups2:

  1. Generación de la pareja público-privada e inclusión en el authorized_keys : BackupsTecnico#generacion_pubk
  2. Inclu

En el Windows origen:

  • Instalar cygwin C:\cygwin64:
  • Crear un directorio .ssh en cygwin: Aquí irá el known hosts
    • mkdir c:\cygwin64\home\%username%\.ssh
  • Crear también un directorio "copias_rsync" en la raiz del perfil de usuario:
    • mkdir %userprofile%\copias_rsync
  • Copiar en este último:
  • Modificar el script script-copia.sh para que coja los directorios que toque (exclusiones, destino, etc.)
  • Ejecutar el .bat y dar OK a añadirlo al known_hosts

CONTRASEÑAS: TODO

Comentar proceso de recuperación también de Vaultwarden