Function Compute:Create your first event function

Python

Select the Runtime Environment option, then choose Built-in Runtime - Python 3.10.

For event functions, it is recommended to use the built-in runtime as the function runtime environment because the built-in runtime includes the dependencies necessary to respond to events from other cloud products (such as the oss2 module for Python). For more information, see Environment description. If you use a custom runtime or custom image as the function runtime environment, you need to install the required dependencies yourself. For a detailed comparison of various runtime environments, see Function runtime environment selection.

Node.js

Select the Runtime Environment as Built-in Runtime - Node.js 20.

For event functions, it is recommended to use the built-in runtime as the function runtime environment because the built-in runtime includes the dependencies necessary to respond to events from other cloud products (such as the ali-oss module for Node.js). For more information, see Environment description. If you use a custom runtime or custom image as the function runtime environment, you need to install the required dependencies yourself. For a detailed comparison of various runtime environments, see Function runtime environment selection.

Python

In the console's WebIDE, open index.py, replace the existing code with the code provided below, and then click Deploy Code to apply the changes.

# -*- coding: utf-8 -*-
import logging
import json
# import oss2  # If you need to create an OSS client, uncomment this line
logger = logging.getLogger()


def handler(event, context):  # The request handler is the entry point for code execution
    logger.info("Parsing event information...")
    input_events = json.loads(event)
    if not input_events.get('events'):  # Check the format of the incoming event
        raise Exception("Event format error: events array does not exist or is of length 0")

    event_obj = input_events['events'][0]
    bucket_name = event_obj['oss']['bucket']['name']  # Parse OSS Bucket name
    object_name = event_obj['oss']['object']['key']  # Parse file name
    region = context.region  # Parse the region where the function is located
    logger.info(f"OSS bucket name is {bucket_name}, file name is {object_name}, Region is {region}")
    # If you already have an OSS Bucket, you can uncomment the following line to create an OSS client instance
    # bucket = get_bucket(region, bucket_name, context)
    bucket = None
    result = process_event(bucket, object_name)  # Call the subprogram to execute the event processing logic
    return result


def process_event(bucket, object_name):
    logger.info("Starting event processing...")
    # Here you can write the event processing logic
    # zip_file = download_file(bucket, object_name)
    # result = extract_and_upload(bucket, zip_file)
    logger.info("Event processing completed...")
    result = 0
    return result  # Returning 0 indicates that the event was processed successfully


# def get_bucket(region, bucket_name, context):
#     # Here, create an OSS Bucket client instance. The required identity authentication information can be obtained from the context
#     creds = context.credentials  # Obtain temporary keys
#     auth = oss2.StsAuth(
#         creds.access_key_id,
#         creds.access_key_secret,
#         creds.security_token)
#     endpoint = f'oss-{region}-internal.aliyuncs.com'
#     bucket = oss2.Bucket(auth, endpoint, bucket_name)
#     return bucket


# def download_file(bucket, object_name):
#     # This is sample code for downloading files from OSS
#     try:
#         file_obj = bucket.get_object(object_name)
#         return file_obj
#     except oss2.exceptions.OssError as e:
#         logger.error(f"File download failed {e}")


# def extract_and_upload(bucket, file_obj):
#     # Here you can define the logic for decompressing and uploading files to OSS
#     return 0;

Understand function code

• def handler(event, context):

  • handler: This Python function serves as the request handler. While your code may include multiple functions, the request handler is the primary entry point for executing code. Ensure that the name of the request handler remains the same when making code modifications, to allow Function Compute to identify it accurately. For more information, see What is a request handler.

    

  • event: The event parameter conveys relevant information when a function is triggered by an event. For instance, if a file is uploaded to OSS, the event includes details such as the Bucket name and file name, all formatted as a JSON object. For details on the information that the event parameter includes for different types of events, see Trigger event format.

  • The context object, which is passed to the function via the context parameter, includes details about the invocation, function configuration, and identity authentication. This authentication information is derived from the role permissions set for the function. Once the role is configured, Function Compute (FC) retrieves a temporary key (STS Token) through the AssumeRole operation and then supplies this key to your function within the credentials field of the context object. For more information, see Grant Function Compute access to other cloud services. To learn what information the context object contains, see Context.

