Create an OpenShift Serverless function

Introduction

You can use a Function-as-a-Service (FaaS) object to process data as needed, with the function shutting down after a period of time if unused. If you try to access the function after it's shut down, there is a slight delay as it restores. Using a service in this way enables you to limit costs because you only pay for the CPU cycles when you actually need them.

In the world of Kubernetes, Knative is the most commonly used technology implementing the FaaS pattern. Red Hat OpenShift implements the FaaS pattern using Knative via the Red Hat OpenShift Serverless operator.

What you’ll be doing

This activity consists of two pieces: A back-end function and a front-end web application. You will implement both pieces. The back end is created from the command line, while the front end is created via the OpenShift web-based user interface (i.e., the “dashboard”). Here are the steps:

1. Start the back-end serverless function.
2. Start the front-end Photobooth application.
3. Open the Photobooth application.
4. Get the serverless URL.
5. Paste the URL into Photobooth.
6. Take a picture and wait for results.
7. Take another picture.
8. Wait, then take third picture.

How long will this activity take?

You should budget about 30 minutes to complete this sandbox activity.

What will you learn?

When you have finished this activity, you will be able to create an OpenShift Serverless function from either the command line or the dashboard.

Prerequisites

You will need the following in order to complete this activity:

• A Developer Sandbox for Red Hat OpenShift account.
• The oc command-line interface installed on your computer.
• A web browser to access your Developer Sandbox dashboard.

Programming languages

You don’t need to know any programming languages to complete this task. If you want to view the code, the back-end is written in Java; the front-end is Blazor running in WebAssembly.

Need help?

If you get stuck, if something isn’t working, or if you simply have questions, you can contact us via email at devsandbox@redhat.com.

---

Preparing for step 1: Log in to your sandbox at the command line

If you’re unsure how to do this, you can find instructions here: Access your Developer Sandbox for Red Hat OpenShift from the command line

In step 1, we’ll create the back-end serverless function from the command line. The only tool needed is the oc command-line interface. We do not need to clone or download the source code GitHub repository; we can reference the YAML file directly from our command line.

Here are the contents of the service.yaml file that we’ll be using—notice the labels and the containers entries:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: overlayimage
  labels:
    sandbox: serverless
    sandbox-serverless: overlay

spec:
  template:
    spec:
      containers:
        - image: quay.io/rhdevelopers/imageoverlay:latest

labels allow us to attach multiple key/value pairs to our objects. In this example, I’m creating unique values that will make it easier to remove all of the objects created.

The containers entry specifies the Linux image that will be run. In order for a container to be used as a serverless function, no special coding is necessary. The OpenShift Operator, based on Knative serving, does all the special work. The OpenShift Operator allows you to implement an existing web API application, written in the programming language of your choice, as a function.

Step 1: Start the back-end serverless function

Run the following command:

oc apply -f https://raw.githubusercontent.com/redhat-developer-demos/image-overlay/master/service.yaml

In the next step, we’ll implement the front-end application, Photobooth, by importing an existing Linux image via the OpenShift dashboard (the web interface).

Step 2: Start the front-end Photobooth application

From the dashboard, select the +Add option (Figure 1).

Next, select the option to add by using an existing container image (Figure 2).

Enter this value for the image (Figure 3): quay.io/rhdevelopers/photobooth:latest

Near the bottom of the form, under Advanced options, select Port 8080 as the port to be used (marked 1 in Figure 4), and select Labels (2).

Enter the following two values for Labels, as shown in Figure 5:

sandbox=serverless

sandbox-serverless=photobooth

Select Resource type. Enter Deployment (marked as 1 in Figure 6) as the Resource type, then Create (2).

Step 3: Open the Photobooth application

Open the Photobooth application in your default web browser by clicking on the external route arrow in the OpenShift dashboard (Figure 7).

Your image will appear, as shown in Figure 8.

Before you can successfully use the Photobooth app, you need to tell it the correct URL for the service. The URL is the path to the service using the overlayImage route.

Note: The route is case-sensitive.

Step 4. Get the serverless URL

At the command line, run the following command and copy the route:

oc get ksvc

Here’s an example of the output:

NAME           URL                                                                                        LATESTCREATED        LATESTREADY          READY   REASON

overlayimage   https://overlayimage-rhn-engineering-foobar-dev.apps.sandbox.x8i5.p1.openshiftapps.com   overlayimage-00001   overlayimage-00001   True

Step 5: Paste the URL into Photobooth

Paste the URL with the appended /overlayImage route into the Photobooth web page and select Apply (Figure 9).

Step 6. Take a picture and wait for the results

Now, click Take Picture and wait for the results to appear. It might take 10 to 15 seconds as the serverless function is scaled from zero to one. Figure 10 shows an example of the output. Note the image you see will be of your face, not mine.

Step 7: Take another picture

Immediately take another picture. Notice that this time, the results are almost instantaneous. This is because the serverless function is awake and serving requests. This will continue until one minute of inactivity, after which the serverless function will scale to zero again.

Step 8: Wait, then take a third picture

After waiting for more than 60 seconds, take another picture.

Again, there is a delay until the serverless function scales to one. This cycle of scaling up and down is the essence of a serverless function; it uses CPU cycles only as needed.

Developer notes:

• When considering a serverless function, you must decide if the slight delay to scale from zero to one is appropriate for the application.
• The back-end application, image-overlay, is written in Java.
• The front-end application, Photobooth, is written in C# using the Blazor WASM framework.
• The image overlay is a 640-480, mostly transparent, PNG file.
• The text (“Serverless!”) is passed from the front-end application.

Go beyond: Move it, remove it, improve it

Now that you know how to create an OpenShift Serverless function from the command line and the dashboard, here are some other ideas to try.

Move it

You can download all of the YAML files associated with this application and use them to move the app to another OpenShift instance by using the Export Application button in the upper-right corner of the OpenShift dashboard.

Remove it

You can remove parts of all of this activity by using one of the following commands:

• To remove only the overlay-image function:

  oc delete all -l sandbox-serverless=overlay

• To remove only the Photobooth application:

  oc delete all -l sandbox-serverless=photobooth

• To remove all of the objects associated with this activity:

  oc delete all -l sandbox=serverless

Improve it

Some ideas to improve or alter this activity:

• Write your own back-end function in a different language.
• Clone the back-end code and use a different overlay image. Rebuild the image and use it instead of quay.io/rhdevelopers/image-overlay.
• Write the front end in another language. Use a server-based web engine where it reads the URL from an environment variable so it doesn’t need to be entered on the screen.