Dos formas de aislar una aplicación
Cuando alguien te dice que “lo tiene en un servidor aislado”, puede referirse a dos tecnologías muy distintas. Por un lado está la máquina virtual, que simula un ordenador completo con su propio firmware, su disco virtual y su sistema operativo. Por otro está el contenedor, que no simula nada: es un proceso normal de Linux al que el kernel le ofrece una vista restringida del sistema. Ambas resuelven el problema clásico de “en mi máquina funciona”, pero lo hacen con costes, garantías y ritmos de trabajo muy diferentes.
En este tutorial vamos a comparar las dos opciones con comandos reales, no solo con diagramas. Levantaremos una máquina virtual con KVM y QEMU, ejecutaremos la misma aplicación en un contenedor con Docker Engine y la orquestaremos con Compose v2. Mediremos el arranque, el consumo de memoria y el tamaño en disco, y observaremos desde el propio anfitrión qué hay realmente debajo de cada abstracción. Al final tendrás un criterio claro para decidir cuándo usar cada tecnología y cuándo combinarlas.
Sobre las versiones: la rama estable actual de Docker Engine es la 29, y las ramas de Compose v2 se invocan con el subcomando docker compose (con espacio, no con guion). En el lado de la virtualización, QEMU publica la serie 11 y libvirt la serie 12. Los comandos del artículo funcionan con esas generaciones; cuando una forma antigua esté obsoleta, lo indicaré. Los ejemplos asumen una distribución Linux de escritorio o servidor reciente, como Ubuntu 26.04 LTS o Debian estable, con un usuario con permisos de sudo.
Qué hay debajo de cada abstracción
Antes de teclear, conviene tener claro el modelo mental. Una máquina virtual se apoya en un hypervisor, que es el componente encargado de repartir CPU, memoria y dispositivos entre los sistemas invitados. Existen dos familias. El hypervisor de tipo 1, o bare-metal, se ejecuta directamente sobre el hardware y ofrece el mejor rendimiento. El de tipo 2 corre como una aplicación más dentro de un sistema operativo anfitrión y es más cómodo para un portátil. KVM es un caso peculiar: es un módulo del propio kernel Linux que convierte al sistema en un hypervisor de tipo 1, mientras QEMU aporta la emulación de dispositivos y libvirt la capa de gestión.
Dentro de una VM corre un kernel completo e independiente. Eso significa que puedes ejecutar un Windows sobre un anfitrión Linux, o un Linux antiguo sobre uno moderno, porque el invitado no depende del kernel del anfitrión. El precio es que cada máquina arrastra su sistema operativo entero: procesos de arranque, servicios, caché de disco, gestor de paquetes y todo lo demás.
Un contenedor funciona al revés. No hay segundo kernel: todos los contenedores de un host comparten el mismo kernel que el sistema anfitrión. Lo que cambia es lo que cada proceso puede ver y consumir. Dos mecanismos del kernel hacen el trabajo:
- Los namespaces separan lo que un proceso percibe: sus identificadores de proceso, sus interfaces de red, sus puntos de montaje, el nombre de host, la comunicación entre procesos y los usuarios.
- Los cgroups limitan y contabilizan lo que un proceso puede gastar: CPU, memoria, operaciones de disco y número de procesos.
A esto se suma un sistema de archivos por capas que ensambla la imagen del contenedor, y un conjunto de filtros de seguridad (capacidades, seccomp y perfiles de AppArmor o SELinux) que recortan lo que el proceso puede pedirle al kernel. Docker no inventó nada de esto; empaquetó estas piezas con una interfaz sencilla y un formato de imagen portable.
Preparar el laboratorio
Para seguir los ejemplos necesitas un equipo con virtualización por hardware activada en la BIOS o UEFI. Comprueba que tu procesador la expone:
egrep -c '(vmx|svm)' /proc/cpuinfo
Si el resultado es mayor que cero, tu CPU soporta virtualización. Instala la pila de KVM en una distribución basada en Debian con estos paquetes:
sudo apt update
sudo apt install -y qemu-system-x86 libvirt-daemon-system libvirt-clients virtinst cloud-image-utils
sudo usermod -aG libvirt,kvm "$USER"
Cierra y abre la sesión para que se apliquen los grupos. Verifica que el módulo del kernel está cargado y que el servicio responde:
lsmod | grep kvm
virsh list --all
Para Docker, usa el repositorio oficial de Docker Engine en lugar del paquete que traiga tu distribución, que suele ir retrasado. Una vez añadido el repositorio según la documentación de tu sistema, instala el motor, la CLI, containerd, buildx y el plugin de Compose:
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
docker version
docker compose version
Fíjate en que Compose ya no es un binario aparte llamado docker-compose con sintaxis de Python: es un plugin de la CLI, y la versión 1 está retirada. Si encuentras tutoriales antiguos con el comando con guion, sustitúyelo por docker compose. Además, el campo version en los archivos YAML de Compose es hoy obsoleto y se puede omitir.
Si quieres una guía introductoria más pausada sobre cómo construir y lanzar tu primera aplicación, puedes consultar Docker paso a paso: construye, ejecuta y despliega tu primera app, que complementa lo que haremos aquí.
Primera prueba: una VM con KVM y libvirt
Vamos a crear una máquina virtual Debian con una imagen cloud, que es el modo moderno de aprovisionar VMs sin pasar por un instalador gráfico. Descargamos una imagen qcow2 oficial y creamos un disco derivado para no tocar la original:
mkdir -p ~/lab/vm && cd ~/lab/vm
qemu-img create -f qcow2 -F qcow2 -b debian-base.qcow2 vm-web.qcow2 10G
qemu-img info vm-web.qcow2
El formato qcow2 ya anticipa una idea que veremos en Docker: un disco base de solo lectura y una capa de escritura encima. Ahora preparamos un archivo de configuración inicial para crear un usuario y una clave SSH:
#cloud-config
hostname: vm-web
users:
- name: lab
sudo: ALL=(ALL) NOPASSWD:ALL
shell: /bin/bash
ssh_authorized_keys:
- ssh-ed25519 AAAA...tu-clave-publica
package_update: true
packages:
- nginx
Genera la imagen de configuración y lanza la VM con virt-install:
cloud-localds seed.img user-data.yaml
virt-install \
--name vm-web \
--memory 2048 --vcpus 2 \
--disk path=vm-web.qcow2 \
--disk path=seed.img,device=cdrom \
--os-variant debian12 \
--import --network network=default \
--graphics none --noautoconsole
Tras unos segundos tendrás un servidor completo. Consulta su estado y su dirección:
virsh list
virsh domifaddr vm-web
Id Nombre Estado
------------------------
1 vm-web ejecutando
Nombre Dirección MAC Protocolo Dirección
vnet0 52:54:00:ab:cd:ef ipv4 192.168.122.45/24
Conéctate por SSH y comprueba que dentro hay un sistema operativo completo, con su propio kernel:
ssh [email protected] 'uname -r; free -m; systemctl is-active nginx'
Anota tres datos de esta prueba: el tiempo que tarda en responder el SSH (normalmente entre quince y cuarenta segundos), la memoria que consume el invitado en reposo (varios cientos de megas, incluso sin hacer nada) y el tamaño del disco derivado. Puedes ver este último así:
du -h vm-web.qcow2
Segunda prueba: el mismo servicio en un contenedor
Ahora replicamos el servidor web, pero con Docker. Un único comando descarga la imagen y arranca el proceso:
docker run -d --name web-ct -p 8080:80 nginx:stable-alpine
docker ps
curl -s -o /dev/null -w "%{http_code}\n" localhost:8080
El arranque es casi instantáneo, normalmente por debajo de un segundo una vez descargada la imagen. Compara el consumo de recursos con el de la VM:
docker stats --no-stream web-ct
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O
3f1a9c2b7d10 web-ct 0.00% 4.2MiB / 15.6GiB 0.03% 1.1kB / 0B
Unos pocos megabytes frente a cientos. Y el tamaño de la imagen, pequeño gracias a la distribución mínima en la que se basa:
docker images nginx
Es importante entender el motivo de esta diferencia: dentro del contenedor no hay init, ni servicios de sistema, ni kernel. Solo corre el proceso de nginx y los archivos que necesita. Si quieres inspeccionar el contenedor desde dentro, la herramienta adecuada es docker exec, que se explica a fondo en la guía completa de docker exec para ejecutar comandos en contenedores.
Cómo comprobar que un contenedor es solo un proceso
La mejor manera de desmitificar los contenedores es mirarlos desde el anfitrión. Pídele a Docker el identificador del proceso principal y busca ese proceso con las herramientas habituales:
docker inspect --format '{{.State.Pid}}' web-ct
ps -fp $(docker inspect --format '{{.State.Pid}}' web-ct)
Verás un proceso de nginx perteneciente a tu máquina, con un PID normal. Si lanzas ps aux en el anfitrión, aparecerá en la lista junto con todo lo demás. Dentro del contenedor, sin embargo, ese mismo proceso se ve como el PID 1. Esa es la magia de los namespaces. Puedes enumerarlos para el proceso:
sudo ls -l /proc/$(docker inspect --format '{{.State.Pid}}' web-ct)/ns
lrwxrwxrwx 1 root root 0 cgroup -> 'cgroup:[4026532561]'
lrwxrwxrwx 1 root root 0 ipc -> 'ipc:[4026532559]'
lrwxrwxrwx 1 root root 0 mnt -> 'mnt:[4026532557]'
lrwxrwxrwx 1 root root 0 net -> 'net:[4026532562]'
lrwxrwxrwx 1 root root 0 pid -> 'pid:[4026532560]'
lrwxrwxrwx 1 root root 0 uts -> 'uts:[4026532558]'
Cada número identifica un espacio de nombres distinto del que usa tu shell. Para jugar sin Docker, crea tu propio aislamiento mínimo con la utilidad unshare, que revela que el contenedor es una función del kernel y no de una herramienta concreta:
sudo unshare --pid --fork --mount-proc --uts --net bash
hostname laboratorio
ps aux
ip link
exit
Dentro de esa shell solo verás tus propios procesos y una interfaz de red vacía. Es un contenedor rudimentario sin imagen, sin límites y sin seguridad adicional, pero demuestra el principio.
Cgroups: poner límites a un contenedor
El aislamiento de vista no impide que un proceso se coma toda la memoria del equipo. De eso se encargan los cgroups. En Docker se aplican con opciones de docker run, y con ellos se establecen límites de memoria y CPU estrictos:
docker run -d --name api-limitada \
--memory 256m --memory-swap 256m \
--cpus 0.5 --pids-limit 100 \
nginx:stable-alpine
Comprueba que el kernel lo ha registrado. En sistemas con cgroups v2, que es lo habitual hoy, los archivos viven en una jerarquía unificada:
docker inspect --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}}' api-limitada
cat /sys/fs/cgroup/system.slice/docker-$(docker inspect --format '{{.Id}}' api-limitada).scope/memory.max
268435456 500000000
268435456
Si la aplicación supera esos 256 MiB, el kernel la termina con el famoso OOM kill. Puedes forzarlo con una prueba controlada y consultar el estado:
docker run --rm --memory 64m python:3-slim python -c "x = bytearray(200*1024*1024)"
echo $?
137
El código de salida 137 indica una terminación por la señal 9, que es el rastro típico de un proceso sacrificado por falta de memoria. En una VM el equivalente es asignar memoria al invitado al crearlo, pero el límite es rígido: el invitado verá exactamente esa RAM y su propio kernel decidirá qué hacer cuando se agote.
Imágenes, capas y el sistema de archivos de unión
Una imagen de contenedor no es un disco entero, sino una pila de capas de solo lectura. Cada capa contiene las diferencias respecto a la anterior, y al arrancar un contenedor se añade encima una capa fina de escritura. Si dos imágenes comparten la misma base, esa base se almacena una sola vez. Puedes ver las capas de una imagen con su historial:
docker history nginx:stable-alpine
Y comprobar dónde las guarda el motor en el disco:
docker info --format '{{.Driver}} {{.DockerRootDir}}'
overlayfs /var/lib/docker
En instalaciones nuevas, Docker usa por defecto el almacén de imágenes de containerd con el snapshotter overlayfs, y la idea es la misma que el disco derivado qcow2 que creamos para la VM: lo común se comparte y lo que cambia se escribe aparte. Esa estrategia de copiar al escribir explica por qué lanzar veinte contenedores de la misma imagen apenas consume más espacio que lanzar uno.
Hay una consecuencia práctica: lo que escribes dentro de un contenedor desaparece cuando lo eliminas. Compruébalo:
docker run --name efimero alpine sh -c 'echo dato > /tmp/nota.txt'
docker rm efimero
docker run --rm alpine cat /tmp/nota.txt
La segunda ejecución falla porque el archivo no existe en la imagen. Con el tiempo, además, acumularás imágenes antiguas y capas huérfanas que ocupan gigas; para mantener el disco bajo control, repasa la guía completa de limpieza de imágenes de Docker.
Dockerfile: la receta reproducible
En el mundo de las VM, la reproducibilidad se logra con herramientas de aprovisionamiento o con imágenes doradas. En el mundo de los contenedores, la receta es el Dockerfile. Cada instrucción genera una capa, así que el orden importa para aprovechar la caché. Veamos una aplicación de ejemplo en Python, una pequeña API de inventario:
inventario/
├── Dockerfile
├── compose.yaml
├── requirements.txt
└── app.py
from flask import Flask, jsonify
app = Flask(__name__)
@app.get("/salud")
def salud():
return jsonify(estado="ok")
@app.get("/articulos")
def articulos():
return jsonify([{"id": 1, "nombre": "teclado"}, {"id": 2, "nombre": "monitor"}])
Y un Dockerfile con buenas prácticas actuales: una imagen de base mínima, dependencias antes del código para cachear, un usuario sin privilegios y una instrucción de comprobación de salud:
FROM python:3-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
WORKDIR /srv
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt gunicorn
COPY app.py .
RUN useradd --system --uid 10001 appuser
USER appuser
EXPOSE 8000
HEALTHCHECK --interval=15s --timeout=3s \
CMD python -c "import urllib.request as u; u.urlopen('http://localhost:8000/salud')"
CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
Construye la imagen con BuildKit, que es el constructor por defecto, y observa cómo la segunda compilación reutiliza capas:
docker build -t inventario:1.0 .
docker build -t inventario:1.0 .
La segunda ejecución marca casi todos los pasos como en caché. Si modificas solo app.py y vuelves a construir, únicamente se rehacen las capas posteriores a esa copia. Por eso el archivo de dependencias se copia antes que el código. Una VM no ofrece nada parecido: reconstruir una imagen de disco entera por un cambio de una línea sería inasumible.
Construcción multi etapa
Para lenguajes compilados, o cuando necesitas herramientas de compilación que no quieres en producción, usa varias etapas. La primera compila y la segunda solo recibe el resultado:
FROM golang:1.25 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /out/servicio ./cmd/servicio
FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /out/servicio /servicio
ENTRYPOINT ["/servicio"]
El resultado final puede pesar apenas unos megas, sin shell ni gestor de paquetes, lo que reduce la superficie de ataque. La etiqueta de la imagen de Go del ejemplo es ilustrativa: usa la versión estable que tengas en tu proyecto.
Volúmenes y persistencia de datos
Como la capa de escritura del contenedor es efímera, los datos que importan deben vivir fuera. Docker ofrece dos mecanismos principales: los bind mounts, que montan una carpeta concreta del anfitrión, y los volúmenes gestionados por Docker. Para una base de datos conviene usar volúmenes con nombre porque el motor se encarga de su ubicación y permisos:
docker volume create datos-pg
docker run -d --name pg \
-e POSTGRES_PASSWORD=cambiar-esto \
-v datos-pg:/var/lib/postgresql \
postgres:17
Destruye el contenedor, vuelve a crearlo y comprueba que la información sigue ahí:
docker rm -f pg
docker run -d --name pg2 -e POSTGRES_PASSWORD=cambiar-esto -v datos-pg:/var/lib/postgresql postgres:17
docker volume inspect datos-pg
Para desarrollo, un bind mount de solo lectura sobre el código evita reconstruir la imagen en cada cambio:
docker run --rm -v "$PWD":/srv:ro -p 8000:8000 inventario:1.0
En la VM, la persistencia es la contraria: el disco virtual conserva todo por defecto, y lo difícil es hacer que sea reproducible y desechable. Esta diferencia filosófica es una de las más importantes: la VM se trata como una mascota que se cuida, mientras el contenedor se trata como ganado que se reemplaza.
Una nota práctica sobre las versiones de PostgreSQL: desde la rama 18 de la imagen oficial, la ruta de datos recomendada cambió respecto a las anteriores. Comprueba la documentación de la imagen que uses antes de decidir el punto de montaje.
Compose v2: varios servicios, un archivo
Las aplicaciones reales raramente son un solo proceso. Compose describe en un archivo YAML todos los servicios, redes y volúmenes, y los levanta con un comando. Este es el archivo compose.yaml para nuestro proyecto con una API y una base de datos:
name: inventario
services:
api:
build: .
image: inventario:1.0
ports:
- "8000:8000"
environment:
DATABASE_URL: postgresql://app:${DB_PASS}@db:5432/inventario
depends_on:
db:
condition: service_healthy
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
db:
image: postgres:17
environment:
POSTGRES_USER: app
POSTGRES_PASSWORD: ${DB_PASS}
POSTGRES_DB: inventario
volumes:
- datos:/var/lib/postgresql
healthcheck:
test: ["CMD-SHELL", "pg_isready -U app -d inventario"]
interval: 5s
timeout: 3s
retries: 10
volumes:
datos:
Guarda la contraseña en un archivo .env que no subas al repositorio y arranca todo:
echo "DB_PASS=una-clave-larga-y-aleatoria" > .env
docker compose up -d --build
docker compose ps
docker compose logs -f api
NAME SERVICE STATUS PORTS
inventario-api-1 api Up 12 seconds (healthy) 0.0.0.0:8000->8000/tcp
inventario-db-1 db Up 18 seconds (healthy)
Los comandos que usarás a diario con Compose v2 son pocos: docker compose up -d para levantar, docker compose down para parar y eliminar, docker compose down -v para eliminar también los volúmenes, docker compose pull para actualizar imágenes y docker compose config para validar y ver el archivo final con las variables resueltas. Dentro de la red que crea Compose, los servicios se encuentran por su nombre, así que la API se conecta a db sin conocer ninguna dirección IP.
Reproducir esto con máquinas virtuales requeriría dos VM, una red entre ellas, un gestor de configuración y bastante más tiempo de arranque. Es posible, y a veces necesario, pero el flujo de trabajo es más pesado.
Comparativa directa con números
Con lo que hemos construido, podemos poner las diferencias en una tabla mental. Los valores son aproximados y dependen del hardware, pero el orden de magnitud es consistente:
- Arranque: una VM necesita de decenas de segundos a minutos; un contenedor, menos de un segundo o unos pocos.
- Memoria en reposo: una VM Linux mínima consume cientos de megas; un contenedor de un servicio simple, unos pocos megas.
- Disco: una imagen de VM ocupa cientos de megas a varios gigas; una imagen de contenedor, de unos pocos megas a unos cientos.
- Densidad: en un mismo servidor caben decenas de VM, pero cientos o miles de contenedores.
- Kernel: la VM trae el suyo; el contenedor usa el del anfitrión.
- Sistemas invitados: la VM puede ser Windows, BSD o cualquier Linux; el contenedor Linux solo ejecuta aplicaciones Linux sobre el kernel del host.
- Portabilidad: la VM se mueve como imagen de disco; el contenedor, como imagen en un registro con etiquetas y firmas.
- Actualización: la VM se parchea in situ o se reemplaza entera; el contenedor se reconstruye y se sustituye.
Puedes verificar el arranque con una medición sencilla en tu propio equipo:
time docker run --rm alpine true
real 0m0.412s
user 0m0.021s
sys 0m0.018s
Y compararlo con el tiempo hasta obtener respuesta SSH de la VM. La diferencia será tan clara que no necesitarás gráficos.
Un detalle sobre Docker Desktop en Windows y macOS: allí los contenedores Linux se ejecutan dentro de una máquina virtual ligera, porque esos sistemas no tienen kernel Linux. Es decir, en tu portátil de trabajo es habitual que ambas tecnologías convivan sin que lo notes. En un servidor Linux, en cambio, no hay capa intermedia.
Seguridad: dónde está la frontera
Aquí está la diferencia más importante para decidir. En una VM, la frontera de aislamiento es el hypervisor y el hardware virtual; escapar de ella exige una vulnerabilidad en el hypervisor o en un dispositivo emulado, algo raro y muy valioso. En un contenedor, la frontera es el kernel compartido: una vulnerabilidad del kernel explotable desde un proceso sin privilegios puede dar acceso al anfitrión y a los demás contenedores. Por eso, cuando varios inquilinos que no se fían entre sí comparten una máquina, la VM sigue siendo la opción más prudente.
Eso no significa que los contenedores sean inseguros. Significa que hay que endurecerlos. Estas son las medidas con mejor relación esfuerzo-beneficio, que se pueden aplicar directamente en la línea de comandos:
docker run -d --name seguro \
--user 10001:10001 \
--read-only --tmpfs /tmp \
--cap-drop ALL \
--security-opt no-new-privileges:true \
--pids-limit 100 --memory 256m \
inventario:1.0
Cada opción cierra una vía de ataque concreta:
--userevita ejecutar el proceso como root dentro del contenedor.--read-onlyimpide que un atacante modifique el sistema de archivos del contenedor, y--tmpfsofrece un espacio temporal en memoria.--cap-drop ALLelimina las capacidades de Linux que el proceso no necesita; añade solo las imprescindibles con--cap-add.no-new-privilegesbloquea la escalada mediante binarios con setuid.- Los límites de procesos y memoria frenan ataques de agotamiento de recursos.
Más reglas que conviene respetar: no montes el socket de Docker dentro de un contenedor, porque equivale a entregar el control root del anfitrión; evita --privileged salvo que sepas con precisión por qué lo necesitas; no publiques puertos de bases de datos hacia el exterior; y fija las imágenes por versión o por resumen en lugar de usar siempre la etiqueta latest. Además, escanea las imágenes en busca de vulnerabilidades conocidas como parte de tu integración continua, y considera el modo sin root de Docker o alternativas como Podman cuando el modelo de amenazas lo exija.
Para cargas que necesitan el aislamiento de una VM con la rapidez de un contenedor existen runtimes como gVisor o Kata Containers, que interponen un kernel de usuario o una micro VM por contenedor. Son una opción intermedia que merece la pena conocer cuando ejecutas código de terceros.
Cuándo elegir cada tecnología
Después de ver ambas en funcionamiento, el criterio se reduce a unas cuantas preguntas.
Elige una máquina virtual cuando:
- Necesites un sistema operativo distinto al del anfitrión, como Windows, o un kernel concreto con módulos propios.
- Alojes cargas de clientes distintos que no deben compartir kernel.
- Ejecutes software heredado que espera un sistema completo, con servicios de init, varios procesos y configuración a mano.
- Quieras reproducir un entorno de pruebas de sistema operativo, de redes o de arranque.
- Tengas requisitos de cumplimiento normativo que exijan una separación fuerte entre cargas.
Elige un contenedor cuando:
- Despliegues aplicaciones modernas, servicios web, APIs o trabajos por lotes que cambian a menudo.
- Necesites entornos de desarrollo idénticos para todo el equipo, y pruebas en integración continua rápidas y desechables.
- Quieras alta densidad y escalado rápido, con arranques casi instantáneos.
- Busques una arquitectura de microservicios con despliegues independientes.
- Prefieras infraestructura inmutable, donde se reemplaza en lugar de reparar.
Y combina ambas cuando tenga sentido, que es lo más habitual en producción. Los servicios en la nube ejecutan los contenedores sobre máquinas virtuales: la VM aporta la frontera fuerte entre clientes y el contenedor aporta la agilidad para tus despliegues. Los clústeres de Kubernetes funcionan así, con nodos que son VM y cargas que son contenedores.
Un caso práctico real: una pequeña empresa tiene un servidor con un ERP antiguo para Windows y varias aplicaciones web propias en Linux. La solución razonable es una VM para el ERP, con su sistema invitado y su copia de seguridad de disco, y un host Linux con Docker Compose para las aplicaciones web, desplegadas desde un repositorio con integración continua. Cada tecnología hace lo que mejor sabe hacer.
Errores comunes al pasar de VM a contenedores
Quien viene del mundo de las máquinas virtuales suele arrastrar hábitos que se vuelven problemas con contenedores. Estos son los más frecuentes:
- Tratar el contenedor como una VM pequeña: instalar SSH dentro, ejecutar varios servicios con un supervisor y entrar a editar archivos a mano. Lo correcto es un proceso por contenedor, configuración por variables y cambios mediante una nueva imagen.
- Guardar datos dentro de la capa de escritura. Cuando se recrea el contenedor, desaparecen. Usa volúmenes.
- Usar siempre la etiqueta latest, lo que hace que dos despliegues distintos obtengan versiones distintas sin avisar. Fija versiones.
- Imágenes enormes por copiar todo el proyecto, incluidas carpetas de dependencias y archivos de control de versiones. Crea un archivo
.dockerignorey usa construcción multi etapa. - Ejecutar como root por comodidad, con los problemas de seguridad que ya vimos.
- Olvidar los límites de recursos, de forma que un contenedor con una fuga de memoria derriba todo el servidor.
- Confiar en
depends_onsin comprobaciones de salud: arrancar antes no es lo mismo que estar listo.
El archivo de exclusión para nuestro proyecto de ejemplo podría ser tan simple como este:
.git
__pycache__
*.pyc
.env
venv
Diagnóstico: cuando algo no funciona
Cuando un contenedor no se comporta, sigue un orden fijo. Primero comprueba si está en ejecución y por qué terminó, después lee sus registros y finalmente inspecciona su configuración:
docker ps -a
docker logs --tail 50 inventario-api-1
docker inspect inventario-api-1 --format '{{.State.ExitCode}} {{.State.OOMKilled}}'
docker events --since 10m
Si la salida muestra OOMKilled en verdadero, necesitas más memoria o corregir una fuga. Si el código de salida es 1 inmediatamente tras arrancar, el error suele estar en la aplicación o en una variable de entorno que falta. Para ver el consumo en tiempo real usa docker stats, y para abrir una shell de depuración en un contenedor vivo, docker exec -it.
En la VM, el diagnóstico equivalente pasa por la consola serie, los registros del invitado y las herramientas de libvirt:
virsh console vm-web
virsh dominfo vm-web
virsh domstats vm-web --cpu-total --balloon
Y para recuperar espacio y tareas pendientes cuando terminas de experimentar, elimina todo lo creado en este laboratorio:
docker compose down -v
docker rm -f web-ct api-limitada seguro pg2
docker volume rm datos-pg
virsh destroy vm-web
virsh undefine vm-web --remove-all-storage
Antes de ejecutar los comandos de borrado, repasa los nombres: down -v elimina los volúmenes y con ellos los datos de la base, y undefine --remove-all-storage borra el disco de la VM sin posibilidad de recuperarlo.
Rendimiento y operación en producción
En rendimiento puro, una VM con KVM y controladores paravirtualizados (virtio) se acerca mucho al hardware real, y la diferencia con un contenedor es pequeña en cálculo. Donde se nota la distancia es en la sobrecarga fija: memoria reservada por invitado, arranque y densidad. En entradas y salidas de disco, un contenedor con overlayfs añade algo de coste en archivos pequeños; para cargas intensivas de escritura, como una base de datos, monta un volumen y evita escribir en la capa del contenedor.
Algunas recomendaciones de operación que conviene aplicar desde el principio:
- Registra la salida de los procesos por la salida estándar y recógela con el driver de logs que prefieras, con rotación para que los archivos no llenen el disco.
- Añade comprobaciones de salud a todos los servicios y una política de reinicio.
- Etiqueta cada imagen con la versión o el identificador de la confirmación de código que la generó.
- Haz copias de seguridad de los volúmenes, no de los contenedores. En las VM, en cambio, las instantáneas del disco sí son una herramienta de recuperación habitual.
- Automatiza la construcción y el escaneo de imágenes en la integración continua, y despliega siempre desde un registro.
- Mantén el anfitrión actualizado: en contenedores, el parche del kernel protege a todos los servicios a la vez, y en VM tendrás que parchear cada invitado.
Si tu aplicación crece y necesitas repartirla entre varias máquinas, el siguiente paso natural es un orquestador como Kubernetes o Docker Swarm. Antes de dar ese salto, asegúrate de que tus imágenes ya son reproducibles, sin estado local y con configuración externa, porque el orquestador amplifica tanto los buenos hábitos como los malos.
Conclusiones
Las máquinas virtuales y los contenedores no compiten tanto como se suele pensar: resuelven niveles distintos del mismo problema. La VM virtualiza el hardware y ofrece una frontera de seguridad fuerte y libertad para elegir sistema operativo, a cambio de más memoria, más disco y arranques más lentos. El contenedor virtualiza el sistema operativo, comparte el kernel y gana en velocidad, densidad y reproducibilidad, a cambio de una frontera más delgada que hay que reforzar a conciencia.
Lo que hemos hecho en este tutorial muestra por qué ocurre así. Un contenedor es un proceso con namespaces que acotan lo que ve y cgroups que acotan lo que consume. Sus imágenes son capas compartidas que se reconstruyen en segundos gracias a la caché del Dockerfile, sus datos persistentes viven en volúmenes y sus servicios se describen en un archivo de Compose v2 que cualquiera de tu equipo puede levantar con un comando. Una VM, en cambio, es un sistema completo con su propio kernel, ideal cuando necesitas otro sistema operativo, aislamiento entre inquilinos o compatibilidad con software heredado.
Mi recomendación práctica: empieza por contenedores para tus aplicaciones, aplica siempre las medidas de endurecimiento básicas (usuario sin privilegios, capacidades mínimas, sistema de archivos de solo lectura, límites de recursos) y reserva las máquinas virtuales para aquello que realmente las necesita o para actuar como frontera exterior bajo tus contenedores. Con ese criterio, y con los comandos de este artículo a mano, podrás medir en tu propio entorno en lugar de decidir por intuición.
