tar agrupa archivos y directorios en un único archivo conservando permisos, propietarios y enlaces, y gzip lo comprime. Juntos siguen siendo la forma más sencilla y portable de hacer copias de seguridad en Linux. En este tutorial crearás archivos .tar.gz en Ubuntu 24.04, excluirás lo que no hace falta guardar, harás copias incrementales, automatizarás una copia diaria con rotación mediante un temporizador de systemd y restaurarás los datos comprobando que están completos.

Requisitos previos

  • Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. Los comandos funcionan igual en Debian 12 y Rocky Linux 9, que también usan GNU tar.
  • Un usuario no root con privilegios sudo.
  • Espacio libre suficiente en el disco de destino. Como referencia, texto y código suelen comprimirse a un 20-30 % de su tamaño; imágenes, vídeos y archivos ya comprimidos apenas se reducen.

Comprueba el tamaño de lo que vas a respaldar y el espacio disponible:

sudo du -sh /etc /var/www
df -h /var/backups

Paso 1: Crear y comprobar un archivo tar.gz

La forma básica de crear una copia es tar -czf: c crea el archivo, z lo comprime con gzip y f indica el nombre del archivo de salida. Crea un directorio para las copias y respalda /etc:

sudo mkdir -p /var/backups/tar
sudo tar -czf /var/backups/tar/etc-$(date +%F).tar.gz -C / etc

La opción -C / hace que tar entre en / antes de añadir etc, así las rutas quedan guardadas como etc/... en lugar de /etc/.... Esto evita el aviso Removing leading '/' from member names y facilita restaurar en cualquier directorio.

Lista el contenido sin extraerlo con -t:

sudo tar -tzf /var/backups/tar/etc-$(date +%F).tar.gz | head -5

etc/
etc/hostname
etc/fstab
etc/passwd
etc/ssh/

Comprueba además que el archivo comprimido no está dañado. gzip -t no muestra nada si todo es correcto y devuelve código 0:

sudo gzip -t /var/backups/tar/etc-$(date +%F).tar.gz && echo "Archivo correcto"

Archivo correcto

Para ver permisos, propietarios y fechas de cada entrada, añade -v al listado: tar -tvzf archivo.tar.gz.

Paso 2: Excluir archivos que no necesitas

Guardar cachés, logs rotados o dependencias que se pueden reinstalar solo hace la copia más lenta y más grande. Usa --exclude con patrones; deben ir antes de los directorios a respaldar:

sudo tar -czf /var/backups/tar/www-$(date +%F).tar.gz \
  --exclude='*.log' \
  --exclude='node_modules' \
  --exclude='var/www/*/cache' \
  --exclude-vcs \
  -C / var/www

--exclude-vcs omite los directorios .git, .svn y similares. Si la lista de exclusiones crece, guárdala en un archivo con un patrón por línea:

sudo nano /etc/backup-exclude.txt

