instruction: Create a Dockerfile for Node.js with production best practices
output: ```dockerfile
  from
  -2147483648 to 1000000000 inclusive. Higher values indicate higher priority.ProbeA check that the kubelet periodically performs against a container that is
  running in a pod, that will define container's state and health and informing container's lifecycle.[+]To learn more, read container probes.ProxyIn computing, a proxy is a server that acts as an intermediary for a remote
  service.[+]A client interacts with the proxy; the proxy copies the client's data to the
  actual server; the actual server replies to the proxy; the proxy sends the
  actual server's reply to the client.kube-proxy is a
  network proxy that runs on each node in your cluster, implementing part of
  the Kubernetes Service concept.You can run kube-proxy as a plain userland proxy service. If your operating
  system supports it, you can instead run kube-proxy in a hybrid mode that
  achieves the same overall effect using less system resources.QoS ClassQoS Class (Quality of Service Class) provides a way for Kubernetes to classify Pods within the cluster into several classes and make decisions about scheduling and eviction.[+]QoS Class of a Pod is set at creation time based on its compute resources requests and limits settings. QoS classes are used to make decisions about Pods scheduling and eviction.
  Kubernetes can assign one of the following QoS classes to a Pod: Guaranteed, Burstable or BestEffort.QuantityA whole-number representation of small or large numbers using SI suffixes.[+]Quantities are representations of small or large numbers using a compact,
  whole-number notation with SI suffixes. Fractional numbers are represented
  using milli units, while large numbers can be represented using kilo,
  mega, or giga units.For instance, the number 1.5 is represented as 1500m, while the number 1000
  can be represented as 1k, and 1000000 as 1M. You can also specify
  binary-notation suffixes; the number 2048 can be written as 2Ki.The accepted decimal (power-of-10) units are m (milli), k (kilo,
  intentionally lowercase), M (mega), G (giga), T (tera), P (peta),
  E (exa).The accepted binary (power-of-2) units are Ki (kibi), Mi (mebi), Gi (gibi),
  Ti (tebi), Pi (pebi), Ei (exbi).RBAC (Role-Based Access Control)Manages authorization decisions, allowing admins to dynamically configure access policies through the Kubernetes API.[+]RBAC utilizes four kinds of Kubernetes objects:RoleDefines permission rules in a specific namespace.ClusterRoleDefines permission rules cluster-wide.RoleBindingGrants the permissions defined in a role to a set of users in a specific namespace.ClusterRoleBindingGrants the permissions defined in a role to a set of users cluster-wide.For more information, see RBAC.ReplicaA copy or duplicate of a Pod or
  a set of pods. Replicas ensure high availability, scalability, and fault tolerance
  by maintaining multiple identical instances of a pod.[+]Replicas are commonly used in Kubernetes to achieve the desired application state and reliability.
  They enable workload scaling and distribution across multiple nodes in a cluster.By defining the number of replicas in a Deployment or ReplicaSet, Kubernetes ensures that
  the specified number of instances are running, automatically adjusting the count as needed.Replica management allows for efficient load balancing, rolling updates, and
  self-healing capabilities in a Kubernetes cluster.ReplicaSetA ReplicaSet (aims to) maintain a set of replica Pods running at any given time.[+]Workload objects such as Deployment make use of ReplicaSets
  to ensure that the configured number of Pods are
  running in your cluster, based on the spec of that ReplicaSet.ReplicationControllerA workload resource that manages a replicated application, ensuring that
  a specific number of instances of a Pod are running.[+]The control plane ensures that the defined number of Pods are running, even if some
  Pods fail, if you delete Pods manually, or if too many are started by mistake.Note:ReplicationController is deprecated. See
  Deployment, which is similar.Resource (infrastructure)Capabilities provided to one or more nodes (CPU, memory, GPUs, etc), and made available for consumption by
  Pods running on those nodes.Kubernetes also uses the term resource to describe an API resource.[+]Computers provide fundamental hardware facilities: processing power, storage memory, network, etc.
  These resources have finite capacity, measured in a unit applicable to that resource (number of CPUs, bytes of memory, etc).
  Kubernetes abstracts common resources
  for allocation to workloads and utilizes operating system primitives (for example, Linux cgroups) to manage consumption by workloads).You can also use dynamic resource allocation to
  manage complex resource allocations automatically.Resource QuotasProvides constraints that limit aggregate resource consumption per Namespace.[+]Limits the quantity of objects that can be created in a namespace by type, as well as the total amount of compute resources that may be consumed by resources in that project.ResourceClaimDescribes the resources that a workload needs, such as
  devices. ResourceClaims are
  used in
  dynamic resource allocation (DRA)
  to provide Pods with access to a specific resource.[+]ResourceClaims can be created by workload operators or generated by Kubernetes
  based on a
  ResourceClaimTemplate.ResourceClaimTemplateDefines a template that Kubernetes uses to create
  <a class=glossary-tooltip title='Describes the resources that a workload needs, such as devices. ResourceClaims can request devices
  ```
  
  ## Production Considerations
  
  ### Security Best Practices
  
  1. **Use non-root user**
  ```dockerfile
  # Create non-root user
  RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
  USER nodejs
  ```
  
  2. **Scan for vulnerabilities**
  ```bash
  # Scan container image
  docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy image <image_name>
  ```
  
  3. **Apply security policies**
  ```yaml
  apiVersion: v1
  kind: Pod
  spec:
    securityContext:
      runAsNonRoot: true
      runAsUser: 1001
      fsGroup: 1001
    containers:
    - name: app
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
          - ALL
  ```
  
  ### Performance Optimization
  
  1. **Resource management**
  ```yaml
  resources:
    requests:
      memory: "128Mi"
      cpu: "100m"
    limits:
      memory: "256Mi"
      cpu: "200m"
  ```
  
  2. **Horizontal Pod Autoscaling**
  ```yaml
  apiVersion: autoscaling/v2
  kind: HorizontalPodAutoscaler
  metadata:
    name: app-hpa
  spec:
    scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: my-app
    minReplicas: 3
    maxReplicas: 10
    metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  ```
  
  ### Backup and Disaster Recovery
  
  1. **Data backup strategy**
  ```bash
  # Automated backup script
  kubectl create job --from=cronjob/backup-job backup-manual-$(date +%Y%m%d-%H%M%S)
  ```
  
  2. **Multi-region deployment**
  ```yaml
  # Anti-affinity rules
  affinity:
    podAntiAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchExpressions:
            - key: app
              operator: In
              values:
              - my-app
          topologyKey: kubernetes.io/zone
  ```