Cómo ejecutar InterSystems IRIS en modo FaaS con Kubeless

La Función como Servicio (FaaS) es un modelo de computación en la nube que proporciona una plataforma que permite a los clientes desarrollar, ejecutar y gestionar funcionalidades de aplicaciones sin la complejidad de crear y mantener la infraestructura típicamente asociada con el desarrollo y lanzamiento de una app. Crear una aplicación siguiendo este modelo es una forma de conseguir una "arquitectura sin servidor ", y se suele utilizar cuando se crean aplicaciones basadas en microservicios.  

Wikipedia

FaaS es un enfoque muy popular para ejecutar cargas de trabajo en la nube, permitiendo a los desarrolladores centrarse en escribir código.

Este artículo muestra cómo desplegar métodos de InterSystems IRIS con un modelo FaaS.

Instalación de Kubernetes

En primer lugar, instala Kubernetes 1.16. Hay muchos manuales disponibles, por lo que no voy a copiarlos ahora, pero yo uso minikube. Para ejecutar kubernetes con minikube es suficiente con ejecutar este comando:

minikube start --kubernetes-version=v1.16.1

Instalación de kubeless

Después, instalamos kubeless. kubeless es un framework nativo de Kubernetes, sin servidor, que permite desplegar pequeños bits de código sin preocuparse de la todos los mecanismos de infraestructura necesarios para que funcione. Aprovecha los recursos de Kubernetes para proporcionar auto-escalado, enrolamiento de APIs, monitorización, resolución de problemas, etc.

kubectl create ns kubeless
kubectl create -f https://github.com/kubeless/kubeless/releases/download/v1.0.8/kubeless-v1.0.8.yaml
kubectl get pods -n kubeless

El resultado debería ser algo así:

NAME                                          READY   STATUS    RESTARTS   AGE
kubeless-controller-manager-666ffb749-26vhh   3/3     Running   0          83s

También hay que instalar un cliente kubeless (en la misma instancia en la que está kubectl). Puedes obtenerlo aquí. La instalación en Linux es tan simple como:

sudo install kubeless /usr/local/bin/kubeless

Prueba de kubeless

En primer lugar, vamos a desplegar una función de Python sencilla, para comprobar que kubeless funciona.

Crea test.py:

def hello(event, context):
  return event['data']

Para saber más sobre el entorno de la función, echa un vistazo aquí. Generalmente la función acepta dos argumentos - "event" y "context" con estos datos:

event:                                  
  data:                                         # Event data
    foo: "bar"                                  # The data is parsed as JSON when required
  event-id: "2ebb072eb24264f55b3fff"            # Event ID
  event-type: "application/json"                # Event content type
  event-time: "2009-11-10 23:00:00 +0000 UTC"   # Timestamp of the event source
  event-namespace: "kafkatriggers.kubeless.io"  # Event emitter
  extensions:                                   # Optional parameters
    request: ...                                # Reference to the request received 
    response: ...                               # Reference to the response to send 
                                                # (specific properties will depend on the function language)
context:
    function-name: "pubsub-nodejs"
    timeout: "180"
    runtime: "nodejs6"
    memory-limit: "128M"

Ahora podemos desplegar nuestra función "hello" al especificar nuestro archivo con una función y entorno de ejecución:

kubeless function deploy hello --runtime python3.7 --from-file test.py --handler test.hello
kubeless function ls hello

Y lo probamos:

kubeless function call hello --data 'Hello world!'

Deberías recibir "Hello World!" como respuesta.

Añadir la configuración de IRIS

A continuación, tenemos que añadir un gestor de funciones InterSystems IRIS. Para hacerlo, abre la configuración de kubeless para editarla:

kubeless get-server-config
kubectl get -n kubeless configmaps -o yaml > configmaps.yaml
kubectl edit -n kubeless configmaps

Añade esta entrada a runtime-images array y guarda:

{"ID": "iris","depName": "","fileNameSuffix": ".cls","versions": [{"images": [{"image": "eduard93/kubeless-iris-runtime:latest","phase": "runtime"}],"name": "iris2022.1","version": "2022.1"}]}

