instruction: Create a Dockerfile for workloads
output: ```dockerfile
  from a deleted Job after they either fail or complete, sometimes those
  lingering pods may cause cluster performance degradation or in worst case cause the
  cluster to go offline due to this degradation.
  You can use LimitRanges and
  ResourceQuotas to place a
  cap on the amount of resources that a particular namespace can
  consume.
  
  Job patterns
  The Job object can be used to process a set of independent but related work items.
  These might be emails to be sent, frames to be rendered, files to be transcoded,
  ranges of keys in a NoSQL database to scan, and so on.
  In a complex system, there may be multiple different sets of work items. Here we are just
  considering one set of work items that the user wants to manage together — a batch job.
  There are several different patterns for parallel computation, each with strengths and weaknesses.
  The tradeoffs are:
  
  One Job object for each work item, versus a single Job object for all work items.
  One Job per work item creates some overhead for the user and for the system to manage
  large numbers of Job objects.
  A single Job for all work items is better for large numbers of items.
  Number of Pods created equals number of work items, versus each Pod can process multiple work items.
  When the number of Pods equals the number of work items, the Pods typically
  requires less modification to existing code and containers. Having each Pod
  process multiple work items is better for large numbers of items.
  Several approaches use a work queue. This requires running a queue service,
  and modifications to the existing program or container to make it use the work queue.
  Other approaches are easier to adapt to an existing containerised application.
  When the Job is associated with a
  headless Service,
  you can enable the Pods within a Job to communicate with each other to
  collaborate in a computation.
  
  The tradeoffs are summarized here, with columns 2 to 4 corresponding to the above tradeoffs.
  The pattern names are also links to examples and more detailed description.
  
  Pattern
  Single Job object
  Fewer pods than work items?
  Use app unmodified?
  
  Queue with Pod Per Work Item
  ✓
  
  sometimes
  
  Queue with Variable Pod Count
  ✓
  ✓
  
  Indexed Job with Static Work Assignment
  ✓
  
  ✓
  
  Job with Pod-to-Pod Communication
  ✓
  sometimes
  sometimes
  
  Job Template Expansion
  
  ✓
  
  When you specify completions with .spec.completions, each Pod created by the Job controller
  has an identical spec.
  This means that all pods for a task will have the same command line and the same
  image, the same volumes, and (almost) the same environment variables. These patterns
  are different ways to arrange for pods to work on different things.
  This table shows the required settings for .spec.parallelism and .spec.completions for each of the patterns.
  Here, W is the number of work items.
  
  Pattern
  .spec.completions
  .spec.parallelism
  
  Queue with Pod Per Work Item
  W
  any
  
  Queue with Variable Pod Count
  
  any
  
  Indexed Job with Static Work Assignment
  W
  any
  
  Job with Pod-to-Pod Communication
  W
  W
  
  Job Template Expansion
  1
  should be 1
  
  Advanced usage
  Suspending a Job
  
  FEATURE STATE: Kubernetes v1.24 [stable]
  
  When a Job is created, the Job controller will immediately begin creating Pods
  to satisfy the Job's requirements and will continue to do so until the Job is
  complete. However, you may want to temporarily suspend a Job's execution and
  resume it later, or start Jobs in suspended state and have a custom controller
  decide later when to start them.
  To suspend a Job, you can update the .spec.suspend field of
  the Job to true; later, when you want to resume it again, update it to false.
  Creating a Job with .spec.suspend set to true will create it in the suspended
  state.
  When a Job is resumed
  ```