instruction: Create a Dockerfile for Nginx, Node.js with production best practices
output: ```dockerfile
  from the name of the StatefulSet
  and the ordinal of the Pod. The pattern for the constructed hostname
  is $(statefulset name)-$(ordinal). The example above will create three Pods
  named web-0,web-1,web-2.
  A StatefulSet can use a Headless Service
  to control the domain of its Pods. The domain managed by this Service takes the form:
  $(service name).$(namespace).svc.cluster.local, where "cluster.local" is the
  cluster domain.
  As each Pod is created, it gets a matching DNS subdomain, taking the form:
  $(podname).$(governing service domain), where the governing service is defined
  by the serviceName field on the StatefulSet.
  Depending on how DNS is configured in your cluster, you may not be able to look up the DNS
  name for a newly-run Pod immediately. This behavior can occur when other clients in the
  cluster have already sent queries for the hostname of the Pod before it was created.
  Negative caching (normal in DNS) means that the results of previous failed lookups are
  remembered and reused, even after the Pod is running, for at least a few seconds.
  If you need to discover Pods promptly after they are created, you have a few options:
  
  Query the Kubernetes API directly (for example, using a watch) rather than relying on DNS lookups.
  Decrease the time of caching in your Kubernetes DNS provider (typically this means editing the
  config map for CoreDNS, which currently caches for 30 seconds).
  
  As mentioned in the limitations section, you are responsible for
  creating the Headless Service
  responsible for the network identity of the pods.
  Here are some examples of choices for Cluster Domain, Service name,
  StatefulSet name, and how that affects the DNS names for the StatefulSet's Pods.
  
  Cluster Domain
  Service (ns/name)
  StatefulSet (ns/name)
  StatefulSet Domain
  Pod DNS
  Pod Hostname
  
  cluster.local
  default/nginx
  default/web
  nginx.default.svc.cluster.local
  web-{0..N-1}.nginx.default.svc.cluster.local
  web-{0..N-1}
  
  cluster.local
  foo/nginx
  foo/web
  nginx.foo.svc.cluster.local
  web-{0..N-1}.nginx.foo.svc.cluster.local
  web-{0..N-1}
  
  kube.local
  foo/nginx
  foo/web
  nginx.foo.svc.kube.local
  web-{0..N-1}.nginx.foo.svc.kube.local
  web-{0..N-1}
  
  Note: Cluster Domain will be set to cluster.local unless
  otherwise configured.
  
  Stable Storage
  For each VolumeClaimTemplate entry defined in a StatefulSet, each Pod receives one
  PersistentVolumeClaim. In the nginx example above, each Pod receives a single PersistentVolume
  with a StorageClass of my-storage-class and 1 GiB of provisioned storage. If no StorageClass
  is specified, then the default StorageClass will be used. When a Pod is (re)scheduled
  onto a node, its volumeMounts mount the PersistentVolumes associated with its
  PersistentVolume Claims. Note that, the PersistentVolumes associated with the
  Pods' PersistentVolume Claims are not deleted when the Pods, or StatefulSet are deleted.
  This must be done manually.
  Pod Name Label
  When the StatefulSet controller creates a Pod,
  it adds a label, statefulset.kubernetes.io/pod-name, that is set to the name of
  the Pod. This label allows you to attach a Service to a specific Pod in
  the StatefulSet.
  Pod index label
  
  FEATURE STATE: Kubernetes v1.28 [beta]
  
  When the StatefulSet controller creates a Pod,
  the new Pod is labelled with apps.kubernetes.io/pod-index. The value of this label is the ordinal index of
  the Pod. This label allows you to route traffic to a particular pod index, filter logs/metrics
  using the pod index label, and more. Note the feature gate PodIndexLabel must be enabled for this
  feature, and it is enabled by default.
  Deployment and Scaling Guarantees
  
  For a StatefulSet with N replicas, when Pods are being deployed, they are created sequentially, in order
  ```