¿Qué son los Services en Kubernetes y cuál es la diferencia entre ClusterIP, NodePort y LoadBalancer?

Question

IT Interview Practice · Accepted Answer

Un **Service** otorga una identidad de red estable (una IP virtual y un nombre DNS) a un *conjunto de Pods* seleccionados por labels. Como los Pods son efímeros y cambian de IP, el Service es la dirección duradera que usan los clientes, y hace **load balancing** entre los Pods sanos que hay detrás.

## Por qué existen los Services

```text
Los Pods van y vienen (IP nueva cada vez). Los clientes necesitan un ENDPOINT ESTABLE.
Un Service:
  → selecciona Pods por label  (selector: app=web)
  → obtiene una IP virtual fija + nombre DNS (web.default.svc.cluster.local)
  → hace load balancing de las peticiones entre los Pods que coinciden y están READY
```

## Los tres tipos principales de Service

```text
ClusterIP    (por defecto)  → alcanzable SOLO dentro del cluster
                              para comunicación pod-a-pod / entre servicios internos
NodePort               → abre un puerto en CADA node (30000-32767)
                          el tráfico externo llega a nodeIP:nodePort → Service → Pods
LoadBalancer           → provisiona un load balancer de cloud externo
                          da una IP pública que enruta al Service
```

```text
       Internet
          │
   ┌──────┴───────┐
   │ LoadBalancer │  (LB de cloud, IP pública)  ← para servicios públicos
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  NodePort    │  (node:30080)            ← expone en cada node
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  ClusterIP   │  (10.96.x.x, interno)    ← el bloque de construcción base
   └──────┬───────┘
       Pods (app=web)
LoadBalancer se apoya en NodePort, que se apoya en ClusterIP.
```

## ClusterIP (interno)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # por defecto; puede omitirse
  selector:
    app: web               # coincide con los Pods con label app=web
  ports:
    - port: 80             # puerto del Service
      targetPort: 8080     # puerto del contenedor
```

Otros Pods lo alcanzan por DNS: `http://web` (mismo namespace) o `http://web.default.svc.cluster.local`.

## NodePort y LoadBalancer

```yaml
# NodePort — cada node escucha en nodePort y reenvía al Service
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # opcional; 30000-32767
---
# LoadBalancer — el cloud provisiona un LB externo con una IP pública
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # ver tipos, cluster IPs e external IPs
kubectl get endpoints web  # las IPs reales de los Pods detrás del Service
```

## Por qué es importante

Los Services son la forma en que funciona la red en Kubernetes, así que entenderlos y entender la jerarquía de tipos es conocimiento esencial y de uso diario. Como los Pods son efímeros y reciben IPs nuevas en cada recreación, no puedes apuntar los clientes directamente a las IPs de los Pods; un **Service** resuelve esto proporcionando una **IP virtual y un nombre DNS estables** por delante de un conjunto de Pods seleccionado por label, y haciendo **load balancing** del tráfico solo entre los Pods que están Ready. Los tres tipos forman una progresión estratificada: **ClusterIP** (el valor por defecto) da una dirección solo interna para comunicación pod-a-pod y servicio-a-servicio y es el bloque de construcción base; **NodePort** abre un puerto fijo en cada node para que el tráfico externo pueda alcanzar el Service; y **LoadBalancer** va más allá provisionando un load balancer de cloud externo con una IP pública, construyéndose cada tipo sobre el de debajo. Saber cuál elegir —ClusterIP para tráfico interno entre microservicios, NodePort para acceso externo básico o entornos on-prem, LoadBalancer para exponer un endpoint público en un cloud (y, en la práctica, Ingress por delante de Services ClusterIP para el enrutamiento HTTP)— es central para diseñar cómo se comunican los componentes entre sí y con el mundo exterior. Como casi todo workload real necesita conectividad estable y load balancing, entender los Services y sus tipos es conocimiento fundamental de la red de Kubernetes que aparece constantemente tanto al diseñar como al depurar.

Por qué existen los Services

Los tres tipos principales de Service

ClusterIP (interno)

NodePort y LoadBalancer

Por qué es importante

Preguntas relacionadas