Guía Completa de Kubernetes Ingress
Configura y soluciona problemas de Kubernetes Ingress. Cubre controladores, TLS con cert-manager, enrutamiento por path, anotaciones y Gateway API.
Introducción
Tienes tres servicios detrás de un mismo dominio — una API, un frontend web y un panel de administración — y cada uno necesita HTTPS. Un balanceador de carga en la nube por servicio funciona, pero acabas con tres IPs públicas, tres configuraciones TLS y ningún punto central para gestionar el enrutamiento. Kubernetes Ingress existe justamente para esto: un único punto de entrada al cluster que reparte las peticiones entre muchos servicios según el hostname y el path.
Esta guía recorre la instalación de un controlador, la escritura de reglas de enrutamiento, la terminación TLS con cert-manager, el ajuste del comportamiento con anotaciones y la depuración de los errores que realmente aparecen en producción. También cubre dónde está parado Ingress hoy: el controlador ingress-nginx fue retirado y Gateway API es el sucesor designado, así que veremos qué significa eso para clusters nuevos y existentes.
Respuesta Rápida
Un Ingress es un conjunto de reglas de enrutamiento L7 — host y path mapeados a un Service — que no hace nada hasta que hay un Ingress controller corriendo en el cluster. Para que el tráfico fluya: instala un controlador mantenido (Traefik, HAProxy o el de tu proveedor cloud), define spec.ingressClassName en cada Ingress y deja que cert-manager emita los certificados TLS. En un cluster recién montado, evalúa Gateway API primero — ahí es donde va la inversión del proyecto.
El resto de esta guía es la versión larga: instalar, enrutar, terminar TLS, ajustar y depurar.
¿Qué es Ingress?
Ingress es un recurso de Kubernetes que gestiona el acceso externo HTTP y HTTPS a los servicios dentro del cluster. Tres piezas importan:
- Ingress resource: un conjunto de reglas de enrutamiento (host, path, servicio backend) guardadas en el API server.
- Ingress controller: un proxy que corre como daemon — NGINX, Traefik, HAProxy, Envoy — que observa los Ingress resources y los convierte en configuración de proxy activa.
- IngressClass: un recurso con alcance de cluster que vincula un Ingress a un controlador concreto, lo que permite que varios controladores coexistan en un mismo cluster.
Sin un controlador, un Ingress resource es solo data en etcd. Nada reacciona a él, y por eso mismo un ingressClassName ausente falla en silencio: ningún controlador reclama el objeto.
Cuándo Usar Ingress
Ingress es la herramienta correcta cuando:
- Varios servicios HTTP comparten un dominio o un puñado de dominios.
- Quieres la terminación TLS centralizada en el borde en vez de por servicio.
- Necesitas enrutamiento por host o por path (
api.example.comvsapp.example.com/api). - Quieres controles L7 en el borde — rate limiting, rewrites, despliegues canary, autenticación básica — sin meterlos en cada aplicación.
No lo uses cuando:
- Un único Service de tipo
LoadBalancercubre la necesidad. Añadir una capa de proxy para una sola app no te compra nada. - Necesitas enrutamiento TCP/UDP crudo — Ingress es solo HTTP/HTTPS (usa
LoadBalancero la configuración de passthrough TCP/UDP del controlador). - Tu service mesh ya gestiona el tráfico norte-sur a través de su propio gateway.
- Estás montando un cluster nuevo — evalúa Gateway API primero, porque ahí es donde Kubernetes está invirtiendo.
Cómo Funciona Ingress
Este es el camino que recorre una petición en un montaje típico:
Dos cosas de este flujo conviene interiorizar. Primero, el Ingress resource no reenvía nada: el controlador se suscribe a los cambios de Ingress, Service y Endpoint en el API server, regenera su configuración de proxy y recarga. Segundo, el enrutamiento apunta a los endpoints del Service, no al Ingress. Si tus pods escalan de 2 a 20, el controlador recoge los nuevos endpoints por su cuenta; nunca tocas el objeto Ingress.
Esa separación entre “reglas” y “ejecutor” es también el origen de la mayoría de la confusión: una ruta rota puede vivir en el Ingress (host/path incorrecto), en el Service (puerto o selector incorrecto) o en el controlador (clase que no coincide, flag ausente). La sección de troubleshooting está ordenada exactamente por esa cadena.
Elegir un Ingress Controller
Contexto que cambia la decisión en 2026: el proyecto Kubernetes anunció el retiro de ingress-nginx, el controlador de la comunidad sobre el que está construida esta guía — y buena parte de internet. El mantenimiento best-effort llegó hasta marzo de 2026; desde entonces no hay releases nuevas, correcciones de errores ni parches de seguridad, aunque el repositorio y los despliegues existentes siguen funcionando.
Tus clusters actuales no se rompen por eso — pero no instales ingress-nginx en un cluster nuevo sin un plan de migración.
| Controlador | Estado | Buena opción cuando |
|---|---|---|
| ingress-nginx | Retirado (sin mantenimiento desde mar 2026) | Ya desplegado; planifica la salida |
| Traefik | Activo | Nativo de Kubernetes, configuración dinámica, soporta Gateway API |
| HAProxy Ingress | Activo | L7 de alto rendimiento, maduro y probado en batalla |
| Kong Ingress | Activo | Quieres capacidades de API gateway (auth, plugins) en el borde |
| NGINX Ingress (F5) | Comercial/activo | Tier de pago NGINX Plus, soporte de vendor |
| Controladores cloud (AWS ALB, GCE, AKS) | Activo | Balanceadores gestionados, integración directa con la nube |
| Envoy Gateway y otras impl. de Gateway API | Activo | Clusters nuevos que van directo a Gateway API |
El resto de esta guía usa ejemplos de ingress-nginx porque sigue siendo lo más desplegado y su modelo de anotaciones es el que asume casi toda la documentación — los conceptos (IngressClass, TLS, reglas, troubleshooting) se transfieren a cualquier controlador. Cuando algo es específico de ingress-nginx, se indica.
Instalar un Ingress Controller
Traefik (recomendado para clusters nuevos)
helm repo add traefik https://traefik.github.io/charts
helm repo update
helm install traefik traefik/traefik \
--namespace traefik \
--create-namespace
ingress-nginx (legacy / clusters existentes)
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install ingress-nginx ingress-nginx/ingress-nginx \
--namespace ingress-nginx \
--create-namespace
# Verificar la instalación
kubectl get pods -n ingress-nginx
kubectl get svc -n ingress-nginx
Verificar el IngressClass
kubectl get ingressclass
# Salida:
# NAME CONTROLLER PARAMETERS AGE
# nginx k8s.io/ingress-nginx <none> 2m
# traefik traefik.io/ingress-controller <none> 1m
Cada Ingress que crees debe referenciar una clase que el controlador realmente atienda, mediante spec.ingressClassName. Los clusters antiguos pueden seguir usando la anotación kubernetes.io/ingress.class — funciona en controladores legacy, pero el campo del spec es la forma documentada, así que úsala.
Ingress Resource Básico
Enrutamiento de un solo servicio
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-app-ingress
spec:
ingressClassName: nginx
rules:
- host: app.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: my-app-service
port:
number: 80
ingressClassName va en spec, no en metadata.annotations — verás ese error en tutoriales viejos y lo único que logra es confundir a quien lea el archivo después.
Enrutamiento por path (varios servicios)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: multi-service-ingress
spec:
ingressClassName: nginx
rules:
- host: app.example.com
http:
paths:
- path: /api
pathType: Prefix
backend:
service:
name: api-service
port:
number: 8080
- path: /web
pathType: Prefix
backend:
service:
name: web-service
port:
number: 80
- path: /
pathType: Prefix
backend:
service:
name: default-service
port:
number: 80
pathType: Prefix coincide en límites de elemento — /api cubre /api y /api/v1, pero no /apis. Usa Exact cuando quieres exactamente esa cadena, y reserva ImplementationSpecific para patrones regex propios del controlador como el ejemplo de rewrite de abajo.
Virtual hosting basado en nombres
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: vhost-ingress
spec:
ingressClassName: nginx
rules:
- host: api.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: api-service
port:
number: 8080
- host: blog.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: blog-service
port:
number: 80
Ambos hosts comparten la IP externa del controlador — el header Host decide a dónde va el tráfico. Este es el patrón que hace que Ingress compense frente a un balanceador por servicio.
Terminación TLS
Instalar cert-manager para TLS automático
helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager jetstack/cert-manager \
--namespace cert-manager \
--create-namespace \
--set crds.enabled=true
El flag de CRDs es crds.enabled desde cert-manager 1.15; los charts más viejos usaban installCRDs. Si fijas una versión antigua del chart, revisa el nombre del flag en la documentación de cert-manager para esa versión.
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: admin@example.com
privateKeySecretRef:
name: letsencrypt-prod
solvers:
- http01:
ingress:
class: nginx
Ingress con TLS
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: tls-ingress
annotations:
cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
ingressClassName: nginx
tls:
- hosts:
- app.example.com
secretName: app-tls-secret
rules:
- host: app.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: my-app-service
port:
number: 80
La anotación le dice a cert-manager que emita el certificado; el bloque tls le dice al controlador qué secret lo contiene. El secret se crea en el mismo namespace que el Ingress — ponlo en otro sitio y TLS falla en silencio.
TLS passthrough (sin terminación)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: passthrough-ingress
annotations:
nginx.ingress.kubernetes.io/ssl-passthrough: "true"
spec:
ingressClassName: nginx
rules:
- host: secure.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: secure-service
port:
number: 443
En ingress-nginx esto solo funciona si el controlador se arrancó con --enable-ssl-passthrough; viene desactivado por defecto y la anotación sola no hace nada. El compromiso: el backend mantiene su certificado de punta a punta, pero pierdes el enrutamiento L7 porque el controlador no puede inspeccionar tráfico cifrado — toda petición a ese host va a un solo backend.
Anotaciones Comunes
Las anotaciones son propias de cada controlador — estas son las anotaciones de ingress-nginx. Traefik, HAProxy y Kong exponen los mismos controles bajo otros nombres de anotación.
Rewrite target
metadata:
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
rules:
- host: app.example.com
http:
paths:
- path: /api(/|$)(.*)
pathType: ImplementationSpecific
backend:
service:
name: api-service
port:
number: 8080
Con esa regla, /api/users llega al backend como /users — y como la forma regex necesita ImplementationSpecific, es la causa clásica del “funciona en staging, da 404 en producción” cuando dos clusters corren controladores distintos.
CORS
metadata:
annotations:
nginx.ingress.kubernetes.io/enable-cors: "true"
nginx.ingress.kubernetes.io/cors-allow-origin: "https://frontend.example.com"
nginx.ingress.kubernetes.io/cors-allow-methods: "GET, POST, PUT, DELETE, OPTIONS"
nginx.ingress.kubernetes.io/cors-allow-headers: "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization"
Rate limiting
metadata:
annotations:
nginx.ingress.kubernetes.io/limit-rps: "10"
nginx.ingress.kubernetes.io/limit-burst: "20"
Los límites aplican por pod del controlador — con tres réplicas, tu techo efectivo es aproximadamente 3× la anotación. Tenlo presente antes de preguntarte por qué pasan las ráfagas.
Autenticación básica
# Crear el archivo htpasswd y el secret
htpasswd -c auth admin
kubectl create secret generic basic-auth --from-file=auth -n my-namespace
metadata:
annotations:
nginx.ingress.kubernetes.io/auth-type: basic
nginx.ingress.kubernetes.io/auth-secret: basic-auth
nginx.ingress.kubernetes.io/auth-realm: "Authentication Required"
Timeouts personalizados
metadata:
annotations:
nginx.ingress.kubernetes.io/proxy-connect-timeout: "10"
nginx.ingress.kubernetes.io/proxy-send-timeout: "300"
nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
Soporte WebSocket
metadata:
annotations:
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
WebSockets funciona de fábrica en ingress-nginx; lo único que mata las conexiones ociosas es el timeout de lectura por defecto de 60s, y por eso se sube.
Tamaño de petición y lista blanca de IPs
metadata:
annotations:
nginx.ingress.kubernetes.io/proxy-body-size: "50m"
nginx.ingress.kubernetes.io/whitelist-source-range: "10.0.0.0/8,192.168.1.0/24"
proxy-body-size es el arreglo para los 413 en subidas de archivos; whitelist-source-range es la forma barata de mantener un panel de administración interno fuera de internet pública.
Afinidad de sesión (sticky sessions)
metadata:
annotations:
nginx.ingress.kubernetes.io/affinity: "cookie"
nginx.ingress.kubernetes.io/session-cookie-name: "route"
nginx.ingress.kubernetes.io/session-cookie-hash: "sha1"
La afinidad por cookie fija a un cliente con el mismo pod de backend. Solo recurrir a ella cuando la app de verdad guarda estado en memoria — un almacén de sesiones compartido es casi siempre la mejor solución.
Configuraciones Avanzadas
Backend por defecto (404 personalizado)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: default-backend-ingress
spec:
ingressClassName: nginx
defaultBackend:
service:
name: custom-404-service
port:
number: 80
Las peticiones que no coinciden con ninguna regla caen en defaultBackend en vez de la página 404 que trae el controlador.
Despliegues canary
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: canary-ingress
annotations:
nginx.ingress.kubernetes.io/canary: "true"
nginx.ingress.kubernetes.io/canary-weight: "10"
spec:
ingressClassName: nginx
rules:
- host: app.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: canary-service
port:
number: 80
El Ingress canary replica el host y path del de producción pero envía el canary-weight por ciento del tráfico al servicio canary. Combina bien con la guía de estrategias de despliegue para rollouts progresivos — las anotaciones te dan reparto de tráfico, pero no análisis de métricas ni rollback automatizado.
Varios Ingress resources para el mismo host
Varios Ingress resources que coinciden con el mismo host se combinan en el controlador — útil para repartir reglas entre equipos o namespaces. El detalle: los conflictos se resuelven por fecha de creación, así que gana la regla más vieja. Una regla posterior que se solape no tomará efecto, y nada te avisa.
Varios controladores en un cluster
Como IngressClass existe, correr dos controladores es legítimo: ingress-nginx para las cargas legacy más Traefik o Envoy Gateway para las nuevas. Cada controlador solo reclama los Ingress de su clase, así que puedes migrar servicio a servicio en vez de hacer un corte de un día para otro.
Ingress en Producción
El objeto Ingress es la parte fácil — el controlador es quien de verdad transporta tu tráfico. Algunos detalles operativos separan un montaje que funciona de una página de 502s a las 3 de la mañana.
Dimensiona el controlador como un balanceador, no como un sidecar. Termina TLS y proxifica cada petición, así que dale requests reales de CPU y memoria y al menos dos réplicas repartidas entre nodos. En ingress-nginx, nginx_ingress_controller_requests y los percentiles de latencia del upstream te dicen cuándo va justo — la latencia de cola se degrada mucho antes de que el pod parezca enfermo.
Alerta sobre las recargas de configuración, no solo sobre la salud del pod. Un pod del controlador puede aparecer Running mientras ignora en silencio tus reglas porque una anotación errónea hizo fallar la validación de la config generada. Mide nginx_ingress_controller_config_last_reload_successful y las tasas de 4xx/5xx por Ingress — entre ambas métricas se cazan la mayoría de los incidentes de “mi ruta desapareció”.
# Fallos de recarga de config y tasas de peticiones en ingress-nginx
kubectl exec -n ingress-nginx deploy/ingress-nginx-controller -- \
curl -s localhost:10254/metrics | grep -E "config_last_reload|controller_requests"
Vigila la caducidad de certificados por separado. Si cert-manager emite tus certificados, alerta sobre certmanager_certificate_expiration_timestamp_seconds — un certificado que expira sin ruido es una caída clásica de Ingress que no tiene nada que ver con el enrutamiento.
Protege el punto de entrada. El controlador es un punto único de entrada por diseño, así que trátalo como tal: un PodDisruptionBudget sobre el Deployment del controlador, ninguna carga ajena en su namespace y un NetworkPolicy que solo admita el tráfico esperado — 80/443 desde el balanceador más tu scraper de métricas.
Ingress vs Gateway API
Gateway API es el sucesor que el SIG de networking de Kubernetes construyó para reemplazar Ingress. Ingress sigue funcionando — la API no está deprecada y los recursos existentes siguen sirviendo tráfico — pero las capacidades nuevas llegan a Gateway API, no a Ingress.
| Función | Ingress | Gateway API |
|---|---|---|
| Capa | Solo L7 | L4 y L7 |
| Enrutamiento | Host + path | Host, path, header, peso |
| TLS | Por Ingress | Por listener |
| Multi-tenant | Limitado | Nativo (Route namespaces) |
| Modelo de roles | Recurso único | Dividido: plataforma posee el Gateway, las apps sus HTTPRoutes |
| Estado | Estable, congelado | GA desde K8s 1.25, en desarrollo activo |
El modelo de roles dividido es la verdadera ganancia: los equipos de plataforma controlan el Gateway (listeners, TLS, IPs) mientras los equipos de aplicación poseen sus HTTPRoutes sin tocar configuración de infraestructura compartida — algo que Ingress nunca modeló bien. El patrón de enrutamiento por gateway cubre la misma idea a nivel de diseño.
La migración tampoco exige una reescritura de golpe: levanta una implementación de Gateway API junto al controlador existente, mueve un hostname por vez de reglas Ingress a HTTPRoutes, y mantén ambos corriendo hasta que la lista de Ingress quede vacía.
Troubleshooting
Recorre la cadena en orden — regla, controlador, servicio, DNS — en vez de adivinar:
# 1. ¿El controlador aceptó el Ingress?
kubectl get ingress -A
kubectl describe ingress my-app-ingress -n my-namespace
# 2. ¿El controlador está sano?
kubectl get pods -n ingress-nginx
kubectl logs -n ingress-nginx -l app.kubernetes.io/name=ingress-nginx
# 3. ¿El Service tiene endpoints vivos?
kubectl get endpoints my-app-service -n my-namespace
kubectl get pods -n my-namespace --show-labels
# 4. ¿El DNS apunta al controlador?
kubectl get svc -n ingress-nginx # IP externa
dig app.example.com
curl -H "Host: app.example.com" http://<ingress-controller-ip>
Si curl -H "Host:" funciona pero el dominio real no, el problema es DNS, no Kubernetes — una comprobación de diez segundos que ahorra una hora.
Problemas comunes
404 Not Found:
- El Service backend no existe o tiene cero pods listos (revisa
kubectl get endpoints). - El path no coincide con ninguna regla — recuerda que
Prefixcoincide en límites de elemento. - El IngressClass falta o no coincide con lo que el controlador atiende;
kubectl describe ingressmuestra si alguna vez se sincronizó.
502 Bad Gateway:
- El puerto del Service en el Ingress no coincide con el
portdel Service — el culpable habitual es apuntar acontainerPortotargetPorten su lugar. - Los pods del backend están arriba pero la app dentro no escucha en el puerto esperado.
503 Service Unavailable:
- No hay endpoints sanos: el selector del Service no coincide con las labels de ningún pod.
- Un readiness probe está fallando, así que los pods quedan fuera de la lista de endpoints aunque estén corriendo.
El certificado TLS no funciona:
- cert-manager no está instalado, o el ClusterIssuer nunca llegó a
Ready(kubectl describe clusterissuer). - El secret TLS vive en un namespace distinto al del Ingress — los secrets deben compartir namespace.
- El dominio no resuelve a la IP externa del controlador, así que el reto HTTP-01 no puede completarse.
kubectl get events -n my-namespace --field-selector reason=Sync
kubectl get certificate -A
kubectl describe certificate app-tls-secret -n my-namespace
Errores Comunes
ingressClassNamedentro demetadata.annotations: va enspec; la forma por anotación (y la legacykubernetes.io/ingress.class) es otra cosa distinta.- Apuntar
backend.service.portal puerto del contenedor: debe coincidir con elportdel Service, que con frecuencia no es el mismo número. - Asumir que las anotaciones son portables: todo lo que cuelga de
nginx.ingress.kubernetes.io/*es dialecto de ingress-nginx. Otro controlador las ignora en silencio. - Olvidar que las anotaciones piden valores string:
canary: true(booleano) falla;canary: "true"funciona. - Reglas host+path solapadas entre namespaces: los merges se resuelven por antigüedad, así que la regla “equivocada” puede ganar sin error visible en ningún lado.
- Editar el Ingress para arreglar un 502: las reglas estaban bien — el Service no tenía endpoints. Depura los endpoints primero.
Mejores Prácticas
- Define siempre
spec.ingressClassName— sin él, ningún controlador reclama el recurso y falla en silencio. - Usa cert-manager para TLS — la rotación manual de certificados en decenas de Ingress no escala; la guía de networking de Kubernetes explica cómo encaja TLS en el modelo de tráfico general.
- Pon requests y limits de recursos al controlador — está en el camino crítico de cada petición.
- Monitoriza el controlador — mide tasas de 4xx/5xx, percentiles de latencia y fallos de recarga de configuración, no solo la salud del pod.
- Prefiere
pathType: Prefix—ImplementationSpecificdepende del controlador y se rompe al migrar. - Mantén los Ingress en el mismo namespace que sus Services — las referencias entre namespaces no están permitidas de todos modos, pero agrupar por namespace hace los merges predecibles.
- Trata las anotaciones como deuda de configuración — reducen portabilidad; cuantas menos uses, más fácil es cambiar de controlador.
- Prueba el enrutamiento antes de apuntar el DNS —
curl -H "Host: app.example.com" http://<ip>valida las reglas sin esperar la propagación. - Planifica el salto a Gateway API — aunque te quedes en Ingress por ahora, los clusters nuevos deberían evaluar controladores mantenidos o Gateway API directamente.
Ver También
- Manifiestos companion — todos los YAML de esta guía, listos para copiar
- Documentación de Kubernetes Ingress
- Documentación de Gateway API
- Instalación de cert-manager
- Referencia de anotaciones de ingress-nginx
- Guía Completa de Kubernetes Networking
Preguntas frecuentes
¿Necesito un Ingress controller?
Sí. Los Ingress resources son solo reglas — sin un controlador que las observe y las haga cumplir, no pasa nada. Elige uno mantenido para clusters nuevos: Traefik, HAProxy, Kong o el controlador de tu proveedor cloud.
¿ingress-nginx está muerto? ¿Tengo que migrar ya?
El controlador de la comunidad se retiró en 2026: no hay más releases ni parches de seguridad. Las instalaciones existentes siguen corriendo, así que esto es un planifica-la-migración, no una caída — pero quedarse a largo plazo significa correr infraestructura de borde sin parches. Gateway API o un controlador mantenido es el destino.
¿Puedo usar Ingress para TCP/UDP?
No con el recurso estándar — Ingress es solo HTTP/HTTPS. Para TCP/UDP, usa un Service LoadBalancer, la configuración de passthrough TCP/UDP del controlador, o los TCPRoute/UDPRoute de Gateway API.
¿Cómo enruto a un servicio en otro namespace?
No puedes — los backends de Ingress deben vivir en el mismo namespace que el Ingress. Las alternativas son un Service de tipo ExternalName o reexportar el servicio localmente, y ambas añaden una indirección de la que la mayoría de equipos se arrepiente después.
¿Cuál es la diferencia entre Ingress y LoadBalancer?
Un Service LoadBalancer te da un balanceador de carga en la nube apuntando a un único Service. Ingress te da un punto de entrada con reglas L7 que reparten hacia muchos Services — virtual hosting, enrutamiento por path y terminación TLS en un solo objeto.
Recursos Relacionados
Kubernetes Básico para Desarrolladores de Aplicaciones
Aprende los conceptos core de Kubernetes que todo desarrollador necesita: Pods, Services, Deployments, ConfigMaps y comandos básicos de kubectl.
GuideKubernetes Avanzado — Más Allá de lo Básico
Guía avanzada de Kubernetes: operators, custom resources, admission controllers, gestión multi-cluster y hardening de producción para usuarios experimentados.
GuideGuía Completa de Networking en Kubernetes
Cómo funciona el networking de Kubernetes: red plana de pods, tipos de Service, Ingress, NetworkPolicies, plugins CNI, DNS y service mesh.
GuideEstrategias de Despliegue: Blue-Green, Canary y Rolling
Guía práctica de estrategias de despliegue: rolling, blue-green, canary, shadow y feature flags. Minimiza el riesgo y el tiempo de rollback al liberar a producción.
PatternPatrón de Enrutamiento de Gateway
Enruta solicitudes a múltiples servicios backend a través de un único punto de entrada que gestiona preocupaciones transversales.
GuideGuía Completa de GitOps con ArgoCD
Despliega apps Kubernetes con GitOps y ArgoCD: instalación, ApplicationSets, estrategias de sync, Helm/Kustomize, RBAC y multi-cluster.