Exécution d'InterSystems IRIS en mode FaaS avec Kubeless

La fonction en tant que service (FaaS) est une catégorie de services de cloud computing qui fournit une plate-forme permettant aux clients de développer, d'exécuter et de gérer des fonctionnalités d'application sans la complexité de la construction et de la maintenance de l'infrastructure généralement associée au développement et au lancement d'une application. Construire une application selon ce modèle est une façon de réaliser une architecture "sans serveur", et est généralement utilisé lors de la construction d'applications microservices.  

> Wikipedia
>

FaaS est une approche extrêmement populaire pour exécuter des charges de travail dans le cloud, permettant aux développeurs de se concentrer sur l'écriture du code.

Cet article vous montrera comment déployer les méthodes d'InterSystems IRIS selon l'approche FaaS.

Installation de Kubernetes

Tout d'abord, installez Kubernetes 1.16. Il y a beaucoup de guides disponibles donc je ne vais pas les copier ici, mais j'utilise minicube. Avec minicube pour lancer kubernetes, il suffit d'exécuter la commande suivante :

minikube start --kubernetes-version=v1.16.1

Installation de kubeless

Ensuite, nous allons installer kubeless. kubeless est un environnement sans serveur natif de Kubernetes qui vous permet de déployer de petits morceaux de code sans vous soucier de la plomberie de l'infrastructure sous-jacente. Il exploite les ressources de Kubernetes pour fournir une mise à l'échelle automatique, un routage API, une surveillance, un dépannage, 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

La sortie devrait ressembler à ceci :

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

Vous devez également installer un client kubeless (sur la même instance que celle où vous avez kubectl). Vous pouvez l'obtenir ici. L'installation sur Linux est aussi simple :

sudo install kubeless /usr/local/bin/kubeless

Test kubeless

Tout d'abord, déployons une simple fonction Python pour vérifier le fonctionnement de kubeless.

Create test.py:

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

Pour en savoir plus sur l'environnement des fonctions, consultez cette documentation. En général, les fonctions acceptent deux arguments - l'événement et le contexte avec les données suivantes :

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"

   Maintenant nous pouvons déployer notre fonction hello en spécifiant notre fichier avec une fonction et un runtime :

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

Et testons-les :

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

Vous devriez recevoir Hello World! comme réponse.

Ajout de la configuration IRIS

Ensuite, nous devons ajouter un gestionnaire de fonction IRIS d'InterSystems, pour ce faire, ouvrez la configuration de kubeless pour modifier :

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

Ajoutez cette entrée au tableau runtime-images et enregistrez :

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

Relancez le contrôleur kubeless pour que les changements prennent effet.

kubectl delete pod -n kubeless -l kubeless=controller

Construction et publication de la fonction IRIS CRD

Maintenant, écrivons notre première fonction dans IRIS d'InterSystems :

Class User.Test {

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

Ensuite, nous devons construire une fonction CRD :

Voici notre modèle :

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: |

Nous avons besoin de remplir le suivant :

• name : nom de la fonction (pour kubeless)
  • handler : class.name_method (pour InterSystems IRIS)
  • function body : ajouter à la fin (n'oubliez pas les tabulations !)

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
    }
    }

Ceci peut être facilement automatisé. Sous Linux, exécutez :

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

Et sous 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

Maintenant nous devons publier notre CRD dans kubeless :

kubectl apply -f function_demo.yaml

Test de la fonction IRIS

Tout d'abord, vérifions que la fonction est déployée et disponible ( la première fois, cela peut prendre quelques minutes) :

kubeless function ls

Et maintenant, faites un appel :

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

Si vous êtes sous Windows, appelez la fonction comme ceci (de même pour tous les autres appels avec des guillemets échappés) :

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

De toute façon, la réponse devrait être 456 puisque 123 est un numéro.

L'accès HTTP

kubeless offre également un accès HTTP. Pour le tester, utilisez la commande kubectl proxy :

kubectl proxy -p 8081

Ensuite, envoyez cette requête en utilisant votre client API REST préféré :

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

{"Text":111}

Voici comment cela se présente dans Postman :

Ensuite, il s'agit de le publier sur l'internet.

Il y a deux approches. Il est préférable de configurer ingress comme décrit ici.

En outre, vous pouvez patcher le service de fonction :

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

Nettoyage

Pour supprimer une fonction déployée, faites un appel :

kubectl delete -f function_demo.yaml

Conclusion

Bien qu'il s'agisse sans aucun doute d'une preuve de concept et non d'une solution de production, cette approche démontre qu'il est possible d'exécuter des charges de travail IRIS d'InterSystems en utilisant l'approche FaaS sans serveur.

Liens

• Minicube
• Kubeless
• InterSystems IRIS runtime