Functions: Get Started using Cloud Shell

Before You Begin

To successfully perform this tutorial, you must have the following:

Requirements

1. Gather Required Information

Collect all the information needed to complete the tutorial.

Gather Region and Registry Information

Create or Select a Compartment

Create an Authorization Token

Collect your Information

2. Create your Virtual Cloud Network (VCN)

Set up a VCN to connect your Linux instance to the internet.

Configure your VCN

To configure virtual cloud network, perform the following steps.

Click the Oracle Cloud icon to go to the main landing page.
- Scroll down to Launch Resources.
- Select Set up a network with a wizard.
In the Start VCN Wizard workflow, select Create VCN with Internet Connectivity and then click Start VCN Wizard .
In the configuration dialog, fill in the VCN Name for your VCN. Your Compartment is already set to the last compartment you were working in, or if it's your first time, to its default value of <your-tenancy> (root).
In the Configure VCN and Subnets section, keep the default values for the CIDR blocks:
- VCN CIDR BLOCK: 10.0.0.0/16
- PUBLIC SUBNET CIDR BLOCK: 10.0.0.0/24
- PRIVATE SUBNET CIDR BLOCK: 10.0.1.0/24
Note

Notice the public and private subnets have different network addresses.
For DNS Resolution, uncheck Use DNS hostnames in this VCN.
Click Next.

The Create a VCN with Internet Connectivity configuration dialog is displayed (not shown here) confirming all the values you just entered.
Click Create to create your VCN.

The Creating Resources dialog is displayed (not shown here) showing all VCN components being created.
Click View Virtual Cloud Network to view your new VCN.

Your new VCN is displayed. Now you need to add a security rule to allow HTTP connections on port 80, the default port for your applications.
With your new VCN displayed, click your Public subnet link.

The public subnet information is displayed with the Security Lists at the bottom of the page. There should be a link to the Default Security List for your VCN.
Click the Default Security List link.

The default Ingress Rules for your VCN are displayed.
Click Add Ingress Rules.

An Add Ingress Rules dialog is displayed.
Fill in the ingress rule with the following information. Once all the data is entered, click Add Ingress Rules.
Fill in the ingress rule as follows:
- Stateless: Checked
- Source Type: CIDR
- Source CIDR: 0.0.0.0/0
- IP Protocol: TCP
- Source Port Range: (leave-blank)
- Destination Port Range: 80
- Description: VCN for applications
Once you click Add Ingress Rules, HTTP connections are allowed to your public subnet.

Note

To open a different port, replace 80 in the last step with the port number.

You have successfully created a VCN that makes your applications available from the internet.

3. Log into the OCI Registry

Next, you log Docker into the OCI Registry (OCIR).

Log Docker into OCIR

Get the information you gathered earlier.
Open a terminal window.
Log in to OCIR:
```
docker login <region-key>.ocir.io
```
You are prompted for your login name and password.
- Username: <tenancy-name>/<user-name>
- Password: <auth-token>

You have logged your instance into OCIR.

4. Configure Functions

To use Oracle Functions, you must configure the Fn application context. The context stores the values needed to connect to the Oracle Functions service. Fn client commands are used to add the required configuration data.

Configure the Fn Context for the Cloud Shell

You need the information you gathered from earlier on. Use Fn client commands to configure Fn.

Open your Cloud Shell instance.
Get a list of Fn contexts.

fn list context

You see contexts for default and <your-region-identifier>.
Select the context named with <your-region-identifier>.

For example: fn use context us-phoenix-1
List the Fn contexts to ensure <your-region-identifier> is selected. (Has a star next to it.)
Set the compartment for Oracle Functions.

Example: fn update context oracle.compartment-id ocid1.compartment.oc1..aaaaaaaarvdfa72n...
Set the URL for your Registry repository.

Sample command: fn update context registry <region-key>.ocir.io/<tenancy-namespace>/<registry-project-name>

Example: fn update context registry phx.ocir.io/my-tenancy/my-func-prj

Note

View/Edit your Context

Your Fn context files are in the ~/.fn/contexts directory. Each context is stored in a .yaml file. For example, your us-phoenix-1.yaml file might look similar to:

api-url: https://functions.us-phoenix-1.oci.oraclecloud.com
oracle.compartment-id: ocid1.compartment.oc1..aaaaaaaarvdfa72n...
provider: oraclecs
registry: phx.ocir.io/my-tenancy/my-func-prj

