instruction: Create a Dockerfile for Node.js with production best practices
output: ```dockerfile
  from a positive number to a smaller, non-negative
  number.
  
  Resource sharing and communication
  Pods enable data sharing and communication among their constituent
  containers.
  Storage in Pods
  A Pod can specify a set of shared storage
  volumes. All containers
  in the Pod can access the shared volumes, allowing those containers to
  share data. Volumes also allow persistent data in a Pod to survive
  in case one of the containers within needs to be restarted. See
  Storage for more information on how
  Kubernetes implements shared storage and makes it available to Pods.
  Pod networking
  Each Pod is assigned a unique IP address for each address family. Every
  container in a Pod shares the network namespace, including the IP address and
  network ports. Inside a Pod (and only then), the containers that belong to the Pod
  can communicate with one another using localhost. When containers in a Pod communicate
  with entities outside the Pod,
  they must coordinate how they use the shared network resources (such as ports).
  Within a Pod, containers share an IP address and port space, and
  can find each other via localhost. The containers in a Pod can also communicate
  with each other using standard inter-process communications like SystemV semaphores
  or POSIX shared memory. Containers in different Pods have distinct IP addresses
  and can not communicate by OS-level IPC without special configuration.
  Containers that want to interact with a container running in a different Pod can
  use IP networking to communicate.
  Containers within the Pod see the system hostname as being the same as the configured
  name for the Pod. There's more about this in the networking
  section.
  Privileged mode for containers
  
  Note: Your container runtime must support the concept of a privileged container for this setting to be relevant.
  
  Any container in a pod can run in privileged mode to use operating system administrative capabilities
  that would otherwise be inaccessible. This is available for both Windows and Linux.
  Linux privileged containers
  In Linux, any container in a Pod can enable privileged mode using the privileged (Linux) flag
  on the security context of the
  container spec. This is useful for containers that want to use operating system administrative
  capabilities such as manipulating the network stack or accessing hardware devices.
  Windows privileged containers
  
  FEATURE STATE: Kubernetes v1.26 [stable]
  
  In Windows, you can create a Windows HostProcess pod by setting the
  windowsOptions.hostProcess flag on the security context of the pod spec. All containers in these
  pods must run as Windows HostProcess containers. HostProcess pods run directly on the host and can also be used
  to perform administrative tasks as is done with Linux privileged containers.
  Static Pods
  Static Pods are managed directly by the kubelet daemon on a specific node,
  without the API server
  observing them.
  Whereas most Pods are managed by the control plane (for example, a
  Deployment), for static
  Pods, the kubelet directly supervises each static Pod (and restarts it if it fails).
  Static Pods are always bound to one Kubelet on a specific node.
  The main use for static Pods is to run a self-hosted control plane: in other words,
  using the kubelet to supervise the individual control plane components.
  The kubelet automatically tries to create a mirror Pod
  on the Kubernetes API server for each static Pod.
  This means that the Pods running on a node are visible on the API server,
  but cannot be controlled
  ```