Saltar al contenido principal

Capítulo 8.3 - Enrutamiento y TLS

Objetivos de Aprendizaje​

Al final de este capítulo, usted será capaz de:

  • Configurar el enrutamiento por hostname
  • Implementar el enrutamiento basado en path
  • Configurar TLS/SSL con certificados
  • Utilizar cert-manager para la gestión automática de certificados
  • Comprender los path types
  • Gestionar los rewrites y redirects

Introducción​

El enrutamiento Ingress permite dirigir el tráfico hacia diferentes servicios según el hostname o el path. La configuración TLS permite asegurar las comunicaciones con HTTPS.

Enrutamiento por Hostname​

Enrutamiento basado en el nombre de dominio:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-host-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: app1.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app1-service
            port:
              number: 80
  - host: app2.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app2-service
            port:
              number: 80
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 80

Resultado:

  • app1.example.com → app1-service
  • app2.example.com → app2-service
  • api.example.com → api-service

Enrutamiento por Path (Basado en Path)​

Enrutamiento basado en el path de la URL:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-based-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 80
      - path: /web
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
      - path: /admin
        pathType: Prefix
        backend:
          service:
            name: admin-service
            port:
              number: 80
      - path: /
        pathType: Prefix
        backend:
          service:
            name: default-service
            port:
              number: 80

Resultado:

  • example.com/api → api-service
  • example.com/web → web-service
  • example.com/admin → admin-service
  • example.com/ → default-service

Path Types​

Prefix​

El path debe comenzar con el prefijo especificado:

- path: /api
  pathType: Prefix

Coincide con:

  • /api
  • /api/v1
  • /api/users
  • /api/v1/users

Exact​

El path debe coincidir exactamente:

- path: /api
  pathType: Exact

Coincide con:

  • Solo /api

No coincide con:

  • /api/v1
  • /api/users

ImplementationSpecific​

Depende de la implementación del Ingress Controller:

- path: /api
  pathType: ImplementationSpecific

Configuración TLS​

Crear un Secret TLS​

# Generar un certificado (ejemplo con openssl)
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout tls.key -out tls.crt \
  -subj "/CN=example.com/O=example.com"

# Crear el Secret
kubectl create secret tls example-tls \
  --cert=tls.crt \
  --key=tls.key

Usar en Ingress​

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tls-ingress
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    - www.example.com
    secretName: example-tls
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
  - host: www.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

Resultado: HTTPS habilitado para example.com y www.example.com.

Cert-Manager para Certificados Automáticos​

cert-manager gestiona automáticamente los certificados TLS con Let's Encrypt.

Instalación​

# Helm
helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --set installCRDs=true

ClusterIssuer (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

Uso en Ingress​

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: cert-ingress
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    secretName: example-tls  # Creado automáticamente por cert-manager
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

Resultado: Certificado TLS obtenido y renovado automáticamente por cert-manager.

Rewrites y Redirects​

Rewrite (NGINX)​

Reescribir la URL antes de enviarla al backend:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: rewrite-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /api(/|$)(.*)
        pathType: ImplementationSpecific
        backend:
          service:
            name: api-service
            port:
              number: 80

Resultado: example.com/api/users → api-service/users

Redirect​

Redirigir hacia otra URL:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: redirect-ingress
  annotations:
    nginx.ingress.kubernetes.io/permanent-redirect: "https://www.example.com"
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

Ejemplo Completo: Aplicación Multi-Tier​

Arquitectura​

Configuración​

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    secretName: example-tls
  rules:
  - host: example.com
    http:
      paths:
      # Web frontend
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
      # API backend
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      # Admin panel
      - path: /admin
        pathType: Prefix
        backend:
          service:
            name: admin-service
            port:
              number: 8080

Comandos Útiles​

Verificación​

# Ver los Ingress
kubectl get ingress

# Detalles
kubectl describe ingress app-ingress

# Ver los certificados
kubectl get certificates
kubectl describe certificate example-tls

# Ver los secrets TLS
kubectl get secrets | grep tls

Test​

# Test HTTP
curl -H "Host: example.com" http://<ingress-ip>/

# Test HTTPS
curl -k https://example.com/

# Test con path
curl -H "Host: example.com" http://<ingress-ip>/api/health

Buenas Prácticas​

1. TLS en Todas Partes​

Utilizar HTTPS para todas las comunicaciones externas.

2. Cert-Manager​

Utilizar cert-manager para la gestión automática de certificados.

3. Path Types​

Elegir el path type adecuado (Prefix para la mayoría de los casos).

4. Anotaciones​

Utilizar anotaciones para funcionalidades avanzadas (rewrites, redirects).

5. Monitoreo​

Supervisar los certificados y su expiración.

Resumen​

En este capítulo, usted ha aprendido:

Enrutamiento por hostname: Varios dominios con un solo Ingress
Enrutamiento por path: Enrutamiento basado en path hacia diferentes servicios
Path types: Prefix, Exact, ImplementationSpecific
TLS: Configuración con secrets de Kubernetes
cert-manager: Gestión automática de certificados Let's Encrypt
Rewrites: Reescritura de URLs con anotaciones
Redirects: Redirecciones permanentes o temporales
Buenas prácticas: TLS en todas partes, cert-manager, monitoreo

Próximos Pasos​

Módulo 9: Seguridad y RBAC
Lab 8.2: Configuración de Ingress para una Aplicación
Lab 8.3: Certificados TLS con Cert-Manager

Capítulo creado el: Diciembre 2024