instruction: Create a Dockerfile for Node.js with production best practices
output: ```dockerfile
  from application failures, but
  they should be used with caution. Liveness probes must be configured carefully
  to ensure that they truly indicate unrecoverable application failure, for example a deadlock.Note:Incorrect implementation of liveness probes can lead to cascading failures. This results in
  restarting of container under high load; failed client requests as your application became less
  scalable; and increased workload on remaining pods due to some failed pods.
  Understand the difference between readiness and liveness probes and when to apply them for your app.Before you beginYou need to have a Kubernetes cluster, and the kubectl command-line tool must
  be configured to communicate with your cluster. It is recommended to run this tutorial on a cluster with at least two nodes that are not acting as control plane hosts. If you do not already have a
  cluster, you can create one by using
  minikube
  or you can use one of these Kubernetes playgrounds:iximiuz LabsKillercodaKodeKloudPlay with KubernetesDefine a liveness commandMany applications running for long periods of time eventually transition to
  broken states, and cannot recover except by being restarted. Kubernetes provides
  liveness probes to detect and remedy such situations.In this exercise, you create a Pod that runs a container based on the
  registry.k8s.io/busybox:1.27.2 image. Here is the configuration file for the Pod:pods/probe/exec-liveness.yaml
  apiVersion: v1
  kind: Pod
  metadata:
   labels:
   test: liveness
   name: liveness-exec
  spec:
   containers:
   - name: liveness
   image: registry.k8s.io/busybox:1.27.2
   args:
   - /bin/sh
   - -c
   - touch /tmp/healthy; sleep 30; rm -f /tmp/healthy; sleep 600
   livenessProbe:
   exec:
   command:
   - cat
   - /tmp/healthy
   initialDelaySeconds: 5
   periodSeconds: 5
  In the configuration file, you can see that the Pod has a single Container.
  The periodSeconds field specifies that the kubelet should perform a liveness
  probe every 5 seconds. The initialDelaySeconds field tells the kubelet that it
  should wait 5 seconds before performing the first probe. To perform a probe, the
  kubelet executes the command cat /tmp/healthy in the target container. If the
  command succeeds, it returns 0, and the kubelet considers the container to be alive and
  healthy. If the command returns a non-zero value, the kubelet kills the container
  and restarts it.When the container starts, it executes this command:/bin/sh -c "touch /tmp/healthy; sleep 30; rm -f /tmp/healthy; sleep 600"
  For the first 30 seconds of the container's life, there is a /tmp/healthy file.
  So during the first 30 seconds, the command cat /tmp/healthy returns a success
  code. After 30 seconds, cat /tmp/healthy returns a failure code.Create the Pod:kubectl apply -f https://k8s.io/examples/pods/probe/exec-liveness.yaml
  Within 30 seconds, view the Pod events:kubectl describe pod liveness-exec
  The output indicates that no liveness probes have failed yet:Type Reason Age
  ```