Mik azok a Service-ek a Kubernetesben, és mi a különbség a ClusterIP, a NodePort és a LoadBalancer között?

Question

IT Interview Practice · Accepted Answer

Egy **Service** stabil hálózati identitást (egy virtuális IP-t és egy DNS-nevet) ad egy *Podok halmazának*, amelyet label-ek alapján választ ki. Mivel a Podok mulandók és IP-t váltanak, a Service az a tartós cím, amelyet a kliensek használnak, és **load balancingot** végez a mögötte lévő egészséges Podok között.

## Miért léteznek a Service-ek

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

## A három fő Service-típus

```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 (belső)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # alapértelmezett; elhagyható
  selector:
    app: web               # az app=web label-ű Podokra illeszkedik
  ports:
    - port: 80             # a Service portja
      targetPort: 8080     # a konténer portja
```

Más Podok DNS-en érik el: `http://web` (ugyanabban a namespace-ben) vagy `http://web.default.svc.cluster.local`.

## NodePort és LoadBalancer

```yaml
# NodePort — minden node figyel a nodePort-on, és továbbít a Service-nek
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # opcionális; 30000-32767
---
# LoadBalancer — a cloud külső LB-t provisionál publikus IP-vel
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # típusok, cluster IP-k és external IP-k megtekintése
kubectl get endpoints web  # a Service mögötti tényleges Pod IP-k
```

## Miért fontos

A Service-ek adják a hálózatozás működését a Kubernetesben, ezért ezek és a típushierarchia megértése elengedhetetlen, mindennapi tudás. Mivel a Podok mulandók, és minden újralétrehozáskor új IP-t kapnak, nem irányíthatod a klienseket közvetlenül a Podok IP-jére; egy **Service** ezt úgy oldja meg, hogy **stabil virtuális IP-t és DNS-nevet** biztosít egy label alapján kiválasztott Pod-halmaz előtt, és **load balancingot** végez csak a Ready állapotú Podok között. A három típus rétegzett sorozatot alkot: a **ClusterIP** (az alapértelmezett) egy kizárólag belső címet ad a pod-to-pod és service-to-service kommunikációhoz, és ez az alap építőkő; a **NodePort** egy fix portot nyit minden node-on, hogy a külső forgalom elérje a Service-t; a **LoadBalancer** pedig még tovább megy egy külső cloud load balancer provisionálásával, publikus IP-vel — mindegyik típus az alatta lévőre épül. Annak ismerete, melyiket érdemes elővenni — ClusterIP a belső microservice-forgalomhoz, NodePort az alapszintű külső eléréshez vagy on-prem beállításokhoz, LoadBalancer egy publikus végpont közzétételéhez a cloudon (és a gyakorlatban Ingress a ClusterIP Service-ek előtt a HTTP-routingoláshoz) — alapvető annak megtervezéséhez, hogyan beszélnek egymással és a külvilággal a komponensek. Mivel szinte minden valódi workloadnak stabil kapcsolatra és load balancingra van szüksége, a Service-ek és típusaik megértése alapvető Kubernetes-hálózatozási tudás, amely folyamatosan felmerül tervezéskor és hibakereséskor egyaránt.

Miért léteznek a Service-ek

A három fő Service-típus

ClusterIP (belső)

NodePort és LoadBalancer

Miért fontos

Kapcsolódó kérdések