check feasibility of lambda functions for each statement of a userstory

[AmitKumarDas]

Assumption:

• Litmus makes use of user stories which are provided as plain english statements.

This issue tracks the feasibility of mapping each statement to corresponding lambda function executed as a web hook on a target container that exposes a hook service which understands these hooks. This hook service should have the ability to invoke kubectl commands.

Why?

• This tries to decouple the code from the user story statement in a much cleaner way
• Implementation of litmus test case will probably become easier

NOTE:

• It will be great if there is already a web hook service that understands kubernetes. In that case, one has to concentrate on writing hooks i.e. otherwise called as lambda functions.

[AmitKumarDas]

References:

What are admission webhooks? Admission webhooks are HTTP callbacks that receive admission requests and do something with them. You can define two types of admission webhooks, validating admission Webhook and mutating admission webhook. With validating admission Webhooks, you may reject requests to enforce custom admission policies. With mutating admission Webhooks, you may change requests to enforce custom defaults

Code in go

• https://github.com/kubernetes/kubernetes/blob/v1.10.0-beta.1/test/images/webhook/main.go & then deploy as a Deployment
• https://github.com/kubernetes/kubernetes/blob/v1.10.0-beta.1/test/e2e/apimachinery/webhook.go#L196

Links:

• https://kubernetes.io/docs/admin/extensible-admission-controllers/

[AmitKumarDas]

• litmus-k8s-service will be a service that runs a function which was passed as http request payload.
• Need to define a schema that defines the request & response for litmus-k8s-service.
• The request need to pass in either files (i.e. bytes) or name of the file (i.e. string). [Need to brainstorm]
• litmus-k8s-service may extract the file contents via ConfigMap if filenames will be passed in the http request.
• litmus-k8s-service may extract the function contents via ConfigMap. The http request URL itself can hold the name of the function. Or the request schema can contain the name of the function.
• function can be defined as a yaml/json which is understood & executed by litmus-k8s-service
• check if function can be jsonnet & remove the dependency of go templating
  • https://jsonnet.org/
  • the initial templating can make use of simple templating tool
  • jsonnet tooling:
    • https://github.com/google/jsonnet/tree/master/case_studies/kubernetes
  • Alternatively make use of https://github.com/ksonnet/kubecfg
    • it understands jsonnet, yaml, json i.e. caters to all kinds of users
• templating inside litmus-k8s-service can make use of go template

[AmitKumarDas]

Current Design

• end user writes user story
• a user story statement is mapped to a go function/code

Future Design

• Enable users to write functions decoupled from any programming language
• Enable users to specify a declarative specification that will replace above programming function
• This declarative spec will map to a user story statement
• This declarative spec will be passed as a http request payload & executed at litmus-service

NOTE: These is otherwise known as lamdba expression or lambda function or web hook

High Level Implementation

Based on above concept, litmus will need a litmus service which can parse & execute the function as a declarative specification. We might build a litmus service from scratch and define the payload or we can build a Kubernetes custom resource and make use of an operator that does the job of a litmus service.

Below are few advantages of using a Kubernetes Custom Resource:

• code generation to build an operator i.e. a http service
• CR has a versioning policy in place
• CR has a validation policy in place
• CR has concept of sub resource
• Building of operator has been made easy via operator framework
• Kubernetes community is working towards making CRD & operator as a high level construct
  • This is better than building http service from scratch
• A CR's status sub-resource will have the details on the declarative spec execution
  • time taken
  • failure reasons
  • timestamps

Below are few disadvantages of using a Kubernetes Custom Resource:

• Declarative yaml/json vs writing functions in a programming language
  • jsonnet or ksonnet to rescue
  • various tools coming up to validate