instruction: Create a Dockerfile for Node.js with production best practices
output: ```dockerfile
  from the
  host's filesystem into the container. When working on an application, you can
  use a bind mount to mount source code into the container. The container sees the
  changes you make to the code immediately, as soon as you save a file. This means
  that you can run processes in the container that watch for filesystem changes
  and respond to them.In this chapter, you'll see how you can use bind mounts and a tool called
  nodemon to watch for file changes, and then restart the application
  automatically. There are equivalent tools in most other languages and
  frameworks.Quick volume type comparisonsThe following are examples of a named volume and a bind mount using --mount:Named volume: type=volume,src=my-volume,target=/usr/local/dataBind mount: type=bind,src=/path/to/data,target=/usr/local/dataThe following table outlines the main differences between volume mounts and bind
  mounts.Named volumesBind mountsHost locationDocker choosesYou decidePopulates new volume with container contentsYesNoSupports Volume DriversYesNoTrying out bind mountsBefore looking at how you can use bind mounts for developing your application,
  you can run a quick experiment to get a practical understanding of how bind mounts
  work.Verify that your getting-started-app directory is in a directory defined in
  Docker Desktop's file sharing setting. This setting defines which parts of your
  filesystem you can share with containers. For details about accessing the setting, see
  File sharing.
  NoteThe File sharing tab is only available in Hyper-V mode, because the files are automatically shared in WSL 2 mode and Windows container mode.Open a terminal and change directory to the getting-started-app
  directory.Run the following command to start bash in an ubuntu container with a
  bind mount.
  Mac / Linux
  
  Command Prompt
  
  Git Bash
  
  PowerShell
  
  $ docker run -it --mount type=bind,src="$(pwd)",target=/src ubuntu bash
  
  $ docker run -it --mount "type=bind,src=%cd%,target=/src" ubuntu bash
  
  $ docker run -it --mount type=bind,src="/$(pwd)",target=/src ubuntu bash
  
  $ docker run -it --mount "type=bind,src=$($pwd),target=/src" ubuntu bash
  The --mount type=bind option tells Docker to create a bind mount, where src is the
  current working directory on your host machine (getting-started-app), and
  target is where that directory should appear inside the container (/src).After running the command, Docker starts an interactive bash session in the
  root directory of the container's filesystem.
  
  root@ac1237fad8db:/# pwd
  /
  root@ac1237fad8db:/# ls
  bin dev home media opt root sbin srv tmp var
  boot etc lib mnt proc run src sys usr
  Change directory to the src directory.This is the directory that you mounted when starting the container. Listing
  the contents of this directory displays the same files as in the
  getting-started-app directory on your host machine.
  
  root@ac1237fad8db:/# cd src
  root@ac1237fad8db:/src# ls
  Dockerfile node_modules package.json spec src yarn.lock
  Create a new file named myfile.txt.
  
  root@ac1237fad8db:/src# touch myfile.txt
  root@ac1237fad8db:/src# ls
  Dockerfile myfile.txt node_modules package.json spec src yarn.lock
  Open the getting-started-app directory on the host and observe that the
  myfile.txt file is in the directory.
  
  âââ getting-started-app/
  â âââ Dockerfile
  â âââ myfile.txt
  â âââ node_modules/
  â âââ package.json
  â âââ spec/
  â âââ src/
  â âââ yarn.lock
  ```