Python handler

To use Python in Function Compute, you must define a Python function as a handler. Current Python runtime environments support either common handlers or handlers with an HTTP trigger. With the HTTP trigger, HTTP requests can be processed more efficiently. Except for the handlers with an HTTP trigger, all other Python-compiled function handlers are the same.

Currently, Function Compute supports the Python 2.7 (runtime version 2.7) and Python 3.6 (runtime version 3). For more information, see Python runtime.

Contents

This topic describes the common handlers and handlers with an HTTP trigger.

• Common handlers

• Handlers with an HTTP trigger

Common handlers

A simple function is defined as follows:

def my_handler(event, context):
    return 'hello world'

Function name

• my_handler: The function name must match the “handler” field provided when a function is created. For example, if handler is specified as main.my_handler, Function Compute obtains the my_handler function defined in main.py.

Parameter event

• The event parameter is defined when you call a function. In Python 2.7, this parameter is of str type. In Python 3, it is of bytes type. The parameter is an input parameter.
• You can convert this parameter as needed because it is not defined by the function. For example, if a JSON string is passed in, you can convert the parameter to one that is of the dict type.Example:Defined event:

  {
  "key": "value"
  }

  Function code:

  # -*- coding: utf-8 -*-
  import json
  def my_handler(event, context):
    evt = json.loads(event)
    return evt['key']

  The value parameter is returned.

Parameter context

• The context parameter contains information generated when the function is executed, for example, the request ID and temporary AccessKey credentials. You can use the generated information when coding. This parameter is of the FCContext type.
• The context parameter can be defined as follows:

class Credentials:
    def __init__(self, access_key_id, access_key_secret, security_token):
        self.access_key_id = access_key_id
        self.access_key_secret = access_key_secret
        self.security_token = security_token
class ServiceMeta:
    def __init__(self, service_name, log_project, log_store):
        self.name = service_name
        self.log_project = log_project
        self.log_store = log_store
        self.qualifier = qualifier
        self.version_id = version_id
class FunctionMeta:
    def __init__(self, name, handler, memory, timeout):
        self.name = name
        self.handler = handler
        self.memory = memory
        self.timeout = timeout
class FCContext:
    def __init__(self, account_id, request_id, credentials, function_meta, service_meta, region):
        self.request_id = request_id
        self.credentials = credentials
        self.function = function_meta
        self.service = service_meta
        self.region = region
        self.account_id = account_id

In the preceding functions, key parameters include:

• request_id: indicates the unique ID of this call. You can note down this parameter for troubleshooting if an exception occurs.
• function: indicates the basic information about this function, including the function name, handler, function memory, and timeout period.
• credentials: indicates a set of keys that Function Compute obtains from assuming your service role. These keys expire 15 minutes after it is generated. You can use this parameter to access certain services, such as Object Storage Service (OSS). This prevents you from permanently writing your AccessKey credentials in the function code.
• service: specifies the details of the service that the current function serves. For example, this parameter may include the service name, and the log project and Logstore in Log Service, qualifier and versionId which indicate the service version.
• region: indicates the region where this function applies, such as cn-shanghai.
• accountId: indicates the ID of your Alibaba Cloud account.

In the following code, a Security Token Service (STS) token is used to send a file to OSS.

import json
import oss2
def my_handler(event, context):
    evt = json.loads(event)
    creds = context.credentials
    # you must enter the security_token
    auth = oss2.StsAuth(creds.access_key_id, creds.access_key_secret, creds.security_token)
    bucket = oss2.Bucket(auth, evt['endpoint'], evt['bucket'])
    bucket.put_object(evt['objectName'], evt['message'])
    return 'success'

Note: You must provide a temporary token for the temporary key so that the key can be used to access OSS.

Handlers with an HTTP trigger

Handlers with an HTTP trigger are different from common handlers. An HTTP trigger supports the following handlers:

