Docker Export Import

Exportar/importar contenedores

La funcionalidad de export e import en Docker permite transferir el sistema de archivos completo de un contenedor entre diferentes entornos sin necesidad de utilizar un registry. Este método resulta especialmente útil cuando necesitas mover contenedores modificados o cuando trabajas en entornos sin acceso a Docker Hub o registries privados.

Exportar contenedores con docker export

El comando docker export captura todo el filesystem de un contenedor en ejecución o detenido y lo empaqueta en un archivo tar. A diferencia de las imágenes, esta operación incluye únicamente el estado actual del sistema de archivos, perdiendo información como el historial de capas, metadatos de la imagen original y configuraciones como CMD o ENTRYPOINT.

docker export CONTENEDOR > archivo.tar

Ejemplo práctico con MySQL:

# Crear y configurar un contenedor MySQL
docker run -d --name mysql-config \
  -e MYSQL_ROOT_PASSWORD=mi_password \
  -e MYSQL_DATABASE=mi_app \
  mysql:8.0

# Esperar a que se inicialice y realizar cambios
docker exec mysql-config mysql -uroot -pmi_password \
  -e "CREATE TABLE mi_app.usuarios (id INT, nombre VARCHAR(50));"

# Exportar el contenedor modificado
docker export mysql-config > mysql-configurado.tar

El archivo resultante contiene todo el filesystem del contenedor, incluyendo las modificaciones realizadas después de su creación.

Importar filesystem con docker import

El comando docker import crea una nueva imagen a partir de un archivo tar exportado previamente. La imagen resultante tendrá únicamente una capa que contiene todo el filesystem, sin historial ni metadatos originales.

docker import archivo.tar [REPOSITORIO[:TAG]]

Continuando con el ejemplo de MySQL:

# Importar el filesystem como nueva imagen
docker import mysql-configurado.tar mysql-personalizado:v1.0

# Verificar que la imagen se ha creado
docker images mysql-personalizado

Es importante destacar que la imagen importada no tendrá configuraciones como puertos expuestos, variables de entorno o comandos de inicio. Deberás especificarlos manualmente:

# Ejecutar contenedor desde imagen importada
docker run -d --name mysql-importado \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD=mi_password \
  mysql-personalizado:v1.0 \
  mysqld --default-authentication-plugin=mysql_native_password

Casos de uso típicos

La combinación export/import resulta ideal en estas situaciones:

• 1. Migración entre entornos sin registry disponible:

# En servidor de desarrollo
docker export app-desarrollo > app-dev.tar
scp app-dev.tar usuario@produccion:/tmp/

# En servidor de producción
docker import /tmp/app-dev.tar mi-app:produccion

• 2. Backup de contenedores con configuraciones específicas:

# Backup de nginx con configuración personalizada
docker export nginx-config > backup-nginx-$(date +%Y%m%d).tar

• 3. Distribución de contenedores preconfigurados en equipos de desarrollo:

# Crear contenedor base con dependencias
docker run -d --name dev-env ubuntu:22.04
docker exec dev-env apt-get update && apt-get install -y nodejs npm git

# Exportar para el equipo
docker export dev-env > entorno-desarrollo.tar

Limitaciones importantes

El proceso de export/import presenta limitaciones que debes considerar:

• Pérdida de metadatos: CMD, ENTRYPOINT, EXPOSE, ENV y otras directivas del Dockerfile original se pierden
• Sin historial de capas: La imagen resultante tendrá una sola capa, lo que puede afectar la eficiencia del almacenamiento
• Mayor tamaño: Al no aprovechar capas compartidas, los archivos tar suelen ser más grandes
• Pérdida de tags: Las etiquetas de la imagen original no se preservan

Por estas razones, export/import es más adecuado para casos específicos donde necesitas el estado exacto del filesystem de un contenedor, mientras que para la distribución general de aplicaciones es preferible usar docker save/load con imágenes o subir a un registry.

Save/load de imágenes

Los comandos docker save y docker load permiten archivar y restaurar imágenes completas manteniendo toda su información estructural. A diferencia de export/import que trabaja con filesystem de contenedores, estos comandos preservan el historial de capas, metadatos, tags y toda la configuración original de la imagen.

Guardar imágenes con docker save

El comando docker save empaqueta una o múltiples imágenes en un archivo tar, conservando todas las capas intermedias, metadatos del Dockerfile y configuraciones como CMD, ENTRYPOINT, EXPOSE y variables de entorno.

