Use an existing compartment to create your function in, or create a new one by opening the Oracle Cloud Menu and clicking "Identity & Security", and then "Compartments"

See the Compartments docs for more information.

Create a group for Oracle Functions users by clicking the Oracle Cloud menu and selecting "Identity & Security", and then click "Groups":

Click "Create Group":

Choose a name and a description, e.g. "mn-function-group", and click "Create":

Create a user by clicking the Oracle Cloud menu and selecting "Identity & Security", and then click "Users":

Click "Create User":

Choose a name and a description, e.g. "mn-function-user", and click "Create":

Scroll down and click "Add User to Group":

Select the group you created and click "Add":

You’ll need an auth token to authenticate to the container registry that will contain the Docker images for your functions. Click "Auth Tokens" and then "Generate Token":

Enter a name for the token, e.g. "mn-ocir", and click "Generate Token":

Copy the token to the clipboard and save it for later:

You will need a password to login as this user, so click the "Create/Reset Password" button:

and then click the "Create/Reset Password" button in the dialog:

Click the "Copy" link and save the generated password for later.

See the Groups and Users docs for more information.

Your function will be deployed as a Docker image, so you need to choose a repo name in your tenancy. The repo will be created for you the first time you push an image to it.

The name can be simple, e.g. "mn-functions", or you can add a path prefix to help group the repos when there are many of them, e.g. "my-username/my-repo/mn-functions"

Update your build script with the location to deploy the Docker container.

Edit pom.xml and change jib.docker.image property in the <properties> section, replacing REGION, TENANCY, and REPO with appropriate values:

For REGION, use the lowercase value from the "Region Key" column in Regions and Availability Domains, e.g. iad.

For TENANCY, use the Object Storage namespace string of the tenancy (as shown on the Tenancy Information page), e.g. my-tenancy.

For REPO, use the name of the repository to use, e.g. mn-functions (or my-username/my-repo/mn-functions).

The final properties should look something like this:

Login to OCIR by running:

Replace <region-key> with the value you used for REGION above, e.g. iad.ocir.io.

For the username, enter <tenancy-namespace>/<username>, e.g. my-tenancy/mn-function-user. If your tenancy is federated with Oracle Identity Cloud Service, use the format <tenancy-namespace>/oracleidentitycloudservice/<username>.

For the password, use the auth token you copied earlier.

See the OCIR login docs for more information.

If you have a suitable VCN and subnet you can use those, or create new ones.

To create a VCN, open the Oracle Cloud Menu and click "Networking", then "Virtual Cloud Networks":

Click "Start VCN Wizard":

Select "VCN with Internet Connectivity" and click "Start VCN Wizard":

Enter a name for the VCN, e.g. "mn-functions-vcn", and change the CIDR block values if needed:

Review the settings and click "Create":

See the VCN and Subnets docs for more information.

We’ll need to create some policies to grant various function-related permissions.

Open the Oracle Cloud Menu and click "Identity & Security", and then "Policies":

Select the root compartment from the drop-down and click "Create Policy":

Choose a name and description, e.g. "mn-functions-root-policy", and click "Show Manual Editor". Copy the following and paste it into the "Policy Builder" field, replacing "<group-name>" with the name of the group created earlier (e.g. "mn-function-group") and "<compartment-name>" with the name of the compartment you’re using, and click "Create":

Create another policy in the compartment where your function will be and choose a name and description, e.g. "mn-functions-compartment-policy". Copy the following and paste it into the "Policy Builder" field, again replacing "<group-name>" and "<compartment-name>", and click "Create":

See the Policies docs for more information.

We will use GraalVM, the polyglot embeddable virtual machine, to generate a Native executable of our function.

Compiling native executables ahead-of-time with GraalVM improves startup time and reduces the memory footprint of JVM-based applications and functions.

The easiest way to install GraalVM on Linux or Mac is to use SDKMan.io.

For installation on Windows, or for manual installation on Linux or Mac, see the GraalVM Getting Started documentation.

After installing GraalVM, install the native-image component, which is not installed by default:

Deploying the function as a native executable is similar to the earlier deployment above.

First you need to update your build script with the location to deploy the native executable Docker container.

Since it’s unlikely that you’ll be deploying both jar-based containers and native executable-based containers, you can use the same repo. If you wish to separate the native executable containers, edit pom.xml and update the jib.docker.image property, appending "-native" to the value:

Next, update the version.

Edit pom.xml and increment the version to 0.2:

Depending on the Micronaut version you’re using, you might also need to update some properties in your build script to update the Docker configuration.

In your pom.xml, if the nativeImageBuildArgs block in the configuration section of the micronaut-maven-plugin plugin includes an arg with value --static, replace it with -H:+StaticExecutableWithDynamicLibC. Also change the base image to frolvlad/alpine-glibc:alpine-3.12 in a new baseImageRun element:

Then from the demo project directory, run:

Once you’ve pushed the Docker container, edit the function in the console to use the new container, and to reduce the memory to 128MB:

Use the same OCI command as before to invoke the function. No changes are needed because the function OCID doesn’t change when deploying new containers.