O que são Services no Kubernetes, e qual a diferença entre ClusterIP, NodePort e LoadBalancer?

Question

IT Interview Practice · Accepted Answer

Um **Service** dá uma identidade de rede estável (um IP virtual e um nome DNS) a um *conjunto de Pods* selecionado por labels. Como os Pods são efêmeros e mudam de IP, o Service é o endereço durável que os clientes usam, e ele faz **load-balance** entre os Pods saudáveis por trás dele.

## Por que existem Services

```text
Pods vão e vêm (novo IP cada vez). Clientes precisam de um ENDPOINT ESTÁVEL.
Um Service:
  → seleciona Pods por label  (selector: app=web)
  → recebe um IP virtual fixo + nome DNS (web.default.svc.cluster.local)
  → faz load-balance das requisições entre os Pods correspondentes e READY
```

## Os três principais tipos de Service

```text
ClusterIP    (padrão)   → alcançável APENAS dentro do cluster
                          para comunicação pod-a-pod / entre serviços internos
NodePort               → abre uma porta em TODOS os nodes (30000-32767)
                          tráfego externo chega em nodeIP:nodePort → Service → Pods
LoadBalancer           → provisiona um load balancer externo na cloud
                          fornece um IP público que roteia para o Service
```

```text
       Internet
          │
   ┌──────┴───────┐
   │ LoadBalancer │  (LB da cloud, IP público)  ← para serviços públicos
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  NodePort    │  (node:30080)             ← expõe em cada node
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  ClusterIP   │  (10.96.x.x, interno)     ← o bloco de construção base
   └──────┬───────┘
       Pods (app=web)
O LoadBalancer é construído sobre o NodePort, que é construído sobre o ClusterIP.
```

## ClusterIP (interno)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # padrão; pode ser omitido
  selector:
    app: web               # corresponde aos Pods com label app=web
  ports:
    - port: 80             # porta do Service
      targetPort: 8080     # porta do container
```

Outros Pods o alcançam por DNS: `http://web` (mesmo namespace) ou `http://web.default.svc.cluster.local`.

## NodePort e LoadBalancer

```yaml
# NodePort — cada node escuta na nodePort e encaminha para o Service
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # opcional; 30000-32767
---
# LoadBalancer — a cloud provisiona um LB externo com IP público
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  # os IPs reais dos Pods por trás do Service
```

## Por que isso importa

Os Services são como a rede funciona no Kubernetes, então entendê-los e à hierarquia de tipos é conhecimento essencial e do dia a dia. Como os Pods são efêmeros e recebem novos IPs a cada recriação, você não pode apontar os clientes diretamente para IPs de Pods; um **Service** resolve isso fornecendo um **IP virtual e nome DNS estáveis** na frente de um conjunto de Pods selecionado por label, e fazendo **load-balance** do tráfego apenas entre os Pods que estão Ready. Os três tipos formam uma progressão em camadas: **ClusterIP** (o padrão) dá um endereço apenas interno para comunicação pod-a-pod e serviço-a-serviço e é o bloco de construção base; **NodePort** abre uma porta fixa em cada node para que o tráfego externo possa chegar ao Service; e **LoadBalancer** vai além provisionando um load balancer externo na cloud com um IP público — cada tipo construído sobre o anterior. Saber qual usar — ClusterIP para tráfego interno de microservices, NodePort para acesso externo básico ou setups on-prem, LoadBalancer para expor um endpoint público numa cloud (e, na prática, Ingress na frente de Services ClusterIP para roteamento HTTP) — é central para projetar como os componentes conversam entre si e com o mundo externo. Como quase todo workload real precisa de conectividade estável e load balancing, entender os Services e seus tipos é conhecimento fundamental de rede no Kubernetes, que aparece constantemente tanto no design quanto no debugging.

Por que existem Services

Os três principais tipos de Service

ClusterIP (interno)

NodePort e LoadBalancer

Por que isso importa

Perguntas relacionadas