The Project | About Us | Contribute | Donations | License

HOME

In Kubernetes, a Service is an abstraction that defines a logical set of Pods and a policy by which to access them. Services enable communication between different components of an application, whether they are within the same cluster or external to it. Kubernetes supports several types of Services, each suited to different use cases.

Types of Services

ClusterIP (default)
NodePort
LoadBalancer
ExternalName

ClusterIP

ClusterIP is the default type of Service. It exposes the Service on an internal IP in the cluster. This type of Service is only accessible within the cluster.

Use Case:

Internal communication between different components of an application.

Example:

apiVersion: v1
kind: Service
metadata:
  name: my-clusterip-service
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376
  type: ClusterIP

In this example:

The Service is named my-clusterip-service.
It selects Pods with the label app: MyApp.
It exposes port 80 and forwards traffic to port 9376 on the selected Pods.

NodePort

NodePort exposes the Service on each Node's IP at a static port (the NodePort). A ClusterIP Service, to which the NodePort Service routes, is automatically created.

Use Case:

Exposing a Service to be accessible from outside the cluster.

Example:

apiVersion: v1
kind: Service
metadata:
  name: my-nodeport-service
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376
      nodePort: 30007
  type: NodePort

In this example:

The Service is named my-nodeport-service.
It selects Pods with the label app: MyApp.
It exposes port 80 and forwards traffic to port 9376 on the selected Pods.
The Service is accessible on port 30007 on each Node's IP.

LoadBalancer

LoadBalancer exposes the Service externally using a cloud provider's load balancer. It is an extension of the NodePort and ClusterIP types.

Use Case:

Exposing a Service to be accessible from outside the cluster with load balancing.

Example:

apiVersion: v1
kind: Service
metadata:
  name: my-loadbalancer-service
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376
  type: LoadBalancer

In this example:

The Service is named my-loadbalancer-service.
It selects Pods with the label app: MyApp.
It exposes port 80 and forwards traffic to port 9376 on the selected Pods.
The cloud provider will provision a load balancer that routes traffic to the NodePort Service.

ExternalName

ExternalName maps a Service to the contents of the externalName field (e.g., foo.bar.example.com), returning a CNAME record with its value. No proxying of any kind is set up.

Use Case:

Mapping a Service to an external DNS name.

Example:

apiVersion: v1
kind: Service
metadata:
  name: my-externalname-service
spec:
  type: ExternalName
  externalName: my.database.example.com

In this example:

The Service is named my-externalname-service.
It maps to the external DNS name my.database.example.com.

Practical Exercise

Task:

Create a Kubernetes Service of type NodePort that exposes a simple web application running in a Pod.

Steps:

Create a Pod definition file webapp-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: webapp
  labels:
    app: webapp
spec:
  containers:
  - name: webapp
    image: nginx
    ports:
    - containerPort: 80

Apply the Pod definition:

kubectl apply -f webapp-pod.yaml

Create a Service definition file webapp-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: webapp-service
spec:
  selector:
    app: webapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30008
  type: NodePort

Apply the Service definition:

kubectl apply -f webapp-service.yaml

Access the web application using the Node's IP and the NodePort (e.g., http://<NodeIP>:30008).

Solution:

Ensure the Pod is running:

kubectl get pods

Ensure the Service is created and accessible:

kubectl get services

Access the web application using a web browser or curl:

curl http://<NodeIP>:30008

Summary

In this section, we covered the different types of Services in Kubernetes:

ClusterIP for internal communication.
NodePort for exposing Services externally.
LoadBalancer for external access with load balancing.
ExternalName for mapping Services to external DNS names.

We also provided a practical exercise to create and expose a web application using a NodePort Service. Understanding these Service types is crucial for managing communication within and outside your Kubernetes cluster.

Service Types

Types of Services

ClusterIP

Use Case:

Example:

NodePort

Use Case:

Example:

LoadBalancer

Use Case:

Example:

ExternalName

Use Case:

Example:

Practical Exercise

Task:

Steps:

Solution:

Summary

Kubernetes Course

Module 1: Introduction to Kubernetes

Module 2: Core Kubernetes Components

Module 3: Configuration and Secrets Management

Module 4: Networking in Kubernetes

Module 5: Storage in Kubernetes

Module 6: Advanced Kubernetes Concepts

Module 7: Monitoring and Logging

Module 8: Security in Kubernetes

Module 9: Scaling and Performance

Module 10: Kubernetes Ecosystem and Tools

Module 11: Case Studies and Real-World Applications

Module 12: Preparing for Kubernetes Certification