Pods are ephemeral — their IPs change on every restart. A Service provides a stable endpoint (a fixed IP and DNS name) that load-balances across a set of Pods. It's the primary mechanism for service discovery and internal/external traffic routing in Kubernetes.

1. ClusterIP — Internal Service Discovery

The default Service type. Creates a virtual IP (ClusterIP) accessible only within the cluster.

apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP                # default — can omit
  selector:
    app: web                     # finds Pods with this label
  ports:
    - name: http
      port: 80                   # Service port (what clients connect to)
      targetPort: 8080           # Pod port (where traffic is forwarded)
      protocol: TCP

How It Works

port vs targetPort vs containerPort

# targetPort can reference a named port:
spec:
  ports:
    - port: 80
      targetPort: http-server    # ← references the Pod's named port
---
# In the Pod:
ports:
  - name: http-server
    containerPort: 8080
# Useful when different Pod versions use different port numbers

2. NodePort — Expose on Every Node

Opens a static port (30000-32767) on every node's IP. External clients connect via <NodeIP>:<NodePort>.

apiVersion: v1
kind: Service
metadata:
  name: web-nodeport
spec:
  type: NodePort
  selector:
    app: web
  ports:
    - port: 80              # ClusterIP port (still created)
      targetPort: 8080      # Pod port
      nodePort: 30080       # Static port on all nodes (optional — auto-assigned if omitted)

Traffic Flow

Client → 192.168.1.10:30080 (any node IP)
       → DNAT to ClusterIP 10.96.0.50:80
       → DNAT to Pod 10.244.2.8:8080

Note: NodePort also creates a ClusterIP — it's a superset.

3. LoadBalancer — Cloud Integration

Provisions an external load balancer (cloud-provider-specific) that routes traffic to the Service's NodePorts.

apiVersion: v1
kind: Service
metadata:
  name: web-lb
  annotations:
    # Cloud-specific annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: nlb     # AWS NLB
    service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
spec:
  type: LoadBalancer
  selector:
    app: web
  ports:
    - port: 443
      targetPort: 8443

What Gets Created

LoadBalancer (external IP: 52.1.2.3)
  └─ NodePort (30080 on all nodes)          ← LB sends traffic here
      └─ ClusterIP (10.96.0.50:443)
          └─ Pods (10.244.x.x:8443)

# Client → 52.1.2.3:443 → Node:30080 → Pod:8443

4. Headless Services (clusterIP: None)

No virtual IP. DNS returns the individual Pod IPs directly. Used for StatefulSets and client-side load balancing.

apiVersion: v1
kind: Service
metadata:
  name: db-headless
spec:
  clusterIP: None           # ← Headless
  selector:
    app: postgres
  ports:
    - port: 5432

# DNS query returns ALL Pod IPs:
nslookup db-headless.default.svc.cluster.local
# 10.244.1.5
# 10.244.2.8
# 10.244.3.2

# With StatefulSet: individual Pod DNS records too:
# postgres-0.db-headless.default.svc.cluster.local → 10.244.1.5

5. ExternalName — DNS Alias

Maps a Service name to an external DNS name. No proxying, no ClusterIP — just a CNAME record.

apiVersion: v1
kind: Service
metadata:
  name: external-db
spec:
  type: ExternalName
  externalName: prod-db.abc123.us-east-1.rds.amazonaws.com

# Inside the cluster:
nslookup external-db.default.svc.cluster.local
# → CNAME: prod-db.abc123.us-east-1.rds.amazonaws.com

# Code just connects to "external-db:5432" — unaware it's external

Use case: Abstract external dependencies behind a K8s Service name. If you later migrate the database into the cluster, just change the Service from ExternalName to ClusterIP — no code changes needed.

6. Advanced Service Features

Session Affinity

spec:
  sessionAffinity: ClientIP        # Same client → same Pod
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 10800        # 3 hours (default)
# Uses source IP to pin connections. Useful for stateful apps
# that store session in memory (not recommended — use external session store)

externalTrafficPolicy

spec:
  type: LoadBalancer
  externalTrafficPolicy: Local     # Preserve client source IP
# The LB health-checks which nodes have Pods — only sends traffic there
# Pods on other nodes are unreachable via this path

Topology Aware Hints (K8s 1.23+)

metadata:
  annotations:
    service.kubernetes.io/topology-mode: Auto
# kube-proxy routes traffic to Pods in the SAME zone preferentially
# Reduces cross-zone data transfer costs (significant on cloud)
# Falls back to other zones if local zone has insufficient capacity

Multi-Port Services

spec:
  ports:
    - name: http             # name required when multiple ports
      port: 80
      targetPort: 8080
    - name: https
      port: 443
      targetPort: 8443
    - name: metrics
      port: 9090
      targetPort: 9090

7. EndpointSlices — How Services Find Pods

When a Service selector matches Pods, Kubernetes creates EndpointSlice objects listing the backing Pod IPs. kube-proxy watches these to build its routing rules.

# Inspect endpoints:
kubectl get endpointslices -l kubernetes.io/service-name=web
# NAME       ADDRESSTYPE   PORTS   ENDPOINTS                     AGE
# web-abc    IPv4          8080    10.244.1.5,10.244.2.8,...     5d

kubectl describe endpointslice web-abc
# Endpoints:
#   - Addresses: 10.244.1.5
#     Conditions: Ready=true
#     TargetRef: Pod/web-abc123
#     NodeName: worker-1
#     Zone: us-east-1a

Services Without Selectors

You can create a Service that points to external IPs by manually creating Endpoints:

# Service without selector:
apiVersion: v1
kind: Service
metadata:
  name: external-api
spec:
  ports:
    - port: 443
---
# Manual EndpointSlice (or Endpoints):
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
  name: external-api-1
  labels:
    kubernetes.io/service-name: external-api
addressType: IPv4
ports:
  - port: 443
endpoints:
  - addresses: ["203.0.113.50", "203.0.113.51"]

Use case: Route to external services (databases, APIs) through a K8s Service name while controlling the endpoint IPs manually.

Summary: Service Types at a Glance