In Kubernetes a deployment is a method of launching a pod with containerized applications and ensuring that the necessary number of replicas is always running on the cluster.

On the other hand, a service is responsible for exposing an interface to those pods, which enables network access from either within the cluster or between external processes and the service.

Kubernetes services connect a set of pods to an abstracted service name and IP address. Services provide discovery and routing between pods. For example, services connect an application front-end to its backend, each of which running in separate deployments in a cluster. Services use labels and selectors to match pods with other applications. The core attributes of a Kubernetes service are:

• A label selector that locates pods
• The clusterIP IP address and assigned port number
• Port definitions
• Optional mapping of incoming ports to a targetPort

Services can be defined without pod selectors. For example, to point a service to another service in a different namespace or cluster.

• ClusterIP. Exposes a service which is only accessible from within the cluster.
• NodePort. Exposes a service via a static port on each node’s IP.
• LoadBalancer. Exposes the service via the cloud provider’s load balancer.
• ExternalName. Maps a service to a predefined externalName field by returning a value for the CNAME record.

What is the Kubernetes ClusterIP service?

ClusterIP is the default type of service, which is used to expose a service on an IP address internal to the cluster. Access is only permitted from within the cluster.

What is a Kubernetes Headless Service?

Services that do not need load balancing and only expose a single IP can create a ‘headless’ service by specifying “none” as the clusterIP.

Headless services can be defined with selectors, in which case endpoint records are created in the API that modify the DNS to return addresses that point to pods that are exposing the service. Headless services without selectors don’t create endpoint records. The DNS system configures either the CNAME record or a record for endpoints with the same name as the service.

What is a Kubernetes NodePort service?

NodePorts are open ports on every cluster node. Kubernetes will route traffic that comes into a NodePort to the service, even if the service is not running on that node. NodePort is intended as a foundation for other higher-level methods of ingress such as load balancers and are useful in development.

What is a Kubernetes ExternalName service?

ExternalName services are similar to other Kubernetes services; however, instead of being accessed via a clusterIP address, it returns a CNAME record with a value that is defined in the externalName: parameter when creating the service.

What is a Kubernetes Load Balancer service?

For clusters running on public cloud providers like AWS or Azure, creating a load LoadBalancer service provides an equivalent to a clusterIP service, extending it to an external load balancer that is specific to the cloud provider. Kubernetes will automatically create the load balancer, provide firewall rules if needed, and populate the service with the external IP address assigned by the cloud provider.

Services simply point to pods using labels. Since services are not node-specific, a service can point to a pod regardless of where it runs in the cluster at any given moment in time. By exposing a service IP address as well as a DNS service name, the application can be reached by either method as long as the service exists.

Services are defined in YAML, as are all Kubernetes objects. Suppose you deployed pods running a back-end service to process data coming from a web front end. To expose a service named ‘service-backend’ on the deployment ‘deployment-backend’ you would use:

apiVersion: v1

kind: Service

metadata:

name: service-backend

spec:

ports:

- port: 4000

protocol: TCP

targetPort: 333

selector:

run: deployment-backend

type: ClusterIP

The service ‘service-backend’ will be created, and any pod in the cluster can access it on their port 333 via http://service-backend:4000, or at the cluster’s IP address using port 4000.

Kubernetes services can also be created using the ‘kubectl expose’ command, which does not require a YAML file. The same service can be created using the command:

kubectl expose deployment deployment-backend - - port=333- - target-port=4000 - - name=service-backend

There are two ways to discover a Kubernetes service:

DNS (most common): The DNS method is the recommended method of discovering services. To use this method, a DNS server must first be installed on the cluster. The DNS server monitors the Kubernetes API, and when a new service is created its name becomes available for easy resolution for requesting applications.

ENV variable: This method relies on the kubelet adding environment variables for each active service for every node a pod is running on.