Cómo convertir ZIP a TAR (migraciones de servidores Linux)
Por qué ZIP y TAR existen en mundos diferentes
ZIP y TAR provienen de dos filosofías informáticas diferentes. ZIP, nacido en 1989 para DOS y Windows, combina el archivado y la compresión en un solo paquete. Gestiona los archivos individualmente, permitiéndote extraer un solo archivo sin descomprimir todo el paquete, y rastrea metadatos al estilo de Windows. TAR, abreviatura de Tape ARchive, es puro Unix. Hace una sola cosa: concatena archivos en un único flujo de datos. Eso es todo. La compresión es un paso aparte, que normalmente se gestiona con herramientas como gzip (.tar.gz) o bzip2 (.tar.bz2). Esta diferencia no es solo académica; tiene enormes consecuencias prácticas en las migraciones de servidores Linux. Recibes un ZIP de un desarrollador de Windows o de una copia de seguridad de cPanel, y de repente te encuentras luchando contra errores de permisos, enlaces simbólicos rotos y metadatos perdidos cuando intentas desplegarlo. TAR fue diseñado para preservar precisamente lo que ZIP ignora: los permisos de archivo de Unix (tus chmod 755 y 644), los datos de propiedad, los enlaces simbólicos y los enlaces duros. Es un salvavidas. Una pesadilla habitual es un sitio de WordPress comprimido en un ZIP desde Windows. El script `wp-cron.php` podría perder su permiso de ejecución, o enlaces simbólicos cruciales podrían aplanarse y convertirse en archivos muertos. Al reempaquetar ese mismo proyecto como un .tar.gz primero, evitas todos estos problemas antes de desplegarlo en tu servidor Apache o Nginx. Convertir de ZIP a TAR no es una simple cuestión de gustos; es un paso necesario para una migración fluida y predecible.
El método más rápido: CocoConvert para archivos pequeños y medianos
Cuando trabajas con un archivo de menos de 2 GB, la solución más rápida es una herramienta online. Cualquiera que haya tenido que levantar una máquina virtual temporal solo para hacer una única conversión sabe que a veces solo quieres resolver el problema ya. Para eso, usa la nube. El [conversor de ZIP a TAR de CocoConvert](/convert/zip-to-tar) se encarga de todo el proceso (extracción y reempaquetado) en sus servidores. No tienes que instalar nada. Usarlo es sencillo: 1. Ve a [cocoConvert.com/convert/zip-to-tar](/convert/zip-to-tar). 2. Arrastra tu archivo .zip a la página o usa el botón 'Seleccionar archivo'. 3. Elige el formato de salida. Puedes obtener un .tar simple, un .tar.gz comprimido o un .tar.bz2. 4. Pulsa 'Convertir'. Un archivo ZIP de 500 MB suele tardar entre 30 y 90 segundos, dependiendo de lo ocupados que estén los servidores. 5. Descarga el archivo TAR finalizado. Puedes guardarlo en tu ordenador o usar `wget` para descargarlo directamente a tu servidor con el enlace proporcionado. Un consejo rápido sobre qué formato elegir: para servidores con poco espacio en disco, .tar.gz es tu mejor opción. Normalmente, reduce el tamaño de bases de código con mucho texto en un 60–70%. Si necesitas una descompresión más rápida en hardware antiguo y puedes tolerar un archivo un poco más grande, .tar.bz2 es una opción sólida, aunque tarda más en crearse. Pero seamos claros sobre los límites. CocoConvert es perfecto para trabajos rápidos y puntuales. No está diseñado para archivos de más de 2 GB, archivos ZIP cifrados o situaciones que exijan una preservación perfecta de ACL (Listas de Control de Acceso) de Unix específicas. Para esas tareas pesadas, tendrás que recurrir a la línea de comandos, de la que hablaremos a continuación.
Conversión por línea de comandos en Linux: el método fiable para archivos grandes
Para archivos grandes, archivos que ya están en un servidor remoto o cualquier cosa con permisos complicados, la línea de comandos es tu mejor aliada. Te da un control total. Solo necesitas dos utilidades que están en prácticamente todos los sistemas Linux: `unzip` y `tar`. Primero, asegúrate de que estén instaladas: ``` which unzip tar ``` En Debian/Ubuntu, puedes instalarlas con: `sudo apt install unzip tar`. En RHEL/CentOS/AlmaLinux, es `sudo dnf install unzip tar`. El proceso en sí es sencillo: descomprimes el archivo en un directorio temporal y luego reempaquetas ese directorio como un archivo TAR. Primero, extrae el ZIP: ``` unzip archive.zip -d ./extracted_content ``` Usar el flag `-d` no es negociable. Crea un directorio dedicado para el contenido. Si lo olvidas, `unzip` esparcirá los archivos por todo tu directorio actual, creando un desastre enorme que tendrás que limpiar a mano. A continuación, empaquétalo en un archivo TAR: ``` tar -czf archive.tar.gz -C ./extracted_content . ``` Analicemos esos flags. `-c` crea un nuevo archivo, `-z` añade compresión gzip y `-f` establece el nombre del archivo de salida. El flag `-C` es el verdadero héroe aquí: le dice a `tar` que cambie al directorio `extracted_content` antes de empezar a archivar. Ese `.` final le indica que archive todo lo que hay en su nuevo directorio actual. Este pequeño truco evita que obtengas un nivel de carpeta extra no deseado dentro de tu archivo, un error clásico que puede romper las rutas de despliegue. ¿Necesitas una compresión diferente? Para .tar.bz2, simplemente cambia `-z` por `-j`: ``` tar -cjf archive.tar.bz2 -C ./extracted_content . ``` Y si tus archivos ya están comprimidos (como imágenes o vídeos), puedes crear un TAR simple, sin comprimir: ``` tar -cf archive.tar -C ./extracted_content . ``` Antes de borrar el directorio temporal, haz siempre una comprobación rápida para asegurarte de que el archivo es válido: ``` tar -tzf archive.tar.gz | head -20 ``` Este comando lista los primeros 20 archivos. Si la estructura parece correcta, ya estás listo.
Gestionar permisos y propiedad de archivos durante la migración
Presta atención aquí, porque este es el paso en el que fallan la mayoría de las migraciones de ZIP a TAR. El problema son los permisos. ZIP tiene un campo de 16 bits para los atributos de archivo, pero es tremendamente inconsistente entre sistemas operativos. Un ZIP de macOS podría hacerlo bien, pero un ZIP del archivador por defecto de Windows casi seguro que lo hará mal. Cuando ejecutas `unzip` en Linux, la herramienta hace lo posible por adivinar los permisos. Normalmente, establece 644 para archivos y 755 para directorios, basándose en el umask de tu sistema (que suele ser 022). Aunque eso está bien para la mayoría de los activos web, es un factor decisivo para cualquier script que necesite permisos de ejecución para funcionar. La única solución fiable es arreglar los permisos tú mismo *antes* de crear el archivo TAR. Audítalos y corrígelos con `find`: ``` # Establecer todos los archivos a un valor seguro por defecto (644) find ./extracted_content -type f -exec chmod 644 {} \; # Establecer todos los directorios a un valor seguro por defecto (755) find ./extracted_content -type d -exec chmod 755 {} \; # Hacer ejecutables los scripts explícitamente find ./extracted_content -name '*.sh' -exec chmod 755 {} \; ``` La propiedad es la otra mitad del rompecabezas. Si estás moviendo una aplicación web, sus archivos probablemente necesiten ser propiedad de `www-data` (en Debian/Ubuntu) o `nginx` o `apache` (en sistemas RHEL). Establece la propiedad antes de crear el archivo, especialmente si un script de despliegue depende de ello: ``` sudo chown -R www-data:www-data ./extracted_content ``` TAR preserva fielmente la propiedad y los permisos que existen en el momento en que creas el archivo. Si los configuras correctamente de antemano, tu despliegue se convierte en una simple extracción, sin más líos de scripts `chmod` post-despliegue. Para despliegues automatizados, esto es una victoria operativa enorme en comparación con tener que lidiar con archivos ZIP.
Automatizar la conversión de ZIP a TAR en scripts de migración
Si vas a convertir más de un archivo, automatízalo. Ya sea que estés migrando docenas de sitios o simplemente procesando copias de seguridad ZIP semanales de un servidor cPanel, un script te ahorrará muchísimo tiempo y evitará errores tontos. Este script de shell es un excelente punto de partida. Encuentra cada archivo ZIP en un directorio de origen, lo convierte y coloca el archivo TAR resultante en un directorio de destino. ```bash #!/bin/bash SOURCE_DIR="/srv/backups/zip" DEST_DIR="/srv/backups/tar" TMP_DIR="/tmp/zip_conversion" mkdir -p "$DEST_DIR" "$TMP_DIR" for zipfile in "$SOURCE_DIR"/*.zip; do basename=$(basename "$zipfile" .zip) extract_path="$TMP_DIR/$basename" echo "Procesando: $basename" mkdir -p "$extract_path" unzip -q "$zipfile" -d "$extract_path" # Arreglar permisos find "$extract_path" -type f -exec chmod 644 {} \; find "$extract_path" -type d -exec chmod 755 {} \; tar -czf "$DEST_DIR/${basename}.tar.gz" -C "$extract_path" . # Verificar antes de limpiar if tar -tzf "$DEST_DIR/${basename}.tar.gz" > /dev/null 2>&1; then echo "Éxito: ${basename}.tar.gz" rm -rf "$extract_path" else echo "ERROR: La conversión falló para $basename" >&2 fi done rm -rf "$TMP_DIR" ``` Para usarlo, guarda el código como `convert_zips.sh`, hazlo ejecutable con `chmod 755 convert_zips.sh` y luego ejecútalo con `./convert_zips.sh`. Fíjate en la comprobación de seguridad: el script valida que el nuevo archivo TAR se pueda leer antes de borrar los archivos temporales extraídos. Este es un paso crucial que evita que pierdas datos accidentalmente si algo sale mal durante el comando `tar`. Para ejecutar esto automáticamente, simplemente añádelo a una tarea de cron. Este ejemplo ejecuta el script todos los días a las 2 AM y registra toda la salida: `0 2 * * * /srv/scripts/convert_zips.sh >> /var/log/zip_conversion.log 2>&1`.
Errores comunes y cómo solucionarlos
Tarde o temprano, una conversión fallará. Suele pasar. Aquí tienes los errores más comunes que te encontrarás al convertir de ZIP a TAR y cómo superarlos. **'End-of-central-directory signature not found'** Esto casi siempre significa que tu archivo ZIP está corrupto o incompleto. Compara su tamaño con el de la fuente original e intenta descargarlo de nuevo. Como último recurso, puedes intentar repararlo: `zip -FF corrupted.zip --out repaired.zip` **'Cannot allocate memory' durante unzip** Normalmente, esto no tiene que ver con la RAM, sino con los descriptores de archivo. Un archivo con millones de ficheros pequeños puede agotar el límite del sistema. Aumenta el límite para tu sesión de shell actual con `ulimit -n 65536` y vuelve a intentarlo. **Faltan enlaces simbólicos en el TAR** Si tus enlaces simbólicos se convierten en archivos de texto plano que contienen la ruta del enlace, es posible que estés usando una versión antigua de `unzip` que no los gestiona bien (algunas versiones requerían el flag `-X`). Compruébalo con `unzip -v` y actualiza si tienes una versión anterior a la 6.0. Una alternativa más robusta es usar el módulo `zipfile` de Python, que es excelente para preservar enlaces simbólicos: `python3 -c "import zipfile; zipfile.ZipFile('archive.zip').extractall('extracted/')"`. **Nombres de archivo con espacios que rompen tar** Ah, el clásico problema de los "nombres de archivo con espacios". Esto puede hacer que fallen los comandos `find` sencillos que se usan para arreglar permisos. La forma infalible de manejarlo es con la opción `-print0` de `find` canalizada a `xargs -0`: `find ./extracted_content -type f -print0 | xargs -0 chmod 644` **El archivo es demasiado grande para /tmp** Muchos sistemas configuran `/tmp` como una partición `tmpfs` en la RAM, a menudo limitada a la mitad de tu memoria total. Si tu archivo es enorme, fallará. Puedes decirle a `unzip` que use un directorio temporal diferente en un disco real (`export TMPDIR=/var/tmp`) o, mejor aún, simplemente especificar una ruta de extracción en disco directamente con el flag `-d`. **Timeout de CocoConvert con archivos grandes** Nuestra herramienta web está pensada para ser cómoda, no para archivos masivos. Cualquier cosa por encima de 2 GB probablemente dará timeout. Es un límite estricto para la mayoría de las subidas basadas en navegador. Para trabajos grandes, tienes que usar el método de la línea de comandos.
Elegir la compresión TAR adecuada para tu entorno de servidor
La compresión que usas con TAR no es un simple detalle; afecta a la velocidad de migración, al uso del disco e incluso al rendimiento del servidor durante el despliegue. Aquí te explicamos cómo elegir la correcta. **.tar.gz (gzip)** Es el estándar de la industria por una razón. Ofrece una buena tasa de compresión (normalmente de 3:1 a 5:1 en código), se descomprime rápidamente (un .tar.gz de 1 GB se desempaqueta en unos 15 segundos en un servidor moderno) y es universalmente compatible. ¿Mi consejo? Simplemente usa este. A menos que tengas una razón muy específica y convincente para elegir otra cosa, .tar.gz es la respuesta correcta. **.tar.bz2 (bzip2)** Con este obtendrás un archivo entre un 10-15% más pequeño que con gzip, pero a un coste significativo: la compresión es de 3 a 4 veces más lenta. La descompresión también es más lenta. Es un equilibrio que solo tiene sentido para el archivado a largo plazo donde cada gigabyte cuenta, no para despliegues activos. **.tar.xz (xz/LZMA)** Este ofrece la mejor compresión, a menudo reduciendo el código fuente un 20-30% más que gzip. Pero la descompresión es lenta y consume mucha memoria: un .tar.xz de 500 MB puede consumir fácilmente 700 MB de RAM solo para desempaquetarse. Deberías evitarlo para las migraciones, especialmente si estás desplegando en un servidor con recursos limitados. **.tar (sin compresión)** No comprimas lo que ya está comprimido. Si tu archivo está lleno de imágenes JPEG, vídeos MP4 o volcados de bases de datos ya comprimidos, envolverlo en gzip es solo un desperdicio de ciclos de CPU para un beneficio de tamaño casi nulo. En este caso, un .tar simple es la opción más eficiente. Para casi cualquier migración relacionada con la web (aplicaciones PHP, proyectos de Node.js o bases de código de Python), .tar.gz es el camino a seguir. Es lo que esperan herramientas de despliegue como Capistrano, Deployer y el módulo unarchive de Ansible, y logra el equilibrio perfecto entre velocidad, tamaño y compatibilidad. Si estás haciendo una conversión puntual y no quieres complicarte con los flags de la línea de comandos, el [conversor de ZIP a TAR de CocoConvert](/convert/zip-to-tar) te da las opciones más prácticas (.tar, .tar.gz y .tar.bz2) directamente en el navegador. Es un buen atajo cuando solo necesitas que el trabajo esté hecho.