Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/lreimer/the-big-faas-lebowski

Demo repository for The Big Cloud Native FaaS Lebowski
https://github.com/lreimer/the-big-faas-lebowski

cloud-native cncf faas fission fnproject kubeless openfaas

Last synced: 7 months ago
JSON representation

Demo repository for The Big Cloud Native FaaS Lebowski

Awesome Lists containing this project

README 

          
# The Big Cloud-native Faas Lebowski



This is the demo repository for my conference talk *The Big Cloud Native FaaS Lebowski*.



Only a few years ago the move towards microservice architecture was the first big disruption in software engineering: instead of running monoliths, systems were now build, composed and run as autonomous services. But this came at the price of added development and infrastructure complexity. Serverless and FaaS seem to be the next disruption, they are the logical evolution trying to address some of the inherent technology complexity we are currently faced when building cloud native apps.



FaaS frameworks are currently popping up like mushrooms: Knative, Kubeless, OpenFn, Fission, OpenFaas or OpenWhisk are just a few to name. But which one of these is safe to pick and use in your next project? Let's find out.



## Preparation



### Step 1: Create Kubernetes cluster



In this first step we are going to create a Kubernetes cluster on GCP. Issue the

following command fire up the infrastructure:

```

$ make prepare cluster

```



### Step 2: Install and Initialize Helm



In this step we are going to install the Helm package manager so we can later easily

install the different FaaS frameworks.



```

$ make helm-install helm-init

```



### Step 3: Prepare Ingress



During clsuter setup an Traefik Ingress has been created. To easily access all the

demo endpoints we are creating a few virtual hostnames in `/etc/hosts`.



First, you need to find out the external IP address of the load balancer. For this, issue the

following command and write down the external IP address for the `traefik-ingress-service`.



```

$ kubectl get svc -n kube-system

```



Now, open your `/etc/hosts` file and enter the following entries. Replace the IP address with

the external IP from the `traefik-ingress-service`.



```

34.76.182.176  traefik-ui.demo

34.76.182.176  fnproject.lb.fn.internal fnproject.api.fn.internal

34.76.182.176  nuclio.demo

34.76.182.176  nuclio-ui.demo

34.76.182.176  fission.demo

34.76.182.176  fission-ui.demo

34.76.182.176  kubeless.demo

34.76.182.176  kubeless-ui.demo

34.76.182.176  openfaas.demo gateway.openfaas.local

```



## Fission Demo



This demo deploys a simple Go function. We use a pool manager size of 5 for the go environment.



```

$ make fission-sources

$ make fission-install

$ kubectl get all -n fission



$ cd fission/

$ fission environment create --name go --image fission/go-env --builder fission/go-builder --poolsize 5



$ kubectl get all -n fission-builder

$ kubectl get all -n fission-function



$ fission fn create --name hello-fission --env go --src hello-fission.go --entrypoint Handler

$ fission pkg info --name 

$ fission function list

$ fission fn test --name hello-fission



$ fission route create --name hello-http --function hello-fission --url /hello-fission --createingress --method GET --host fission.demo



$ http get http://fission.demo/hello-fission

$ hey -c 50 -z 30s http://fission.demo/hello-fission

$ wrk -c 50 -t 4 -d 30s http://fission.demo/hello-fission



$ fission env create --name jvm --image fission/jvm-env --version 2 --keeparchive=true --builder fission/jvm-builder

$ cd fission/examples/jvm

$ mvn clean package

$ fission fn create --name hello-jvm --deploy target/hello-world-1.0-SNAPSHOT-jar-with-dependencies.jar --env jvm --entrypoint io.fission.HelloWorld

$ fission pkg info --name 

$ fission function list

$ fission fn test --name hello-jvm



$ fission route create --name hello-jvm --function hello-jvm --url /hello-jvm --createingress --method GET --host fission.demo

$ http get http://fission.demo/hello-jvm



$ make fission-delete

```



## Kubeless Demo



This demo deploys a simple Go function. We set CPU limits to 100m so that the configured HPA

is working correctly. The functions scales from 5 to 20 replicas.



```

$ make kubeless-sources

$ make kubeless-install

$ kubectl get all -n kubeless

$ kubeless get-server-config



$ cd kubeless/hello-kubeless/

$ kubeless function deploy hello-kubeless --from-file func.go --handler func.Handler --runtime go1.12 --cpu 500m

$ kubeless function call hello-kubeless



$ kubeless trigger http create hello-kubeless --function-name hello-kubeless --path hello-kubeless --gateway traefik --hostname kubeless.demo



http get http://kubeless.demo/hello-kubeless



$ cd kubeless/java-kubeless/

$ kubeless function deploy hello-java8 --runtime java1.8 --handler HelloJug.hello --from-file HelloJug.java

$ kubeless function deploy hello-java11 --runtime java11 --handler HelloJug.hello --from-file HelloJug.java



$ kubeless function call hello-java8

$ kubeless trigger http create hello-java8 --function-name hello-java8 --path hello-java8 --gateway traefik --hostname kubeless.demo



$ kubeless function call hello-java11

$ kubeless trigger http create hello-java11 --function-name hello-java11 --path hello-java11 --gateway traefik --hostname kubeless.demo



$ kubeless autoscale create hello-kubeless --min 5 --max 20 --metric cpu --value 75

$ kubectl scale deployment hello-kubeless --replicas 5



$ hey -c 50 -z 30s http://kubeless.demo/hello-kubeless

$ wrk -c 50 -t 4 -d 30s http://kubeless.demo/hello-kubeless



$ make kubeless-delete

```



