Amazon Web Services Feed
Introducing the new Serverless LAMP stack
This is the first in a series of posts for PHP developers. The series will explain how to use serverless technologies with PHP. It covers the available tools, frameworks and strategies to build serverless applications, and why now is the right time to start.
In future posts, I demonstrate how to use AWS Lambda for web applications built with PHP frameworks such as Laravel and Symfony. I show how to move from using Lambda as a replacement for web hosting functionality to a decoupled, event-driven approach. I cover how to combine multiple Lambda functions of minimal scope with other serverless services to create performant scalable microservices.
In this post, you learn how to use PHP with Lambda via the custom runtime API. Visit this GitHub repository for the sample code.
The Serverless LAMP stack
The challenges with traditional PHP applications
Scalability is an inherent challenge with the traditional LAMP stack. A scalable application is one that can handle highly variable levels of traffic. PHP applications are often scaled horizontally, by adding more web servers as needed. This is managed via a load balancer, which directs requests to various web servers. Each additional server brings additional overhead with networking, administration, storage capacity, backup and restore systems, and an update to asset management inventories. Additionally, each horizontally scaled server runs independently. This can result in configuration synchronization challenges.
Horizontal scaling with traditional LAMP stack applications.
New storage challenges arise as each server has its own disks and filesystem, often requiring developers to add a mechanism to handle user sessions. Using serverless technologies, scalability is managed for the developer.
If traffic surges, the services scale to meet the demand without having to deploy additional servers. This allows applications to quickly transition from prototype to production.
The serverless LAMP architecture
A traditional web application can be split in to two components:
- The static assets (media files, css, js)
- The dynamic application (PHP, MySQL)
A serverless approach to serving these two components is illustrated below:
The serverless LAMP stack
All requests for dynamic content (anything excluding /assets/*) are forwarded to Amazon API Gateway. This is a fully managed service for creating, publishing, and securing APIs at any scale. It acts as the “front door” to the PHP application, routing requests downstream to Lambda functions. The Lambda functions contain the business logic and interaction with the MySQL database. You can pass the input to the Lambda function as any combination of request headers, path variables, query string parameters, and body.
Notable AWS features for PHP developers
During re:Invent 2017, AWS announced Aurora Serverless, an on-demand serverless relational database with a pay-per-use cost model. This manages the responsibility of relational database provisioning and scaling for the developer.
Lambda Layers and custom runtime API.
At re:Invent 2018, AWS announced two new Lambda features. These enable developers to build custom runtimes, and share and manage common code between functions.
Improved VPC networking for Lambda functions.
In September 2019, AWS announced significant improvements in cold starts for Lambda functions inside a VPC. This results in faster function startup performance and more efficient usage of elastic network interfaces, reducing VPC cold starts.
At re:Invent 2019, AWS announced the launch of a new service called Amazon RDS Proxy. A fully managed database proxy that sits between your application and your relational database. It efficiently pools and shares database connections to improve the scalability of your application.
Significant moments in the serverless LAMP stack timeline
Combining these services, it is possible to build secure and performant scalable serverless applications with PHP and relational databases.
Custom runtime API
The custom runtime API is a simple interface to enable Lambda function execution in any programming language or a specific language version. The custom runtime API requires an executable text file called a bootstrap. The bootstrap file is responsible for the communication between your code and the Lambda environment.
To create a custom runtime, you must first compile the required version of PHP in an Amazon Linux environment compatible with the Lambda execution environment. To do this, follow these step-by-step instructions.
The bootstrap file
The file below is an example of a basic PHP bootstrap file. This example is for explanation purposes as there is no error handling or abstractions taking place. To ensure that you handle exceptions appropriately, consult the runtime API documentation as you build production custom runtimes.
#!/opt/bin/php
<?PHP // This invokes Composer's autoloader so that we'll be able to use Guzzle and any other 3rd party libraries we need.
require __DIR__ . '/vendor/autoload.php; // This is the request processing loop. Barring unrecoverable failure, this loop runs until the environment shuts down.
do { // Ask the runtime API for a request to handle. $request = getNextRequest(); // Obtain the function name from the _HANDLER environment variable and ensure the function's code is available. $handlerFunction = array_slice(explode('.', $_ENV['_HANDLER']), -1)[0]; require_once $_ENV['LAMBDA_TASK_ROOT'] . '/src/' . $handlerFunction . '.php; // Execute the desired function and obtain the response. $response = $handlerFunction($request['payload']); // Submit the response back to the runtime API. sendResponse($request['invocationId'], $response);
} while (true); function getNextRequest()
{ $client = new GuzzleHttpClient(); $response = $client->get('http://' . $_ENV['AWS_LAMBDA_RUNTIME_API'] . '/2018-06-01/runtime/invocation/next'); return [ 'invocationId' => $response->getHeader('Lambda-Runtime-Aws-Request-Id')[0], 'payload' => json_decode((string) $response->getBody(), true) ];
} function sendResponse($invocationId, $response)
{ $client = new GuzzleHttpClient(); $client->post( 'http://' . $_ENV['AWS_LAMBDA_RUNTIME_API'] . '/2018-06-01/runtime/invocation/' . $invocationId . '/response', ['body' => $response] );
}The #!/opt/bin/php declaration instructs the program loader to use the PHP binary compiled for Amazon Linux.
The bootstrap file performs the following tasks, in an operational loop:
- Obtains the next request.
- Executes the code to handle the request.
- Returns a response.
Follow these steps to package the bootstrap and compiled PHP binary together into a `runtime.zip`.
Libraries and dependencies
The runtime bootstrap uses an HTTP-based local interface. This retrieves the event payload for each Lambda function invocation and returns back the response from the function. This bootstrap file uses Guzzle, a popular PHP HTTP client, to make requests to the custom runtime API. The Guzzle package is installed using Composer package manager. Installing packages in this way creates a mechanism for incorporating additional libraries and dependencies as the application evolves.
Follow these steps to create and package the runtime dependencies into a `vendors.zip` binary.
Lambda Layers provides a mechanism to centrally manage code and data that is shared across multiple functions. When a Lambda function is configured with a layer, the layer’s contents are put into the /opt directory of the execution environment. You can include a custom runtime in your function’s deployment package, or as a layer. Lambda executes the bootstrap file in your deployment package, if available. If not, Lambda looks for a runtime in the function’s layers. There are several open source PHP runtime layers available today, most notably:
The following steps show how to publish the `runtime.zip` and `vendor.zip` binaries created earlier into Lambda layers and use them to build a Lambda function with a PHP runtime:
- Use the AWS Command Line Interface (CLI) to publish layers from the binaries created earlier
aws lambda publish-layer-version --layer-name PHP-example-runtime --zip-file fileb://runtime.zip --region eu-west-1
aws lambda publish-layer-version --layer-name PHP-example-vendor --zip-file fileb://vendors.zip --region eu-west-1
- Make note of each command’s LayerVersionArn output value (for example arn:aws:lambda:eu-west-1:XXXXXXXXXXXX:layer:PHP-example-runtime:1), which you’ll need for the next steps.
Creating a PHP Lambda function
You can create a Lambda function via the AWS CLI, the AWS Serverless Application Model (SAM), or directly in the AWS Management Console. To do this using the console:
- Navigate to the Lambda section of the AWS Management Console and choose Create function.
- Enter “PHPHello” into the Function name field, and choose Provide your own bootstrap in the Runtime field. Then choose Create function.
- Right click on bootstrap.sample and choose Delete.
- Choose the layers icon and choose Add a layer.
- Choose Provide a layer version ARN, then copy and paste the ARN of the custom runtime layer from in step 1 into the Layer version ARN field.
- Repeat steps 6 and 7 for the vendor ARN.
- In the Function Code section, create a new folder called src and inside it create a new file called index.php.
- Paste the following code into index.php:
//index function function index($data) { return "Hello, ". $data['name']; } - Insert “index” into the Handler input field. This instructs Lambda to run the index function when invoked.
- Choose Save at the top right of the page.
- Choose Test at the top right of the page, and enter “PHPTest” into the Event name field. Enter the following into the event payload field and then choose Create:
{ "name": "world"}
- Choose Test and Select the dropdown next to the execution result heading.
You can see that the event payload “name” value is used to return “hello world”. This is taken from the $data['name'] parameter provided to the Lambda function. The log output provides details about the actual duration, billed duration, and amount of memory used to execute the code.
Conclusion
This post explains how to create a Lambda function with a PHP runtime using Lambda Layers and the custom runtime API. It introduces the architecture for a serverless LAMP stack that scales with application traffic.
Lambda allows for functions with mixed runtimes to interact with each other. Now, PHP developers can join other serverless development teams focusing on shipping code. With serverless technologies, you no longer have to think about restarting webhosts, scaling or hosting.
Start building your own custom runtime for Lambda.