instruction: Create a comprehensive Dockerfile for cluster applications with best practices
output: ```dockerfile
  from the published OpenAPI including but not
  limited to default, able, oneOf.OpenAPI V2The Kubernetes API server serves an aggregated OpenAPI v2 spec via the
  /openapi/v2 endpoint. You can request the response format using
  request headers as follows:Valid request header values for OpenAPI v2 queriesHeaderPossible valuesNotesAccept-Encodinggzipnot supplying this header is also acceptableAcceptapplication/com.github.proto-openapi.spec.v2@v1.0+protobufmainly for intra-cluster useapplication/jsondefault*serves application/jsonWarning:The validation rules published as part of OpenAPI schemas may not be complete, and usually aren't.
  Additional validation occurs within the API server. If you want precise and complete verification,
  a kubectl apply --dry-run=server runs all the applicable validation (and also activates admission-time
  checks).OpenAPI V3FEATURE STATE:
  Kubernetes v1.27 [stable] (enabled by default: true)Kubernetes supports publishing a description of its APIs as OpenAPI v3.A discovery endpoint /openapi/v3 is provided to see a list of all
  group/versions available. This endpoint only returns JSON. These
  group/versions are provided in the following format:{
   "paths": {
   ...,
   "api/v1": {
   "serverRelativeURL": "/openapi/v3/api/v1?hash=CC0E9BFD992D8C59AEC98A1E2336F899E8318D3CF4C68944C3DEC640AF5AB52D864AC50DAA8D145B3494F75FA3CFF939FCBDDA431DAD3CA79738B297795818CF"
   },
   "apis/admissionregistration.k8s.io/v1": {
   "serverRelativeURL": "/openapi/v3/apis/admissionregistration.k8s.io/v1?hash=E19CC93A116982CE5422FC42B590A8AFAD92CDE9AE4D59B5CAAD568F083AD07946E6CB5817531680BCE6E215C16973CD39003B0425F3477CFD854E89A9DB6597"
   },
   ....
   }
  }
  The relative URLs are pointing to immutable OpenAPI descriptions, in
  order to improve client-side caching. The proper HTTP caching headers
  are also set by the API server for that purpose (Expires to 1 year in
  the future, and Cache-Control to immutable). When an obsolete URL is
  used, the API server returns a redirect to the newest URL.The Kubernetes API server publishes an OpenAPI v3 spec per Kubernetes
  group version at the /openapi/v3/apis/<group>/<version>?hash=<hash>
  endpoint.Refer to the table below for accepted request headers.Valid request header values for OpenAPI v3 queriesHeaderPossible valuesNotesAccept-Encodinggzipnot supplying this header is also acceptableAcceptapplication/com.github.proto-openapi.spec.v3@v1.0+protobufmainly for intra-cluster useapplication/jsondefault*serves application/jsonA Golang implementation to fetch the OpenAPI V3 is provided in the package
  k8s.io/client-go/openapi3.Kubernetes 1.33 publishes
  OpenAPI v2.0 and v3.0; there are no plans to support 3.1 in the near future.Protobuf serializationKubernetes implements an alternative Protobuf based serialization format that
  is primarily intended for intra-cluster communication. For more information
  about this format, see the Kubernetes Protobuf serialization
  design proposal and the
  Interface Definition Language (IDL) files for each schema located in the Go
  packages that define the API objects.PersistenceKubernetes stores the serialized state of objects by writing them into
  etcd.API groups and versioningTo make it easier to eliminate fields or restructure resource representations,
  Kubernetes supports multiple API versions, each at a different API path, such
  as /api/v1 or /apis/rbac.authorization.k8s.io/v1alpha1.Versioning is done at the API level rather than at the resource or field level
  to ensure that the API presents a clear, consistent view of system resources
  and behavior, and to enable controlling access to end-of-life and/or
  experimental APIs.To make it easier to evolve and to extend its API, Kubernetes implements
  API groups that can be
  enabled or disabled.API resources are distinguished by their API group, resource type, namespace
  (for namespaced resources), and name. The API server handles the conversion between
  API versions transparently: all the different versions are actually representations
  of the same persisted data. The API server may serve the same underlying data
  through multiple API versions.For example, suppose there are two API versions, v1 and v1beta1, for the same
  resource. If you originally created an object using the v1beta1 version of its
  API, you can later read, update, or delete that object using either the v1beta1
  or the v1 API version, until the v1beta1 version is deprecated and removed.
  At that point you can continue accessing and modifying the object using the v1 API.API changesAny system that is successful needs to grow and change as new use cases emerge or existing ones change.
  Therefore, Kubernetes has designed the Kubernetes API to continuously change and grow.
  The Kubernetes project aims to not break compatibility with existing clients, and to maintain that
  compatibility for a length of time so that other projects have an opportunity to adapt.In general, new API resources and new resource fields can be added often and frequently.
  Elimination of resources or fields requires following the
  API deprecation policy.Kubernetes makes a strong commitment to maintain compatibility for official Kubernetes APIs
  once they reach general availability (GA), typically at API version v1. Additionally,
  Kubernetes maintains compatibility with data persisted via beta API versions of official Kubernetes APIs,
  and ensures that data can be converted and accessed via GA API versions when the feature goes stable.If you adopt a beta API version, you will need to transition to a subsequent beta or stable API version
  once the API graduates. The best time to do this is while the beta API is in its deprecation period,
  since objects are simultaneously accessible via both API versions. Once the beta API completes its
  deprecation period and is no longer served, the replacement API version must be used.Note:Although Kubernetes also aims to maintain compatibility for alpha APIs versions, in some
  circumstances this is not possible. If you use any alpha API versions, check the release notes
  for Kubernetes when upgrading your cluster, in case the API did change in incompatible
  ways that require deleting all existing alpha objects prior to upgrade.Refer to API versions reference
  for more details on the API version level definitions.API ExtensionThe Kubernetes API can be extended in one of two ways:Custom resources
  let you declaratively define how the API server should provide your chosen resource API.You can also extend the Kubernetes API by implementing an
  aggregation layer.What's nextLearn how to extend the Kubernetes API by adding your own
  CustomResourceDefinition.Controlling Access To The Kubernetes API describes
  how the cluster manages authentication and authorization for API access.Learn about API endpoints, resource types and samples by reading
  API Reference.Learn about what constitutes a compatible change, and how to change the API,
  ```