Contenerizar una aplicación Bun con Docker

NOTE

Esta guía asume que ya tienes [Docker Desktop](https://www.docker.com/products/docker-desktop/) instalado.

Docker es una plataforma para empaquetar y ejecutar una aplicación como un contenedor ligero y portable que encapsula todas las dependencias necesarias.

Para contenerizar nuestra aplicación, definimos un Dockerfile. Este archivo contiene una lista de instrucciones para inicializar el contenedor, copiar nuestros archivos de proyecto locales en él, instalar dependencias e iniciar la aplicación.

docker

# usar la imagen oficial de Bun
# ver todas las versiones en https://hub.docker.com/r/oven/bun/tags
FROM oven/bun:1 AS base
WORKDIR /usr/src/app

# instalar dependencias en directorio temporal
# esto las cacheará y acelerará futuras compilaciones
FROM base AS install
RUN mkdir -p /temp/dev
COPY package.json bun.lock /temp/dev/
RUN cd /temp/dev && bun install --frozen-lockfile

# instalar con --production (excluir devDependencies)
RUN mkdir -p /temp/prod
COPY package.json bun.lock /temp/prod/
RUN cd /temp/prod && bun install --frozen-lockfile --production

# copiar node_modules desde el directorio temporal
# luego copiar todos los archivos del proyecto (no ignorados) en la imagen
FROM base AS prerelease
COPY --from=install /temp/dev/node_modules node_modules
COPY . .

# [opcional] tests y build
ENV NODE_ENV=production
RUN bun test
RUN bun run build

# copiar dependencias de producción y código fuente en la imagen final
FROM base AS release
COPY --from=install /temp/prod/node_modules node_modules
COPY --from=prerelease /usr/src/app/index.ts .
COPY --from=prerelease /usr/src/app/package.json .

# ejecutar la aplicación
USER bun
EXPOSE 3000/tcp
ENTRYPOINT [ "bun", "run", "index.ts" ]

Ahora que tienes tu imagen de docker, veamos .dockerignore que tiene la misma sintaxis que .gitignore, aquí necesitas especificar los archivos/directorios que no deben ir en ninguna etapa de la compilación de docker. Un ejemplo para un archivo de ignorado es:

txt

node_modules
Dockerfile*
docker-compose*
.dockerignore
.git
.gitignore
README.md
LICENSE
.vscode
Makefile
helm-charts
.env
.editorconfig
.idea
coverage*

Ahora usaremos docker build para convertir este Dockerfile en una imagen de Docker, una plantilla autocontenida que contiene todas las dependencias y configuración necesarias para ejecutar la aplicación.

El flag -t nos permite especificar un nombre para la imagen, y --pull le dice a Docker que descargue automáticamente la última versión de la imagen base (oven/bun). La compilación inicial tomará más tiempo, ya que Docker descargará todas las imágenes base y dependencias.

bash

docker build --pull -t bun-hello-world .

txt

[+] Building 0.9s (21/21) FINISHED
 => [internal] load build definition from Dockerfile                                                                                     0.0s
 => => transferring dockerfile: 37B                                                                                                      0.0s
 => [internal] load .dockerignore                                                                                                        0.0s
 => => transferring context: 35B                                                                                                         0.0s
 => [internal] load metadata for docker.io/oven/bun:1                                                                                    0.8s
 => [auth] oven/bun:pull token for registry-1.docker.io                                                                                  0.0s
 => [base 1/2] FROM docker.io/oven/bun:1@sha256:373265748d3cd3624cb3f3ee6004f45b1fc3edbd07a622aeeec17566d2756997                         0.0s
 => [internal] load build context                                                                                                        0.0s
 => => transferring context: 155B                                                                                                        0.0s
 # ...muchos comandos...
 => exporting to image                                                                                                                   0.0s
 => => exporting layers                                                                                                                  0.0s
 => => writing image sha256:360663f7fdcd6f11e8e94761d5592e2e4dfc8d167f034f15cd5a863d5dc093c4                                             0.0s
 => => naming to docker.io/library/bun-hello-world                                                                                       0.0s

Hemos creado una nueva imagen de Docker. Ahora usemos esa imagen para iniciar un contenedor real en ejecución.

Usaremos docker run para iniciar un nuevo contenedor usando la imagen bun-hello-world. Se ejecutará en modo desacoplado (-d) y mapearemos el puerto 3000 del contenedor al puerto 3000 de nuestra máquina local (-p 3000:3000).

El comando run imprime una cadena que representa el ID del contenedor.

docker run -d -p 3000:3000 bun-hello-world

txt

7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d

El contenedor ahora está ejecutándose en segundo plano. Visita localhost:3000. Deberías ver un mensaje Hello, World!.

Para detener el contenedor, usaremos docker stop <container-id>.

docker stop 7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d

Si no puedes encontrar el ID del contenedor, puedes usar docker ps para listar todos los contenedores en ejecución.

docker ps

txt

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
7f03e212a15e        bun-hello-world     "bun run index.ts"       2 minutes ago       Up 2 minutes        0.0.0.0:3000->3000/tcp   flamboyant_cerf

¡Eso es todo! Consulta la documentación de Docker para más uso avanzado.