fission

README

Fission: Serverless Functions for Kubernetes

fission.io @fissionio

Fission is a fast serverless framework for Kubernetes with a focus on developer productivity and high performance.

Fission operates on just the code: Docker and Kubernetes are abstracted away under normal operation, though you can use both to extend Fission if you want to.

Fission is extensible to any language; the core is written in Go, and language-specific parts are isolated in something called environments (more below). Fission currently supports NodeJS and Python, with more languages coming soon.

Performance: 100msec cold start

Fission maintains a pool of "warm" containers that each contain a small dynamic loader. When a function is first called, i.e. "cold-started", a running container is chosen and the function is loaded. This pool is what makes Fission fast: cold-start latencies are typically about 100msec.

Kubernetes is the right place for Serverless

We're built on Kubernetes because we think any non-trivial app will use a combination of serverless functions and more conventional microservices, and Kubernetes is a great framework to bring these together seamlessly.

Building on Kubernetes also means that anything you do for operations on your Kubernetes cluster — such as monitoring or log aggregation — also helps with ops on your Fission deployment.

Fission Concepts

A function is a piece of code that follows the fission function interface.

An environment contains the language- and runtime-specific parts of running a function. Fission comes with NodeJS and Python environments; you can also extend environments or create entirely new ones if you want. (An environment is essentially just a container with a webserver and dynamic loader.)

A trigger is something that maps an event to a function; Fission supports HTTP routes as triggers today, with upcoming support for other types of event triggers, such as timers and Kubernetes events.

Usage

  # Add the stock NodeJS env to your Fission deployment
  $ fission env create --name nodejs --image fission/node-env

  # A javascript one-liner that prints "hello world"
  $ echo 'module.exports = function(context, callback) { callback(200, "Hello, world!\n"); }' > hello.js  

  # Upload your function code to fission
  $ fission function create --name hello --env nodejs --code hello.js

  # Map GET /hello to your new function
  $ fission route create --method GET --url /hello --function hello

  # Run the function.  This takes about 100msec the first time.
  $ curl http://$FISSION_ROUTER/hello
  Hello, world!

Running Fission on your Cluster

Setup Kubernetes

You can install Kubernetes on your laptop with minikube: https://github.com/kubernetes/minikube

Or, you can use Google Container Engine's free trial to get a 3 node cluster.

Verify access to the cluster

  $ kubectl version

Get and Run Fission

If you're using GKE, use the fission.yaml unmodified. If you're using minikube, change all instances of LoadBalancer services to NodePort.

  $ kubectl create -f http://fission.io/fission.yaml 
  $ kubectl --namespace fission get services

Save the external IP addresses of controller and router services in FISSION_URL and FISSION_ROUTER, respectively. FISSION_URL is used by the fission CLI to find the server. (FISSION_ROUTER is only needed for the examples below to work.)

Install the client CLI

  $ curl http://fission.io/fission > fission

  $ chmod +x fission

  $ sudo mv fission /usr/local/bin/

Run an example

  $ fission env create --name nodejs --image fission/node-env
  
  $ echo 'module.exports = function(context, callback) { callback(200, "Hello, world!\n"); }' > hello.js  

  $ fission function create --name hello --env nodejs --code hello.js
  
  $ fission route create --method GET --url /hello --function hello
  
  $ curl http://$FISSION_ROUTER/hello
  Hello, world!

Compiling Fission

[You only need to do this if you're making Fission changes; if you're just deploying Fission, use fission.yaml which points to prebuilt images.]

You'll need go installed, along with the glide dependecy management tool. You'll also need docker for building images.

The server side is compiled as one binary ("fission-bundle") which contains controller, poolmgr and router; it invokes the right one based on command-line arguments.

To build fission-bundle: clone this repo, then from the top level directory:

  # Get dependencies
  $ glide install

  # Build fission server and an image
  $ pushd fission-bundle
  $ ./build.sh

  # Edit push.sh to point to your registry
  $ $EDITOR push.sh
  $ ./push.sh
  $ popd

  # To install, update fission.yaml to point to your compiled image
  $ $EDITOR fission.yaml
  $ kubectl create -f fission.yaml

If you're changing the CLI:

  # Build Fission CLI
  $ cd fission-cli && go install

Status

Fission is in early alpha. Don't use it in production just yet!

Right now, we're looking for developer feedback -- tell us which languages you care about, what use cases you might use it for, and so on.

Documentation

Index

• Constants
• func GetHTTPError(err error) (int, string)
• func MakeErrorFromHTTP(resp *http.Response) error
• type Environment
  • func (e Environment) Key() string
• type Error
  • func MakeError(code int, msg string) Error
  • func (e Error) Error() string
  • func (err Error) HTTPStatus() int
• type Function
  • func (f Function) Key() string
• type HTTPTrigger
  • func (ht HTTPTrigger) Key() string
• type Metadata

Constants

const (
	ErrorInternal = iota

	ErrorNotAuthorized
	ErrorNotFound
	ErrorNameExists
	ErrorInvalidArgument
	ErrorNoSpace
)

Functions

func GetHTTPError

func GetHTTPError(err error) (int, string)

func MakeErrorFromHTTP

func MakeErrorFromHTTP(resp *http.Response) error

Types

type Environment

type Environment struct {
	Metadata             `json:"metadata"`
	RunContainerImageUrl string `json:"runContainerImageUrl"`
}

Environment identifies the language and OS specific resources that a function depends on. For now this includes only the function run container image. Later, this will also include build containers, as well as support tools like debuggers, profilers, etc.

func (Environment) Key

func (e Environment) Key() string

type Error

type Error struct {
	Code    errorCode `json:"code"`
	Message string    `json:"message"`
}

Errors returned by the Fission API.

func MakeError

func MakeError(code int, msg string) Error

func (Error) Error

func (e Error) Error() string

func (Error) HTTPStatus

func (err Error) HTTPStatus() int

type Function

type Function struct {
	Metadata    `json:"metadata"`
	Environment Metadata `json:"environment"`
	Code        string   `json:"code"`
}

Function is a unit of executable code. Though it's called a function, the code may have more than one function; it's usually some sort of module or package.

func (Function) Key

func (f Function) Key() string

type HTTPTrigger

type HTTPTrigger struct {
	Metadata   `json:"metadata"`
	UrlPattern string   `json:"urlpattern"`
	Method     string   `json:"method"`
	Function   Metadata `json:"function"`
}

HTTPTrigger maps URL patterns to functions. Function.UID is optional; if absent, the latest version of the function will automatically be selected.

func (HTTPTrigger) Key

func (ht HTTPTrigger) Key() string

type Metadata

type Metadata struct {
	Name string `json:"name"`
	Uid  string `json:"uid,omitempty"`
}

Metadata is used as the general identifier for all kinds of resources managed by the controller.