docker save -o archivo.tar IMAGEN[:TAG]

Ejemplo con imagen de nginx:

# Guardar una imagen específica con tag
docker save -o nginx-stable.tar nginx:stable

# Guardar múltiples imágenes en un solo archivo
docker save -o web-stack.tar nginx:latest mysql:8.0 redis:7.0

# Usar redirección en lugar de -o
docker save nginx:stable > nginx-backup.tar

La ventaja principal es que el archivo resultante mantiene la estructura de capas, lo que permite aprovechar las capas compartidas al cargar la imagen posteriormente.

Guardar todas las versiones de una imagen:

# Guardar todos los tags de MySQL
docker save mysql > mysql-complete.tar

# Verificar el contenido del archivo
tar -tf mysql-complete.tar | head -10

Cargar imágenes con docker load

El comando docker load restaura imágenes desde un archivo tar creado con docker save, reconstruyendo exactamente la misma estructura de capas y metadatos originales.

docker load -i archivo.tar

Ejemplo de restauración:

# Cargar imagen desde archivo
docker load -i nginx-stable.tar

# Usar redirección
docker load < nginx-backup.tar

# Verificar que la imagen se cargó correctamente
docker images nginx
docker inspect nginx:stable

Al cargar la imagen, todas las configuraciones originales quedan intactas, incluyendo puertos expuestos, variables de entorno y comandos de inicio.

Flujo completo con PostgreSQL

Escenario práctico: transferir una imagen personalizada de PostgreSQL entre servidores de desarrollo.

# En servidor origen - guardar imagen personalizada
docker save -o postgres-custom.tar postgres:15-alpine

# Transferir archivo (ejemplo con scp)
scp postgres-custom.tar usuario@servidor-destino:/tmp/

# En servidor destino - cargar imagen
docker load -i /tmp/postgres-custom.tar

# Verificar disponibilidad y ejecutar
docker run -d --name db-app \
  -e POSTGRES_PASSWORD=secreto \
  -p 5432:5432 \
  postgres:15-alpine

Ventajas de save/load vs export/import

El enfoque save/load presenta beneficios significativos frente a export/import:

• 1. Preservación completa de metadatos:

# La imagen cargada mantiene todas las configuraciones
docker inspect mysql:8.0 | grep -A5 "Config"
# Muestra: Cmd, Env, ExposedPorts, etc. intactos

• 2. Optimización de almacenamiento mediante capas compartidas:

# Múltiples imágenes comparten capas base
docker save -o lamp-stack.tar mysql:8.0 php:8.1-apache
# El archivo será más pequeño que exportar contenedores individuales

• 3. Mantenimiento de tags y versionado:

# Los tags se preservan automáticamente
docker load -i nginx-backup.tar
docker images nginx  # Muestra todos los tags originales

Casos de uso empresariales

La funcionalidad save/load es especialmente útil en:

• 1. Distribución de imágenes personalizadas sin registry:

# Crear paquete de imágenes para despliegue offline
docker save -o aplicacion-v2.tar \
  mi-app:v2.0 \
  nginx:stable \
  postgres:15

• 2. Backup de imágenes críticas:

# Backup programado de imágenes de producción
docker save $(docker images --format "{{.Repository}}:{{.Tag}}" | grep -v "<none>") \
  -o backup-images-$(date +%Y%m%d).tar

• 3. Migración entre entornos aislados:

# Preparar paquete para entorno sin internet
docker save -o migration-pack.tar \
  registry.interno/app:latest \
  mysql:8.0 \
  redis:7.0

Diferencias clave con export/import

Es fundamental entender cuándo usar cada método:

| Aspecto | docker save/load | docker export/import | |---------|------------------|---------------------| | Origen | Imágenes completas | Filesystem de contenedor | | Capas | Preserva estructura | Crea una sola capa | | Metadatos | Conserva todo | Pierde configuraciones | | Tags | Mantiene tags | Requiere especificar nuevo tag | | Tamaño | Optimizado por capas | Potencialmente mayor | | Uso típico | Distribución de imágenes | Snapshot de contenedores modificados |

Recomendación práctica: utiliza docker save/load para distribuir imágenes estándar y docker export/import únicamente cuando necesites capturar el estado específico de un contenedor modificado.