instruction: Create a Dockerfile for Node.js with production best practices
output: ```dockerfile
  from the cluster, those Pods are garbage
  collected. Deleting a DaemonSet will clean up the Pods it created.Some typical uses of a DaemonSet are:running a cluster storage daemon on every noderunning a logs collection daemon on every noderunning a node monitoring daemon on every nodeIn a simple case, one DaemonSet, covering all nodes, would be used for each type of daemon.
  A more complex setup might use multiple DaemonSets for a single type of daemon, but with
  different flags and/or different memory and cpu requests for different hardware types.Writing a DaemonSet SpecCreate a DaemonSetYou can describe a DaemonSet in a YAML file. For example, the daemonset.yaml file below
  describes a DaemonSet that runs the fluentd-elasticsearch Docker image:controllers/daemonset.yaml
  apiVersion: apps/v1
  kind: DaemonSet
  metadata:
   name: fluentd-elasticsearch
   namespace: kube-system
   labels:
   k8s-app: fluentd-logging
  spec:
   selector:
   matchLabels:
   name: fluentd-elasticsearch
   template:
   metadata:
   labels:
   name: fluentd-elasticsearch
   spec:
   tolerations:
   # these tolerations are to have the daemonset runnable on control plane nodes
   # remove them if your control plane nodes should not run pods
   - key: node-role.kubernetes.io/control-plane
   operator: Exists
   effect: NoSchedule
   - key: node-role.kubernetes.io/master
   operator: Exists
   effect: NoSchedule
   containers:
   - name: fluentd-elasticsearch
   image: quay.io/fluentd_elasticsearch/fluentd:v2.5.2
   resources:
   limits:
   memory: 200Mi
   requests:
   cpu: 100m
   memory: 200Mi
   volumeMounts:
   - name: varlog
   mountPath: /var/log
   # it may be desirable to set a high priority class to ensure that a DaemonSet Pod
   # preempts running Pods
   # priorityClassName: important
   terminationGracePeriodSeconds: 30
   volumes:
   - name: varlog
   hostPath:
   path: /var/log
  Create a DaemonSet based on the YAML file:kubectl apply -f https://k8s.io/examples/controllers/daemonset.yaml
  Required FieldsAs with all other Kubernetes config, a DaemonSet needs apiVersion, kind, and metadata fields. For
  general information about working with config files, see
  running stateless applications
  and object management using kubectl.The name of a DaemonSet object must be a valid
  DNS subdomain name.A DaemonSet also needs a
  .spec
  section.Pod TemplateThe .spec.template is one of the required fields in .spec.The .spec.template is a pod template.
  It has exactly the same schema as a Pod,
  except it is nested and does not have an apiVersion or kind.In addition to required fields for a Pod, a Pod template in a DaemonSet has to specify appropriate
  labels (see pod selector).A Pod Template in a DaemonSet must have a RestartPolicy
  equal to Always, or be unspecified, which defaults to Always.Pod SelectorThe .spec.selector field is a pod selector. It works the same as the .spec.selector of
  a Job.You must specify a pod selector that matches the labels of the
  .spec.template.
  Also, once a DaemonSet is created,
  its .spec.selector can not be mutated. Mutating the pod selector can lead to the
  unintentional orphaning of Pods, and it was found to be confusing to users.The .spec.selector is an object consisting of two fields:matchLabels - works the same as the .spec.selector of a
  ReplicationController.matchExpressions - allows to build more sophisticated selectors by specifying key,
  list of values and an operator that relates the key and values.When the two are specified the result is ANDed.The .spec.selector must match the .spec.template.metadata.labels.
  Config with these two not matching will be rejected by the API.Running Pods on select NodesIf you specify a .spec.template.spec.nodeSelector, then the DaemonSet controller will
  create Pods on nodes which match that node selector.
  Likewise if you specify a .spec.template.spec.affinity,
  then DaemonSet controller will create Pods on nodes which match that
  node affinity.
  If you do not specify either, then the DaemonSet controller will create Pods on all nodes.How Daemon Pods are scheduledA DaemonSet can be used to ensure that all eligible nodes run a copy of a Pod.
  The DaemonSet controller creates a Pod for each eligible node and adds the
  spec.affinity.nodeAffinity field of the Pod to match the target host. After
  the Pod is created, the default scheduler typically takes over and then binds
  the Pod to the target host by setting the .spec.nodeName field. If the new
  Pod cannot fit on the node, the default scheduler may preempt (evict) some of
  the existing Pods based on the
  priority
  of the new Pod.Note:If it's important that the DaemonSet pod run on each node, it's often desirable
  to set the .spec.template.spec.priorityClassName of the DaemonSet to a
  PriorityClass
  with a higher priority to ensure that this eviction occurs.The user can specify a different scheduler for the Pods of the DaemonSet, by
  setting the .spec.template.spec.schedulerName field of the DaemonSet.The original node affinity specified at the
  .spec.template.spec.affinity.nodeAffinity field (if specified) is taken into
  consideration by the DaemonSet controller when evaluating the eligible nodes,
  but is replaced on the created Pod with the node affinity that matches the name
  of the eligible node.nodeAffinity:
   requiredDuringSchedulingIgnoredDuringExecution:
   nodeSelectorTerms:
   - matchFields:
   - key: metadata.name
   operator: In
   values:
   - target-host-name
  Taints and tolerationsThe DaemonSet controller automatically adds a set of tolerations to DaemonSet Pods:Tolerations for DaemonSet podsToleration keyEffectDetailsnode.kubernetes.io/not-readyNoExecuteDaemonSet Pods can be scheduled onto nodes that are not healthy or ready to accept Pods. Any DaemonSet Pods running on such nodes will not be evicted.node.kubernetes.io/unreachableNoExecuteDaemonSet Pods can be scheduled onto nodes that are unreachable
  ```