instruction: Create a Dockerfile for Node.js with production best practices
output: ```dockerfile
  from the machine's hostname.
  
  Currently, the kubelet cannot automatically detect the cgroup driver used by the container runtime,
  but the value of --cgroup-driver must match the cgroup driver used by the container runtime to ensure
  the health of the kubelet.
  
  To specify the container runtime you must set its endpoint with the
  --container-runtime-endpoint=<path> flag.
  
  The recommended way of applying such instance-specific configuration is by using
  KubeletConfiguration patches.
  Configure kubelets using kubeadm
  It is possible to configure the kubelet that kubeadm will start if a custom
  KubeletConfiguration
  API object is passed with a configuration file like so kubeadm ... --config some-config-file.yaml.
  By calling kubeadm config print init-defaults --component-configs KubeletConfiguration you can
  see all the default values for this structure.
  It is also possible to apply instance-specific patches over the base KubeletConfiguration.
  Have a look at Customizing the kubelet
  for more details.
  Workflow when using kubeadm init
  When you call kubeadm init, the kubelet configuration is marshalled to disk
  at /var/lib/kubelet/config.yaml, and also uploaded to a kubelet-config ConfigMap in the kube-system
  namespace of the cluster. A kubelet configuration file is also written to /etc/kubernetes/kubelet.conf
  with the baseline cluster-wide configuration for all kubelets in the cluster. This configuration file
  points to the client certificates that allow the kubelet to communicate with the API server. This
  addresses the need to
  propagate cluster-level configuration to each kubelet.
  To address the second pattern of
  providing instance-specific configuration details,
  kubeadm writes an environment file to /var/lib/kubelet/kubeadm-flags.env, which contains a list of
  flags to pass to the kubelet when it starts. The flags are presented in the file like this:
  KUBELET_KUBEADM_ARGS="--flag1=value1 --flag2=value2 ..."
  In addition to the flags used when starting the kubelet, the file also contains dynamic
  parameters such as the cgroup driver and whether to use a different container runtime socket
  (--cri-socket).
  After marshalling these two files to disk, kubeadm attempts to run the following two
  commands, if you are using systemd:
  systemctl daemon-reload && systemctl restart kubelet
  If the reload and restart are successful, the normal kubeadm init workflow continues.
  Workflow when using kubeadm join
  When you run kubeadm join, kubeadm uses the Bootstrap Token credential to perform
  a TLS bootstrap, which fetches the credential needed to download the
  kubelet-config ConfigMap and writes it to /var/lib/kubelet/config.yaml. The dynamic
  environment file is generated in exactly the same way as kubeadm init.
  Next, kubeadm runs the following two commands to load the new configuration into the kubelet:
  systemctl daemon-reload && systemctl restart kubelet
  After the kubelet loads the new configuration, kubeadm writes the
  /etc/kubernetes/bootstrap-kubelet.conf KubeConfig file, which contains a CA certificate and Bootstrap
  Token. These are used by the kubelet to perform the TLS Bootstrap and obtain a unique
  credential, which is stored in /etc/kubernetes/kubelet.conf.
  When the /etc/kubernetes/kubelet.conf file is written, the kubelet has finished performing the TLS Bootstrap.
  Kubeadm deletes the /etc/kubernetes/bootstrap-kubelet.conf file after completing the TLS Bootstrap.
  The kubelet drop-in file for systemd
  kubeadm ships with configuration for how systemd should run the kubelet.
  Note that the kubeadm CLI command never touches this drop-in file.
  This configuration file installed by the kubeadm
  package is written to
  /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf and is used by systemd.
  It augments the basic
  kubelet.service.
  If you want to override that further, you can make a directory /etc/systemd/system/kubelet.service.d/
  (not /usr/lib/systemd/system/kubelet.service.d/) and put your own customizations into a file there.
  For example, you might add a new local file /etc/systemd/system/kubelet.service.d/local-overrides.conf
  to override the unit settings configured by kubeadm.
  Here is what you are likely to find in /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf:
  Note:The contents below are just an example. If you don't want to use a package manager
  follow the guide outlined in the (Without a package manager)
  section.
  [Service]
  Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf"
  Environment="KUBELET_CONFIG_ARGS=--config=/var/lib/kubelet/config.yaml"
  # This is a file that "kubeadm init" and "kubeadm join" generate at runtime, populating
  # the KUBELET_KUBEADM_ARGS variable dynamically
  EnvironmentFile=-/var/lib/kubelet/kubeadm-flags.env
  # This is a file that the user can use for overrides of the kubelet args as a last resort. Preferably,
  # the user should use the .NodeRegistration.KubeletExtraArgs object in the configuration files instead.
  # KUBELET_EXTRA_ARGS should be sourced
  ```