• logger.info(): You can use the standard logging function of the programming language to output logs. For example, in Python, use the logging module to output information to the log. This example uses statements to print the Bucket name, file name, and Region name. After the function call ends, you can view the log output through the console. For more information, see Log.

Node.js

In the console's WebIDE, open index.mjs, replace the existing code with the code provided below, and then click Deploy Code to apply the changes.

'use strict';
// import OSSClient from 'ali-oss'; // If you need to create an OSS client, uncomment this line

export const handler = async (event, context) => { // The request handler is the entry point for code execution
  console.log("Parsing event information...");
  const inputEvents = JSON.parse(event);
  if (!Array.isArray(inputEvents.events) || inputEvents.events.length === 0) { // Check the format of the incoming event
    throw new Error("Event format error: events array does not exist or is of length 0");
  }
  const eventObj = inputEvents.events[0];
  const bucketName = eventObj.oss.bucket.name; // Parse OSS Bucket name
  const objectName = eventObj.oss.object.key; // Parse file name
  const region = context.region;  // Parse the region where the function is located
  console.log(`OSS bucket name is ${bucketName}, object file name is ${objectName}, Region is ${region}`);
  // If you already have an OSS Bucket, you can uncomment the following line to create an OSS client instance
  // const bucket = getBucket(region, context)
  const bucket = null;
  const result = processEvent(bucket, objectName); // Call the subprogram to execute the event processing logic
  return result;
};


async function processEvent (bucket, objectName) {
  console.log("Starting event processing...");
  // Here you can write the event processing logic
  // const zipFile = downloadFile(bucket, objectName);
  // const result = extractAndUpload(bucket, zipFile);
  console.log("Event processing completed");
  const result = 0;
  return result;
}


// function getBucket (region, context) {
//   // Here, create an OSS Bucket client instance. The required identity authentication information can be obtained from the context
//   const bucket = new OSSClient({
//     region: region,
//     accessKeyId: context.credentials.accessKeyId,
//     accessKeySecret: context.credentials.accessKeySecret,
//     securityToken: context.credentials.securityToken
//   });
//   return bucket;
// }


// async function downloadFile (bucket, objectName) {
//   try {
//     // Sample code for downloading files from OSS
//     const result = await bucket.get(objectName, objectName);
//     console.log(result);
//     return result;
//   } catch (e) {
//     console.log(e);
//   }
// }

// async function extractAndUpload (bucket, zipFile) {
//     // Here you can define the logic for decompressing and uploading files to OSS
//     return 0;
// }

Understand function code

• export const handler = async (event, context)

  • handler refers to the Node.js function that serves as the request handler. Although your code may include multiple Node.js functions, the request handler is the primary entry point for executing code. To ensure Function Compute can accurately recognize it, maintain the request handler's name when making code changes. For more information, see What is a request handler.

    

  • event: When an event triggers the function, the relevant information of the event is passed in through the event parameter (for example, in the event of uploading a file to OSS, event contains the Bucket name and Object name, etc.), formatted as a JSON object. For more information on what information the event contains for various events, see Trigger event format.

  • The context object, which is passed to the function via the context parameter, includes details about the invocation, function configuration, and identity authentication. This authentication data is derived from the role permissions set for the function. Once the role is configured, Function Compute (FC) retrieves a temporary key (STS Token) through the AssumeRole operation and then supplies this key to your function within the credentials field of the context object. For more information, see Grant Function Compute access to other cloud services. To learn what information the context object contains, see Context.

• The console.log() function is the standard method for logging in many programming languages. In Node.js, for instance, you can use the console module to write information to the log. This particular example demonstrates how to print the Bucket name, file name, and Region name. Once the function execution completes, you can review the log output in the console. For more information, see Log.