Help Center> FunctionGraph> User Guide> Building Functions> Creating a Function from Scratch> Creating an HTTP Function
Updated on 2024-04-01 GMT+08:00
View PDF

Creating an HTTP Function

Overview

HTTP functions are designed to optimize web services. You can send HTTP requests to URLs to trigger function execution. HTTP functions support APIG and APIC triggers only.

  • HTTP functions do not distinguish between programming languages. The handler must be set in the bootstrap file. You can directly write the startup command, and allow access over port 8000. The bound IP address is 127.0.0.1.
  • The bootstrap file is the startup file of the HTTP function. The HTTP function can only read bootstrap as the startup file name. If the file name is not bootstrap, the service cannot be started. For more information, see the bootstrap file example.
  • HTTP functions support multiple programming languages.
  • Functions must return a valid HTTP response.
  • This section uses Node.js as an example. To use another runtime, simply change the runtime path. The code package path does not need to be changed. For the paths of other runtimes, see Table 1.
  • For details about how to build a FunctionGraph HTTP function using Go, see Building a FunctionGraph HTTP Function Using Go.

Prerequisites

Before calling an API, ensure that the network of your service system can communicate with the API access domain name or address. This depends on where your service system is in relative to the ROMA Connect instance.

  • The same VPC: Let the instance directly access the API.
  • Two VPCs in the same region: Connect the instance and the service system with a peering connection. For details, see VPC Peering Connection.
  • Two VPCs in two regions: Create a cloud connection and load the VPCs that need to communicate with each other. For details, see Network Communications Among VPCs Across Regions.
  • Communication over the public network: Ensure that the instance must be bound with an EIP.
  1. Prepare a Node.js script. A code example is as follows:
    const http = require('http'); // Import Node.js core module
 
var server = http.createServer(function (req, res) {   //create web server
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.write('<html><body><h2>This is http function.</h2></body></html>');
    res.end();
});
 
server.listen(8000, '127.0.0.1'); //6 - listen for any incoming requests
 
console.log('Node.js web server at port 8000 is running..')
  2. You have prepared a bootstrap file as the startup file of the HTTP function.

    Example

    The content of the bootstrap file is as follows:

    /opt/function/runtime/nodejs12.13/rtsp/nodejs/bin/node $RUNTIME_CODE_ROOT/index.js
  3. Compress the preceding two files into a ZIP package.
    Figure 1 Compressing files into a ZIP package

    For HTTP functions in Python, add the -u parameter in the bootstrap file to ensure that logs can be flushed to the disk. Example:

    /opt/function/runtime/python3.6/rtsp/python/bin/python3 -u $RUNTIME_CODE_ROOT/index.py

    To use another runtime, change the runtime path by referring to Table 1. The code package path does not need to be changed.

    Table 1 Paths for different runtimes

    Runtime

    Path

    Java 8

    /opt/function/runtime/java8/rtsp/jre/bin/java

    Java 11

    /opt/function/runtime/java11/rtsp/jre/bin/java

    Node.js 6

    /opt/function/runtime/nodejs6.10/rtsp/nodejs/bin/node

    Node.js 8

    /opt/function/runtime/nodejs8.10/rtsp/nodejs/bin/node

    Node.js 10

    /opt/function/runtime/nodejs10.16/rtsp/nodejs/bin/node

    Node.js 12

    /opt/function/runtime/nodejs12.13/rtsp/nodejs/bin/node

    Node.js 14

    /opt/function/runtime/nodejs14.18/rtsp/nodejs/bin/node

    Node.js 16

    /opt/function/runtime/nodejs16.17/rtsp/nodejs/bin/node

    Node.js 18

    /opt/function/runtime/nodejs18.15/rtsp/nodejs/bin/node

    Python 2.7

    /opt/function/runtime/python2.7/rtsp/python/bin/python

    Python 3.6

    /opt/function/runtime/python3.6/rtsp/python/bin/python3

    Python 3.9

    /opt/function/runtime/python3.9/rtsp/python/bin/python3

    PHP 7.3

    /opt/function/runtime/php7.3/rtsp/php/bin/php

Procedure

  1. Create a function.
    1. Create an HTTP function. For details, see Creating an Event Function. Pay special attention to the following parameters:
      • Function Type: HTTP function
      • Region: Select a region where you will deploy your code.
    2. Choose Upload > Local ZIP, upload the ZIP package, and click Deploy.
      Figure 2 Uploading a ZIP file
  2. Create a trigger.

    HTTP functions support APIG and APIC triggers only.

    1. On the function details page, choose Configuration > Triggers and click Create Trigger.
    2. Set the trigger information. This step uses an APIG trigger as an example. For more information, see Using an APIG Trigger.

      Figure 3 Creating a trigger

      In this example, Security Authentication is set to None. You need to select an authentication mode based on site requirements.

      • App: AppKey and AppSecret authentication. This mode is of high security and is recommended.
      • IAM: IAM authentication. This mode grants access permissions to IAM users only and is of medium security.
      • None: No authentication. This mode grants access permissions to all users.
    3. When the configuration is complete, click OK. After the trigger is created, API_test_http will be generated on the APIG console.
  3. Publish the API.
    1. On the Triggers tab page, click an API name to go to the API overview page.
      Figure 4 APIG trigger
    2. Click Edit in the upper right corner. The Basic Information page is displayed.
      Figure 5 Editing an API
    3. Click Next. On the Define API Request page that is displayed, change Path to /user/get and click Finish.
      Figure 6 Defining an API request
    4. Click Publish API. On the displayed page, click Publish.
  4. Trigger a function.
    1. Go to the FunctionGraph console, choose Functions > Function List in the navigation pane, and click the created HTTP function to go to its details page.
    2. Choose Configuration > Triggers, copy the URL, and access it using a browser.
      Figure 7 Copying the URL
    3. View the request result.
      Figure 8 Viewing the request result

Common Function Request Headers

The following table lists the default request header fields of an HTTP function.

Table 2 Default request header fields

Field

Description

X-CFF-Request-Id

ID of the current request

X-CFF-Memory

Allocated memory

X-CFF-Timeout

Function timeout duration

X-CFF-Func-Version

Function version

X-CFF-Func-Name

Function name

X-CFF-Project-Id

Project ID

X-CFF-Package

App to which the function belongs

X-CFF-Region

Current region