Containerizzare un'applicazione Bun con Docker

NOTE

Questa guida presuppone che tu abbia già [Docker Desktop](https://www.docker.com/products/docker-desktop/) installato.

Docker è una piattaforma per impacchettare ed eseguire un'applicazione come container leggero e portatile che racchiude tutte le dipendenze necessarie.

Per containerizzare la nostra applicazione, definiamo un Dockerfile. Questo file contiene un elenco di istruzioni per inizializzare il container, copiare i file del progetto locale, installare le dipendenze e avviare l'applicazione.

docker

# usa l'immagine ufficiale Bun
# vedi tutte le versioni su https://hub.docker.com/r/oven/bun/tags
FROM oven/bun:1 AS base
WORKDIR /usr/src/app

# installa le dipendenze nella directory temporanea
# questo le memorizzerà nella cache e accelererà le build future
FROM base AS install
RUN mkdir -p /temp/dev
COPY package.json bun.lock /temp/dev/
RUN cd /temp/dev && bun install --frozen-lockfile

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

# copia node_modules dalla directory temporanea
# poi copia tutti i file del progetto (non ignorati) nell'immagine
FROM base AS prerelease
COPY --from=install /temp/dev/node_modules node_modules
COPY . .

# [opzionale] test & build
ENV NODE_ENV=production
RUN bun test
RUN bun run build

# copia le dipendenze di produzione e il codice sorgente nell'immagine finale
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 .

# esegui l'app
USER bun
EXPOSE 3000/tcp
ENTRYPOINT [ "bun", "run", "index.ts" ]

Ora che hai la tua immagine docker, diamo un'occhiata a .dockerignore che ha la stessa sintassi di .gitignore, qui devi specificare i file/directory che non devono andare in alcuna fase della build docker. Un esempio per un file ignore è

txt

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

Ora useremo docker build per convertire questo Dockerfile in un'immagine Docker, un modello autonomo contenente tutte le dipendenze e la configurazione necessarie per eseguire l'applicazione.

Il flag -t ci consente di specificare un nome per l'immagine e --pull dice a Docker di scaricare automaticamente l'ultima versione dell'immagine base (oven/bun). La build iniziale richiederà più tempo, poiché Docker scaricherà tutte le immagini base e le dipendenze.

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
 # ...molti comandi...
 => 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

Abbiamo costruito una nuova immagine Docker. Ora usiamo quell'immagine per avviare un container effettivo in esecuzione.

Useremo docker run per avviare un nuovo container usando l'immagine bun-hello-world. Verrà eseguito in modalità detached (-d) e mapperemo la porta 3000 del container alla porta 3000 della macchina locale (-p 3000:3000).

Il comando run stampa una stringa che rappresenta l'ID del container.

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

txt

7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d

Il container è ora in esecuzione in background. Visita localhost:3000. Dovresti vedere un messaggio Hello, World!.

Per fermare il container, useremo docker stop <container-id>.

docker stop 7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d

Se non riesci a trovare l'ID del container, puoi usare docker ps per elencare tutti i container in esecuzione.

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

Questo è tutto! Consulta la documentazione Docker per un utilizzo più avanzato.