What are Services in Kubernetes, and what is the difference between ClusterIP, NodePort, and LoadBalancer?

Question

IT Interview Practice · Accepted Answer

A **Service** gives a stable network identity (a virtual IP and a DNS name) to a *set of Pods* selected by labels. Since Pods are ephemeral and change IPs, the Service is the durable address clients use, and it **load-balances** across the healthy Pods behind it.

## Why Services exist

```text
Pods come and go (new IP each time). Clients need a STABLE endpoint.
A Service:
  → selects Pods by label  (selector: app=web)
  → gets a fixed virtual IP + DNS name (web.default.svc.cluster.local)
  → load-balances requests across the matching, READY Pods
```

## The three main Service types

```text
ClusterIP    (default)  → reachable ONLY inside the cluster
                          for pod-to-pod / internal service communication
NodePort               → opens a port on EVERY node (30000-32767)
                          external traffic hits nodeIP:nodePort → Service → Pods
LoadBalancer           → provisions an external cloud load balancer
                          gives a public IP that routes to the Service
```

```text
       Internet
          │
   ┌──────┴───────┐
   │ LoadBalancer │  (cloud LB, public IP)   ← for public services
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  NodePort    │  (node:30080)            ← exposes on each node
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  ClusterIP   │  (10.96.x.x, internal)   ← the base building block
   └──────┬───────┘
       Pods (app=web)
LoadBalancer builds on NodePort, which builds on ClusterIP.
```

## ClusterIP (internal)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # default; can be omitted
  selector:
    app: web               # matches Pods labelled app=web
  ports:
    - port: 80             # Service port
      targetPort: 8080     # container port
```

Other Pods reach it by DNS: `http://web` (same namespace) or `http://web.default.svc.cluster.local`.

## NodePort and LoadBalancer

```yaml
# NodePort — every node listens on nodePort and forwards to the Service
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # optional; 30000-32767
---
# LoadBalancer — cloud provisions an external LB with a public IP
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # see types, cluster IPs and external IPs
kubectl get endpoints web  # the actual Pod IPs behind the Service
```

## Why it matters

Services are how networking works in Kubernetes, so understanding them and the type hierarchy is essential, everyday knowledge. Because Pods are ephemeral and get new IPs on every recreation, you cannot point clients at Pod IPs directly; a **Service** solves this by providing a **stable virtual IP and DNS name** in front of a label-selected set of Pods, and by **load-balancing** traffic across only the Pods that are Ready. The three types form a layered progression: **ClusterIP** (the default) gives an internal-only address for pod-to-pod and service-to-service communication and is the base building block; **NodePort** opens a fixed port on every node so external traffic can reach the Service; and **LoadBalancer** goes further by provisioning an external cloud load balancer with a public IP — each type building on the one below it. Knowing which to reach for — ClusterIP for internal microservice traffic, NodePort for basic external access or on-prem setups, LoadBalancer for exposing a public endpoint on a cloud (and, in practice, Ingress in front of ClusterIP Services for HTTP routing) — is core to designing how components talk to each other and to the outside world. Since almost every real workload needs stable connectivity and load balancing, understanding Services and their types is foundational Kubernetes networking knowledge that comes up constantly in both design and debugging.

Why Services exist

The three main Service types

ClusterIP (internal)

NodePort and LoadBalancer

Why it matters

Related questions