Serverless PHP on AWS Lambda

Like, Simon Wardley, I think that serverless computing is an interesting space because the billing is granular (pay only when your code executes) and you don't need to worry about maintaining and provisioning servers or containers. So much so, that I maintain the Open Source PHP Runtime for Apache OpenWhisk which is available commercially as IBM Cloud Functions.

There are other serverless providers, and AWS Lambda is the market leader, but until recently PHP support could most charitably described as "cumbersome." That all changed at the end of 2018 with Lambda's new runtime API and support for layers.

Let's look at the practicalities of serverless PHP on Lambda with serverless framework.

TL;DR

The source code for a simple Hello World is in my lambda-php-sls-hello-world Github repository. Just follow the Notes section and you should be good to go.

PHP Runtime

The runtime API allows for any runtime to be used with Lambda. In some ways, it looks a bit like the way OpenWhisk runtimes work in that there's an HTTP API between the serverless platform and the runtime. One very obvious difference is that with Lambda, the runtime calls back to the platform to get its invocation data whereas OpenWhisk calls an endpoint that the runtime must implement. More details are in Michael Moussa's article on the AWS blog, which inspired my work.

To get back on track, we need a PHP runtime for Lambda! This will comprise the PHP binary, the code to invoke our PHP serverless function and a bootstrap file as required by the platform. We put these three things into a layer. Layers are reusable across accounts, so I'm quite surprised that AWS doesn't provide a PHP one for us. Stackery does, but they aren't using PHP 7.3, so we'll build our own.

We'll put all the files in the layer/php directory in our project.

Building the PHP Binary

We need a PHP binary that will run inside Lambda's containers. The easiest way to do this is to compile it on the same platform as Lambda, so we use EC2. Michael's article explains how to do it and so I turned those commands into a compile_php.sh script, so that I could copy it up to the EC2 instance, run it, then copy the binary back to my computer:

$ export AWS_IP=ec2-user@{ipaddress}
$ export SSH_KEY_FILE=~/.ssh/aws-key.rsa

$ scp -i $SSH_KEY_FILE compile_php.sh $AWS_IP:doc/compile_php.sh
$ ssh -i $SSH_KEY_FILE -t $AWS_IP "chmod a+x compile_php.sh && ./compile_php.sh 3.7.0"
$ scp -i $SSH_KEY_FILE $AWS_IP:php-7-bin/bin/php layer/php/php

This makes it nicely repeatable and hopefully, it will be fairly simple to update to newer versions of PHP.

Bootstrapping

As we are using the runtime API, we need a bootstrap file. This filename is required by Lambda and is responsible for invoking the function by making relevant API calls in a while loop.

Essentially, we need to sit in a loop and call the /next endpoint to find out what to invoke, invoke it and then send the response to the /response endpoint.

AWS provides an example in BASH using curl:

while true
do
  # Get an event
  HEADERS="$(mktemp)"
  EVENT_DATA=$(curl -sS -LD "$HEADERS" -X GET "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/next")
  REQUEST_ID=$(grep -Fi Lambda-Runtime-Aws-Request-Id "$HEADERS" | tr -d '[:space:]' | cut -d: -f2)

  # Execute the handler function from the script
  RESPONSE=$($(echo "$_HANDLER" | cut -d. -f2) "$EVENT_DATA")

  # Send the response
  curl -X POST "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/response"  -d "$RESPONSE"
done

(You don't need to understand this code in detail as the three comments explain the required process well enough!)

We want to do the same thing in PHP and while I could write it myself, Parikshit Agnihotry has already done so in PHP-Lambda-Runtime/runtime.php, so we'll use that and copy it into layer/php/runtime.php. I made a couple of changes to my version, so that it does the json_encoding and also to add better error handling.

The layer/php/bootstrap file is very simple as all it needs to do is run the PHP binary with this file:

#!/bin/sh
cd $LAMBDA_TASK_ROOT
/opt/php /opt/runtime.php

That's it. We now have three files in layer/php:

• php - the PHP executable
• runtime.php - The runtime API worker
• bootstrap - The Lambda-required bootstrap stub

These will become our PHP Layer in our Lambda application and when copied into the container on invocation, will be in /opt.

Set Up Serverless Framework

Serverless Framework allows repeatable configuration and deployment of a serverless application. I'm a fan of this concept and want to use tools like this more. We'll use it for our PHP Hello World.

As there's no handy Serverless Framework template for PHP applications, we'll just create a serverless.yml file in our project directory.

First, the basics:

service: php-hello-world
provider:
  name: aws
  runtime: provided
  region: eu-west-2
  memorySize: 128

We name our application php-hello-world and we're using AWS as our provider. As I'm in the UK, I set the region to London and we don't need much memory, so 128MB is enough.

The runtime is usually the language that you want your function to be executed in. To use the runtime API which will execute our bootstrap stub, you set this to provided.

You'll also want a .gitignore file containing:

.serverless

as we don't want that directory in git.

Let's add our layer to serverless.yml next, by adding:

layers:
  php:
    path: layer/php

This will create the AWS layer and give it a name of PhpLambdaLayer which we can then reference in our function.

Write Our Hello World Function

We can now write our PHP serverless function. This goes in handler.php:

function hello($eventData) : array
{
    return ["msg" => "hello from PHP " . PHP_VERSION];
}

The function takes the information about the event and returns an associative array.

To tell Serverless Framework to deploy it, we add it to serverless.yml:

functions:
  hello:
    handler: handler.hello
    layers:
      - {Ref: PhpLambdaLayer}

Serverless Framework supports multiple functions per application. Each one has a name, "hello", in this case and a handler, which is the file name without the extension followed by a full stop and then the function name within that file. So a handler of handler.hello means that we will run the hello() function in handler.php.

Finally, we also tell the function about our PHP layer, so that it can execute the PHP code.

Deploy to Lambda

To deploy our function with its layer we run:

 $slsdeploy 

This will whirr and click for a bit and produce an output like this:

Invoke Our Function

Finally, we can invoke our function using:

$ sls invoke -f hello -l

And we're done!

To Sum up

With the new layers and runtime API, it's now possible to easily run PHP serverless functions on Lambda. This is great news and worth playing if you're a PHP developer stuck tied to AWS.