Acelerar la compresión con 'tar' y 'pigz'

Tim Koschützki

Cofundador · Berlín, Alemania · Mostrar bio

En el mundo del desarrollo de software, un archivado de archivos eficiente resulta esencial para gestionar proyectos y optimizar flujos de trabajo. El comando tar es una potente utilidad que permite a los desarrolladores agrupar varios archivos y directorios en un único archivo contenedor. Al dominar técnicas avanzadas de tar, podemos mejorar nuestros procesos de archivado, ahorrar tiempo y agilizar nuestros flujos de trabajo de desarrollo.

Comprender tar y su importancia

El comando tar (tape archive) es un elemento básico de los sistemas tipo Unix para crear y manipular archivos contenedores. Se usa ampliamente para copias de seguridad, distribución de software y para combinar varios archivos en uno solo y manejarlos con mayor facilidad. Esta guía utiliza GNU tar v1.34 y pigz v2.8.

Comandos básicos de tar

• Crear un archivo contenedor:

  tar -cf archive.tar /path/to/directory
  

• Extraer un archivo contenedor:

  tar -xf archive.tar
  

• Listar el contenido de un archivo contenedor:

  tar -tf archive.tar
  

Opciones avanzadas de compresión con tar

Comprimir los archivos contenedores reduce el espacio de almacenamiento y acelera los tiempos de transferencia. tar admite varios métodos de compresión, lo que te permite equilibrar la velocidad de compresión y la tasa de compresión.

Usar gzip

El método de compresión más habitual con tar consiste en usar gzip:

tar -czf archive.tar.gz /path/to/directory

La opción -z le indica a tar que comprima el archivo contenedor con gzip.

Usar bzip2

Para obtener una mejor compresión a costa de la velocidad, usa bzip2:

tar -cjf archive.tar.bz2 /path/to/directory

La opción -j usa bzip2 para la compresión.

Usar xz

Para obtener la máxima tasa de compresión:

tar -cJf archive.tar.xz /path/to/directory

La opción -J usa xz, que ofrece tasas de compresión más altas que gzip o bzip2, aunque con una velocidad de compresión más lenta.

Acelerar la compresión con pigz

Las herramientas de compresión tradicionales como gzip utilizan un solo núcleo de CPU, lo que puede convertirse en un cuello de botella en los sistemas modernos de varios núcleos. pigz (Parallel Implementation of GZip) resuelve esto usando varios núcleos para la compresión.

Instalar pigz

En Ubuntu/Debian

sudo apt-get update
sudo apt-get install pigz

En macOS (con Homebrew)

brew install pigz

En CentOS/RHEL

sudo yum update
sudo yum install pigz

Usar tar con pigz

Para usar pigz con tar, especifícalo como el programa de compresión:

tar -I pigz -cf archive.tar.gz /path/to/directory

Para obtener la máxima compresión, puedes indicar el nivel de compresión:

tar -I 'pigz -9' -cf archive.tar.gz /path/to/directory

Excluir archivos y directorios

Al crear archivos contenedores, es posible que quieras excluir ciertos archivos o directorios que son innecesarios o demasiado grandes.

Excluir un solo archivo o directorio

tar -czf archive.tar.gz --exclude='*.log' /path/to/directory

Este comando excluye todos los archivos que terminan en .log.

Usar un archivo de exclusiones

Crea un archivo exclude.txt que contenga los patrones que quieres excluir:

*.log
node_modules
.git

Luego usa la opción --exclude-from:

tar -czf archive.tar.gz --exclude-from='exclude.txt' /path/to/directory

Copias de seguridad incrementales con tar

tar puede realizar copias de seguridad incrementales archivando solo los archivos que han cambiado desde la última copia de seguridad. El archivo de instantánea, como backup.snar, debe conservarse entre copias de seguridad para mantener el historial incremental.

Crear una copia de seguridad completa

tar --listed-incremental=backup.snar -czf backup-full.tar.gz /path/to/directory

Realizar una copia de seguridad incremental

tar --listed-incremental=backup.snar -czf backup-incremental-$(date +%F).tar.gz /path/to/directory

Archivado por ssh: copias de seguridad remotas

Puedes crear archivos contenedores en sistemas remotos o transferirlos por la red mediante SSH.

