Docker: qué es, cómo funciona y diferencias con VM y Kubernetes

Si alguna vez has trabajado en desarrollo de software, seguramente te has enfrentado al clásico problema: «En mi máquina funciona perfectamente, pero en producción no» (parece chiste, pero es anécdota). Esta frase ha atormentado a desarrolladores durante años, hasta que apareció Docker.

Docker es una tecnología que ha transformado la forma en que desarrollamos, desplegamos y ejecutamos aplicaciones. Gracias a la virtualización por contenedores, ahora podemos garantizar que nuestras aplicaciones se ejecuten de manera consistente en cualquier entorno, sin importar si estamos en desarrollo, pruebas o producción.

Hoy te explicaré de manera clara y sencilla qué es, cómo funciona su arquitectura, y cuáles son las diferencias fundamentales entre las máquinas virtuales (VM) y Kubernetes.

¿Qué es Docker?

Imagina un puerto donde llegan barcos con carga. Antes, cada barco traía su mercancía empaquetada de manera diferente: sacos sueltos, barriles, cajas de todos los tamaños, lo que hacía que cargar y descargar tomara semanas porque cada puerto necesitaba equipos y métodos distintos.

Luego llegaron los contenedores estándar: cajas metálicas del mismo tamaño donde puedes meter cualquier cosa. Ahora, cualquier grúa puede mover cualquier contenedor, y un contenedor cargado en un puerto funciona perfectamente en cualquier otro puerto del mundo.

Así funciona: empaqueta tu aplicación con todo lo que necesita dentro de un «contenedor digital» estándar, y ese contenedor funciona exactamente igual en tu computadora, en el servidor de pruebas o en la nube de producción, sin importar las diferencias entre estos entornos.

En el desarrollo tradicional, cuando querías trabajar con un proyecto, debías instalar todas las dependencias, configurar el entorno, y asegurarte de que todo estuviera exactamente como lo necesitaba la aplicación. Esto consume tiempo, recursos y genera problemas de compatibilidad.

Docker facilita la creación, implementación y ejecución de aplicaciones mediante contenedores. Pero esto nos lleva a la siguiente pregunta: ¿qué es exactamente un contenedor?

Definición de Contenedor

Un contenedor es un entorno ligero, aislado y portable que contiene todo lo necesario para ejecutar una aplicación: código fuente, dependencias, bibliotecas, variables de entorno y configuraciones. Los contenedores suelen tener un único proceso en ejecución, aunque es posible ejecutar varios.

La gran ventaja de los contenedores es que garantizan que una aplicación se ejecute de la misma manera en cualquier entorno, ya sea en tu computadora local, en un servidor de pruebas o en la nube.

graph TB
    subgraph "Aplicación Tradicional"
        A1["Servidor Físico/VM"] --> A2["Sistema Operativo Completo"]
        A2 --> A3["Runtime & Dependencias"]
        A3 --> A4["Bibliotecas"]
        A4 --> A5["Aplicación 1"]
        
        A2 --> B3["Runtime & Dependencias"]
        B3 --> B4["Bibliotecas"]
        B4 --> B5["Aplicación 2"]
        
        A2 --> C3["Runtime & Dependencias"]
        C3 --> C4["Bibliotecas"]
        C4 --> C5["Aplicación 3"]
    end
    
    subgraph "Aplicación en Contenedor"
        D1["Servidor Físico/VM"] --> D2["Sistema Operativo Host"]
        D2 --> D3["Docker Engine"]
        
        D3 --> E1["Contenedor 1"]
        E1 --> E2["Runtime & Dependencias"]
        E2 --> E3["Bibliotecas"]
        E3 --> E4["Aplicación 1"]
        
        D3 --> F1["Contenedor 2"]
        F1 --> F2["Runtime & Dependencias"]
        F2 --> F3["Bibliotecas"]
        F3 --> F4["Aplicación 2"]
        
        D3 --> G1["Contenedor 3"]
        G1 --> G2["Runtime & Dependencias"]
        G2 --> G3["Bibliotecas"]
        G3 --> G4["Aplicación 3"]
    end
    
    style A1 fill:#ffcccc, color: #000000
    style A2 fill:#ffdddd, color: #000000
    style D1 fill:#ccffcc, color: #000000
    style D2 fill:#ddffdd, color: #000000
    style D3 fill:#aaffaa, color: #000000
    style E1 fill:#cce5ff, color: #000000
    style F1 fill:#cce5ff, color: #000000
    style G1 fill:#cce5ff, color: #000000

¿Docker es lo Mismo que una Máquina Virtual?

Esta es una de las preguntas más comunes, pero la respuesta es no. Aunque ambas tecnologías permiten virtualización y aislamiento, funcionan de maneras completamente diferentes.

Máquinas Virtuales (VM)

