Saltar al contenido principal

Lab 8.2 - Enrutamiento basado en rutas

Objetivos del Lab​

Al final de este laboratorio, usted será capaz de:

  • Configurar el enrutamiento basado en rutas (path-based).
  • Enrutar el tráfico hacia diferentes aplicaciones según la ruta.
  • Comprender los diferentes pathTypes.
  • Probar el enrutamiento con varias rutas.

Duración Estimada​

45-60 minutos

Requisitos Previos​

  • kubectl instalado y configurado.
  • Cluster Kubernetes local funcional con Ingress Controller.
  • Conocimientos sobre Ingress (Lab 8.1).

Parte 1: Despliegue de Múltiples Aplicaciones​

Vamos a desplegar dos aplicaciones diferentes para probar el enrutamiento basado en rutas.

Paso 1.1: Desplegar la Aplicación Frontend​

Cree frontend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: nginx
        image: nginx:1.20
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: frontend-service
spec:
  selector:
    app: frontend
  ports:
  - port: 80
    targetPort: 80

Paso 1.2: Desplegar la Aplicación Backend​

Cree backend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: httpd
        image: httpd:2.4
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: backend-service
spec:
  selector:
    app: backend
  ports:
  - port: 80
    targetPort: 80

Aplique los despliegues:

kubectl apply -f frontend-deployment.yaml
kubectl apply -f backend-deployment.yaml

Parte 2: Configuración de Ingress con Enrutamiento basado en rutas​

Paso 2.1: Crear el Ingress con Múltiples Rutas​

Cree ingress-path-based.yaml:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-based-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: app.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend-service
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: backend-service
            port:
              number: 80
      - path: /backend
        pathType: Prefix
        backend:
          service:
            name: backend-service
            port:
              number: 80

Explicación:

  • /: Ruta hacia el frontend (página principal).
  • /api: Ruta hacia el backend.
  • /backend: Ruta alternativa hacia el backend.

Aplique el Ingress:

kubectl apply -f ingress-path-based.yaml

Parte 3: Personalización de las Aplicaciones para la Prueba​

Para visualizar mejor el enrutamiento, personalicemos las respuestas de las aplicaciones.

Paso 3.1: Personalizar el Frontend​

Cree un ConfigMap para el frontend:

apiVersion: v1
kind: ConfigMap
metadata:
  name: frontend-config
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Frontend Application</title></head>
    <body>
      <h1>Frontend Application</h1>
      <p>Usted está en la página principal (/)</p>
      <p><a href="/api">Acceder a la API</a></p>
    </body>
    </html>

Aplique y monte el ConfigMap en el frontend (modifique el Deployment si es necesario).

Paso 3.2: Personalizar el Backend​

Cree un ConfigMap para el backend:

apiVersion: v1
kind: ConfigMap
metadata:
  name: backend-config
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Backend API</title></head>
    <body>
      <h1>Backend API</h1>
      <p>Usted está en la API (/api o /backend)</p>
      <p>Este es el servicio backend</p>
    </body>
    </html>

Parte 4: Prueba del Enrutamiento​

Paso 4.1: Configurar el Hostname​

Agregue app.local a su archivo /etc/hosts (o equivalente en Windows) apuntando a la IP del Ingress Controller.

Paso 4.2: Probar las Diferentes Rutas​

Pruebe el enrutamiento:

# Página principal (debería ir al frontend)
curl http://app.local/

# API (debería ir al backend)
curl http://app.local/api

# Backend alternativo (debería ir al backend)
curl http://app.local/backend

Debería ver diferentes respuestas según la ruta.

Parte 5: Comprender los pathTypes​

Los pathType determinan cómo se comparan las rutas:

  • Exact: Coincidencia exacta de la ruta.
  • Prefix: Coincidencia por prefijo (la más común).
  • ImplementationSpecific: Depende de la implementación del Ingress Controller.

Ejemplo con Exact​

- path: /api/v1
  pathType: Exact
  backend:
    service:
      name: api-v1-service
      port:
        number: 80

Parte 6: Limpieza​

Elimine los recursos:

kubectl delete ingress path-based-ingress
kubectl delete -f frontend-deployment.yaml
kubectl delete -f backend-deployment.yaml
kubectl delete configmap frontend-config backend-config

Resumen del Lab​

En este laboratorio, usted ha configurado el enrutamiento basado en rutas con Ingress. Ha aprendido a enrutar el tráfico hacia diferentes aplicaciones según la ruta de la URL, a utilizar diferentes pathTypes y a probar el enrutamiento.

Próximos Pasos​

El próximo laboratorio le mostrará cómo configurar TLS/SSL con cert-manager para asegurar las comunicaciones HTTPS.

Lab 8.3: TLS/SSL con Cert-Manager

Lab creado el: diciembre 2024