*.log
*.tmp
node_modules
var/www/*/cache

Y pásala con --exclude-from:

sudo tar -czf /var/backups/tar/www-$(date +%F).tar.gz --exclude-from=/etc/backup-exclude.txt -C / var/www

Verifica que los archivos excluidos no están en la copia. Si el comando no devuelve nada, la exclusión ha funcionado:

sudo tar -tzf /var/backups/tar/www-$(date +%F).tar.gz | grep -E 'node_modules|\.log$'

Paso 3: Elegir el nivel y el algoritmo de compresión

gzip usa el nivel 6 por defecto, un buen equilibrio. Si quieres otro nivel o un compresor distinto, usa -I (--use-compress-program) en lugar de -z:

sudo tar -I 'gzip -9' -cf /var/backups/tar/etc-max.tar.gz -C / etc

En servidores con varios núcleos, pigz comprime en paralelo y genera archivos gzip normales, compatibles con tar -xzf:

sudo apt install pigz
sudo tar -I pigz -cf /var/backups/tar/www-pigz.tar.gz -C / var/www

GNU tar en Ubuntu 24.04 también admite zstd con --zstd, que suele comprimir más que gzip y mucho más rápido. El archivo resultante (.tar.zst) necesita zstd para descomprimirse:

sudo apt install zstd
sudo tar --zstd -cf /var/backups/tar/www.tar.zst -C / var/www

Compara los tamaños obtenidos:

ls -lh /var/backups/tar/
OpciónVelocidadTamañoCuándo usarla
-z (gzip -6)MediaMedioPor defecto, máxima compatibilidad
-I 'gzip -9'LentaAlgo menorRara vez compensa
-I pigzRápida (multinúcleo)Igual que gzipDirectorios grandes en servidores con varios núcleos
--zstdMuy rápidaMenorCopias que restaurarás en sistemas modernos

El resto de la guía usa gzip por compatibilidad.

Paso 4: Hacer copias incrementales

Con --listed-incremental (o -g), tar guarda en un archivo de instantánea (.snar) el estado de cada archivo. La primera ejecución crea una copia completa (nivel 0) y las siguientes, con el mismo archivo de instantánea, solo guardan lo que ha cambiado:

sudo mkdir -p /var/backups/tar/incremental
sudo tar -czf /var/backups/tar/incremental/www-full.tar.gz \
  --listed-incremental=/var/backups/tar/incremental/www.snar \
  -C / var/www

Modifica o crea algún archivo y lanza la copia incremental:

sudo touch /var/www/prueba-incremental.txt
sudo tar -czf /var/backups/tar/incremental/www-inc1.tar.gz \
  --listed-incremental=/var/backups/tar/incremental/www.snar \
  -C / var/www

La copia incremental ocupa mucho menos y contiene sobre todo directorios (tar los registra para saber qué archivos se borraron) y los archivos nuevos o modificados:

sudo tar -tzf /var/backups/tar/incremental/www-inc1.tar.gz | grep -v '/$'

var/www/prueba-incremental.txt

Para empezar un nuevo ciclo completo, borra o renombra el archivo .snar. Para restaurar, extrae primero la copia completa y después cada incremental en orden, siempre con --listed-incremental=/dev/null. De esa forma tar también elimina los archivos que se borraron entre copias:

sudo mkdir -p /srv/restore
sudo tar -xzf /var/backups/tar/incremental/www-full.tar.gz --listed-incremental=/dev/null -C /srv/restore
sudo tar -xzf /var/backups/tar/incremental/www-inc1.tar.gz --listed-incremental=/dev/null -C /srv/restore

Paso 5: Automatizar la copia diaria con rotación

Un script corto es la herramienta adecuada aquí: genera la copia, comprueba su integridad y borra las antiguas. Créalo en /usr/local/sbin:

sudo nano /usr/local/sbin/backup-tar.sh

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

DEST="/var/backups/tar/daily"
RETENTION_DAYS=14
SOURCES=(etc var/www)
STAMP="$(date +%F_%H%M)"
ARCHIVE="${DEST}/backup-${STAMP}.tar.gz"

mkdir -p "$DEST"
chmod 700 "$DEST"

# tar devuelve 1 si algún archivo cambió mientras lo leía: la copia es válida.
rc=0
tar -czf "$ARCHIVE" --exclude-from=/etc/backup-exclude.txt -C / "${SOURCES[@]}" || rc=$?
if [ "$rc" -gt 1 ]; then
  echo "tar falló con código $rc" >&2
  rm -f "$ARCHIVE"
  exit "$rc"
fi

gzip -t "$ARCHIVE"
echo "Copia creada: $ARCHIVE ($(du -h "$ARCHIVE" | cut -f1))"

find "$DEST" -name 'backup-*.tar.gz' -type f -mtime +"$RETENTION_DAYS" -print -delete

Hazlo ejecutable y pruébalo a mano:

sudo chmod 750 /usr/local/sbin/backup-tar.sh
sudo /usr/local/sbin/backup-tar.sh

Copia creada: /var/backups/tar/daily/backup-2026-09-25_1012.tar.gz (48M)

Ahora crea una unidad de servicio de systemd que ejecute el script:

sudo nano /etc/systemd/system/backup-tar.service

[Unit]
Description=Copia de seguridad diaria con tar

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/backup-tar.sh
Nice=10
IOSchedulingClass=idle

Y el temporizador que la lanza cada noche a las 03:00. Persistent=true ejecuta la copia al arrancar si el servidor estaba apagado a esa hora:

sudo nano /etc/systemd/system/backup-tar.timer

[Unit]
Description=Ejecuta backup-tar cada noche

[Timer]
OnCalendar=*-*-* 03:00:00
RandomizedDelaySec=15m
Persistent=true

[Install]
WantedBy=timers.target

Activa el temporizador y comprueba la próxima ejecución:

sudo systemctl daemon-reload
sudo systemctl enable --now backup-tar.timer
systemctl list-timers backup-tar.timer

NEXT                        LEFT     LAST PASSED UNIT             ACTIVATES
Sat 2026-09-26 03:07:12 UTC 16h left -    -      backup-tar.timer backup-tar.service

Para lanzar una ejecución de prueba y revisar su salida:

sudo systemctl start backup-tar.service
journalctl -u backup-tar.service -n 20 --no-pager

Paso 6: Restaurar y verificar

Restaura siempre primero en un directorio temporal y compara antes de sobrescribir datos en producción:

sudo mkdir -p /srv/restore
sudo tar -xzf /var/backups/tar/daily/backup-2026-09-25_1012.tar.gz -C /srv/restore
ls /srv/restore

etc  var

Al ejecutar tar como root, los propietarios y permisos se restauran tal como estaban. Si también necesitas conservar ACL y atributos extendidos, añade --acls --xattrs tanto al crear como al extraer la copia.

Para recuperar solo un archivo o directorio, indica su ruta tal como aparece en el listado:

sudo tar -xzf /var/backups/tar/daily/backup-2026-09-25_1012.tar.gz -C /srv/restore etc/nginx/nginx.conf

Puedes comparar el contenido de la copia con el sistema actual usando --compare (-d). tar solo muestra las diferencias:

sudo tar -dzf /var/backups/tar/daily/backup-2026-09-25_1012.tar.gz -C / etc

etc/nginx/nginx.conf: Mod time differs
etc/nginx/nginx.conf: Size differs

Cuando hayas confirmado qué quieres recuperar, cópialo a su sitio, por ejemplo con sudo rsync -a /srv/restore/etc/nginx/ /etc/nginx/, y recarga el servicio afectado. Al terminar, borra el directorio temporal:

sudo rm -rf /srv/restore

Solución de problemas

  • tar: ...: file changed as we read it: un archivo se modificó durante la copia. tar termina con código 1 y la copia es válida, pero ese archivo puede estar a medias. Para bases de datos usa mysqldump o pg_dump en lugar de copiar sus archivos en caliente.
  • gzip: stdin: unexpected end of file: el archivo está truncado, normalmente por falta de espacio en disco durante la copia. Revisa df -h y repite la copia.
  • Cannot open: Permission denied: estás ejecutando tar sin sudo sobre archivos de otros usuarios.
  • La restauración deja archivos con propietario incorrecto: extrajiste sin sudo; como usuario normal, tar asigna tus propios UID/GID.

Conclusión

Ya tienes copias .tar.gz diarias de /etc y /var/www con exclusiones, comprobación de integridad y rotación automática, además de un procedimiento de restauración probado. Como siguientes pasos, envía las copias fuera del servidor con rclone, añade un volcado de tus bases de datos antes de ejecutar tar y programa pruebas de restauración periódicas para asegurarte de que las copias sirven cuando las necesites.