Docker para Principiantes: Contenedores, Imágenes y Docker Compose [Guía 2026]

En el vertiginoso mundo del desarrollo y la administración de sistemas, la eficiencia y la portabilidad son pilares fundamentales. Aquí es donde Docker emerge como una herramienta revolucionaria. Esta docker guía completa está diseñada para principiantes y usuarios de Linux que buscan dominar los fundamentos de la contenerización. Exploraremos qué es Docker, cómo funciona y por qué se ha convertido en un estándar de la industria. Aprenderá los conceptos clave como contenedores Docker e imágenes, y cómo orquestar aplicaciones multicontenedor con Docker Compose. Este docker tutorial le proporcionará las bases para construir, desplegar y gestionar sus aplicaciones de forma ágil y robusta para el año 2026 y más allá.

Docker vs. máquinas virtuales: una comparación esencial

Antes de sumergirnos en los detalles de Docker, es crucial entender cómo se diferencia de una tecnología de virtualización más tradicional: las máquinas virtuales (VMs). Ambas ofrecen aislamiento y recursos dedicados, pero lo hacen de maneras fundamentalmente distintas, lo que repercute en su rendimiento, eficiencia y casos de uso.

¿Qué son las máquinas virtuales (VMs)?

Una máquina virtual es una emulación de un sistema informático que puede ejecutar un sistema operativo completo. Requiere un hipervisor (como VMware, VirtualBox o KVM) que se instala directamente sobre el hardware (Tipo 1) o sobre un sistema operativo anfitrión (Tipo 2). Cada VM incluye su propio sistema operativo huésped completo (kernel, librerías, aplicaciones), lo que las hace pesadas y lentas de iniciar. Proporcionan un aislamiento total a nivel de hardware, lo que es ideal para ejecutar sistemas operativos diferentes o para entornos de alta seguridad donde la separación completa es prioritaria.

¿Qué son los contenedores Docker?

Los contenedores Docker, por otro lado, operan a un nivel superior. En lugar de virtualizar el hardware, virtualizan el sistema operativo. Comparten el kernel del sistema operativo anfitrión (Linux en este caso), lo que los hace increíblemente ligeros y rápidos. Un contenedor solo empaqueta la aplicación y sus dependencias, no un sistema operativo completo. Esta arquitectura significa que múltiples contenedores pueden ejecutarse en un único host Docker sin la sobrecarga de un sistema operativo duplicado en cada uno. El aislamiento se logra a través de características del kernel de Linux como cgroups y namespaces, que limitan y separan los recursos y los procesos de cada contenedor. Esta eficiencia los convierte en la opción preferida para microservicios y despliegues ágiles.

Característica	Máquinas Virtuales (VMs)	Contenedores Docker
Abstracción	Hardware	Sistema Operativo
Sistema Operativo Huésped	Completo por cada VM	Comparten el kernel del SO anfitrión
Tamaño	Gigabytes (pesadas)	Megabytes (ligeras)
Tiempo de Inicio	Minutos	Segundos o milisegundos
Aislamiento	Fuerte (a nivel de hardware)	Medio (a nivel de proceso, comparte kernel)
Portabilidad	Necesita hipervisor compatible	Alta (ejecuta en cualquier Docker Host)
Casos de Uso	Ejecutar SOs diferentes, entornos de alta seguridad, consolidación de servidores.	Microservicios, desarrollo y pruebas consistentes, CI/CD, despliegues rápidos.

En resumen, si bien las VMs ofrecen una separación completa, los contenedores Docker sobresalen en agilidad, eficiencia y portabilidad, haciendo de ellos la opción dominante para el desarrollo y despliegue de aplicaciones modernas. Esta flexibilidad es clave para cualquier profesional que busque optimizar sus flujos de trabajo en Linux.

Anatomía de Docker: entendiendo su arquitectura

Para trabajar eficazmente con Docker, es fundamental comprender cómo sus componentes interactúan entre sí. La arquitectura de Docker sigue un modelo cliente-servidor, donde un cliente Docker se comunica con un demonio Docker, y ambos interactúan con registros para gestionar imágenes.

El demonio Docker (dockerd)

