instruction: Create a Dockerfile for Nginx, Node.js with production best practices
output: ```dockerfile
  from the same spec, but are not interchangeable: each has a persistent identifier that it maintains across any rescheduling.If you want to use storage volumes to provide persistence for your workload, you can use a StatefulSet as part of the solution. Although individual Pods in a StatefulSet are susceptible to failure, the persistent Pod identifiers make it easier to match existing volumes to the new Pods that replace any that have failed.Using StatefulSetsStatefulSets are valuable for applications that require one or more of the
  following.Stable, unique network identifiers.Stable, persistent storage.Ordered, graceful deployment and scaling.Ordered, automated rolling updates.In the above, stable is synonymous with persistence across Pod (re)scheduling.
  If an application doesn't require any stable identifiers or ordered deployment,
  deletion, or scaling, you should deploy your application using a workload object
  that provides a set of stateless replicas.
  Deployment or
  ReplicaSet may be better suited to your stateless needs.LimitationsThe storage for a given Pod must either be provisioned by a
  PersistentVolume Provisioner (examples here)
  based on the requested storage class, or pre-provisioned by an admin.Deleting and/or scaling a StatefulSet down will not delete the volumes associated with the
  StatefulSet. This is done to ensure data safety, which is generally more valuable than an
  automatic purge of all related StatefulSet resources.StatefulSets currently require a Headless Service
  to be responsible for the network identity of the Pods. You are responsible for creating this
  Service.StatefulSets do not provide any guarantees on the termination of pods when a StatefulSet is
  deleted. To achieve ordered and graceful termination of the pods in the StatefulSet, it is
  possible to scale the StatefulSet down to 0 prior to deletion.When using Rolling Updates with the default
  Pod Management Policy (OrderedReady),
  it's possible to get into a broken state that requires
  manual intervention to repair.ComponentsThe example below demonstrates the components of a StatefulSet.apiVersion: v1
  kind: Service
  metadata:
   name: nginx
   labels:
   app: nginx
  spec:
   ports:
   - port: 80
   name: web
   clusterIP: None
   selector:
   app: nginx
  ---
  apiVersion: apps/v1
  kind: StatefulSet
  metadata:
   name: web
  spec:
   selector:
   matchLabels:
   app: nginx # has to match .spec.template.metadata.labels
   serviceName: "nginx"
   replicas: 3 # by default is 1
   minReadySeconds: 10 # by default is 0
   template:
   metadata:
   labels:
   app: nginx # has to match .spec.selector.matchLabels
   spec:
   terminationGracePeriodSeconds: 10
   containers:
   - name: nginx
   image: registry.k8s.io/nginx-slim:0.24
   ports:
   - containerPort: 80
   name: web
   volumeMounts:
   - name: www
   mountPath: /usr/share/nginx/html
   volumeClaimTemplates:
   - metadata:
   name: www
   spec:
   accessModes: [ "ReadWriteOnce" ]
   storageClassName: "my-storage-class"
   resources:
   requests:
   storage: 1Gi
  Note:This example uses the ReadWriteOnce access mode, for simplicity. For
  production use, the Kubernetes project recommends using the ReadWriteOncePod
  access mode instead.In the above example:A Headless Service, named nginx, is used to control the network domain.The StatefulSet, named web, has a Spec that indicates that 3 replicas of the nginx container will be launched in unique Pods.The volumeClaimTemplates will provide stable storage using
  PersistentVolumes provisioned by a
  PersistentVolume Provisioner.The name of a StatefulSet object must be a valid
  DNS label.Pod SelectorYou must set the .spec.selector field of a StatefulSet to match the labels of its
  .spec.template.metadata.labels. Failing to specify a matching Pod Selector will result in a
  validation error during StatefulSet creation.Volume Claim TemplatesYou can set the .spec.volumeClaimTemplates field to create a
  PersistentVolumeClaim.
  This will provide stable storage to the StatefulSet if eitherThe StorageClass specified for the volume claim is set up to use dynamic
  provisioning, orThe cluster already contains a PersistentVolume with the correct StorageClass
  and sufficient available storage space.Minimum ready secondsFEATURE STATE:
  Kubernetes v1.25 [stable].spec.minReadySeconds is an optional field that specifies the minimum number of seconds for which a newly
  created Pod should be running and ready without any of its containers crashing, for it to be considered available.
  This is used to check progression of a rollout when using a Rolling Update strategy.
  This field defaults to 0 (the Pod will be considered available as soon as it is ready). To learn more about when
  a Pod is considered ready, see Container Probes.Pod IdentityStatefulSet Pods have a unique identity that consists of an ordinal, a
  stable network identity, and stable storage. The identity sticks to the Pod,
  regardless of which node it's (re)scheduled on.Ordinal IndexFor a StatefulSet with N replicas, each Pod in the StatefulSet
  will be assigned an integer ordinal, that is unique over the Set. By default,
  pods will be assigned ordinals
  ```