Archivar un directorio remoto de forma local

Crea un archivo contenedor de un directorio remoto con la máxima compresión y guárdalo de forma local:

ssh user@remote "tar -I 'pigz -9' -cf - /path/to/remote/directory" > archive.tar.gz

Para ver el progreso, si tienes pv (Pipe Viewer) instalado, puedes monitorear la transferencia:

ssh user@remote "tar -I 'pigz -9' -cf - /path/to/remote/directory" | pv > archive.tar.gz

Archivar un directorio local en un host remoto

Crea un archivo contenedor de un directorio local y guárdalo en un host remoto:

tar -I 'pigz -9' -cf - /path/to/directory | ssh user@remote "cat > /path/to/save/archive.tar.gz"

O bien, con monitoreo del progreso mediante pv:

tar -I 'pigz -9' -cf - /path/to/directory | pv | ssh user@remote "cat > /path/to/archive.tar.gz"

Combinar tar con find para archivar de forma selectiva

Con find puedes incluir archivos de forma selectiva en un archivo contenedor según criterios como la fecha de modificación o el tamaño.

Ejemplo: archivar los archivos modificados en los últimos 7 días

find /path/to/directory -type f -mtime -7 -print0 | tar -czf archive.tar.gz --null -T -

Las opciones --null -T - le indican a tar que lea los nombres de archivo desde la entrada estándar, separados por caracteres nulos.

Dividir archivos contenedores grandes en partes más pequeñas

Cuando trabajas con archivos contenedores muy grandes, es posible que necesites dividirlos en fragmentos más pequeños para almacenarlos o transferirlos.

Dividir un archivo contenedor

tar -czf - /path/to/directory | split -b 500M - archive_part_

Este comando crea partes comprimidas de 500 MB cada una, llamadas archive_part_aa, archive_part_ab, etc.

Reensamblar el archivo contenedor

cat archive_part_* > archive.tar.gz

Automatizar tareas de tar en tu flujo de trabajo de desarrollo

Automatizar las tareas de archivado ahorra tiempo y garantiza la consistencia.

Ejemplo de script de Bash

Crea un script backup.sh:

#!/bin/bash

TIMESTAMP=$(date +%F)
BACKUP_DIR="/path/to/backup"
SOURCE_DIR="/path/to/directory"
EXCLUDE_FILE="/path/to/exclude.txt"

tar -I 'pigz -9' -cf "$BACKUP_DIR/backup-$TIMESTAMP.tar.gz" \
    --exclude-from="$EXCLUDE_FILE" "$SOURCE_DIR"

if [ $? -ne 0 ]; then
  echo "Backup failed" >&2
  exit 1
fi

echo "Backup successful: $BACKUP_DIR/backup-$TIMESTAMP.tar.gz"

Haz que el script sea ejecutable:

chmod +x backup.sh

Programar con cron

Programa el script para que se ejecute a diario a medianoche editando tu crontab:

crontab -e

Luego agrega la siguiente línea:

0 0 * * * /path/to/backup.sh

Buenas prácticas para un archivado de archivos eficiente

• Copias de seguridad periódicas: programa copias de seguridad con regularidad para protegerte frente a la pérdida de datos.
• Excluye los archivos innecesarios: usa las opciones --exclude para evitar archivar archivos que no hacen falta.
• Monitorea los procesos de copia de seguridad: revisa los logs o configura alertas para asegurarte de que las copias de seguridad se completen correctamente.
• Almacena las copias de seguridad de forma segura: guárdalas en ubicaciones seguras y redundantes.
• Verifica los archivos contenedores: después de crear uno, verifica su integridad con un comando como tar -tf archive.tar.gz.
• Usa compresión en paralelo: aprovecha pigz en sistemas de varios núcleos para comprimir más rápido.
• Consideraciones de memoria: los niveles altos de compresión con pigz pueden aumentar el uso de memoria. Ajusta el nivel de compresión (p. ej., de -9 a uno más bajo) si la memoria es limitada.
• Documenta los procedimientos: mantén documentación clara de los procesos de copia de seguridad y restauración.

Al aplicar estas técnicas avanzadas de tar, puedes crear soluciones de copia de seguridad eficientes y automatizadas que protegen tus datos a la vez que optimizan los recursos del sistema.