Las máquinas virtuales representan la forma tradicional de virtualización, donde se virtualiza el hardware completo (CPU, memoria, almacenamiento). Cada máquina virtual ejecuta su propio Guest OS (sistema operativo invitado), con su propio kernel, bibliotecas y aplicaciones.

Esto hace que las VMs sean pesadas, consumiendo gigabytes de espacio y requiriendo varios minutos para arrancar.

Docker y los Contenedores

Docker representa una forma moderna de virtualización a nivel de sistema operativo. En lugar de virtualizar hardware completo, los contenedores comparten el kernel del sistema operativo del host, pero mantienen aisladas sus dependencias, bibliotecas y procesos.

Esto hace que los contenedores sean extremadamente ligeros (ocupan megabytes en lugar de gigabytes) y arranquen en segundos en lugar de minutos.

Tabla Comparativa: Contenedores vs. Máquinas Virtuales

Docker, Máquinas Virtuales y Kubernetes: ¿Cuál Usar?

Ahora que entendemos las diferencias entre contenedores y máquinas virtuales, es importante mencionar Kubernetes (K8s), otra tecnología que frecuentemente se confunde con Docker.

¿Qué es Kubernetes?

Kubernetes es una plataforma de orquestación de contenedores. Te permite trabajar con muchos contenedores, gestionándolos, escalándolos y manteniéndolos automáticamente.

Kubernetes no reemplaza a Docker, sino que lo complementa, especialmente en entornos de producción donde necesitas gestionar cientos o miles de contenedores.

Comparativa: VM, Docker y Kubernetes

graph TB
    subgraph "Desarrollador"
        A["Escribe código"] --> B["Crea Dockerfile"]
    end
    
    subgraph "Docker"
        B --> C["docker build"]
        C --> D["Imagen Docker"]
        D --> E["docker push"]
        E --> F["Docker Registry<br/>(Docker Hub)"]
    end
    
    subgraph "Kubernetes Cluster"
        F --> G["kubectl apply"]
        G --> H["Kubernetes Master<br/>(Control Plane)"]
        
        H --> I["Scheduler"]
        H --> J["API Server"]
        H --> K["Controller Manager"]
        
        I --> L["Nodo 1"]
        I --> M["Nodo 2"]
        I --> N["Nodo 3"]
        
        L --> O["Pod 1<br/>(Contenedor Docker)"]
        L --> P["Pod 2<br/>(Contenedor Docker)"]
        M --> Q["Pod 3<br/>(Contenedor Docker)"]
        M --> R["Pod 4<br/>(Contenedor Docker)"]
        N --> S["Pod 5<br/>(Contenedor Docker)"]
        N --> T["Pod 6<br/>(Contenedor Docker)"]
    end
    
    subgraph "Resultado"
        O -.->|Escalado| U["Aplicación<br/>Distribuida"]
        P -.-> U
        Q -.-> U
        R -.-> U
        S -.-> U
        T -.-> U
    end
    
    style A fill:#e1f5ff, color: #000000
    style D fill:#ffd6a5, color: #000000
    style H fill:#caffbf, color: #000000
    style U fill:#fdffb6, color: #000000

Arquitectura de Docker: Cómo Funciona por Dentro

Para comprender realmente Docker, es esencial conocer su arquitectura y componentes principales.

Componentes Principales

1. Cliente Docker (Docker Client): Es la herramienta con la que el usuario interactúa, ya sea desde la terminal o mediante una API. Cuando ejecutas un comando como docker build o docker run, el cliente lo envía al dockerd.
2. Demonio Docker (Dockerd): Es el proceso principal que ejecuta y gestiona los contenedores. Se encarga de escuchar las peticiones del cliente, gestionar los contenedores, construir y almacenar imágenes, y gestionar redes, volúmenes y plugins. El daemon es el núcleo operativo de Docker y se ejecuta en segundo plano.
3. Docker Registry: Es el repositorio donde se almacenan las imágenes de contenedores. El registro oficial y más popular es Docker Hub, pero también puedes crear registros privados.

Flujo de Trabajo en Docker

El flujo típico de trabajo con Docker sigue estos pasos:

1. El desarrollador escribe un Dockerfile que define la imagen del contenedor
2. Se construye la imagen usando docker build
3. La imagen se puede almacenar en un registry (Docker Hub u otro)
4. Se ejecuta un contenedor basado en esa imagen usando docker run
5. El dockerd gestiona el ciclo de vida del contenedor

