PHP handler

To use PHP in Function Compute, you must first define a PHP function as a handler. This topic describes the PHP handlers that you may use and their definitions.

Overview

To make it easy to handle HTTP requests, Function Compute supports using HTTP triggers to call PHP functions. The HTTP triggered function is known as a handler with an HTTP trigger. Currently, the PHP runtime environment supports two types of handlers:

• Common handlers

• Handlers with an HTTP trigger

Common handlers

A basic handler is defined as follows:

<? php
function handler($event, $context) {
    return "hello world";
}

Function name

handler must be consistent with the “handler” field you have specified when you create this function. For example, if you set “handler” to index.handler, Function Compute loads the handler function defined in file index.php.

Parameter $event

Parameter $event is an input parameter of the function. You must pass in this parameter when you call this function. The data type of this parameter is string. The PHP function directly uses the $event parameter that you have specified, without any preprocessing. You can parse the $event parameter in the function based on your needs. For example, if the input data is a JSON string, you can convert this parameter to an array. See the following example.

• The input parameter $event is as follows:

  {
    "key": "value"
  }

• Parse $event to return value using the following code:

    <? php
    function handler($event, $context) {
         $eventObj = json_decode($event, $assoc = true);
         return $eventObj['key'];
    }

Parameter $context

The $context parameter contains the runtime information of the function, such as the request ID (requestId) and the temporary security credentials (securityToken). The data type of $context is array, and $context is defined as follows:

[
  'requestId' => 'b1c5100f-819d-c421-3a5e-7782a27d8a33',
  'credentials' => [
    'accessKeyId' => 'STS.access_key_id',
    'accessKeySecret' => 'access_key_secret',
    'securityToken' => 'security_token',
  ],
  'function' => [
    'name' => 'my-func',
    'handler' => 'index.handler',
    'memory' => 128,
    'timeout' => 10,
  ],
  'service' =>[
     'name' => 'my-service',
     'logProject' => 'my-log-project',
     'logStore' => 'my-log-store',
  ],
  'region' => 'cn-shanghai',
  'accountId' => '123456'
]

Parameter $context contains the following fields:

Example of a common handler

Temporary security credentials are used to verify the user identity and permissions. You must specify securityToken when you access other Alibaba Cloud services, for example, OSS. The following example uses temporary security credentials to upload a TXT file to an OSS bucket.

<? php
use OSS\OssClient;
function handler($event, $context) {
     $accessKeyId = $context["credentials"]["accessKeyId"];
     $accessKeySecret = $context["credentials"]["accessKeySecret"];
     $securityToken = $context["credentials"]["securityToken"];
     $endpoint = "oss-cn-shenzhen.aliyuncs.com";
     $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint, false, $securityToken);
     $bucket = "my-bucket";
     $object = "php.txt";
     $content = "Hello fc!" ;
     try {
        $ossClient->putObject($bucket, $object, $content);
     } catch (OssException $e) {
        print($e->getMessage());
     }
    return 'sucess';
};

Handlers with an HTTP trigger

A basic handler with an HTTP trigger is defined as follows:

<? php
use RingCentral\Psr7\Response;
function handler($request, $context): Response{
    /*
    $body       = $request->getBody()->getContents();
    $queries    = $request->getQueryParams();
    $method     = $request->getMethod();
    $headers    = $request->getHeaders();
    $path       = $request->getAttribute("path");
    $requestURI = $request->getAttribute("requestURI");
    $clientIP   = $request->getAttribute("clientIP");
    */
    return new Response(
        200,
        array(
            "custom_header1" => "v1",
            "custom_header2" => ["v2", "v3"],
        ),
        "hello world"
    );
}

Parameter $context

The $context parameter is the same as the $context parameter defined in common handlers.

Parameter $request

The $request parameter follows the RSR standards on HTTP message interfaces. For more information, see PSR-7-http-message. For more information about coding standards, see PSR Http Message.

The following example demonstrates the methods of $request:

<? php
    $queries = $request->getQueryParams();
    $method = $request->getMethod();
    $headers = $request->getHeaders();
    $path = $request->getAttribute("path");
    $requestURI = $request->getAttribute("requestURI");
    $clientIP = $request->getAttribute("clientIP");
    $body = $request->getBody()->getContents();

Note:
Function Compute provides system fields by default, which cannot be used as custom fields. The default system fields are accept-encoding, connection, keep-alive, proxy-authorization, te, trailer, transfer-encoding, and fields starting with x-fc-.

Parameter $response

$response follows the RSR standards on HTTP message interfaces. The constructor of Response is as follows:

<? php
/**
     * @param int    $status  Status code for the response, if any.
     * @param array  $headers Headers for the response, if any.
     * @param mixed  $body    Stream body.
     */
    public function __construct(
        $status = 200,
        array $headers = array(),
        $body = null,
    ) 
    {
       //...
    }

The body field can be a String or Stream. If the body field is a Stream, the body must implement the StreamInterface interface defined in PSR-7-http-message.

Example of a handler with an HTTP trigger

The following example demonstrates how to use $request and Response of a handler with an HTTP trigger.

use RingCentral\Psr7\Response;
function php_http_handler($request, $context): Response{
    $body = $request->getBody()->getContents();
    $queries = $request->getQueryParams();
    $method = $request->getMethod();
    $headers = $request->getHeaders();
    $path = $request->getAttribute("path");
    $requestURI = $request->getAttribute("requestURI");
    $clientIP = $request->getAttribute("clientIP");
    $params = array(
        'method' => $method,
        'clientIP' => $clientIP,
        'requestURI' => $requestURI,
        'path' => $path,
        'queriesMap' => $queries,
        'headersMap' => $headers,
        'body' => $body,
    );
    $respHeaders = array('Content-Type' => 'application/json');
    $respBody = json_encode($params);
    return new Response(200, $respHeaders, $respBody);
}

Limits on handlers with an HTTP trigger

Limits on Request

If the following limits are exceeded, the system throws HTTP status code 400 and error code InvalidArgument.

Response limits

If the following limits are exceeded, the system throws HTTP status code 502 and BadResponse error code.

Reference

For more information, see PHP runtime environment.