Vad är Services i Kubernetes, och vad är skillnaden mellan ClusterIP, NodePort och LoadBalancer?

Question

IT Interview Practice · Accepted Answer

En **Service** ger en stabil nätverksidentitet (en virtuell IP och ett DNS-namn) till en *uppsättning Pods* som väljs via labels. Eftersom Pods är efemära och byter IP är Service:en den beständiga adress som klienter använder, och den **load-balanserar** över de friska Pods bakom den.

## Varför Services finns

```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
```

## De tre huvudsakliga Service-typerna

```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 (internt)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # standard; kan utelämnas
  selector:
    app: web               # matchar Pods med label app=web
  ports:
    - port: 80             # Service-port
      targetPort: 8080     # container-port
```

Andra Pods når den via DNS: `http://web` (samma namespace) eller `http://web.default.svc.cluster.local`.

## NodePort och LoadBalancer

```yaml
# NodePort — varje nod lyssnar på nodePort och vidarebefordrar till Service:en
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # valfritt; 30000-32767
---
# LoadBalancer — molnet tillhandahåller en extern LB med en publik IP
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # se typer, cluster-IP:er och externa IP:er
kubectl get endpoints web  # de faktiska Pod-IP:erna bakom Service:en
```

## Varför det är viktigt

Services är hur nätverk fungerar i Kubernetes, så att förstå dem och typhierarkin är väsentlig, daglig kunskap. Eftersom Pods är efemära och får nya IP:er vid varje återskapande kan du inte peka klienter direkt mot Pod-IP:er; en **Service** löser detta genom att tillhandahålla en **stabil virtuell IP och ett DNS-namn** framför en label-vald uppsättning Pods, och genom att **load-balansera** trafik enbart över de Pods som är Ready. De tre typerna bildar en skiktad progression: **ClusterIP** (standard) ger en enbart intern adress för kommunikation pod-till-pod och service-till-service och är basbyggstenen; **NodePort** öppnar en fast port på varje nod så att extern trafik kan nå Service:en; och **LoadBalancer** går längre genom att tillhandahålla en extern molnbaserad load balancer med en publik IP — varje typ byggd på den under den. Att veta vilken man ska ta till — ClusterIP för intern mikrotjänsttrafik, NodePort för grundläggande extern åtkomst eller on-prem-uppsättningar, LoadBalancer för att exponera en publik endpoint i ett moln (och, i praktiken, Ingress framför ClusterIP-Services för HTTP-routing) — är centralt för att designa hur komponenter pratar med varandra och med omvärlden. Eftersom nästan varje verklig workload behöver stabil anslutning och load balancing är förståelse av Services och deras typer grundläggande Kubernetes-nätverkskunskap som dyker upp ständigt i både design och felsökning.

Varför Services finns

De tre huvudsakliga Service-typerna

ClusterIP (internt)

NodePort och LoadBalancer

Varför det är viktigt

Relaterade frågor