El corazón de Docker es el demonio Docker, también conocido como dockerd. Este proceso en segundo plano se ejecuta en el sistema operativo anfitrión y es responsable de construir, ejecutar y distribuir los contenedores Docker. Es el que gestiona los objetos de Docker como imágenes, contenedores, redes y volúmenes. Cuando usted envía un comando Docker (por ejemplo, docker run), el cliente Docker se comunica con este demonio para ejecutar la operación.

El cliente Docker

El cliente Docker es la interfaz principal con la que interactúan los usuarios. Cuando ejecuta un comando docker en su terminal, este comando es interpretado por el cliente Docker, que luego envía las solicitudes al demonio Docker a través de una API REST. El cliente y el demonio pueden residir en la misma máquina o en máquinas diferentes, lo que permite gestionar hosts Docker remotos. Esta separación facilita la administración centralizada y la automatización.

Registros de Docker (Docker Registry)

Un registro de Docker es un repositorio centralizado para almacenar y distribuir imágenes Docker. El registro público más conocido es Docker Hub, que contiene una vasta colección de imágenes preconfiguradas que puede usar. También puede configurar registros privados para almacenar sus propias imágenes de forma segura. Cuando ejecuta un comando docker pull, el cliente indica al demonio que obtenga una imagen del registro. Cuando usa docker push, el demonio envía su imagen construida al registro.

Imágenes Docker

Una imagen Docker es una plantilla de solo lectura que contiene las instrucciones para crear un contenedor. Es un paquete estático que incluye el código de una aplicación, un entorno de ejecución (como Node.js o Python), bibliotecas, herramientas del sistema y configuraciones. Las imágenes son la base de los contenedores y son inmutables: una vez creadas, no se modifican. En su lugar, se crean nuevas imágenes a partir de cambios. Por ejemplo, una imagen puede contener Ubuntu, Apache y su aplicación web. Puede pensar en una imagen como la "clase" y el contenedor como la "instancia" de esa clase.

Contenedores Docker

Un contenedor Docker es una instancia ejecutable de una imagen. Cuando ejecuta una imagen, se crea un contenedor. Un contenedor es un proceso aislado que incluye todo lo necesario para ejecutar la aplicación que define la imagen. Es portátil, ligero y puede ejecutarse de forma consistente en cualquier entorno que tenga Docker instalado. Los contenedores pueden iniciarse, detenerse, moverse y eliminarse. Son la unidad fundamental de ejecución en el ecosistema Docker y el verdadero motor que da vida a sus aplicaciones.

Consejo: piense en Docker como un sistema de paquetes altamente eficiente para entornos de ejecución. Las imágenes son los instaladores y los contenedores son las instalaciones vivas y aisladas.

Comandos esenciales de Docker para principiantes

Dominar Docker comienza con la familiarización de sus comandos CLI (Command Line Interface). Estos comandos le permiten interactuar con el demonio Docker para gestionar imágenes, contenedores y otros recursos. Aquí le presentamos 10 comandos fundamentales que todo principiante debe conocer para empezar su docker tutorial.

1. docker pull [nombre_imagen]:[etiqueta]
   Este comando descarga una imagen de un registro (por defecto, Docker Hub) a su máquina local. Si no se especifica una etiqueta (tag), por defecto se descargará la imagen con la etiqueta latest.

   docker pull ubuntu:22.04

2. docker run [opciones] [nombre_imagen]:[etiqueta] [comando]
   El comando run es uno de los más utilizados. Primero, si la imagen no existe localmente, Docker la descargará (como con pull). Luego, crea un nuevo contenedor a partir de esa imagen y lo inicia. Opciones comunes incluyen -p para mapear puertos, -d para ejecutar en segundo plano (detached mode), y --name para asignar un nombre al contenedor.

   docker run -d -p 80:80 --name mi_servidor_web nginx:latest

3. docker build -t [nombre_imagen]:[etiqueta] [ruta_contexto]
   Este comando construye una imagen Docker a partir de un Dockerfile y un contexto (generalmente el directorio actual .). La opción -t se usa para etiquetar la imagen con un nombre y una etiqueta para su fácil identificación.

   docker build -t mi_aplicacion_node:1.0 .

4. docker ps [opciones]
   Lista los contenedores en ejecución. Usando -a o --all, mostrará todos los contenedores, incluyendo los que están detenidos. Es fundamental para ver el estado y los ID de sus contenedores.

   docker ps -a

5. docker stop [id_o_nombre_contenedor]
   Detiene uno o más contenedores en ejecución. Envía una señal SIGTERM al proceso principal del contenedor, esperando que este se cierre de forma elegante.

   docker stop mi_servidor_web

