Function Compute:Use event functions to process events generated by Alibaba Cloud services

Sample scenario

Consider a requirement to store uncompressed files in OSS while accepting ZIP uploads for transfer efficiency. In this case, an automated process is needed to decompress the files and save them back to OSS.

Conventional approaches would necessitate building and integrating multiple programs to monitor and process file changes on OSS, while also considering the deployment and maintenance of these programs. In contrast, using event functions allows you to focus solely on the decompression logic. Whenever a file is uploaded to OSS, the preconfigured event trigger automatically invokes your logic if the event meets your specified conditions. After processing, computing resources are released automatically, saving costs.

The following part of this topic demonstrates event function implementation.

It simulates an OSS upload event that triggers an event function to decompress the file, printing file metadata, such as name and bucket information, on the Function Compute console. This demo does not rely on any actual OSS resources, so that you do not need to prepare an OSS bucket.

You will experience the following items in the demo:

1. Completing the entire process of creating event functions, writing handlers, and testing functions in the Function Compute console

2. Understanding key concepts such as the Function Compute execution environment and built-in runtimes

3. Learning about the request parameters event and context in the handler

Prerequisites

Procedure

# -*- coding: utf-8 -*-
import logging
import json
# import oss2  # Uncomment this section if you want to create an OSS client instance.
logger = logging.getLogger()


def handler(event, context): # The handler serves as 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("Invalid event format: events array is missing or empty")
    event_obj = input_events['events'][0]
    bucket_name = event_obj['oss']['bucket']['name']  # Parse the OSS bucket name.
    object_name = event_obj['oss']['object']['key']  # Parse the file name.
    region = context.region  # Parse the region where the function is located.
    logger.info(f"OSS bucket: {bucket_name}, file: {object_name}, region: {region}")
    # If you already have an OSS bucket, uncomment the following section to create an OSS client instance.
    # bucket = get_bucket(region, bucket_name, context)
    bucket = None
    result = process_event(bucket, object_name)  # Invoke event processing subroutine.
    return result


def process_event(bucket, object_name):
    logger.info("Starting event processing...")
    # Add logic here for event processing.
    # zip_file = download_file(bucket, object_name)
    # result = extract_and_upload(bucket, zip_file)
    logger.info("Event processing completed")
    result = 0
    return result  # 0 indicates successful event processing.


# def get_bucket(region, bucket_name, context):
#     # Create an OSS bucket client instance. The required authentication information can be obtained from the context.
#     creds = context.credentials  # Obtain the Security Token Service (STS) token.
#     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):
#     # Example code for downloading a file 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):
#     # Add logic here to decompress files and upload them to OSS.
#     return 0;

'use strict';
// import OSSClient from 'ali-oss'; // Uncomment this section if you want to create an OSS client instance.

export const handler = async (event, context) => { // The handler serves as 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("Invalid event format: events array is missing or empty");
  }
  const eventObj = inputEvents.events[0];
  const bucketName = eventObj.oss.bucket.name; // Parse the OSS bucket name.
  const objectName = eventObj.oss.object.key; // Parse the file name.
  const region = context.region;  // Parse the region where the function is located.
  console.log(`OSS bucket: ${bucketName}, object: ${objectName}, region: ${region}`);
  // If you already have an OSS bucket, uncomment the following section to create an OSS client instance.
  // const bucket = getBucket(region, context)
  const bucket = null;
  const result = processEvent(bucket, objectName); // Invoke event processing subroutine.
  return result;
};


async function processEvent (bucket, objectName) {
  console.log("Starting event processing...");
  // Add logic here for event processing.
  // const zipFile = downloadFile(bucket, objectName);
  // const result = extractAndUpload(bucket, zipFile);
  console.log("Event processing completed");
  const result = 0;
  return result;
}


// function getBucket (region, context) {
//   // Create an OSS bucket client instance. The required 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 {
//     // Example code for downloading a file from OSS
//     const result = await bucket.get(objectName, objectName);
//     console.log(result);
//     return result;
//   } catch (e) {
//     console.log(e);
//   }
// }

// async function extractAndUpload (bucket, zipFile) {
//     // Add logic here to decompress files and upload them to OSS.
//     return 0;
// }

Advanced operations

You have now created an event function via the Function Compute console, configured the function handler, and tested the function using a simulated event. For further configuration, refer to the following advanced operations based on your business requirements:

• Add a trigger:

  • Considering that you may not already have an OSS bucket, the demo in this topic used a simulated OSS event for testing, without relying on any actual OSS resources. However, if you want to process real OSS events in your business, you must add an OSS trigger for your function. For more information about adding a trigger, see Configure a native OSS trigger.

  • In addition to OSS, events from various other Alibaba Cloud services (such as message queue services, Tablestore, and Simple Log Service) can also trigger function execution in Function Compute. For more information about the trigger types supported by Function Compute, see Trigger types.

• Add dependencies: While common dependencies for event processing are already included in each built-in runtime of Function Compute, they may not meet your specific business requirements. In this case, the simplest solution is to package your code and any additional dependencies into a ZIP file and deploy it to Function Compute. For detailed steps, see Deploy a code package. If you want to reduce the size of code packages to mitigate the cold start of functions, you can use layers to manage the dependencies. For more information, see Create a custom layer.

• Configure logging: To facilitate debugging, troubleshooting, and security auditing of functions, we recommend that you configure the logging feature for your function. For detailed steps, see Configure the logging feature.

References

• In addition to using the Function Compute console to create a function, you can also use Serverless Devs to do so. For more information, see Quick start.

• We recommend that you refer to the following hands-on tutorial to learn more about event functions:

  • Use Function Compute to perform message cleansing