graph TD
    A["Desarrollador escribe Dockerfile"] --> B["docker build -t nombre:tag ."]
    B --> C["Docker Client envía comando al Daemon"]
    C --> D["Dockerd lee el Dockerfile"]
    D --> E["Se construye la imagen capa por capa"]
    E --> F["Imagen almacenada localmente"]
    F --> G{"¿Subir a Registry?"}
    G -->|Sí| H["docker push nombre:tag"]
    H --> I["Imagen en Docker Hub/Registry"]
    G -->|No| J["docker run nombre:tag"]
    I --> J
    J --> K["Docker Client solicita ejecución"]
    K --> L["Dockerd crea el contenedor"]
    L --> M["Se aplican namespaces y cgroups"]
    M --> N["Se monta el sistema de archivos UnionFS"]
    N --> O["Container Runtime ejecuta el proceso"]
    O --> P["Contenedor en ejecución"]
    P --> Q{"Estado del contenedor"}
    Q -->|Running| R["Aplicación funcionando"]
    Q -->|Stopped| S["docker stop"]
    Q -->|Removed| T["docker rm"]

Tecnologías base del kernel de Linux que hacen posible Docker

Lo que hace mágico a Docker, son sus tecnologías fundamentales del kernel de Linux que le permiten el aislamiento y la gestión eficiente de recursos.

Namespaces

Los namespaces aíslan los recursos del sistema para cada contenedor, como procesos, red, sistemas de archivos, usuarios, etc. Por ejemplo, un contenedor no puede ver los procesos de otro contenedor, lo que proporciona seguridad y aislamiento.

Control Groups (cgroups)

Los cgroups limitan y asignan recursos como CPU, memoria, disco o red a cada contenedor. Esto evita que un contenedor consuma más recursos de los asignados, garantizando estabilidad en el sistema.

Union File System (UnionFS)

El UnionFS permite que las imágenes se construyan en capas. La ventaja es que múltiples contenedores pueden compartir las mismas capas base, reduciendo el uso de espacio y acelerando las operaciones de construcción y despliegue.

Container Runtime

El container runtime se encarga de ejecutar los contenedores. Docker utiliza containerd y runc como runtimes para la creación y gestión de contenedores ligeros y eficientes.

graph TB
    subgraph "Aplicación"
        A["Aplicación en Contenedor"]
    end
    
    subgraph "Docker Engine"
        B["Docker Daemon (dockerd)"]
        C["containerd"]
        D["runc (Container Runtime)"]
    end
    
    subgraph "Kernel de Linux"
        E["Namespaces"]
        F["cgroups (Control Groups)"]
        G["UnionFS (Sistema de Archivos)"]
        H["Netfilter (iptables)"]
    end
    
    subgraph "Namespaces Específicos"
        E1["PID Namespace<br/>(Aislamiento de Procesos)"]
        E2["Network Namespace<br/>(Aislamiento de Red)"]
        E3["Mount Namespace<br/>(Sistema de Archivos)"]
        E4["User Namespace<br/>(Usuarios y Permisos)"]
        E5["IPC Namespace<br/>(Comunicación entre Procesos)"]
        E6["UTS Namespace<br/>(Hostname)"]
    end
    
    subgraph "cgroups Resources"
        F1["CPU"]
        F2["Memoria"]
        F3["Disco I/O"]
        F4["Red"]
    end
    
    subgraph "Hardware"
        I["CPU Física"]
        J["RAM"]
        K["Disco"]
        L["Interfaz de Red"]
    end
    
    A --> B
    B --> C
    C --> D
    
    D --> E
    D --> F
    D --> G
    D --> H
    
    E --> E1
    E --> E2
    E --> E3
    E --> E4
    E --> E5
    E --> E6
    
    F --> F1
    F --> F2
    F --> F3
    F --> F4
    
    F1 --> I
    F2 --> J
    F3 --> K
    F4 --> L
    
    style A fill:#e1f5ff, color: #000000
    style B fill:#ffd6a5, color: #000000
    style E fill:#caffbf, color: #000000
    style F fill:#ffadad, color: #000000
    style G fill:#fdffb6, color: #000000
    style I fill:#bdb2ff, color: #000000
    style J fill:#bdb2ff, color: #000000
    style K fill:#bdb2ff, color: #000000
    style L fill:#bdb2ff, color: #000000

Conclusión

Si lo analizas bien, es increíble cómo Docker ha cambiado la forma en cómo desarrollamos y desplegamos aplicaciones en diferentes ambientes. Su capacidad para crear entornos portables, ligeros y consistentes lo ha convertido en un arsenal para cualquier desarrollador o equipo de DevOps.

Si estás interesado, te mostraré cómo utilizar Docker en la práctica con ejemplos paso a paso para que puedas crear tus primeros contenedores y haré una guía de los fundamentos de Docker para profundizar en el tema.

¿Tienes dudas o quieres compartir tu experiencia? Cuéntamelo en los comentarios

---

🧠 Aprendizaje continuo | 💻 Frontend + backend curioso | 🎶 Música y baile | 🎮 Videojuegos | ⚡ Productividad en cada paso

Sigueme en mis redes sociales para más contenido

• Facebook
• Twitter
• Instagram
• LinkedIn
• GitHub

---