6. docker rm [id_o_nombre_contenedor]
   Elimina uno o más contenedores. Solo se pueden eliminar contenedores detenidos. Para eliminar un contenedor en ejecución, primero debe detenerlo o usar la opción -f (force), aunque esta última no es recomendable en producción.

   docker rm mi_servidor_web

7. docker exec -it [id_o_nombre_contenedor] [comando]
   Ejecuta un comando dentro de un contenedor en ejecución. La opción -it es comúnmente utilizada para obtener una sesión interactiva (shell) dentro del contenedor.

   docker exec -it mi_servidor_web bash

8. docker logs [opciones] [id_o_nombre_contenedor]
   Muestra los logs (salida estándar y de error) de un contenedor. La opción -f (follow) permite seguir los logs en tiempo real, similar a tail -f.

   docker logs -f mi_servidor_web

9. docker inspect [id_o_nombre_contenedor_o_imagen]
   Devuelve información detallada de bajo nivel sobre un objeto Docker (contenedor, imagen, volumen, red). Es útil para depuración y para entender la configuración interna.

   docker inspect mi_servidor_web

10. docker stats [id_o_nombre_contenedor]
    Muestra un flujo en vivo de métricas de uso de recursos para uno o más contenedores, incluyendo CPU, memoria, E/S de red y disco. Es una herramienta valiosa para monitorear el rendimiento.

    docker stats

Consejo: siempre intente detener y eliminar contenedores antes de eliminarlos. Esto previene errores y asegura una limpieza adecuada. Use docker system prune para limpiar recursos no utilizados (contenedores detenidos, redes, imágenes sin usar).

Creando imágenes personalizadas con Dockerfile

El Dockerfile es un archivo de texto simple que contiene una serie de instrucciones que el demonio Docker utiliza para construir una imagen. Es la receta para crear sus entornos de aplicación personalizados. Aprender las instrucciones clave de Dockerfile es esencial para cualquier docker guía avanzada.

Instrucciones clave del Dockerfile

• FROM [imagen_base]:[etiqueta]
  Define la imagen base sobre la cual se construirá la nueva imagen. Cada Dockerfile debe comenzar con esta instrucción.

  FROM node:18-alpine

• RUN [comando]
  Ejecuta cualquier comando en una nueva capa sobre la imagen actual y commitea el resultado. Es ideal para instalar paquetes, crear directorios, o configurar el entorno durante el proceso de construcción de la imagen. Se pueden encadenar múltiples comandos con && para reducir el número de capas.

  RUN apk add --no-cache curl && mkdir /app

• COPY [origen] [destino]
  Copia archivos o directorios desde la ruta de origen de su sistema local (el contexto de construcción) al sistema de archivos del contenedor en la ruta de destino.

  COPY ./package.json /app/

• ADD [origen] [destino]
  Similar a COPY, pero con capacidades adicionales: puede extraer archivos comprimidos automáticamente y copiar desde URLs remotas. Sin embargo, se prefiere COPY por su simplicidad y seguridad, salvo que necesite estas características avanzadas.

  ADD https://ejemplo.com/archivo.tar.gz /tmp/

• WORKDIR [ruta]
  Establece el directorio de trabajo para las instrucciones RUN, CMD, ENTRYPOINT, COPY y ADD que le sigan. Si el directorio no existe, se creará.

  WORKDIR /app

• ENV [clave]=[valor]
  Establece variables de entorno dentro del contenedor. Estas variables pueden ser utilizadas por la aplicación dentro del contenedor y pueden ser accedidas durante la ejecución.

  ENV NODE_ENV=production

• EXPOSE [puerto]
  Documenta qué puertos están siendo expuestos por el contenedor en tiempo de ejecución. No publica el puerto automáticamente; es una declaración de intención. Para publicar el puerto, debe usar la opción -p con docker run o configurarlo en Docker Compose.

  EXPOSE 3000

• CMD [comando]
  Define el comando por defecto que se ejecutará cuando un contenedor se inicie a partir de la imagen. Solo puede haber una instrucción CMD por Dockerfile; si especifica más de una, solo la última tendrá efecto. Puede ser sobrescrito por un comando pasado a docker run.

  CMD ["node", "server.js"]

