Getting started with Serverless on Oracle Cloud


 

Serverless computing is where your cloud provider runs the servers in which your eventual application code runs, dynamically allocating resources. It allow you as the developer can focus on your application code.

Functions can be manually triggered, or fire in response to events in the tenancy, such as a compute instance changing state.

Installation

The platform the supports serverless on Oracle Cloud is The Fn Project. So to get started the first task we need to do is install this in our local machine. The pre-requisites for this software is Docker - as at time of writing, this requires a minimum docker version of 17.10. If you're on Ubuntu you can install from the package docker.io. Alternatively, you can review the installation docs for best steps to install on your platform.

Once Docker is installed, to install Fn, you can follow the install instructions as mentioned within their GitHub documentation. For a Linux environment, this is basically a matter of running an installer shell script like so. 

curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh

Create application

Once you have Fn installed, you should have a command on your computer available, fn. To set up the boilerplate for a serverless function we need to choose what language we would like to use. Once you've decided you use the sub-command init. This will set up a hello world style function. 

$ fn init --runtime go fn-demo-hello && cd fn-demo-hello
$ ls -1
func.go
func.yaml
go.mod

So, Fn created 3 files, where the main one we will be interested in is func.go.

Run application

During development you will want to run your application locally, so do to so we need to start a local Fn server. This is provided through the sub-command start. Once started, we need to deploy our function to be able to run it. But first you need to have an application that houses the function. So we need to create an application and then deploy it through the deploy sub-command.

fn create app fn-demo-app
fn deploy --app hello-app --local

We must specify --local in order that it doesn't try to push the built image to a remote docker registry. Local basically makes it so the docker image is built and called in your local container registry. After a function deployment, we will see the function image in our local registry.

$ docker images fn-demo-hello --format "{{.Repository}} (version={{.Tag}})"
fn-demo-hello (version=0.0.4)
fn-demo-hello (version=0.0.2)
fn-demo-hello (version=0.0.3)

Now finally we will be able to test our function. In the simplest form, we can use the invoke sub-command. 

fn invoke fn-demo-app fn-demo-hello

The sample function that gets created accepts a parameter in a JSON object, name. So we can change the invocation to pass in a parameter from the command line by piping in a JSON object

echo '{"name": "John"}' | fn -v invoke fn-demo-app fn-demo-hello

You may want to run your program locally through URL access. We can also test by starting up a REST test client such as Postman and calling the invocation URL that we get by inspecting the function. To find the invocation URL we can run the following command, or a variation of.

fn inspect function fn-demo-app fn-demo-hello | jq -r '."annotations"."fnproject.io/fn/invokeEndpoint"'

We can then take that URL to build up an endpoint in Postman:


Deploy to Oracle Cloud

Now that we have a serverless function, we can look to deploy this to our cloud environment.

Configure your tenancy

You will need to set up some policies to enable serverless functions to work within your cloud environment. These are all in the functions documenttion but at the most basic level you need to give the Functions service access to both the network as well as the ability to read the container registry - where the docker images end up living. Depending on your current permission levels you may need some additional policies - refer back to the aforementioned documentation for full details.

Allow service FaaS to use virtual-network-family in compartment fn-demo
Allow service FaaS to read repos in tenancy

We will also need to make sure to set up a Docker container registry. This is so Fn has somewhere to push your Docker images to. In the console, go to Developer Services -> Container Registry. Then Create a Repository - for this post, I created one called fn-demo-repo.

You also need to have an API token to log into this registry - done through the user details page within the OCI Console. The login URL becomes one of the URLs specified here. You username would become the object storage namespace + your regular login e-mail address: abcdefabcdef/user@email.com. And finally the password would be your generated API token.

So at the command prompt, enter: docker login mel.ocir.io (adjusting the URL depending on your location) and follow the prompts.

Configure Fn to talk to Oracle Cloud

Fn works with contexts. So far we have been using the default context - which is typically our local environment. In order to use our Function against Oracle Cloud we need to create a new context, and set some configuration. Information will will need for this:

  • The OCID of the compartment where your function will live
  • The API URL - this is dependent on the region of your function
  • The registry URL <region key>.ocir.io/<object storage namespace>/repo-name
  • The profile name used to connect to OCI (from your $HOME/.oci/config file)