## OpenFaas Demo



The OpenFaas demo has been tuned with the help of @alexellis. The function itself has been labeled

to scale from 5 to 20 pods. The gateway component of OpenFaaS has been scaled to 5 replicas. Also

have a look at https://docs.openfaas.com/architecture/performance/



```

$ make openfaas-sources

$ make openfaas-install-arcade



$ kubectl get svc -o wide gateway-external -n openfaas

$ export OPENFAAS_URL=":8080"



# This command retrieves your password

$ PASSWORD=$(kubectl get secret -n openfaas basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode; echo)



# This command logs in and saves a file to ~/.openfaas/config.yml

$ echo -n $PASSWORD | faas-cli login --username admin --password-stdin



$ faas-cli list

$ open http://$OPENFAAS_URL



$ make openfaas-deploy



$ faas template pull https://github.com/openfaas-incubator/golang-http-template



$ cd openfaas

$ faas template pull https://github.com/openfaas-incubator/golang-http-template



$ faas build -f hello-openfaas.yml

$ faas push -f hello-openfaas.yml

$ faas deploy -f hello-openfaas.yml



$ kubectl scale deployment gateway --replicas=5 -n openfaas



$ kubectl get all -n openfaas

$ kubectl get all -n openfaas-fn



$ http get http://:8080/function/hello-openfaas

$ hey -c 50 -z 30s http://:8080/function/hello-openfaas

$ wrk -c 50 -t 4 -d 30s http://:8080/function/hello-openfaas



$ http get http://openfaas.demo/function/hello-openfaas

$ hey -c 50 -z 30s http://openfaas.demo/function/hello-openfaas

$ wrk -c 50 -t 4 -d 30s http://openfaas.demo/function/hello-openfaas



# https://github.com/pmlopes/openfaas-quarkus-native-template

$ faas template pull https://github.com/pmlopes/openfaas-quarkus-native-template



$ mkdir quarkus-function

$ cd quarkus-function

$ faas new --lang quarkus-native quarkus-function

$ mvn clean package



$ faas build -f quarkus-function.yml

$ faas push -f quarkus-function.yml

$ faas deploy -f quarkus-function.yml



$ make openfaas-delete

```



## Knative Demo



## Kyma Demo



## Nuclio Demo



This demo deploys a simple Go function that scales up to 20 replicas. The ingress used here

is Traefik.



```

$ make nuclio-sources

$ make nuclio-install

$ kubectl get all -n nuclio



$ helm install --name nuclio-rabbitmq -f rabbitmq/values.yaml stable/rabbitmq



$ cd nuclio/

$ ./nuctl create project hello-nuclio -n nuclio

$ ./nuctl deploy hello-nuclio --path hello-nuclio/main.go --file hello-nuclio/function.yaml --project-name hello-nuclio -n nuclio --max-replicas 20 --registry lreimer



$ open http://nuclio-ui.demo:8070/

$ http get http://nuclio.demo/hello-nuclio

$ hey -c 50 -z 30s http://nuclio.demo/hello-nuclio

$ wrk -c 50 -t 4 -d 30s http://nuclio.demo/hello-nuclio



$ make nuclio-delete

```



Note: sometimes the CLI times out during deployment of the function. Use the dashboard instead.

In case Nuclio has trouble accessing the Docker registry, make sure you have the correct credentials

set in the Kubernetes secret.



```

$ kubectl get secrets registry-credentials -n nuclio -o 'go-template={{index .data ".dockerconfigjson"}}' | base64 -D

```



## Fn Project Demo



```

$ make fnproject-sources

$ make fnproject-install

$ kubectl get all



$ fn create context fnproject --api-url http://fnproject.api.fn.internal --provider default --registry lreimer

$ fn use context fnproject



$ fn init --runtime go hello-fn

$ fn create app demo

$ fn deploy --app demo

$ fn invoke demo hello-fn



$ fn create trigger --source /hello-fn --type http demo hello-fn hello-http

$ http get http://fnproject.lb.fn.internal/t/demo/hello-fn

$ hey -c 50 -z 30s http://fnproject.lb.fn.internal/t/demo/hello-fn

$ wrk -c 50 -t 4 -d 30s http://fnproject.lb.fn.internal/t/demo/hello-fn



$ make fnproject-delete

```



## Maintainer



M.-Leander Reimer (@lreimer), 



## License



This software is provided under the MIT open source license, read the `LICENSE`

file for details.