instruction: Create a Kubernetes Service configuration with best practices
output: ```dockerfile
  from being used as a proxy to endpoints the caller may not be authorized to access.
  
  An ExternalName Service is a special case of Service that does not have
  selectors and uses DNS names instead. For more information, see the
  ExternalName section.
  EndpointSlices
  
  FEATURE STATE: Kubernetes v1.21 [stable]
  
  EndpointSlices are objects that
  represent a subset (a slice) of the backing network endpoints for a Service.
  Your Kubernetes cluster tracks how many endpoints each EndpointSlice represents.
  If there are so many endpoints for a Service that a threshold is reached, then
  Kubernetes adds another empty EndpointSlice and stores new endpoint information
  there.
  By default, Kubernetes makes a new EndpointSlice once the existing EndpointSlices
  all contain at least 100 endpoints. Kubernetes does not make the new EndpointSlice
  until an extra endpoint needs to be added.
  See EndpointSlices for more
  information about this API.
  Endpoints
  In the Kubernetes API, an
  Endpoints
  (the resource kind is plural) defines a list of network endpoints, typically
  referenced by a Service to define which Pods the traffic can be sent to.
  The EndpointSlice API is the recommended replacement for Endpoints.
  Over-capacity endpoints
  Kubernetes limits the number of endpoints that can fit in a single Endpoints
  object. When there are over 1000 backing endpoints for a Service, Kubernetes
  truncates the data in the Endpoints object. Because a Service can be linked
  with more than one EndpointSlice, the 1000 backing endpoint limit only
  affects the legacy Endpoints API.
  In that case, Kubernetes selects at most 1000 possible backend endpoints to store
  into the Endpoints object, and sets an
  annotation on the Endpoints:
  endpoints.kubernetes.io/over-capacity: truncated.
  The control plane also removes that annotation if the number of backend Pods drops below 1000.
  Traffic is still sent to backends, but any load balancing mechanism that relies on the
  legacy Endpoints API only sends traffic to at most 1000 of the available backing endpoints.
  The same API limit means that you cannot manually update an Endpoints to have more than 1000 endpoints.
  Application protocol
  
  FEATURE STATE: Kubernetes v1.20 [stable]
  
  The appProtocol field provides a way to specify an application protocol for
  each Service port. This is used as a hint for implementations to offer
  richer behavior for protocols that they understand.
  The value of this field is mirrored by the corresponding
  Endpoints and EndpointSlice objects.
  This field follows standard Kubernetes label syntax. Valid values are one of:
  
  IANA standard service names.
  
  Implementation-defined prefixed names such as mycompany.com/my-custom-protocol.
  
  Kubernetes-defined prefixed names:
  
  Protocol
  Description
  
  kubernetes.io/h2c
  HTTP/2 over cleartext as described in RFC 7540
  
  Multi-port Services
  For some Services, you need to expose more than one port.
  Kubernetes lets you configure multiple port definitions on a Service object.
  When using multiple ports for a Service, you must give all of your ports names
  so that these are unambiguous.
  For example:
  apiVersion: v1
  kind: Service
  metadata:
   name: my-service
  spec:
   selector:
   app.kubernetes.io/name: MyApp
   ports:
   - name: http
   protocol: TCP
   port: 80
   targetPort: 9376
   - name: https
   protocol: TCP
   port: 443
   targetPort: 9377
  
  Note: As with Kubernetes names in general, names for ports
  must only contain lowercase alphanumeric characters and -. Port names must
  also start and end with an alphanumeric character.
  For example, the names 123-abc and web are valid, but 123_abc and -web are not.
  
  Service type
  For some parts of your application (for example, frontends) you may want to expose a
  Service onto an external IP address, one that's accessible
  ```