A common Helm chart was once maintained for Kubeless as the project is seeking help. Instead of the chart, Kubeless can be installed with manifest bundles.

This scenario has been testing with this recent release:

RELEASE=v1.0.8

Create a namespace for the installation target:

kubectl create namespace kubeless

To install Kubeless onto Kubernetes use this command:

kubectl create -f https://github.com/kubeless/kubeless/releases/download/$RELEASE/kubeless-$RELEASE.yaml

Kubeless also supports a web console. Install the console as well:

kubectl create -f https://raw.githubusercontent.com/kubeless/kubeless-ui/master/k8s.yaml

As part of the installation, there will be two Pods started in the new kubeless namespace on your Kubernetes cluster.

• The Kubeless controller deployment will watch for function objects to be created.
• The Kubeless UI deployment serves up a browser-based dashboard showing the functions

Observe the availability of each deployment as they progress from 0 to 1:

kubectl get deployments,pods --namespace kubeless

It may take a few moments before all the Kubeless containers are Running.

Once running, new functions can be deployed to Kubeless.

Kubeless has a command-line interface (CLI) tool named appropriately kubeless. Use this tool to manage your functions on Kubeless. Let's get a recent Kubeless command-line interface (CLI) binary for this Linux account:

curl -L http://github.com/kubeless/kubeless/releases/download/$RELEASE/kubeless_linux-amd64.zip -o kubeless.zip

unzip -Cj kubeless.zip "bundles/kubeless_linux-amd64/kubeless" -d /usr/local/bin

This tool version will match the controller installed in the next step. Verify this CLI is working by inspecting its current version:

kubeless --help && kubeless version

Kubeless Dashboard

There is also a user interface as an alternative way to manage Kubeless and your functions.

Currently, it's on a random Kubernetes NodePort (some value above 30000) and this next line will force the NodePort to 31000:

kubectl patch service ui --namespace=kubeless --type='json' --patch='[{"op": "replace", "path": "/spec/ports/0/nodePort", "value":31000}]'

Ideally, this port adjustment should have happened when the Kubeless Helm chart was installed, but the chart currently does not allow the NodePort value to be specified. As a workaround, we adjust the port after installation with the above command. We can now point your browser to the service that serves up the Kubeless UI

The Kubeless UI is located as a tab above the command-line area or from this link: https://[[HOST_SUBDOMAIN]]-31000-[[KATACODA_HOST]].environments.katacoda.com/

Kubeless supports a variety of languages and versions out of the box. To see the list of runtimes use this command.

kubeless get-server-config

To deploy a Python function, the Kubeless CLI tool needs some information:

• The name you will use to access the function over the Web
• The runtime to be executed to run the code (e.g. Python)
• The name of the file containing the function code
• The name of the function inside the file

kubeless function deploy fibonacci --from-file fibonacci.py --runtime python3.6 --handler fibonacci.values

With the above, here is a breakdown of this function registration request:

• kubeless function deploy fibonacci tells Kubeless to register a new function named fibonacci. The function will be accessible over the Web using this name. This doesn’t need to be the same as the function name used inside the code (this is instead specified using the --handler option).

• --runtime python3.6 tells Kubeless to use Python 3.6 to execute the code. Other runtimes are available such as: Java, NodeJS, Ruby, PHP, Go, .NET, and Ballerina. You can also supply a custom runtime as a container.

• --handler fibonacci.values informs Kubeless the name of the function to call inside the code module. You can see in the Python code above that the function is called values().

• --from-file /tmp/fibonacci.py tells Kubeless to upload and use the /tmp/fibonacci.py file as the source for the function. It is possible to pass a function in other ways.

You can list the new function with the Kubeless CLI:

kubeless function list

While the function is deploying inspect the actual Python function source code:

cat fibonacci.py

With the deploy command, Kubeless automatically created a Kubernetes deployment and service for your function. Observe that a Deployment containing your function is running and exposed as a service in the default namespace:

Execute this command until Available turns from 0 to 1.

kubectl get deployments,pods,services

Call from CLI

Use the Kubeless CLI tool to call the function.

kubeless function call fibonacci --data '{"length":"10"}'

Call from URL