• ENTRYPOINT [comando]
  Define el comando principal que se ejecutará al iniciar el contenedor. A diferencia de CMD, ENTRYPOINT no se sobrescribe fácilmente y siempre se ejecuta. Los argumentos pasados a docker run se añaden al ENTRYPOINT. Es útil para envolver la aplicación en un script de entrada, por ejemplo.

  ENTRYPOINT ["/usr/bin/supervisord"]

Un Dockerfile bien estructurado es clave para construir imágenes eficientes y seguras. Al optimizar las capas y el orden de las instrucciones, se pueden reducir los tiempos de construcción y el tamaño final de la imagen.

Orquestación con Docker Compose para aplicaciones multicontenedor

Las aplicaciones modernas a menudo consisten en múltiples servicios interconectados: una base de datos, un backend API, un frontend web, un sistema de cache, etc. Gestionar estos contenedores individualmente puede volverse complejo. Aquí es donde Docker Compose brilla, permitiéndole definir y ejecutar aplicaciones multicontenedor con un solo archivo y un solo comando. Es una parte fundamental de cualquier docker guía para desarrollo.

¿Qué es Docker Compose?

Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker de múltiples contenedores. Utiliza un archivo YAML para configurar los servicios de su aplicación, sus redes y volúmenes. Con un solo comando, docker compose up, puede iniciar toda su aplicación, con todos sus servicios funcionando y comunicándose entre sí. Esto simplifica enormemente el ciclo de vida de desarrollo, pruebas y despliegue.

Sintaxis básica de Docker Compose (docker-compose.yml)

El archivo docker-compose.yml es el corazón de Docker Compose. Aquí se define la estructura de su aplicación. Veamos un ejemplo común: una aplicación Node.js con una base de datos PostgreSQL.

version: '3.8' # Especifica la versión de Docker Compose file format

services:
  web:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app # Monta el directorio actual del host en /app dentro del contenedor
    environment:
      DATABASE_URL: postgres://user:password@db:5432/mydatabase
    depends_on:
      - db
    networks:
      - app-network

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db-data:/var/lib/postgresql/data # Volumen persistente para los datos de la base de datos
    networks:
      - app-network

volumes:
  db-data: # Define un volumen con nombre para los datos de la DB

networks:
  app-network: # Define una red personalizada para los servicios
    driver: bridge

• version: La versión del formato de archivo Compose.
• services: Define los diferentes componentes (contenedores) de su aplicación.
  • web: Nuestro servicio de aplicación Node.js.
    • build: .: Indica a Docker Compose que construya una imagen a partir del Dockerfile en el directorio actual.
    • ports: - "3000:3000": Mapea el puerto 3000 del host al puerto 3000 del contenedor web.
    • volumes: - .:/app: Crea un volumen de tipo bind mount, sincronizando el código fuente local con el contenedor.
    • environment: Pasa variables de entorno al contenedor.
    • depends_on: - db: Indica que el servicio web depende del servicio db. Docker Compose intentará iniciar db primero.
    • networks: - app-network: Asigna el servicio a la red personalizada.
  • db: Nuestro servicio de base de datos PostgreSQL.
    • image: postgres:13: Utiliza una imagen preexistente de Docker Hub.
    • environment: Configura las variables de entorno para PostgreSQL.
    • volumes: - db-data:/var/lib/postgresql/data: Monta un volumen con nombre para la persistencia de los datos de la base de datos.
• volumes: Define los volúmenes con nombre que se usarán para la persistencia de datos.
• networks: Define las redes personalizadas para la comunicación entre servicios.

Consejo: use siempre versiones específicas de imágenes (ej. postgres:13 en lugar de postgres:latest) para asegurar la reproducibilidad de su entorno.

Gestión de datos persistentes con Docker Volumes

Los contenedores son efímeros por naturaleza: cuando se elimina un contenedor, todos los datos que contiene se pierden. Para la persistencia de datos, Docker ofrece volúmenes:

• Volúmenes con nombre (Named Volumes): Son la forma preferida de persistir datos generados y utilizados por los contenedores Docker. Son gestionados por Docker y se crean en una ubicación específica del sistema de archivos del host que Docker administra. Son fáciles de respaldar y migrar. En el ejemplo anterior, db-data es un volumen con nombre.
• Montajes de Bind (Bind Mounts): Permiten mapear un archivo o directorio del sistema de archivos del host directamente dentro del contenedor. Son útiles para el desarrollo, ya que permiten que el código fuente del host se refleje instantáneamente en el contenedor sin necesidad de reconstruir la imagen. El - .:/app en el ejemplo es un bind mount.

