Function Compute:Event handlers

Event handler signature

The following sample code describes the signature for an event handler.

// index.mjs
export const handler = async (event, context) => {
  console.log("event: \n" + event);
  return "Hello World!";
};

// index.js
exports.handler = async function(event, context) {
  console.log("event: \n" + event);
  return "Hello World!";
};

// index.js
exports.handler = async function(event, context, callback) {
  console.log("event: \n" + event);
  callback(null, 'hello world');
};

Parameter description:

handler indicates the method name, which corresponds to the value of the Handler parameter configured in the Function Compute console. For example, if you set Handler to index.handler when you create a function, Function Compute loads the handler function defined in index.js and starts to execute code.

Function Compute runtimes pass request parameters to the handler. The first parameter is the event object, which contains the request payload information. The event object is of the Buffer type. You can convert it to another object type based on your business requirements. The second parameter is a context object that provides context information during invocations. For more information, see Context.

Async/Await

We recommend that you use Async/Await in Node.js 18 or later. Async/Await is a simple and easy-to-read way to write asynchronous code in Node.js without nested callbacks or method chaining.

Compared with callback, Async/Await delivers the following benefits:

• Better readability: The code in Async/Await mode is more linear and synchronous, and easier to understand and maintain. It prevents nests of high levels and makes the code structure clearer.

• Easy to debug and handle errors: You can use try-catch blocks to catch and handle errors in asynchronous operations more easily. Error stacks can be easily located and traced.

• Higher efficiency: In most cases, callback functions must switch between different parts of code. Async/Await can reduce the number of context switches, thereby improving code efficiency.

Example 1: Parse JSON-formatted parameters

Sample code

When you pass JSON-formatted parameters into functions of Function Compute, Function Compute passes through the parameters, and you need to parse the parameters in the code. The following sample code provides an example on how to parse a JSON-formatted event.

export const handler = async (event, context) => {
  var eventObj = JSON.parse(event.toString());
  return eventObj['key'];
};

exports.handler = function(event, context, callback) {
  var eventObj = JSON.parse(event.toString());
  callback(null, eventObj['key']);
};

Prerequisites

A Node.js function is created. For more information, see Create a function. If you want to specify the code as an ECMAScript module, you must select Node.js 18 or Node.js 20 as the runtime when you create a function.

Procedure

1. Log on to the Function Compute console. In the left-side navigation pane, click Services & Functions.

2. In the top navigation bar, select a region. On the Services page, click the desired service.

3. On the Functions page, click the name of the desired function. On the Function Details page that appears, click the Code tab.

4. On the Code tab, enter the preceding sample code in the code editor and click Deploy.

   Note

   In the preceding sample code, the handler is the handler method in index.js or index.mjs. If you specify a different handler, use the actual file and method.

5. On the Code tab, click the icon next to Test Function, select Configure Test Parameters from the drop-down list, configure the following test parameters, and then click OK.

   {
     "key": "value"
   }

6. Click Test Function.

   After the function is executed, the execution result is returned. The execution result is value.

Example 2: Read and write OSS resources by using a temporary AccessKey pair

Sample code

You can use a temporary AccessKey pair that is provided by Function Compute to access Object Storage Service (OSS). This section provides sample code.

// index.mjs
import OSSClient from 'ali-oss';

export const handler = async (event, context) => {
    console.log(event.toString());

    var ossClient = new OSSClient({
        accessKeyId: context.credentials.accessKeyId,
        accessKeySecret: context.credentials.accessKeySecret,
        stsToken: context.credentials.securityToken,
        region: 'oss-cn-shenzhen',
        bucket: 'my-bucket',
    });

    try {
      // Upload an object to OSS. object indicates the name of the object in OSS. localfile indicates the path of the on-premises file. 
      const uploadResult = await ossClient.put('myObj', Buffer.from('hello, fc', "utf-8"));
      console.log('upload success, ', uploadResult);
      return "succ"
    } catch (error) {
      throw error
    }
};

var OSSClient = require('ali-oss');

exports.handler = function (event, context, callback) {
    console.log(event.toString());

    var ossClient = new OSSClient({
        accessKeyId: context.credentials.accessKeyId,
        accessKeySecret: context.credentials.accessKeySecret,
        stsToken: context.credentials.securityToken,
        region: 'oss-cn-shenzhen',
        bucket: 'my-bucket',
    });

    ossClient.put('myObj', Buffer.from('hello, fc', "utf-8")).then(function (res) {
        callback(null, 'succ');
    }).catch(function (err) {
        callback(err);
    });
};

Prerequisites

• A role that has the permissions to access OSS is configured for the service. For more information, see Grant Function Compute permissions to access other Alibaba Cloud services.

• A function that runs in a Node.js runtime is created. For more information, see Create a function. If you want to specify the code as an ECMAScript module, you must select Node.js 18 or Node.js 20 as the runtime when you create a function.

Procedure

1. Log on to the Function Compute console. In the left-side navigation pane, click Services & Functions.

2. In the top navigation bar, select a region. On the Services page, click the desired service.

3. On the Functions page, click the name of the desired function. On the Function Details page that appears, click the Code tab.

4. Optional. On the Code tab, click WebIDE in the lower part of the page. On the WebIDE page, click Terminal > New Terminal. Run the following command to install ali-oss dependencies in the terminal:

   npm install ali-oss --save

   After the installation is complete, you can see that the node_modules folder is generated in the code directory on the left side of WebIDE. The folder contains the ali-oss directory and other dependent libraries.

5. On the Code tab, enter the preceding sample code in the code editor, save the code, and then click Deploy.

   Note

   • The request handler of the functions in the preceding sample code is the handler method in index.js or index.mjs. If you specify a different handler, use the actual file and method.

   • In the preceding sample code, specify region and bucket based on the actual values.

6. Click Test Function.

   After the function is executed, the execution result is returned. The execution result is succ.

Example 3: Call external commands

You can use a Node.js program to create a fork process to call external commands. For example, you can use the child_process module to call the ls -l command. After you call the command, the files in the current directory are returned. This section provides sample code.

import { exec } from 'child_process';
import { promisify } from 'util';

const execPromisify = promisify(exec);
export const handler = async (event, context) => {
  try {
    const { stdout, stderr } = await execPromisify("ls -l");
    console.log(`stdout: ${stdout}`);
    if (stderr !== "") {
      console.error(`stderr: ${stderr}`);
    }
    return stdout;
  } catch (error) {
    console.error(`exec error: ${error}`);
    return error;
  }
}

'use strict';

var exec = require('child_process').exec;
exports.handler = (event, context, callback) => {
  console.log('start to execute a command');
  exec("ls -l", function(error, stdout, stderr){
    callback(null, stdout);
});
}