instruction: Create a Dockerfile for workloads
output: ```dockerfile
  From Message
   ---- ------ ---- ---- -------
   Normal SuccessfulCreate 13s replicaset-controller Created pod: frontend-gbgfx
   Normal SuccessfulCreate 13s replicaset-controller Created pod: frontend-rwz57
   Normal SuccessfulCreate 13s replicaset-controller Created pod: frontend-wkl7w
  And lastly you can check for the Pods brought up:kubectl get pods
  You should see Pod information similar to:NAME READY STATUS RESTARTS AGE
  frontend-gbgfx 1/1 Running 0 10m
  frontend-rwz57 1/1 Running 0 10m
  frontend-wkl7w 1/1 Running 0 10m
  You can also verify that the owner reference of these pods is set to the frontend ReplicaSet.
  To do this, get the yaml of one of the Pods running:kubectl get pods frontend-gbgfx -o yaml
  The output will look similar to this, with the frontend ReplicaSet's info set in the metadata's ownerReferences field:apiVersion: v1
  kind: Pod
  metadata:
   creationTimestamp: "2024-02-28T22:30:44Z"
   generateName: frontend-
   labels:
   tier: frontend
   name: frontend-gbgfx
   namespace: default
   ownerReferences:
   - apiVersion: apps/v1
   blockOwnerDeletion: true
   controller: true
   kind: ReplicaSet
   name: frontend
   uid: e129deca-f864-481b-bb16-b27abfd92292
  ...
  Non-Template Pod acquisitionsWhile you can create bare Pods with no problems, it is strongly recommended to make sure that the bare Pods do not have
  labels which match the selector of one of your ReplicaSets. The reason for this is because a ReplicaSet is not limited
  to owning Pods specified by its template-- it can acquire other Pods in the manner specified in the previous sections.Take the previous frontend ReplicaSet example, and the Pods specified in the following manifest:pods/pod-rs.yaml
  apiVersion: v1
  kind: Pod
  metadata:
   name: pod1
   labels:
   tier: frontend
  spec:
   containers:
   - name: hello1
   image: gcr.io/google-samples/hello-app:2.0
  
  ---
  
  apiVersion: v1
  kind: Pod
  metadata:
   name: pod2
   labels:
   tier: frontend
  spec:
   containers:
   - name: hello2
   image: gcr.io/google-samples/hello-app:1.0
  As those Pods do not have a Controller (or any object) as their owner reference and match the selector of the frontend
  ReplicaSet, they will immediately be acquired by it.Suppose you create the Pods after the frontend ReplicaSet has been deployed and has set up its initial Pod replicas to
  fulfill its replica count requirement:kubectl apply -f https://kubernetes.io/examples/pods/pod-rs.yaml
  The new Pods will be acquired by the ReplicaSet, and then immediately terminated as the ReplicaSet would be over
  its desired count.Fetching the Pods:kubectl get pods
  The output shows that the new Pods are either already terminated, or in the process of being terminated:NAME READY STATUS RESTARTS AGE
  frontend-b2zdv 1/1 Running 0 10m
  frontend-vcmts 1/1 Running 0 10m
  frontend-wtsmm 1/1 Running 0 10m
  pod1 0/1 Terminating 0 1s
  pod2 0/1 Terminating 0 1s
  If you create the Pods first:kubectl apply -f https://kubernetes.io/examples/pods/pod-rs.yaml
  And then create the ReplicaSet however:kubectl apply -f https://kubernetes.io/examples/controllers/frontend.yaml
  You shall see that the ReplicaSet has acquired the Pods and has only created new ones according to its spec until the
  number of its new Pods and the original matches its desired count. As fetching the Pods:kubectl get pods
  Will reveal in its output:NAME READY STATUS RESTARTS AGE
  frontend-hmmj2 1/1 Running 0 9s
  pod1 1/1 Running 0 36s
  pod2 1/1 Running 0 36s
  In this manner, a ReplicaSet can own a non-homogeneous set of PodsWriting a ReplicaSet manifestAs with all other Kubernetes API objects, a ReplicaSet needs the apiVersion, kind, and metadata fields.
  For ReplicaSets, the kind is always a ReplicaSet.When the control plane creates new Pods for a ReplicaSet, the .metadata.name of the
  ReplicaSet is part of the basis for naming those Pods. The name of a ReplicaSet must be a valid
  DNS subdomain
  value, but this can produce unexpected results for the Pod hostnames. For best compatibility,
  the name should follow the more restrictive rules for a
  DNS label.A ReplicaSet also needs a .spec section.Pod TemplateThe .spec.template is a pod template which is also
  required to have labels in place. In our frontend.yaml example we had one label: tier: frontend.
  Be careful not to overlap with the selectors of other controllers, lest they try to adopt this Pod.For the template's restart policy field,
  .spec.template.spec.restartPolicy, the only allowed value is Always, which is the default.Pod SelectorThe .spec.selector field is a label selector. As discussed
  earlier these are the labels used to identify potential Pods to acquire. In our
  frontend.yaml example, the selector was:matchLabels:
   tier: frontend
  In the ReplicaSet, .spec.template.metadata.labels must match spec.selector, or it will
  be rejected by the API.Note:For 2 ReplicaSets specifying the same .spec.selector but different
  .spec.template.metadata.labels and .spec.template.spec fields, each ReplicaSet ignores the
  Pods created by the other ReplicaSet.ReplicasYou can specify how many Pods should run concurrently by setting .spec.replicas. The ReplicaSet will create/delete
  its Pods to match this number.If you do not specify .spec.replicas, then it defaults to 1.Working with ReplicaSetsDeleting a ReplicaSet and its PodsTo delete a ReplicaSet and all of its Pods, use
  kubectl delete. The
  Garbage collector automatically deletes all of
  the dependent Pods by default.When using the REST API or the client-go library, you must set propagationPolicy to
  Background or Foreground in the -d option. For example:kubectl proxy --port=8080
  curl -X DELETE 'localhost:8080/apis/apps/v1/namespaces/default/replicasets/frontend' \
   -d '{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Foreground"}' \
   -H "Content-Type: application/json"
  Deleting just a ReplicaSetYou can delete a ReplicaSet without affecting any of its Pods using
  kubectl delete
  with the --cascade=orphan option.
  When using the REST API or the client-go library, you must set propagationPolicy to Orphan.
  For example:kubectl proxy --port=8080
  curl -X DELETE 'localhost:8080/apis/apps/v1/namespaces/default/replicasets/frontend' \
   -d '{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Orphan"}' \
   -H "Content-Type: application/json"
  Once the original is deleted, you can create a new ReplicaSet to replace it. As long
  as the old and new .spec.selector are the same, then the new one will adopt the old Pods.
  However, it will not make any effort to make existing Pods match a new, different pod template.
  To update Pods to a new spec in a controlled way, use a
  Deployment, as
  ReplicaSets do not support a rolling update directly.Terminating PodsFEATURE STATE:
  Kubernetes v1.33 [alpha] (enabled by default: false)You can enable this feature by setting the DeploymentReplicaSetTerminatingReplicas
  feature gate
  on the API server
  and on the kube-controller-managerPods that become terminating due to deletion or scale down may take a long time to terminate, and may consume
  additional resources during that period. As a result, the total number of all pods can temporarily exceed
  .spec.replicas. Terminating pods can be tracked using the .status.terminatingReplicas field of the ReplicaSet.<h3 id=isolating-pods-
  ```