Para aprender más sobre cómo la organización de contenido influye en la visibilidad y el rendimiento de tu sitio, te invitamos a explorar nuestra guía sobre qué es la autoridad temática, un concepto clave en SEO semántico, que también aplica a cómo estructuramos los volúmenes para optimizar el acceso a los datos de Docker.

Redes Docker

Docker proporciona diferentes drivers de red para conectar contenedores. Los más comunes son:

• bridge (por defecto): Crea una red privada interna entre contenedores en un mismo host. Los contenedores en esta red pueden comunicarse entre sí usando sus nombres de servicio (ej. web puede comunicarse con db usando el hostname db). Para acceder a la aplicación desde fuera de la red, se deben mapear puertos al host. Es el driver más común para aplicaciones Compose.
• host: El contenedor comparte la pila de red del host, lo que significa que no hay aislamiento de red entre el host y el contenedor. Si la aplicación en el contenedor escucha en el puerto 8000, estará disponible directamente en el puerto 8000 del host. Esto puede mejorar el rendimiento, pero reduce el aislamiento.
• overlay: Utilizado para orquestación de clústeres (como Docker Swarm), permite que contenedores en diferentes hosts Docker se comuniquen entre sí como si estuvieran en la misma red.

Comprender y configurar las redes y volúmenes es crucial para construir aplicaciones robustas y escalables con Docker Compose. Al definir una red personalizada como app-network, se asegura que solo los servicios deseados puedan comunicarse entre sí de forma segura.

Consolida tus conocimientos en Linux y Virtualización

Si esta guía te ha parecido útil y deseas profundizar en el mundo de la administración de sistemas, la virtualización y la contenerización, nuestro Curso de Administración de Servidores Linux es tu próximo paso. Aprende las mejores prácticas y técnicas avanzadas para gestionar infraestructuras con confianza.

Ver Curso

Registros de imágenes: Docker Hub y registros privados

Una vez que ha construido sus imágenes Docker, necesita un lugar para almacenarlas y compartirlas. Los registros de imágenes Docker son repositorios donde se guardan estas imágenes, permitiendo que cualquiera con los permisos adecuados las descargue y las use. Esta sección de la docker guía explora las dos opciones principales: Docker Hub y los registros privados.

Docker Hub: el registro público predeterminado

Docker Hub es el servicio de registro y repositorio predeterminado que utiliza Docker. Es una plataforma en la nube operada por Docker Inc. y es el hogar de millones de imágenes públicas. Aquí puede encontrar:

• Imágenes oficiales: Imágenes verificadas y mantenidas por los proveedores de software (ej. ubuntu, nginx, node, postgres). Son la base de la mayoría de los Dockerfiles.
• Imágenes de la comunidad: Creadas y compartidas por usuarios individuales y organizaciones. Pueden variar en calidad y mantenimiento.
• Sus propias imágenes: Puede publicar sus imágenes públicas de forma gratuita o almacenar imágenes privadas con una suscripción.

Docker Hub facilita la distribución de imágenes y es una excelente fuente de imágenes base. Su uso es intuitivo con los comandos docker pull y docker push.

# Acceder a Docker Hub
docker login

# Subir una imagen (después de construirla y etiquetarla)
docker push mi_usuario/mi_imagen:1.0

Registros privados: control y seguridad

Aunque Docker Hub es conveniente, para entornos empresariales o para manejar información sensible, es común utilizar registros privados. Un registro privado puede ser una instancia de un servicio de registro ejecutándose en sus propios servidores o una solución ofrecida por proveedores de la nube (ej. Amazon ECR, Google Container Registry, Azure Container Registry). Las ventajas de usar un registro privado incluyen:

• Seguridad: Control total sobre quién tiene acceso a sus imágenes y dónde se almacenan. Es crucial para el cumplimiento de normativas de seguridad y privacidad.
• Rendimiento: Si su infraestructura está cerca del registro privado, las operaciones de pull/push pueden ser más rápidas.
• Personalización: Puede integrar el registro con sus sistemas de CI/CD y gestión de usuarios existentes.
• Aislamiento: Evita exponer imágenes propietarias o sensibles al público, incluso si se marcan como privadas en Docker Hub, la infraestructura sigue siendo compartida.

