Writing Function-as-a-Service [1]: First Function using Extension Center

With other words:

We write our first funny serverless Function
with
SAP Cloud Platform Serverless Runtime
and we use the cloud based tool
Extension Center

This blog is part of a series of tutorials explaining how to write serverless functions using the Function-as-a-Service offering in SAP Cloud Platform Serverless Runtime

Quicklinks:
Preparation Blog
Quick Guide

Overview

A “serverless function” is a function.
It is written in Javascript for Node.js
It is deployed to the “Functions-as-a-Service” runtime of SAP Cloud Platform
The function can be created using the nice tool “Extension Center” which is available in SAP Cloud Platform

This blog guides you through the creation of a simple silly example
The titles of the chapters show how simple it is:

• Open Extension Center
• Create Project
• Create Function
• Create Trigger
• Try it

Prerequisites

You should be an absolute newbie
But not too much absolute newbie
You should have gone through the Preparation blog, so you’re able to open the Extension Center

Open Extension Center

Opening the Extension Center is mentioned in the Prerequisites section, so we can assume that it is already open
Hence closing this chapter

Create Project

Make sure that Extensions is selected in the left menu pane
Note:
As you know, under the umbrella of “Serverless Runtime”, we also get the Capability ‘”OData Provisioning” which can by accessed from “Extension Center” -> “Services” entry as well.
But we ignore it

Click on New Extension
The wizard for creating a new “Extension” is opened

What is that, a new “Extension”?
For my small brain (not “extended”), things are easier to understand with concrete and simple words.
So, translated into my language (which consists of limited set of simple words):
A new Extension is a new project
And yes, you can use it to extend SAP solutions or whatever

OK, now we really create that extension.
The first wizard page allows to choose a template, which helps to create a project structure.
There’s a template called “Blank Template”. Let’s choose this one.
It is less convenient, please forgive me, but that means better learning experience

After selecting the template, click on “step 2 “
Enter a dumb “Name” for your extension, e.g. “testproject”, choose whatever “Runtime” you prefer and press “Create”

The development environment is presented to us in its full glory:

The wizard has created the minimum skeleton: 2 files in 1 project

The main entry file is opened in the editor:
faas.json
In my language I call it the manifest (or: main descriptor) of a Functions project
Or you can think of it as descriptor of your extension
Note:
This file is waiting to be edited manually, only be aware of one rule:
Never change the property “project”. The value is generated according to the “extension” name and if it isn’t equal, the deployment fails

The second file is the package.json file, the descriptor of Node.js projects

Note:
Yes, currently a Function can only be implemented in Node.js, Java as runtime might be supported later

Sigh… an empty functions project is like a bottle without wine…

Create Function

What we want is a function.
Now 2 things are required:
– Create a javascript file
– Let faas.json know where it is

We could do both steps manually:
The development environment allows us to create files and folders
Also, we can edit the faas.json file directly in the editor

BUT:
Extension Center offers a nice form-based editor.
So it is time to hit the toggle-button “Form View” to change from the plain code editor to the form based editor

Now, in the “Functions” tab, we can press the button “Add Function”
In the creation dialog, we’re asked for the required information:

Function name: This is really just a name (not file name)
Module name: This is really a file name (not just a name)
Handler name: This is really….well, since a module can have multiple methods, we’re required to mention the main entry
Timeout: we can leave the default

After entering some values, we have to press the  +  button.
Afterwards, we can create more functions (files), or press “Add” to close the dialog

Now the new function is there, in the list. But what has happened?
Let’s switch back to the Code View
We can see:
a “lib” folder has been created
the new javascript file inside
our handler function inside
the metadata has been added to the descriptor file

And one thing is noteworthy – and for sure you have to get used to it:
The faas.json file has been edited, so it is dirty
Now, we cannot just “save” the file. I mean locally save the changes in the file
We have to press Save and Deploy
And we really should do that.
Because if we forget that (important) click and do any other (silly) click somewhere in the Extension Center, or in the browser, then all changes are lost
Remember my words:
Someday you will lose your changes – and then you will remember me, and the lesson I told you:
Always do saveanddeploy

And what now?
We have a function
What to do with it?
Open it with double click: now we can see the function
But it does nothing
Let’s add one line:

console.log('*** MIAOW ***')

Oh – now it really does something

Let me again show the whole code of the function:

 module.exports = { 
	myhandler: function (event, context) { 
		console.log('*** MIAOW ***') ;
		return '...miaow...!';
	  } 
 }

This is really all:
Just a function.
It has to be exported such that it can be called by the Node.js runtime

Create Trigger

While we’re having a coffee and waiting for the function to miaow….
We can have a look at our Extension Center, Form View again
We created a Function with the help of the first Tab

But what’s that second tab: “Triggers” ?
Yes, a “Trigger” is just a trigger.
In the Serverless-Universe, every“thing” is strolling around in the space, along with its container – until it is needed
I like to compare it with my pussycat:

It is sleeping all the day (not during night)
If I want to cuddle it, I have to wake it up
Then it does its job (being fluffy and purr)
Then it goes back to sleep

I have a few possibilities to wake it up:

Talk to it (“come here my pussycat” – typically useless)
Call it (“miu miu miu” – pussycat might move one ear)
Tease it (ends with scratches on my hands)
Seduce it (Showing favorite snacks – irresistible!)

OK, hope you like the cat-comparison
It is silly
Good. Going back, our function is in the cloud and it is sleeping.
We need to choose a trigger to wake it up and do something

In the Extension Center, we switch to the “Form View” and open the “Triggers” tab
We expand the drop-down of the “Add Trigger” button
Choose “HTTP” from the drop down
In the dialog, we enter the required values:

The name is just a name. It will be used in faas.json to reference the trigger
Also we specify the function which should be triggered

Press Add and don’t forget to remember my famous last words (already forgotten? Here they are: Always do saveanddeploy)
We have to “saveanddeploy” the updated function-project, to let the framework generate a URL
After the deployment status turns to a greenish “Ready”, we can view the details of the new trigger.
Click on the little “details” button to display a popup which contains the trigger URL

Try it

At this point in time, our cat is still sleeping on a fluffy cloud but the snack is already in our hands…
We only need to use it, to wake up the sleeping beauty:

We just need to click the link

As a result, we get that cute response

That’s it:
We’ve created our first function
Silly – but serverless

Summary

We’ve created a function using the Extension Center in the cloud
The function can be invoked with an HTTP URL, by anybody
The function sleeps until we wake it up
The function does its job, then goes back to sleep

The good thing: payment is only required when the function is awake
With other words:
Food can be consumed only while pussycat is awake :burrito:

Quick Guide

To create a function with extension center:
Create project
Create function
Create trigger
Use Details button for URL

Don’t forget saveanddeploy

Links

See Overview Blog

Appendix: The sleeping function