Reinicia el controlador de kubeless para que tengan efecto los cambios.

kubectl delete pod -n kubeless -l kubeless=controller

Generar la función CRD de IRIS y publicarla

Ahora vamos a escribir nuestra primera función en InterSystems IRIS:

Class User.Test {

ClassMethod hi(event, context) As %Status
{
    if $isObject(event) {
        write event.Text + event.Text
    } else {
        write "HELLO FROM IRIS"
    }
    quit $$$OK
}
}

A continuación, tenemos que generar una función CRD:

Esta es nuestra plantilla:

apiVersion: kubeless.io/v1beta1
kind: Function
metadata:
  name: !name!
  namespace: default
spec:
  runtime: iris2022.1
  timeout: "180"
  handler: !handler!
  deps: ""
  function-content-type: text
  deployment:
    spec:
      template:
        spec:
          securityContext:
            runAsUser: 51773
            runAsGroup: 51773
  function: |

Y tenemos que completar:

• name: nombre de la función (para kubeless)
• handler: class.name_method (para InterSystems IRIS)
• function body: añadir al final (¡no te olvides de los tabuladores!)

Así, nuestro CRD se parece a esto:

apiVersion: kubeless.io/v1beta1
kind: Function
metadata:
  name: iris-demo
  namespace: default
spec:
  runtime: iris2022.1
  timeout: "180"
  handler: User_Test.hi
  deps: ""
  function-content-type: text
  deployment:
    spec:
      template:
        spec:
          securityContext:
            runAsUser: 51773
            runAsGroup: 51773
  function: |
    Class User.Test {
    
    ClassMethod hi(event, context) As %Status
    {
        if $isObject(event) {
            write event.Text + event.Text
        } else {
            write "HELLO FROM IRIS"
        }
        quit $$$OK
    }
    }

Esto se puede automatizar fácilmente. En Linux, ejecuta:

sed 's/!name!/iris-demo/; s/!handler!/User_Test.hi/' function.yaml > function_demo.yaml
sed  's/^/     /'  User.Test.cls >> function_demo.yaml

Y en Windows (PowerShell):

Get-Content function.yaml | ForEach-Object { $_ -replace "!handler!", "User_Test.hi" -replace "!name!", "iris-demo" } | Set-Content function_demo.yaml
"    " + [string]((Get-Content User.Test.cls)  -join "`r`n    ") | Add-Content function_demo.yaml

Ahora tenemos que publicar nuestro CRD en kubeless:

kubectl apply -f function_demo.yaml

Probar la función IRIS

En primer lugar, vamos a comprobar que la función está desplegada y lista (puede llevar unos minutos la primera vez):

kubeless function ls

Y ahora la llamamos:

kubeless function call iris-demo --data '{"Text":123}'

Si estás en Windows, llama a la función así (igual para otras llamadas con dobles comillas escapadas):

kubeless function call iris-demo --data '{\"Text\":123}'

En cualquier caso, la respuesta debería ser 456 ya que 123 es un número.

Acceso HTTP

kubeless también ofrece acceso HTTP. Para probarlo, usa el comando kubectl proxy:

kubectl proxy -p 8081

A continuación, envía esta solicitud usando tu cliente API REST preferido:

GET http://localhost:8081/api/v1/namespaces/default/services/iris-demo:http-function-port/proxy/

{"Text":111}

Así se ve en Postman:

Ahora, vamos a publicarlo en internet.

Hay dos enfoques. Preferiblemente, configura ingress como se describe aquí.

Adicionalmente puedes parchear el servicio:

kubectl get svc
kubectl patch svc iris-demo -p '{"spec": {"type": "LoadBalancer"}}'
kubectl get svc

Limpieza

Para quitar una función desplegada, llama:

kubectl delete -f function_demo.yaml

Conclusión

Aunque esto es sin duda una prueba de concepto y no una solución para producción, este enfoque muestra que es posible ejecutar cargas de trabajo de InterSystems IRIS usando el enfoque FaaS sin servidor.

Enlaces de interés

• Minikube
• Kubeless
• InterSystems IRIS runtime