Configurar un registro privado implica más trabajo inicial, pero ofrece un nivel de control y seguridad indispensable para muchas organizaciones. La elección entre Docker Hub y un registro privado dependerá de sus requisitos de seguridad, cumplimiento y la escala de sus operaciones. Los principios del SEO semántico también se aplican a cómo se estructuran y se accede a los repositorios de imágenes, facilitando la identificación y el uso de los recursos correctos.

Consejo: para entornos de producción, la combinación de un registro privado y un sistema robusto de CI/CD es la mejor práctica para la gestión de imágenes Docker.

Ejemplo práctico: contenerizando una aplicación Node.js

Para solidificar los conceptos aprendidos en esta docker guía, vamos a ver un ejemplo práctico: contenerizar una sencilla aplicación web Node.js. Esto le mostrará cómo se combinan Dockerfile, imágenes y contenedores en un flujo de trabajo real.

Paso 1: Crear la aplicación Node.js

Primero, cree un directorio para su proyecto y dentro de él, cree un archivo app.js y un package.json.

app.js:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('¡Hola desde mi aplicación Dockerizada con Node.js!');
});

app.listen(port, () => {
  console.log(`Aplicación escuchando en http://localhost:${port}`);
});

package.json:

{
  "name": "docker-node-app",
  "version": "1.0.0",
  "description": "Simple Node.js app for Docker tutorial",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

Instale las dependencias localmente (opcional, Docker lo hará):

npm install

Paso 2: Crear el Dockerfile

Ahora, en el mismo directorio raíz del proyecto, cree un archivo llamado Dockerfile (sin extensión):

# Utiliza la imagen base de Node.js
FROM node:18-alpine

# Establece el directorio de trabajo dentro del contenedor
WORKDIR /app

# Copia los archivos package.json y package-lock.json (si existe)
# Esto permite que Docker use el caché de capas si solo cambian los archivos fuente, no las dependencias
COPY package.json ./

# Instala las dependencias de la aplicación
RUN npm install

# Copia el resto del código de la aplicación
COPY . .

# Expone el puerto en el que la aplicación Node.js escucha
EXPOSE 3000

# Define el comando para iniciar la aplicación
CMD ["npm", "start"]

Cree también un archivo .dockerignore para excluir archivos innecesarios de la imagen, como node_modules local:

node_modules
.git
npm-debug.log

Paso 3: Construir la imagen Docker

Abra su terminal en el directorio de su proyecto y ejecute el siguiente comando para construir la imagen:

docker build -t mi-app-node:1.0 .

El -t mi-app-node:1.0 etiqueta su imagen con el nombre mi-app-node y la versión 1.0. El . al final indica que el contexto de construcción es el directorio actual.

Paso 4: Ejecutar la aplicación en un contenedor

Una vez que la imagen ha sido construida, puede ejecutar un contenedor a partir de ella:

docker run -p 3000:3000 --name mi-contenedor-node mi-app-node:1.0

• -p 3000:3000: Mapea el puerto 3000 de su máquina host al puerto 3000 dentro del contenedor.
• --name mi-contenedor-node: Asigna un nombre amigable a su contenedor.
• mi-app-node:1.0: Especifica la imagen de la que se creará el contenedor.

Ahora puede abrir su navegador y visitar http://localhost:3000. ¡Debería ver el mensaje "¡Hola desde mi aplicación Dockerizada con Node.js!"!

Paso 5: Gestión del contenedor

Para ver su contenedor en ejecución:

docker ps

Para detener el contenedor:

docker stop mi-contenedor-node

Para eliminar el contenedor (una vez detenido):

docker rm mi-contenedor-node

Este ejemplo demuestra el ciclo completo de contenerización de una aplicación, desde la creación del código hasta su ejecución en un contenedor aislado. La simplicidad y repetibilidad de este proceso son las razones principales por las que Docker es tan valioso en el desarrollo moderno. Para entender cómo se estructura este tipo de contenido para ser encontrado fácilmente en buscadores, es útil conocer qué son las entidades SEO y cómo se relacionan entre sí en un ecosistema digital.

Consejo: para aplicaciones más complejas con bases de datos u otros servicios, use Docker Compose para definir y gestionar todos los contenedores de su aplicación en un solo archivo.