• Method 1. User provides the function. Function Compute calls the function to process the request and send back the response.

  HELLO_WORLD = b"Hello world!\n"
  def handler(environ, start_response):
    context = environ['fc.context']
    request_uri = environ['fc.request_uri']
    for k, v in environ.items():
        if k.startswith("HTTP_"):
            # process custom request headers
            pass
    # get request_body
    try:
        request_body_size = int(environ.get('CONTENT_LENGTH', 0))
    except (ValueError):
        request_body_size = 0
    request_body = environ['wsgi.input'].read(request_body_size)
    # get request_method
    request_method = environ['REQUEST_METHOD']
    # get path info
    path_info = environ['PATH_INFO']
    # get server_protocol
    server_protocol = environ['SERVER_PROTOCOL']
    # get content_type
    try:
        content_type = environ['CONTENT_TYPE']
    except (KeyError):
        content_type = " "
    # get query_string
    try:
        query_string = environ['QUERY_STRING']    
    except (KeyError):
        query_string = " "
    print 'request_body: {}'.format(request_body)
    print 'method: {}\n path: {}\n  query_string: {}\n server_protocol: {}\n'.format(request_method, path_info,  query_string, server_protocol)
    # do something here
    status = '200 OK'
    response_headers = [('Content-type', 'text/plain')]
    start_response(status, response_headers)
    # return value must be iterable
    return [HELLO_WORLD]

• Method 2. User provides the callable class object. Function Compute calls the object to process the request and send back the response.

  HELLO_WORLD = b"Hello world!\n"
  class AppClass:
    """Produce the same output, but using a class
    """
    def __init__(self, environ, start_response):
        self.environ = environ
        self.start = start_response
    def __iter__(self):
        status = '200 OK'
        response_headers = [('Content-type', 'text/plain')]
        self.start(status, response_headers)
        yield HELLO_WORLD
  def handler(environ, start_response):
    return AppClass(environ, start_response)

Function signatures in Python runtime environments comply with the Python Web Server Gateway Interface (WSGI) convention.

Input parameters

• environ: This parameter represents a Python dictionary that stores all client-related information. For more information, see Parameter environ. Two user-defined keys, fc.context and fc.request_uri, are added to Function Compute.

  • fc.context: functions as the context parameter of common handlers.

  • fc.request_uri: indicates the URL of the request. This parameter is a string.

  Note: The HTTP_Variables field of environ contains the request header. For example, if the request header is 'x-Custom-key':'value', the environ parameter will be environ['HTTP_X_CUSTOM_KEY']='value'. According to WSGI, the key in the request header is processed as follows: key = "HTTP_" + k.upper().replace("-","_").

• start_response: The start_response callable is provided in runtime environments of Function Compute. It has two required positional parameters and one optional parameter. For more information, see the-start-response-callable. In the following example, the three parameters are named status, response_headers, and exc_info. You can use other names as needed.

  # Provided by Function Compute runtime. 
  # status: a string such as '200 OK' or '403 FORBIDDEN'
  # return: must be a write(body_data) callable
  def start_response(status, response_headers, exc_info=None):
      ...

  • status: indicates the HTTP response status. This parameter is a string.

  • response_headers: represents the HTTP request headers. It is a list that contains a tuple in the (header_name, header_value) format.

  • exc_info (optional): indicates the information that the server needs to return to the client.

  After the application object completes executing the service logic based on the environ parameter, the application object must return the result to the server. An HTTP response must contain the status, headers, and body parameters. Therefore, before the application returns the value of body, you must call the start_response() function to return the value of status and headers to the server. In this way, the server knows that the application is starting to return the value of body.

Deploy WSGI-based web frameworks for Function Compute

The preceding Method2 example shows that you can run projects that are built on WSGI-based web frameworks using Flask and Django in Python runtime environments of Function Compute. The following uses Flask as an example:

from flask import Flask
from flask import request
from flask import make_response
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def home():
    resp = make_response('<h1>Home</h1>', 200)
    return resp
@app.route('/signin', methods=['GET'])
def signin_form():
    # service_name,function_name in action url need to be replaced
    html = '''<form action="/2016-08-15/proxy/service_name/func_name/signin" method="post">
         <p><input name="username"></p>
         <p><input name="password" type="password"></p>
         <p><button type="submit">Sign In</button></p>
         </form>'''
    resp = make_response(html, 200)
    return resp
@app.route('/signin', methods=['POST'])
def signin():
    if request.form['username'] == 'admin' and request.form['password'] == 'password':
        html = '<h3>Hello, admin!</h3>'
    else:
        html = '<h3>Bad username or password.</h3>'
    resp = make_response(html, 200)
    return resp
@app.route('/signin2', methods=['GET'])
def signin2():
    if request.args.get('username') == 'admin' and request.args.get('password') == 'password':
        html = '<h3>Hello2, admin!</h3>'
    else:
        html = '<h3>Bad username or password.</h3>'
    resp = make_response(html, 200)
    return resp
def handler(environ, start_response):
    # do something here
    return app(environ, start_response)