Would using mutagen-compose be better than a multistage docker build?

Question

Using MacOS, I have a docker compose that uses three services in the following way

services:
  service_1:
    volumes:
      - ./apps:/usr/src/app/apps
      - ./packages:/usr/src/app/packages\
    build:
      dockerfile: Dockerfile

  service_2:
    volumes:
      - ./apps:/usr/src/app/apps
      - ./packages:/usr/src/app/packages
    build:
      dockerfile: Dockerfile

  service_3:
    volumes:
      - ./apps:/usr/src/app/apps
      - ./packages:/usr/src/app/packages
    build:
      dockerfile: Dockerfile

Current Dockerfile:

FROM node as builder

COPY . /app

RUN yarn install

FROM node

ARG app_name

COPY --from=builder /app /app

WORKDIR /app/$app_name

RUN yarn start

Would it be more performant to use a builder in the dockerfile or to use something like mutagen or an NFS mount? I have read about Yarn/NPM installs taking significantly longer in containers on MacOS and this has led to some confusion about whether my use case could be increased by changing my volumes to nfs/mutagen synced.

Answer 1

Docker's standard model is that the application code is built into immutable images. You shouldn't normally need to distribute or inject the code separately from what's built into an image. In the example you show above, I would normally expect to see the builder RUN in the Dockerfile, and to not have the separate volumes: mounts you show.

Performance-wise, there are known issues with bind mounts on non-Linux platforms. Some of the workarounds using an NFS service instead of Docker Desktop's native filesystem handler will be a little faster, but not as fast as using the local filesystem. Using code built into an image avoids these performance issues entirely.

services:
  service_1:
    build:
      context: .
      args:
        app_name: app1
    # but no volumes: