SysAdmin Blog
Guía para actualizaciones del clúster EKS
Estándares de codificación

Arquitectura serverless con KNative

arquitectura servelles con KNative

La arquitectura serverless con KNative combina los beneficios de serverless con la flexibilidad y el control de Kubernetes, lo que permite a los desarrolladores crear aplicaciones escalables y reactivas de manera eficiente en entornos de nube basados en contenedores.

Serverless es un modelo de ejecución de aplicaciones en la nube donde el proveedor de servicios en la nube (como AWS, Google Cloud, Azure, etc.) se encarga de administrar la infraestructura subyacente, lo que permite a los desarrolladores centrarse en escribir código sin preocuparse por la gestión de servidores o recursos. En lugar de pagar por máquinas virtuales o contenedores en ejecución, solo se paga por la cantidad de recursos de cómputo utilizados durante la ejecución de una función o servicio.

Knative, por otro lado, es un proyecto de código abierto que proporciona una plataforma para construir, implementar y administrar aplicaciones serverless basadas en contenedores en entornos de Kubernetes. Kubernetes es una plataforma de orquestación de contenedores ampliamente utilizada, y Knative se integra con ella para ofrecer una experiencia serverless sobre Kubernetes. Algunos de los componentes clave de Knative incluyen:

  • Knative Serving: Este componente se utiliza para implementar y escalar automáticamente contenedores basados en solicitudes HTTP. Permite a los desarrolladores definir servicios serverless y se encarga de la gestión de la escalabilidad y el enrutamiento del tráfico.
  • Knative Eventing: Proporciona un sistema de eventos que permite a las aplicaciones responder a eventos de manera serverless. Esto es útil para construir aplicaciones reactivas que pueden responder a cambios en el estado de la aplicación o eventos externos.
  • Knative Build: Ofrece capacidades de automatización de compilación de contenedores, lo que facilita la construcción de imágenes de contenedor a partir del código fuente y su implementación en la plataforma.

Índice

Ventajas de la arquitectura serverless con Knative

  • Escalabilidad automática: Knative puede escalar automáticamente las instancias de contenedores en función de la demanda, lo que garantiza un rendimiento óptimo sin necesidad de intervención manual.
  • Abstracción de infraestructura: Los desarrolladores pueden centrarse en el código de la aplicación sin preocuparse por la infraestructura subyacente.
  • Costos basados en el uso: Solo se paga por el tiempo de ejecución y los recursos utilizados, lo que puede ser más rentable que mantener servidores en funcionamiento todo el tiempo.
  • Flexibilidad: Knative es compatible con contenedores, lo que significa que puedes utilizar tus propias imágenes de contenedor personalizadas.
  • Event-Driven: Puedes construir aplicaciones que respondan a eventos de manera eficiente, lo que es útil para casos de uso como procesamiento de eventos en tiempo real.

Prueba de Arquitectura serverless con KNative

Instalar Knative en un clúster de Kubernetes local, como Kind (Kubernetes in Docker), es un proceso que requiere varios pasos. A continuación, te proporcionaré una guía básica para instalar Knative en un clúster Kind. Ten en cuenta que los detalles específicos pueden variar según la versión de Knative y Kind que estés utilizando, así que asegúrate de consultar la documentación más actualizada.

También puedes ver:

Guía-Tutorial Kubernetes

1. Instala Docker: Si aún no tienes Docker instalado en tu sistema, necesitarás instalarlo. Puedes encontrar las instrucciones de instalación en el sitio web oficial de Docker.

2. Instala Kind: Kind es una herramienta que te permite crear clústeres de Kubernetes locales. Puedes descargar Kind desde GitHub y seguir las instrucciones de instalación proporcionadas en su documentación.

3. Crea un clúster Kind: Utiliza el comando kind create cluster para crear un clúster de Kubernetes local con Kind. Por ejemplo:

kind create cluster --name mi-cluster-knative

Esto creará un clúster de Kubernetes local llamado «mi-cluster-knative».

4. Instala kubectl: kubectl es la herramienta de línea de comandos de Kubernetes que necesitas para interactuar con tu clúster. Puedes instalar kubectl siguiendo las instrucciones proporcionadas en la documentación oficial de Kubernetes.

5. Instala Knative: Para instalar Knative en tu clúster de Kind, puedes usar el comando kubectl junto con los archivos de manifiesto YAML proporcionados por Knative. Asegúrate de utilizar la versión de Knative que desees. Por ejemplo:

kubectl apply -f https://github.com/knative/serving/releases/download/v0.26.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/v0.26.0/serving-core.yaml
kubectl apply -f https://github.com/knative/net-istio/releases/download/v0.26.0/release.yaml

Estos comandos instalan los recursos necesarios para Knative Serving y la integración con Istio. Asegúrate de utilizar las URL de los archivos YAML correspondientes a la versión de Knative que desees.

6. Verifica la instalación: Puedes verificar que Knative se haya instalado correctamente ejecutando el siguiente comando:

kubectl get pods --namespace knative-serving

Esto mostrará los pods en el espacio de nombres de Knative Serving y deberías ver que todos los componentes de Knative están en un estado «Running» o «Completed».

7. Utiliza Knative: Una vez que Knative esté instalado, puedes comenzar a utilizarlo para implementar y escalar aplicaciones serverless en tu clúster de Kubernetes local.

Esta es una guía básica y los detalles pueden variar según las versiones específicas de las herramientas y las configuraciones que desees utilizar. Siempre es recomendable consultar la documentación oficial de Knative y Kind para obtener información actualizada y detallada sobre la instalación y la configuración.

Ejemplos de uso de la Arquitectura serveless con KNative

A continuación veremos ejemplos paso a paso de cómo utilizar Knative Functions, Knative Serving y Knative Eventing en un clúster de Kubernetes local utilizando Kind. Estos ejemplos asumen que has instalado la arquitectura serveless de Knative siguiendo las instrucciones anteriores.

Knative Functions

Knative Functions te permite implementar y ejecutar funciones serverless en tu clúster de Kubernetes. A continuación, se muestra un ejemplo básico de cómo crear y desplegar una función con Knative Functions:

1. Crea un archivo de función mi-funcion.js con el siguiente contenido:

module.exports = (context, callback) => {
  const mensaje = "¡Hola, Knative Functions!";
  callback(null, { mensaje });
};

2. Crea un archivo func.yaml que describa tu función:

apiVersion: serving.knative.dev/v1
kind: Function
metadata:
  name: mi-funcion
spec:
  container:
    image: nodejs12
    resources:
      limits:
        memory: "64Mi"
        cpu: "100m"

3. Implementa la función en Knative:

kn func deploy --name mi-funcion --runtime nodejs12 mi-funcion.js

4. Verifica que la función se haya implementado correctamente:

kn func list

5. Invoca la función:

kn func invoke mi-funcion

Knative Serving

Knative Serving te permite implementar aplicaciones serverless basadas en contenedores en tu clúster de Kubernetes. Aquí hay un ejemplo de cómo implementar una aplicación web sencilla:

1. Crea un archivo Dockerfile para tu aplicación web, por ejemplo, Dockerfile:

FROM nginx:alpine
COPY index.html /usr/share/nginx/html/index.html

2. Crea un archivo index.html con el contenido de tu página web.

3. Construye y sube tu imagen de Docker a un registro de contenedores (por ejemplo, Docker Hub o Google Container Registry).

4. Crea un archivo de servicio mi-servicio.yaml para describir tu aplicación:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: mi-servicio
spec:
  template:
    spec:
      containers:
        - image: NOMBRE_DE_TU_IMAGEN_DOCKER

5. Implementa la aplicación con Knative Serving:

kubectl apply -f mi-servicio.yaml

6. Verifica que el servicio esté en funcionamiento:

kubectl get ksvc mi-servicio

7. Accede a tu aplicación web utilizando la URL proporcionada por Knative Serving.

Knative Eventing

Knative Eventing te permite construir aplicaciones reactivas que respondan a eventos. Aquí hay un ejemplo de cómo configurar un receptor HTTP para manejar eventos:

1. Crea un archivo receptor.yaml que describa el receptor HTTP:

apiVersion: eventing.knative.dev/v1
kind: Broker
metadata:
  name: default
---
apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
  name: mi-trigger
spec:
  broker: default
  filter:
    attributes:
      type: mi-evento

2. Crea un archivo JavaScript receptor.js para manejar eventos:

const http = require('http');

const server = http.createServer((req, res) => {
  console.log('Evento recibido:', req.body);
  res.end();
});

server.listen(8080, () => {
  console.log('Receptor HTTP en funcionamiento en el puerto 8080');
});

3. Implementa el receptor y la configuración de Knative Eventing:

kubectl apply -f receptor.yaml
kn service create receptor --image NOMBRE_DE_TU_IMAGEN_DOCKER --env TARGET=8080

4. Crea un evento y envíalo al receptor:

kubectl apply -f - <

5. Observa los registros del receptor para ver la llegada del evento:

kubectl logs -l app=receptor -c user-container

Usos más concretos de la Arquitectura serveless con KNative

Vamos a ver unos usos más concretos para la Arquitectura Serverless con KNative:

  • Implementar Triggers de Eventos
  • Escalabilidad Automática Avanzada
  • Despliegues Avanzados

Implementar Triggers de Eventos

Los Triggers en Knative Eventing te permiten realizar acciones específicas cuando ocurren ciertos eventos. En este ejemplo, configuraremos un Trigger para responder a eventos específicos con una función serverless.

1. Crear un Trigger: Define un Trigger que escuche un tipo de evento específico y reaccione a él. Crea un archivo mi-trigger.yaml con el siguiente contenido:

apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
  name: mi-trigger
spec:
  filter:
    attributes:
      type: mi-evento
  subscriber:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: mi-servicio

Este Trigger está configurado para escuchar eventos de tipo mi-evento y redirigirlos a un servicio llamado mi-servicio.

2. Aplicar el Trigger: Implementa el Trigger en tu clúster Knative:

kubectl apply -f mi-trigger.yaml

3. Generar un Evento: Crea un evento de tipo mi-evento para activar el Trigger:

kubectl apply -f - <

4. Verificar la reacción del Trigger: Verifica que el Trigger funcione redirigiendo el evento al servicio mi-servicio configurado. Observa los registros del servicio para confirmar que recibió el evento:

kubectl logs -l serving.knative.dev/service=mi-servicio -c user-container

Escalabilidad Automática Avanzada

Knative ofrece opciones de escalabilidad avanzada. Vamos a explorar cómo puedes ajustar la configuración de escalabilidad de tus servicios.

1. Modificar la Configuración de Escalabilidad: Edita la configuración de uno de tus servicios Knative (por ejemplo, mi-servicio) para ajustar los límites de recursos y la configuración de escalabilidad. Puedes modificar el archivo mi-servicio.yaml:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: mi-servicio
spec:
  template:
    spec:
      containers:
        - image: NOMBRE_DE_TU_IMAGEN_DOCKER
          resources:
            limits:
              memory: "128Mi"
              cpu: "250m"
          # Configura la política de autoscaling según tus necesidades
          autoscale:
            minScale: 1
            maxScale: 10

En este ejemplo, hemos aumentado los límites de recursos y configurado la escala mínima y máxima del servicio.

2. Aplicar la Configuración Actualizada: Aplica la configuración actualizada a tu servicio:

kubectl apply -f mi-servicio.yaml

3. Monitorear la Escalabilidad: Observa cómo el servicio responde a la demanda y ajusta su escalabilidad automáticamente según la configuración que hayas especificado.

Despliegues Avanzados

La arquitectura serverless con Knative también facilita los despliegues avanzados. Vamos a realizar un despliegue canario para una nueva versión de un servicio.

1. Crear una Nueva Versión del Servicio: Modifica tu servicio para crear una nueva versión. Puedes cambiar el código o simplemente actualizar la imagen del contenedor.

2. Definir un Tráfico de Prueba: Crea un archivo mi-despliegue.yaml para definir cómo se enruta el tráfico entre las versiones actual y nueva del servicio:

apiVersion: serving.knative.dev/v1
kind: Configuration
metadata:
  name: mi-despliegue
spec:
  traffic:
    - revisionName: mi-servicio
      percent: 90
    - revisionName: mi-servicio-nueva
      percent: 10

Esto enruta el 90% del tráfico a la versión actual y el 10% a la nueva.

3. Aplicar la Configuración de Despliegue: Implementa la configuración de despliegue:

kubectl apply -f mi-despliegue.yaml

4. Observar el Despliegue Canario: Observa cómo el tráfico se divide entre las dos versiones del servicio y verifica que el despliegue canario funcione correctamente.

Limpiar la máquina local

Recomendamos que elimines el clúster utilizado para este tutorial para liberar recursos en tu máquina local.

Si deseas continuar experimentando con Knative después de eliminar el clúster, también puedes efectuar la instalación con el plugin quickstart:

kn quickstart kind

Eliminar cluster e imágenes Docker

1. Eliminar el clúster Kind. Puedes eliminar todo el clúster Kind, lo que eliminará todas las aplicaciones y recursos en el clúster. Ejecuta el siguiente comando para eliminar el clúster:

kind delete cluster --name NOMBRE_DEL_CLUSTER

2. (Opcional) Eliminar imágenes de contenedor. Si también quieres eliminar las imágenes de contenedor que utilizaste en el clúster, puedes ejecutar comandos de Docker para eliminarlas. Esto es opcional, pero puede liberar espacio en tu sistema. Puedes listar las imágenes de contenedor con docker images y luego eliminarlas con docker rmi.

# Listar imágenes de contenedor
docker images

# Eliminar una imagen (reemplaza IMAGEN_ID con el ID de la imagen)
docker rmi IMAGEN_ID

Una limpieza más profunda de docker sería con el comando:

docker system prune -a

Este comando se utiliza para limpiar recursos de Docker que no están en uso. Los recursos incluyen imágenes de contenedor, contenedores detenidos, redes no utilizadas y volúmenes no utilizados.

Si además quieres eliminar los volumenes que esten sin usar añade la opción –volumes:

docker system prune -a --volumes

Más apuntes

Invítame a un café con bitcoins:
1QESjZDPxWtZ9sj3v5tvgfFn3ks13AxWVZ

Bitcoins para café
También puedes invitarme a algo para mojar...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Rellena este campo
Rellena este campo
Por favor, introduce una dirección de correo electrónico válida.
Tienes que aprobar los términos para continuar