Skip to content

Your first OpenFaaS Function with Python

Let's write a Python function with OpenFaaS that executes hello-world and then move onto something more. We'll start by deploying OpenFaaS on our machine and then we'll install the CLI and write the handler for our function.

OpenFaaS is democratising serverless functions - through Docker containers.


You can read my Introduction to Functions as a Service here.

Step 1 - Install OpenFaaS

If you already have FaaS and the CLI configured, skip to step 3.

Deploy OpenFaaS using one of the Deployment guides.

Step 2 - Install the CLI

The CLI is a convenient way to interact with your functions. You can use it to build and/or deploy functions to your cluster.

On a Mac if you're using brew then you can type in:

$ brew install faas-cli

On Linux (or Mac without brew available) type in:

$ curl -sSL | sudo sh

If you're using Windows, then you're not out of luck, you can actually find the Windows executable on the FaaS releases page.

Step 3 - Write your function

Create a new folder for your work:

$ mkdir -p ~/functions && \
  cd ~/functions

Now let's scaffold a new Python function using the CLI:

$ faas-cli new --lang python hello-python

This creates three files for you:


Let's edit the file:

def handle(req):
    print("Hello! You said: " + req)

All your functions should be specified in a YAML file like this - it tells the CLI what to build and deploy onto your OpenFaaS cluster.

Checkout the YAML file hello-python.yml:

  name: openfaas

    lang: python
    handler: ./hello-python
    image: hello-python


  • gateway- here we can specify a remote gateway if we need to, what the programming language is and where our handler is located within the filesystem.

  • functions - this block defines the functions in our stack

  • lang: python - even though Docker is used behind the scenes to package your function. You don't have to write your own Dockerfile unless you want to.

  • handler - this is the folder / path to your file and any other source code you need

  • image - this is the Docker image name. If you are going to push to the Docker Hub change the prefix from hello-python to include your Docker Hub account - i.e. alexellis/hello-python

So let's build the function.

$ faas-cli build -f ./hello-python.yml

Successfully tagged hello-python:latest
Image: hello-python built.

You'll now see output from the Docker Engine as it builds your function into an image in your local Docker library. You'll see the image appear on docker images

For example you could run:

$ docker images | grep hello-python
hello-python        latest       e0344b26305f     one minute ago

Testing on a single host

If you're using Kubernetes and minikube and don't want to push to a remote container registry, then see the helm chart for how to set the ImagePullPolicy. This will enable use of images from the local library on Kubernetes.

Remote host, or multi-node cluster

If you are using a remote server or a multi-node cluster then you can push your function's image to a registry or the Docker Hub. The Docker Hub is a free service provided by Docker Inc for sharing container images over the Internet.

If you are an advanced user, you can also run a container image registry within your own network. Link: Docker Registry docs

You'll also need to image the image: name to include your Hub account such as image: alexellis2/hello-python.

Here's how to upload the function to a remote registry (if needed):

$ faas-cli push -f ./hello-python.yml

Once you have multiple functions you can also use the --parallel argument to speed things up.

Let's deploy the function:

$ faas-cli deploy -f ./hello-python.yml
Deploying: hello-python.
No existing service to remove
200 OK

And it's ready to be tested! Either open up the UI or use curl to call it:

$ curl -d "it's Alex here"
Hello! You said: its Alex here

You can even use the faas-cli to list and invoke your functions.

Try playing with these two commands including looking at the help page with the --help parameter:

  • faas-cli list
  • echo "Hello!" | faas-cli invoke hello-python

Step 4 - Import 3rd party dependencies

So what if you need some dependencies to add behaviour beyond the standard Python libraries? Well you can use pip by providing a requirements.txt file along with your function handler.

Let's include the popular requests module which we can use to interact with webpages.

You will see a file called hello-python/requirements.txt. Add the following line:


Now we can update our Python code. Let's make it so it can accept JSON request of a URL and a string we want to test for:

We'll trigger it using a JSON request, which will take this format:

 "url": "",
 "term": "docker"

Now update the hello-python/ file:

import requests
import json

def handle(req):
    result = {"found": False}
    json_req = json.loads(req)
    r = requests.get(json_req["url"])
    if json_req["term"] in r.text:
        result = {"found": True}

    print json.dumps(result)

Then just rebuild, (re-push if needed) and re-deploy.

$ faas-cli build -f ./hello-python.yml && \
  faas-cli deploy -f ./hello-python.yml
*This time you'll see pip installing your function's modules such as requests.

Finally test it out!

$ curl --data-binary '{
 "url": "",
 "term": "docker"

Here's the result:

{"found": true}

Let's try another site:

$ curl --data-binary '{
 "url": "",
 "term": "docker"
{"found": False}

You can also access the function just as easily via the UI.

Preview of invocations

If you run into any errors you can follow our troubleshooting guide in the documentation

Step 5 - Going further

Please show support and Star the project on Github

Now that you've built your first function, why not checkout some of the examples built by the OpenFaaS community? You can share your first serverless OpenFaaS function with us on Twitter or Github.

Want to know more about the OpenFaaS Serverless framework for containers?

You can read my Introduction to Functions as a Service here.

Setup OpenFaaS with free credits

Learn Docker If you want to learn more about Docker for DevOps and developers, checkout my Docker series.

  • Acknowledgements:

This post is based upon Your first serverless Python function with OpenFaaS by Alex Ellis