You can edit the file directly with an editor if necessary.

For a detailed explanation of each step, see: Oracle Functions on Cloud Shell Quickstart

You have now setup the Fn context for your instance.

5. Create and Deploy a Function

With your configuration complete, create and deploy a function.

Create an Application

Choose a Language

Select one of the following languages to create and deploy a function. If you want, you can do all three.

Create and Deploy a Java Function

With your application created, deploy a Java function. Follow these steps to create a Java "Hello World" function.

Note

Ensure Java 8+ is installed to perform these steps.

Open Cloud Shell.

Create a directory to store your functions and change into that directory.

mkdir my-dir-name
cd my-dir-name

Create a Java "Hello World" function with Fn.
```
fn init --runtime java my-func-name
```
This command creates a directory named my-func-name with several files in it.
- func.yaml - Function configuration file.
- pom.xml - Maven build file.
- src/main/java/com/example/fn/HelloFunction.java - The actual function file.
Change into the directory.
Deploy the function.
```
fn -v deploy --app your-app-name
```
Various messages are displayed as the docker images are built, pushed to OCIR, and eventually deployed to Oracle Functions.
Invoke the function.
```
fn invoke your-app-name my-func-name
```
Returns: Hello, world!
Invoke the function with a parameter.
```
echo -n "Bob" | fn invoke your-app-name my-func-name
```
Returns: Hello, Bob!
If you want to connect to your function from the net, you need to get the function's invoke endpoint. To find your invoke endpoint use the inspect command.
```
fn inspect function your-app-name my-func-name
```

Examine the results of the inspect command. Notice the invoke endpoint URL is included in the annotatins section of the returned JSON data.

