Curso Kubernetes 09 — Services, Ingress, DNS e TLS

Pods nascem e morrem com IPs diferentes. Nenhum cliente sério vai acompanhar isso. O Service dá um nome e um IP estável; o Ingress dá uma porta de entrada HTTP(S); o DNS resolve nomes; o TLS protege o caminho.

Selo do curso: testado em Kubernetes 1.35, ingress-nginx e cert-manager.

Service: o nome estável

Um Service seleciona pods por label e balanceia o tráfego.

apiVersion: v1
kind: Service
metadata:
  name: api
  namespace: portal
spec:
  selector:
    app: api
  ports:
    - port: 80
      targetPort: 8080
  type: ClusterIP

Tipos:

Tipo	Acesso	Uso
ClusterIP	interno	padrão; app → app
NodePort	porta em cada nó	laboratório, acesso direto
LoadBalancer	IP externo	cloud com LB
ExternalName	CNAME	apontar para serviço externo
Headless (clusterIP: None)	DNS por pod	StatefulSet

Verifique se o Service encontrou os pods:

kubectl -n portal get endpoints api
kubectl -n portal get endpointslices

Se ENDPOINTS estiver vazio, o selector não casou com nenhum pod ou os pods não estão Ready. Esse é o erro nº 1 de Service.

DNS

O CoreDNS resolve nomes dentro do cluster:

api.portal.svc.cluster.local

Dentro do mesmo namespace, api já resolve. Entre namespaces, use api.portal ou o FQDN completo.

kubectl -n portal run dns --image=busybox:1.36 --rm -it --restart=Never -- \
  nslookup api.portal

Cuidado com ndots e search domains: nomes parciais podem ser tentados em vários sufixos antes de resolver. Em aplicações com latência sensível, use o FQDN.

NodePort e LoadBalancer

NodePort abre uma porta (30000–32767) em todos os nós:

spec:
  type: NodePort
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080

É útil para laboratório, mas ruim para produção: expõe portas, não faz TLS e depende do IP do nó. Em cloud, LoadBalancer provisiona um LB; em bare-metal, você precisa de MetalLB ou equivalente.

Ingress: a porta HTTP

Ingress é uma regra L7: host + path → Service.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: portal
  namespace: portal
spec:
  ingressClassName: nginx
  rules:
    - host: portal.exemplo.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: frontend
                port:
                  number: 80
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api
                port:
                  number: 80

Requisitos:

• Um Ingress Controller instalado (ingress-nginx, Traefik, etc.).
• ingressClassName correto.
• DNS do host apontando para o controller.
• Service com endpoints saudáveis.

Teste localmente com --resolve:

curl -k --resolve portal.exemplo.com:443:127.0.0.1 https://portal.exemplo.com/

TLS com cert-manager

O cert-manager emite e renova certificados. Um ClusterIssuer para Let's Encrypt:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: [email protected]
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
      - http01:
          ingress:
            class: nginx

No Ingress:

metadata:
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
    - hosts:
        - portal.exemplo.com
      secretName: portal-tls

Acompanhe:

kubectl -n portal get certificate,order,challenge
kubectl -n portal describe certificate portal-tls

Use o staging do Let's Encrypt nos testes: o produção tem rate limit e você vai bater nele.

Laboratório

1. Suba um Deployment e um Service ClusterIP.
2. Teste com port-forward.
3. Crie um Ingress com host fictício e teste com --resolve.
4. Emita um certificado (staging) e confira o secret TLS.
5. Force HTTP → HTTPS com annotation do ingress-nginx.

Erros comuns

Sintoma	Causa
Service sem endpoints	selector errado ou pods não Ready
404 no Ingress	host/path não casam ou class errada
502/503	Service sem endpoints ou app fora do ar
Certificado não emitido	DNS não aponta, challenge bloqueado ou rate limit
default backend - 404	Ingress não encontrado no controller
DNS não resolve	CoreDNS quebrado ou namespace errado

Checklist

• [ ] Service com selector e endpoints corretos.
• [ ] Sei a diferença entre ClusterIP, NodePort e Ingress.
• [ ] Ingress com ingressClassName e DNS apontando.
• [ ] TLS emitido e renovando.
• [ ] Testei HTTP → HTTPS.
• [ ] Não expus NodePort desnecessariamente.

Glossário

• ClusterIP: IP virtual interno do Service.
• EndpointSlice: lista de pods prontos atrás do Service.
• Ingress: regra L7 de entrada.
• Ingress Controller: implementação que aplica o Ingress.
• ACME: protocolo do Let's Encrypt.
• ClusterIssuer: emissor de certificados cluster-wide.

Próximo

Agora que a aplicação está acessível, vamos ao capítulo mais útil do curso: o que fazer quando o pod não sobe.

Próximo: Curso Kubernetes 10 — O primeiro “não subiu”: diagnosticando pods