Once you have that information, you will set it up your context similar to:

fn create context oci-demo-context --provider oracle
fn use context oci-demo-context
fn update context oracle.compartment-id TODO_COMPARTMENT_ID
fn update context oracle.profile DEMO
fn update context api-url https://functions.ap-melbourne-1.oci.oraclecloud.com
fn update context registry mel.ocir.io/<namespace>/fn-demo-repo

At this point you will want to verify the configuration is working by trying to list your apps. You should see an empty list.

In the Console, go to Developer Services -> Functions and create a new application. I called mine fn-demo-app



Now we can go ahead and deploy our function

fn deploy --app fn-demo-app

Now that our function is deployed, we can test in a number of ways:

  • Using fn invoke much like we did when we set up our function to run locally
  • Using the OCI CLI client with the command oci fn function invoke --function-id TODO --body TODO
  • Using the OCI CLI client with the raw-request sub-command - using the URL you get by inspecting the function using fn inspect
  • Using the oci-curl custom bash script you can build, that handles all the signings, using the URL you get by inspecting the function using the fn tool
  • Set up an API Gateway Service - be sure that your VCN has the relevant security group rules in place to accept HTTPS requests

Quick Links

https://docs.cloud.oracle.com/en-us/iaas/Content/Functions/Concepts/functionsprerequisites.htm
https://docs.cloud.oracle.com/en-us/iaas/Content/Functions/Tasks/functionsinvokingfunctions.htm
https://github.com/fnproject/fdk-go/blob/225736950b1c233d370a4c97cd4633f2198deec9/fdk_example_test.go

Popular posts from this blog

Report row buttons firing a dynamic action

Image
A lot of the time on reports of data, we'll define a link column, and specify an image which is the beloved pencil icon. Which is good and all, but looking in the Sample Database Application (packaged application), they have taken a different approach to style links - a button that stretches the width of it's containing cell. So, the UI ends up looking like so: So, is this done? Well first, you define a new column for the placeholder. Suppose I want my link column to be Report, I define an extra column in my query: , 'Report' report_link Then I need to go to my new column's attributes, and change the column type to a link. And, in the link attributes, set the text to what you want displayed. Here, I'm just going to display the value of the new column and point to my desired page. So I set the target page, then also the Link text as #REPORT_LINK#. At this point the report will just show link text, as we expect. So, then to replicate t
Read more

Accessing the last request value from a page submission

Image
When you submit the page, you will typically have page processes that run. For me, I use these request values to determine which processes are run. This is rather straight forward for on submit processes as you can just specify the condition request = Expression 1 Or, if you have multiple requests that link to this process, Request is Contained within Expression 1, and Expression 1 would be a comma delimited set of values. Request simply refers to the bind variable :REQUEST (or apex_application.g_request). If we try and do the same on a page rendering process, we no longer have access to this value - which makes sense. If you update the branch, to set the request portion of the URL, we will then be able to access the bind variable :REQUEST in all page rendering processing points. This has the obvious downside that if the user wants to reload the page,  clicks in the address bar and hits enter (or clicks refresh), the processes on that condition
Read more

Installing Oracle Instant Client on Ubuntu

Now that Oracle has enabled us to download instant client without any click through for accepting the license , I wanted to revisit a seamless install of the instant client on a new set up. Ubuntu has the documentation about installing the instant client here: https://help.ubuntu.com/community/Oracle%20Instant%20Client. First - because Oracle provides their releases in RPM archive format (or a tarball), in order to have an installer you need to create a DEB archive. There is a package in the archives, alien, which aids this process. This gives the start of the script: #!/bin/bash # Install dependencies sudo apt install alien The 3 packages the Ubuntu documentation tells us to retrieve are: - devel - basic (I opt for basiclite instead) - sqlplus So, over at the downloads page: https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html we can grab the link. # Download files. Example specific to 19.3 # Some links were not correct on the do
Read more