Eine Bun-Anwendung mit Docker containerisieren

NOTE

Diese Anleitung setzt voraus, dass Sie bereits [Docker Desktop](https://www.docker.com/products/docker-desktop/) installiert haben.

Docker ist eine Plattform zum Packen und Ausführen einer Anwendung als leichter, portabler Container, der alle erforderlichen Abhängigkeiten kapselt.

Um unsere Anwendung zu containerisieren, definieren wir eine Dockerfile. Diese Datei enthält eine Liste von Anweisungen zum Initialisieren des Containers, Kopieren unserer lokalen Projektdateien, Installieren von Abhängigkeiten und Starten der Anwendung.

docker

# das offizielle Bun-Image verwenden
# alle Versionen unter https://hub.docker.com/r/oven/bun/tags ansehen
FROM oven/bun:1 AS base
WORKDIR /usr/src/app

# Abhängigkeiten in temp-Verzeichnis installieren
# dies cached sie und beschleunigt zukünftige Builds
FROM base AS install
RUN mkdir -p /temp/dev
COPY package.json bun.lock /temp/dev/
RUN cd /temp/dev && bun install --frozen-lockfile

# mit --production installieren (devDependencies ausschließen)
RUN mkdir -p /temp/prod
COPY package.json bun.lock /temp/prod/
RUN cd /temp/prod && bun install --frozen-lockfile --production

# node_modules aus temp-Verzeichnis kopieren
# dann alle (nicht ignorierten) Projektdateien in das Image kopieren
FROM base AS prerelease
COPY --from=install /temp/dev/node_modules node_modules
COPY . .

# [optional] Tests & Build
ENV NODE_ENV=production
RUN bun test
RUN bun run build

# Produktionsabhängigkeiten und Quellcode in das finale Image kopieren
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 .

# die App ausführen
USER bun
EXPOSE 3000/tcp
ENTRYPOINT [ "bun", "run", "index.ts" ]

Nachdem Sie nun Ihr Docker-Image haben, schauen wir uns .dockerignore an, das die gleiche Syntax wie .gitignore hat. Hier müssen Sie die Dateien/Verzeichnisse angeben, die in keiner Phase des Docker-Builds enthalten sein dürfen. Ein Beispiel für eine Ignorierdatei ist:

txt

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

Wir verwenden nun docker build, um diese Dockerfile in ein Docker-Image zu konvertieren, eine eigenständige Vorlage, die alle Abhängigkeiten und Konfigurationen enthält, die zum Ausführen der Anwendung erforderlich sind.

Das -t-Flag ermöglicht es uns, einen Namen für das Image anzugeben, und --pull weist Docker an, automatisch die neueste Version des Basis-Images (oven/bun) herunterzuladen. Der erste Build dauert länger, da Docker alle Basis-Images und Abhängigkeiten herunterladen muss.

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
 # ...viele Befehle...
 => 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

Wir haben ein neues Docker-Image erstellt. Jetzt verwenden wir dieses Image, um einen tatsächlichen, laufenden Container zu starten.

Wir verwenden docker run, um einen neuen Container mit dem bun-hello-world-Image zu starten. Er wird im detached Modus (-d) ausgeführt und wir mappen den Port 3000 des Containers auf den Port 3000 unseres lokalen Rechners (-p 3000:3000).

Der run-Befehl gibt eine Zeichenkette aus, die die Container-ID darstellt.

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

txt

7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d

Der Container wird nun im Hintergrund ausgeführt. Besuchen Sie localhost:3000. Sie sollten eine Hello, World!-Nachricht sehen.

Um den Container zu stoppen, verwenden wir docker stop <container-id>.

docker stop 7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d

Wenn Sie die Container-ID nicht finden können, können Sie docker ps verwenden, um alle laufenden Container aufzulisten.

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

Das war's! Siehe Docker-Dokumentation für weitere fortgeschrittene Verwendung.