Compartir comentarios
Las respuestas se generan en base a la documentación.

Contenedorizar una aplicación

Tabla de contenidos

Durante el resto de esta guía, trabajarás con un sencillo administrador de lista de tareas pendientes que se ejecuta en Node.js. Si no estás familiarizado con Node.js, no te preocupes. Esta guía no requiere experiencia previa con JavaScript.

Prerrequisitos

Obtener la aplicación

Antes de poder ejecutar la aplicación, debes obtener el código fuente de la aplicación en tu máquina.

  1. Clona el repositorio getting-started-app con el siguiente comando:

    $ git clone https://github.com/docker/getting-started-app.git

  2. Observa el contenido del repositorio clonado. Deberías ver los siguientes archivos y subdirectorios.

    ├── getting-started-app/
│ ├── .dockerignore
│ ├── package.json
│ ├── package-lock.json   
│ ├── README.md
│ ├── spec/
│ ├── src/

Compilar la imagen de la aplicación

Para compilar la imagen, necesitarás usar un Dockerfile. Un Dockerfile es simplemente un archivo de texto sin extensión que contiene un script con instrucciones. Docker utiliza este script para compilar una imagen de contenedor.

  1. En el directorio getting-started-app, en la misma ubicación que el archivo package.json, crea un archivo llamado Dockerfile con el siguiente contenido:

    # syntax=docker/dockerfile:1

FROM node:24-alpine
WORKDIR /app
COPY . .
RUN npm install --omit=dev
CMD ["node", "src/index.js"]
EXPOSE 3000

    Este Dockerfile hace lo siguiente:

    • Utiliza node:24-alpine como imagen base, una imagen ligera de Linux con Node.js preinstalado.
    • Establece /app como el directorio de trabajo.
    • Copia el código fuente en la imagen.
    • Instala las dependencias necesarias.
    • Especifica el comando para iniciar la aplicación.
    • Documenta que la aplicación escucha en el puerto 3000.

  2. Compila la imagen utilizando los siguientes comandos:

    En la terminal, asegúrate de estar en el directorio getting-started-app. Reemplaza /path/to/getting-started-app con la ruta a tu directorio getting-started-app.

    $ cd /path/to/getting-started-app

    Compila la imagen:

    $ docker build -t getting-started .

    El comando docker build utiliza el Dockerfile para compilar una nueva imagen. Es posible que hayas notado que Docker descargó muchas "capas". Esto se debe a que le indicaste al constructor que querías comenzar desde la imagen node:24-alpine. Pero, como no la tenías en tu máquina, Docker tuvo que descargar la imagen.

    Después de que Docker descargara la imagen, las instrucciones del Dockerfile copiaron tu aplicación y utilizaron npm para instalar las dependencias de tu aplicación.

    Finalmente, la bandera -t etiqueta tu imagen. Piensa en esto como un nombre legible por humanos para la imagen final. Dado que llamaste a la imagen getting-started, puedes hacer referencia a ella cuando ejecutes un contenedor.

    El punto . al final del comando docker build le indica a Docker que debe buscar el Dockerfile en el directorio actual.

Iniciar un contenedor de la aplicación

Ahora que tienes una imagen, puedes ejecutar la aplicación en un contenedor utilizando el comando docker run.

  1. Ejecuta tu contenedor utilizando el comando docker run y especifica el nombre de la imagen que acabas de crear:

    $ docker run -d -p 127.0.0.1:3000:3000 getting-started

    La bandera -d (abreviatura de --detach) ejecuta el contenedor en segundo plano. Esto significa que Docker inicia tu contenedor y te devuelve al indicador de la terminal. Además, no muestra los registros (logs) en la terminal.

    La bandera -p (abreviatura de --publish) crea un mapeo de puertos entre el host y el contenedor. La bandera -p toma un valor de cadena en el formato HOST:CONTENEDOR, donde HOST es la dirección en el host y CONTENEDOR es el puerto en el contenedor. El comando publica el puerto 3000 del contenedor en 127.0.0.1:3000 (localhost:3000) en el host. Sin el mapeo de puertos, no podrías acceder a la aplicación desde el host.

  2. Después de unos segundos, abre tu navegador web en http://localhost:3000. Deberías ver tu aplicación.

    Lista de tareas vacía

  3. Agrega un elemento o dos y comprueba que funciona como esperas. Puedes marcar los elementos como completados y eliminarlos. Tu frontend está almacenando correctamente los elementos en el backend.

En este punto, tienes un administrador de lista de tareas en ejecución con algunos elementos.

Si echas un vistazo rápido a tus contenedores, deberías ver al menos un contenedor en ejecución que utiliza la imagen getting-started en el puerto 3000. Para ver tus contenedores, puedes usar la CLI o la interfaz gráfica de Docker Desktop.

Ejecuta el comando docker ps en una terminal para enumerar tus contenedores.

$ docker ps

Debería aparecer una salida similar a la siguiente.

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                      NAMES
df784548666d        getting-started     "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes        127.0.0.1:3000->3000/tcp   priceless_mcclintock

En Docker Desktop, selecciona la pestaña Containers para ver una lista de tus contenedores.

Docker Desktop con el contenedor get-started en ejecución

Resumen

En esta sección, aprendiste los conceptos básicos sobre cómo crear un Dockerfile para compilar una imagen. Una vez compilada la imagen, iniciaste un contenedor y viste la aplicación en ejecución.

Información relacionada:

Siguientes pasos

A continuación, realizarás una modificación en tu aplicación y aprenderás cómo actualizar tu aplicación en ejecución con una nueva imagen. En el camino, aprenderás algunos otros comandos útiles.

Actualizar la aplicación