StackPractices
intermediate Por Mathias Paulenko

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.com vs app.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 LoadBalancer cubre 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 LoadBalancer o 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:

flowchart diagram: Cliente

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.

ControladorEstadoBuena opción cuando
ingress-nginxRetirado (sin mantenimiento desde mar 2026)Ya desplegado; planifica la salida
TraefikActivoNativo de Kubernetes, configuración dinámica, soporta Gateway API
HAProxy IngressActivoL7 de alto rendimiento, maduro y probado en batalla
Kong IngressActivoQuieres capacidades de API gateway (auth, plugins) en el borde
NGINX Ingress (F5)Comercial/activoTier de pago NGINX Plus, soporte de vendor
Controladores cloud (AWS ALB, GCE, AKS)ActivoBalanceadores gestionados, integración directa con la nube
Envoy Gateway y otras impl. de Gateway APIActivoClusters 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ónIngressGateway API
CapaSolo L7L4 y L7
EnrutamientoHost + pathHost, path, header, peso
TLSPor IngressPor listener
Multi-tenantLimitadoNativo (Route namespaces)
Modelo de rolesRecurso únicoDividido: plataforma posee el Gateway, las apps sus HTTPRoutes
EstadoEstable, congeladoGA 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 Prefix coincide en límites de elemento.
  • El IngressClass falta o no coincide con lo que el controlador atiende; kubectl describe ingress muestra si alguna vez se sincronizó.

502 Bad Gateway:

  • El puerto del Service en el Ingress no coincide con el port del Service — el culpable habitual es apuntar a containerPort o targetPort en 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

  • ingressClassName dentro de metadata.annotations: va en spec; la forma por anotación (y la legacy kubernetes.io/ingress.class) es otra cosa distinta.
  • Apuntar backend.service.port al puerto del contenedor: debe coincidir con el port del 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 — ImplementationSpecific depende 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

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.