{
    "annotations": {
        "fnproject.io/fn/invokeEndpoint": "https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke",
        "oracle.com/oci/compartmentId": "ocid1.compartment.oc1..aaaaaaaa...",
        "__comment":"Remaining output left out for brevity",

Use the URL returned from inspect to invoke the function. Because functions require requests to be digitally signed, the

oci
                        raw-request

command is used for this example.

oci raw-request --http-method POST --request-body "" --target-uri https://https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke

The command returns:

{
    "data": "Hello, world!",
    "headers": {
        "Content-Length": "13",
        "Content-Type": "text/plain",
        "Date": "Tue, 20 Oct 2020 00:53:08 GMT",
        "Fn-Call-Id": "11111111111",
        "Fn-Fdk-Version": "fdk-java/1.0.111 (jvm=OpenJDK 64-Bit Server VM, jvmv=11.0.8)",
        "Opc-Request-Id": "1111111/11111"
    },
    "status": "200 OK"
}

Note

You can connect to a Functions endpoint using tools like curl. However, because of security considerations, the script is complex. As an alternative, use the OCI CLI raw-request command. See Invoking Functions: Sending a Signed Request to a Function with raw-request.

You have successfully deployed and tested a Java function.

Create and Deploy a Python Function

With your application created, deploy a Python function. Follow these steps to create a Python "Hello World" function.

Open Cloud Shell.

Create a directory to store your functions and change into that directory.

mkdir my-dir-name
cd my-dir-name

Create a Python "Hello World" function with Fn.
```
fn init --runtime python my-func-name
```
This command creates a directory named my-func-name with several files in it.
- func.yaml - Function configuration file.
- requirements.txt - List of required Python libraries.
- func.py - The actual function file.
Change into the directory.
Deploy the function.
```
fn -v deploy --app your-app-name
```
Various messages are displayed as the docker images are built, pushed to OCIR, and eventually deployed to Oracle Functions.
Invoke the function.
```
fn invoke your-app-name my-func-name
```
Returns: {"message": "Hello World"}
Invoke the function with a parameter.
```
echo -n '{"name":"Bob"}' | fn invoke your-app-name my-func-name
```
Returns: {"message": "Hello Bob"}
If you want to connect to your function from the net, you need to get the function's invoke endpoint. To find your invoke endpoint use the inspect command.
```
fn inspect function your-app-name my-func-name
```

Examine the results of the inspect command. Notice the invoke endpoint URL is included in the annotatins section of the returned JSON data.

{
    "annotations": {
        "fnproject.io/fn/invokeEndpoint": "https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke",
        "oracle.com/oci/compartmentId": "ocid1.compartment.oc1..aaaaaaaa...",
        "__comment":"Remaining output left out for brevity",

Use the URL returned from inspect to invoke the function. Because functions require requests to be digitally signed, the oci raw-request command is used for this example.
```
oci raw-request --http-method POST --request-body "" --target-uri https://https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke
```
The command returns:
```
{
    "data": "Hello World",
    "headers": {
        "Content-Length": "24",
        "Content-Type": "application/json",
        "Date": "Tue, 20 Oct 2020 00:53:08 GMT",
        "Fn-Call-Id": "11111111111",
        "Fn-Fdk-Version": "fdk-python/0.1.18",
        "Opc-Request-Id": "1111111/11111"
    },
    "status": "200 OK"
}
```
Note

You can connect to a Functions endpoint using tools like curl. However, because of security considerations, the script is complex. As an alternative, use the OCI CLI raw-request command. See Invoking Functions: Sending a Signed Request to a Function with raw-request.

You have successfully deployed and tested a Python function.

Create and Deploy a Node Function

With your application created, deploy a Node function. Follow these steps to create a Node "Hello World" function.

Note

Ensure Node.js 10+ is installed to perform these steps.

Open Cloud Shell.

Create a directory to store your functions and change into that directory.

mkdir my-dir-name
cd my-dir-name

Create a Node "Hello World" function with Fn.
```
fn init --runtime node my-func-name
```
This command creates a directory named my-func-name with several files in it.
- func.yaml - Function configuration file.
- package.json - NPM build file.
- func.js - The actual function file.
Change into the directory.
Deploy the function.
```
fn -v deploy --app your-app-name
```
Various messages are displayed as the docker images are built, pushed to OCIR, and eventually deployed to Oracle Functions.
Invoke the function.
```
fn invoke your-app-name my-func-name
```
Returns: {"message":"Hello World"}
Invoke the function with a parameter.
```
echo -n '{"name":"Bob"}' | fn invoke your-app-name my-func-name
```
Returns: {"message":"Hello Bob"}
If you want to connect to your function from the net, you need to get the function's invoke endpoint. To find your invoke endpoint use the inspect command.
```
fn inspect function your-app-name my-func-name
```

Examine the results of the inspect command. Notice the invoke endpoint URL is included in the annotatins section of the returned JSON data.

{
    "annotations": {
        "fnproject.io/fn/invokeEndpoint": "https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke",
        "oracle.com/oci/compartmentId": "ocid1.compartment.oc1..aaaaaaaa...",
        "__comment":"Remaining output left out for brevity",

Use the URL returned from inspect to invoke the function. Because functions require requests to be digitally signed, the

oci
                        raw-request

command is used for this example.

oci raw-request --http-method POST --request-body "" --target-uri https://https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke

The command returns:

{
    "data": "Hello World",
    "headers": {
        "Content-Length": "23",
        "Content-Type": "application/json",
        "Date": "Tue, 22 Oct 2020 00:53:08 GMT",
        "Fn-Call-Id": "11111111111",
        "Fn-Fdk-Version": "fdk-node/0.1.18 (njsv=v11.15.0)",
        "Opc-Request-Id": "1111111/11111"
    },
    "status": "200 OK"
}

Note

You can connect to a Functions endpoint using tools like curl. However, because of security considerations, the script is complex. As an alternative, use the OCI CLI raw-request command. See Invoking Functions: Sending a Signed Request to a Function with raw-request.

You have successfully deployed and tested a Node function.

6. Review Function Information

After your functions run, information about your functions is available in the OCI Console.

View Function Images in OCIR

View Function Execution Information

Enable and View Logging Information

What's Next

You have successfully created a function and deployed it to Oracle Functions.

To explore more information about development with Oracle products, check out these sites:

Oracle Cloud Infrastructure Documentation Try Free Tier

Functions: Get Started using Cloud Shell

Before You Begin 🔗

1. Gather Required Information 🔗

2. Create your Virtual Cloud Network (VCN) 🔗

3. Log into the OCI Registry 🔗

4. Configure Functions 🔗

5. Create and Deploy a Function 🔗

Choose a Language

6. Review Function Information 🔗

What's Next 🔗

Oracle Cloud Infrastructure Documentation
Try Free Tier

Before You Begin

1. Gather Required Information

2. Create your Virtual Cloud Network (VCN)

3. Log into the OCI Registry

4. Configure Functions

5. Create and Deploy a Function

6. Review Function Information

What's Next