Run a Kubernetes proxy to expose the cluster at a port.

kubectl proxy --port 8080

Call the function via curl.

curl --data '{"length":"20"}' localhost:8080/api/v1/namespaces/default/services/fibonacci:8080/proxy/ --header "Content-Type:application/json" && echo

Get a description of the deployed function

kubeless function describe fibonacci

Inspect the execution logs of the function

kubeless function logs fibonacci

Call the function with a bad input

kubeless function call fibonacci --data '{"introduce-error":"-1"}'

and reinspect the logs

kubeless function logs fibonacci

or

kubectl logs -l function=fibonacci

To review, here is a very simple Python function. Just two lines:

cat get.py

Register the function

kubeless function deploy get --runtime python3.6 --from-file get.py --handler get.greeting

Wait a few seconds for it to start, then call it.

kubeless function call get

or

curl localhost:8080/api/v1/namespaces/default/services/get:8080/proxy/ && echo

The Kubeless secret sauce is your function's source code is deployed into a Kubernetes ConfigMap. The ConfigMap contents is listed with this:

kubectl get configmaps

You can view ConfigMap and see the deployed code here:

kubectl describe configmap fibonacci

When the Kubeless CLI tool registers your function it sends a custom and declarative Kubernetes manifest file. The file itself has a custom Kubernetes kind. These kinds are registered as CRDs. The list of CRDs for Kubeless can be found with this

kubectl get crds --namespace kubeless

On deployment Kubeless starts a pre-baked container containing the Python executable, then your function's source code is referenced from the ConfigMap and injected into the Python container. In turn, the container is fronted by a Kubernetes Service where you can invoke the function from a Service call. Inspect the Deployment and Service with this command:

kubectl get deployments,pods,services

You can also explore the Kubeless functions in the Kubernetes dashboard.

Instead of using the Kubeless CLI, it is possible to deploy Kubeless Functions directly using the Kubernetes API and creating Function objects. A manifest can be defined and submitted to Kubernetes with the kubectl create command. Take a look at this example manifest

cat ruby-example.yaml

Notice at the top the manifest Kind is Function. Function is not part of the core set of Kubernetes Kinds. Instead, this Kind is an extension added by the Kubeless framework. This illustrates the extensibility of Kubernetes to allow custom extensions to the Kubernetes API. The Kubernetes feature of custom resource definitions (CRDs) permits this solution. To see the CRDs that Kubeless has added run this

kubectl get crds --namespace kubeless

Now, let's try running a function submitted by definition through a Kubernetes manifest file

kubectl create -f ruby-example.yaml

Wait until the deployment is Available.

kubectl get deployments

If it's needed, add a proxy. It may benignly show error as a previous step already asked you to start a proxy as it may have been added in one of the previous lessons.

kubectl proxy --port 8080

Exercise the function.

echo "The latest version of Kubeless CLI is $(curl -s localhost:8080/api/v1/namespaces/default/services/ruby-example:8080/proxy/)"

This function outputs the latest release version found online for Kubeless.

Notice all these steps were accomplished without Kubeless commands, just Kubernetes commands.

There are additional languages also supported out of the box from Kubeless. Here is a NodeJS example. Deploy the function:

kubeless function deploy hello-js --runtime nodejsCE8 --from-file hello.js --handler hello.greeting

See the new function hello.greeting listed and confirm the status is Ready, it may take a minute:

kubeless function list

kubeless function describe hello-js

Once ready, run the function:

kubeless function call hello-js --data '{"kubeless":"rocks"}'

Install the Serverless command-line tool.

npm install serverless -g

Clone the serverless-kubeless repo and check the example function

git clone https://github.com/serverless/serverless-kubeless

cd serverless-kubeless/examples/get-python

cat serverless.yml

Download dependencies

npm install

Deploy hello function

serverless deploy

The function will be deployed to Kubernetes via Kubeless.

kubectl get function

kubeless function list

kubectl get pods

Now, call the function

serverless invoke -f hello -l

or

curl localhost:8080/api/v1/namespaces/default/services/hello:8080/proxy/ && echo

Check the logs

serverless logs -f hello

Inspect Serverless

serverless info