Unit-testing Bref lambda handlers

Hopefully this helps someone out there unit-testing Bref lambda consumers (eg. AWS lambda handlers for SNS / EventBridge / SQS, etc) with PHPUnit;

Essentially this includes the consumer (which is essentially a PHP function), and calls the function with array of event-data (in the same format AWS would normally give it).

The function (handler) would then return a response (hopefully with no thrown errors), and any unit-testing on the result would be done.

public function testConsumeUpdatePerson() {
        $handler = include(__DIR__ . '/../bin/consume');

        $data = json_encode([
            'action' => 'update-person',
            'id' => 1234
        $overallJson = '{
  "Records": [
      "EventVersion": "1.0",
      "EventSubscriptionArn": "arn:aws:sns:us-east-2:123456678:sns-lambda:abc-123",
      "EventSource": "aws:sns",
      "Sns": {
        "SignatureVersion": "1",
        "Timestamp": "2019-01-02T12:45:07.000Z",
        "Signature": "aaaabbbb/ccccdddd/111111==",
        "SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotificationService-aaaabbbb.pem",
        "MessageId": "aaaabbbbb",
        "Message": "' . addslashes($data) . '",
        "MessageAttributes": {
          "Test": {
            "Type": "String",
            "Value": "TestString"
          "TestBinary": {
            "Type": "Binary",
            "Value": "TestBinary"
        "Type": "Notification",
        "UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-2:111122222:test-lambda:aaaaa-bbbbb",
        "TopicArn" : "arn:aws:sns:ap-southeast-2:1111222222:topic-name-goes-here",
        "Subject": "TestInvoke"
        $event = json_decode($overallJson, true);

        $response = $handler($event, new Context('', 300, '', ''));
        $this->assertEquals('OK', $response);

More unit-tests can obviously be added below, but the basics of this test that there’s no errors, unhandled exceptions, etc which you hadn’t fully tested otherwise

Serializer – array to Object

To convert from an array (including multi-dimensional arrays) to an object, the following code might help!

Ref; https://symfony.com/doc/current/components/serializer.html

// all callback parameters are optional (you can omit the ones you don't use)
$extractor = new PropertyInfoExtractor([], [new PhpDocExtractor(), new ReflectionExtractor()]);
$normalizer = new ObjectNormalizer(null, null, null, $extractor);
$serializer = new Serializer(
        new ArrayDenormalizer(),

$obj = $serializer->denormalize(
    [ObjectNormalizer::DISABLE_TYPE_ENFORCEMENT => true]


This can also be achieved by installing the following packages, which Symfony will pickup & use with it’s serializer;

composer require phpdocumentor/reflection-docblock
composer require symfony/property-info

Then, in your service (or controller);

public function __construct(SerializerInterface $serializer) {
    $this->serializer = $serializer;

And in your code;

$obj = $this->serializer->denormalize(

You can also lessen the enforcement of variable-types (strings vs ints) with the following;

$obj = $serializer->denormalize(
    [ObjectNormalizer::DISABLE_TYPE_ENFORCEMENT => true]

Ref; https://symfony.com/doc/current/components/property_info.html

Including the git tag as an environment var in AWS Lambda (via Bitbucket Pipeline Deployments & serverless)

When deploying with the Serverless framework (which Bitbucket Pipelines can do), I wanted to include a version number (or other vars & options passed in the Serverless CLI) which triggered the deploy (via Bitbucket Pipelines).

In my case, this is shown in the footer of a Symfony web-app (more on that below).

Here’s how this can be achieved;


In serverless.yml, we need to define our env-var within the function (or as i’ve done, for all functions, by placing it in the ‘provider’ -> ‘environment’ variables);

DEPLOY_VERSION: ${opt:deploy-version, 'unknown'}

In the above example, my ENV file will be called ‘DEPLOY_VERSION’

The ‘${opt:…} basically gets an option we’ve specified in the serverless deploy command-line (eg. serverless deploy –deploy-version v1.2.3 )

This allows us to pass environment vars from the command line, to our functions (in our case, we’re saying version 1.2.3 of our software is getting deployed).

Then, in Bitbucket;

Next, in our bitbucket-pipelines.yml file, we need to include some extra vars in the ‘atlassian/serverless-deploy:…’ pipe – eg;

EXTRA_ARGS: '... --deploy-version $BITBUCKET_TAG'

Here, we just specify our own option called ‘deploy-version’ (eg. ‘–deploy-version’), and used a variable which bitbucket includes at deploy-time (in our case, it’s called BITBUCKET_TAG).

In my case, i’m using tags to deploy new version of an app (eg. v1.2.3)

Using it with Symfony

From there, it’s upto you how your AWS Lambda function actually uses the environment variable. In my case, i’m using Symfony (with Bref to run it on Lambda). This requires an additional couple of steps;

In the .env file, I need to specify my default value for the env file (eg. when i’m developing it locally, etc);


From there, in my case I then include it as a global variable in my templates, by adding it to my ‘config/packages/twig.yaml‘ file;

    deploy_version: '%env(DEPLOY_VERSION)%'

        deploy_version: '%deploy_version%'

And then in the footer of my pages, I can include it (eg. base.twig.html);

<p><small>Version: {{ deploy_version }}</small></p>


In summary, now when we deploy via Bitbucket Pipelines, we’ll have the version number used in the tag, included in our Symfony app (or whatever Lambda function you have).

Of course this could be used for any variable available in Bitbucket Pipelines (or event via the command-line in the Serverless framework)


Symfony with Bref (and AWS Lambda)

Bref is a serverless framework allowing you to use AWS Lambda with PHP sites, including Symfony apps.

In the serverless.yml file, include the following to allow the headers from the API Gateway to be picked up (eg. so Symfony knows you’re using https rather than http … and makes your absolute URLs with https accordingly);


Ref; https://symfony.com/doc/current/deployment/proxies.html

As part of this, some optimisations need to be made to the php.ini file, to get Symfony running a little faster;

; maximum memory that OPcache can use to store compiled PHP files

; maximum number of files that can be stored in the cache

; don't check timestamps for php files in cache (comment out if php files are getting edited on the server)
; needs a clear-cache script prepared

; maximum memory allocated to store the results

; save the results for 10 minutes (600 seconds)

Ref; https://symfony.com/doc/current/performance.html

Adding the imagick extension to Bref

Recently the ‘GD’ extension was added to Bref, allowing images to be created.

Continuing on that theme, the ‘imagick’ extension was also going to be a nice addition.

To add it in, you need to do the following;

  1. Checkout bref from Github
  2. Add in the lines suggested here, into the ‘runtimes/php-intermediary.Dockerfile’; https://github.com/brefphp/bref/issues/267#issuecomment-476578009
  3. Go into the ‘runtimes’ dir and run ‘make layers’

This will make a few zip files in the ‘runtimes/export’ dir, which are the layers (runtimes) which need to be uploaded to Lambda. That can be done by;

aws lambda publish-layer-version --region=ap-southeast-2 --layer-name=php-73-fpm-with-imagick --zip-file fileb://php-73-fpm.zip --compatible-runtimes provided --output text
aws lambda publish-layer-version --region=ap-southeast-2 --layer-name=php-73-with-imagick --zip-file fileb://php-73.zip --compatible-runtimes provided --output text

Don’t forget to change the region name in the above commands!

Once that’s done, you’ll see the layers in the ‘Lambda’ ‘Layers’ page. Copy the ARN from there into your serverless .yml file, and away you go!

Don’t forget to enable the extension – this is done by creating a ‘php.ini’ file at /php/conf.d/php.ini (in your code-base), with the following;


If you want to make sure it works, include the following in your PHP file and it’ll output a full list of info about the PHP environment, including a section on imagick if it’s been enabled & setup properly.


Using AWS Cognito for authentication on your app

The aim here is to use AWS Cognito to authenticate users on your Symfony app, using oAuth2 so all the auth happens externally on AWS Cognito.

I’m not storing user data locally with this — it just makes sure that they’re valid users. Groups functionality would need to be added separately if required (it’s referenced in the MyBuilder article and has instructions on how groups can be obtained).

I’ve used the knpuniversity bundle as I tried to get HWI OAuth package to work but there wasn’t any providers already written up to support Cognito.

Composer packages used;

  • knpuniversity/oauth2-client-bundle
  • cakedc/oauth2-cognito

So – to get it going, follow the KNPUniversity instructions on their git-hub account.

From there, use the following for the Authenticator class;


namespace App\Security;

use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
use KnpU\OAuth2ClientBundle\Client\OAuth2Client;
use KnpU\OAuth2ClientBundle\Security\Authenticator\SocialAuthenticator;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\User\UserProviderInterface;

class CognitoAuthenticator extends SocialAuthenticator
    private $clientRegistry;
    private $router;

    public function __construct(ClientRegistry $clientRegistry, RouterInterface $router)
        $this->clientRegistry = $clientRegistry;
        $this->router = $router;

    public function supports(Request $request)
        // continue ONLY if the current ROUTE matches the check ROUTE
        return $request->attributes->get('_route') === 'connect_cognito_check';

    public function getCredentials(Request $request)
        // this method is only called if supports() returns true
        return $this->fetchAccessToken($this->getClient());

     * @return OAuth2Client
    private function getClient()
        return $this->clientRegistry

    public function getUser($credentials, UserProviderInterface $userProvider)
        return $userProvider->loadUserByUsername($this->getClient()->fetchUserFromToken($credentials)->getId());

    public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey)
        $targetUrl = $this->router->generate('app_default_index');

        return new RedirectResponse($targetUrl);

        // or, on success, let the request continue to be handled by the controller
        //return null;

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception)
        $message = strtr($exception->getMessageKey(), $exception->getMessageData());

        return new Response($message, Response::HTTP_FORBIDDEN);

     * Called when authentication is needed, but it's not sent.
     * This redirects to the 'login'.
     * @param Request $request
     * @param AuthenticationException|null $authException
     * @return RedirectResponse
    public function start(Request $request, AuthenticationException $authException = null)
        return new RedirectResponse(
            // might be the site, where users choose their oauth provider

My ‘SecurityCognitoController’ class looks like this;


namespace App\Controller;

use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;

class SecurityCognitoController extends AbstractController
     * Link to this controller to start the "connect" process
     * @Route("/security/connect-cognito", name="connect_cognito_start")
    public function connectAction(ClientRegistry $clientRegistry)
        // will redirect to AWS Cognito!
        return $clientRegistry
            ->getClient('cognito') // key used in config/packages/knpu_oauth2_client.yaml

     * After going to Facebook, you're redirected back here
     * because this is the "redirect_route" you configured
     * in config/packages/knpu_oauth2_client.yaml
     * @Route("/security/cognito/check", name="connect_cognito_check")
    public function connectCheckAction(Request $request, ClientRegistry $clientRegistry)
        // ** if you want to *authenticate* the user, then
        // leave this method blank and create a Guard authenticator

My security.yaml file looks something like this;

            id: knpu.oauth2.user_provider

            anonymous: true
                    - App\Security\CognitoAuthenticator
        - { path: ^/security/connect-cognito, roles: IS_AUTHENTICATED_ANONYMOUSLY }

And the following config was used in the ‘pnpu_oauth2_client.yaml’ file;

        # configure your clients as described here: https://github.com/knpuniversity/oauth2-client-bundle#configuration
            type:       'generic'
            provider_class:       '\CakeDC\OAuth2\Client\Provider\Cognito'
            client_id:  '<your client id here>'
            client_secret: '<your client secret here>'
            redirect_route: connect_cognito_check
                region: <your region here>
                cognitoDomain: <your cognito domain here>
                scope: 'email'

A few things are above;

  • client id; This is found in the ‘App integration’ -> ‘App client settings’ page
  • client_secret: This is in the ‘General settings’ -> ‘App clients’ page, and generated when the ‘app client’ is added
  • region: the region your Cognito user-pool is in
  • scope: I’ve just used email, but if you want you can expand it to capture other information as well.
  • redirect_route: In my case I set it to ‘connect_cognito_check’ … this endpoint is used to receive the ‘OK’ from AWS Cognito that your user has been authenticated and pass back a code which internally is used to retrieve the actual account info of the person which was authenticated.

In AWS Cognito, in your ‘App client’ you’ve setup, make sure you have the following settings;

In AWS Cognito, in your ‘App client’ you’ve setup, make sure you have the following settings;

In this case, the ‘Authorization code grant’ is required as part of the oAuth process
The scopes ticked here are what you’ve specified in the config above.
The sign-in & out URLs should be roughly like the above. (obviously this is for dev … use a prod url for your prod environment.
The callback URLs should match your ‘check’ url

Thanks to the following sites which helped get this far;


PHP GD on AWS Lambda (using Bref)

Warning: This is still a work in progress — i’ve tried to get as far as I could to but ran out of time.

The current error is the following, which I think is due to the GD extension using config from a later version of PHP, rather than the version Bref uses;

PHP Warning: PHP Startup: Unable to load dynamic library 'gd' (tried: /opt/bref/lib/php/extensions/no-debug-zts-20180731/gd (/opt/bref/lib/php/extensions/no-debug-zts-20180731/gd: cannot open shared object file: No such file or directory), /opt/bref/lib/php/extensions/no-debug-zts-20180731/gd.so (/opt/bref/lib/php/extensions/no-debug-zts-20180731/gd.so: undefined symbol: executor_globals)) in Unknown on line 0

Basically the following needs to be done to get GD added as a layer (and thus, extension) available to PHP, within AWS Lambda (using PHP Bref).

  1. Compile GD as a ‘bundle’ (including all required libraries as part of it).
  2. Zip up the gd.so bundle file, along with any other libraries it requires
    This is unzipped in the /opt dir in lambda, so the directory structure in the Zip file should be setup in whatever way makes it all work
  3. Publish the zip file as a layer, which is then included after the bref layer in lambda

Compile GD

I followed this guide for the commands;

Download and compile the following required libraries;

  • libwebp (GD compiles, but then complains the library isn’t there when you try to use the GD PHP extension if you don’t include this library)
    libxpm (GD doesn’t seem to compile without it, and it’s not included using the AWS AMI by default)

Follow the instructions on each of their respective websites to build, and run the ‘./configure’ command with ‘–with-prefix=/opt/…’ (replacing ‘…’ with the name of the library)

Download PHP from the php.net site, (get the same version of PHP as Bref uses).

Unzip, and go into the /modules/gd dir (in your unzipped PHP dir)

Run the following to generate a ./configure command and make files

sudo phpize

The following configures and compiles the GD extension, followed by ‘make test’ to check the extension is working.

It references the ‘libwebp’ and ‘libxpm’ directories which are already compiled and output in the /opt/… dir (using ./configure –with-prefix=/opt/.. command)

sudo ./configure --with-php-config=/usr/bin/php-config --with-gd --with-freetype-dir=/usr --with-jpeg-dir=/usr --with-xpm-dir=/opt/libxpm/ --with-png-dir=/usr --with-webp-dir=/opt/libwebp/
sudo make
make test

Zip up the gd bundle

For me, I include the following in the zip file;

  • libwebp (GD compiles, but then complains the library isn’t there when you try to use the GD PHP extension if you don’t include this library)
  • libxpm (GD doesn’t seem to compile without it, and it’s not included using the AWS AMI by default)
  • bref/lib/php/extensions/no-debug-zts-20180731/gd.so
    This is my compiled GD extension, in this directory (to coincide with the extensions dir bref uses — found using phpinfo(); )

The following command creates a ‘gd.zip’ file with the above libraries & files;

zip -r gd.zip lib* bref

Publish the zip file as an AWS lambda layer

This part’s the easy one;

aws lambda publish-layer-version --layer-name php-7-3-gd --description "gd php extension" --zip-file fileb://gd.zip

The lambda layer name can be whatever you like, along with the description. The file part (.zip) refers to the zip file you’ve created, stored on your local machine

AWS will spit out some JSON, with the ‘LayerVersionArn’ as well — this is what you need to include in your list of Lambda layers for your function, eg;

     "LayerVersionArn": "arn:aws:lambda:ap-southeast-2:1234567:layer:php-7-3-gd:16", 
     "Version": 16, 
     "Description": "gd php extension",

Using Symfony on Lambda

For those going down the server-less route and using Symfony, this will hopefully give you a decent starting point.

I’ve added a ‘part 2‘ to this post, with performance optimisations, as well as handling being behind the API Gateway.

This uses a project called Bref – their website is a great starting point and has loads of info.

Ingredients (what you’ll need on-hand);

Method (how do we do this);

A lot of these instructions come from https://bref.sh

For this example, we’ll use ap-southeast-2 as the region (as all my scripts are written using it)

IMPORTANT: If you decide to use a different region (eg. one closer to home/your users), make sure you use the same region for S3 as well as the runtime (mentioned later). Otherwise you’ll run into permission issues you’ll never be able to solve!

2) Jump into the project dir (eg. my-project), and install bref using composer;

1) Install the Symfony skeleton project (see https://symfony.com/doc/current/setup.html) & check to make sure it works as expected.

composer require mnapoli/bref

You may also need to run the following;

vendor/bin/bref init

3) Create an AWS S3 bucket to store your ‘packaged’ files;

aws s3 mb s3://symfony-lambda --region=ap-southeast-2

4) Create a deploy.sh executable file to save yourself some typing;


# Package up your files and send it to an S3 bucket you're going to use;
sam package --output-template-file .stack-symfony.yaml     --s3-bucket symfony-lambda --region=ap-southeast-2

# Deploy (using cloud-formation, which will create your lambda function, etc)
sam deploy --template-file .stack-symfony.yaml --stack-name symfony-lambda --capabilities CAPABILITY_IAM --region=ap-southeast-2

5) Create a cloudformation template file (we’ll call this ‘.stack-symfony.yaml’ … if you want to call it something different, put in the new name in the above command instead);

 AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Description: ''
    Description: URL of our function in the *Prod* environment
    Value: !Sub 'https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/'

                APP_ENV: prod
      CodeUri: s3://<your s3 bucket here>/94ce2f32ac156cd3f06208d3e05dca8f
      Description: ''
            Method: ANY
            Path: /
          Type: Api
            Method: ANY
            Path: /{proxy+}
          Type: Api
      FunctionName: symfony-website
      Handler: public/index.php
      MemorySize: 1024
        - arn:aws:lambda:ap-southeast-2:416566615250:layer:php-72-fpm:8
      Runtime: provided
      Timeout: 30
    Type: AWS::Serverless::Function
      CodeUri: s3://<your s3 bucket here>/94ce2f32ac156cd3f06208d3e05dca8f
      FunctionName: symfony-console
      Handler: bin/console
      Timeout: 120  # in seconds
        - arn:aws:lambda:ap-southeast-2:416566615250:layer:php-72-fpm:8
        - arn:aws:lambda:ap-southeast-2:416566615250:layer:console:4
      Runtime: provided
    Type: AWS::Serverless::Function

Runtimes (basically the PHP executable which is needed by Lambda (PHP isn’t built into lambda, so we supply it as a ‘layer’). See; https://bref.sh/docs/runtimes/

In the file above, add in your s3 bucket name, and replace the ‘layers’ mentioned above with the later from your region (if you’ve decided to use a different one). See; https://bref.sh/docs/runtimes/

6) Run your ./deploy.sh script and follow the prompts if there’s any issues.

I ran into multiple permission issues which were all easily solved by giving access to the user i’d created for this project.

See the Symfony bref guide for more details if you get stuck; https://bref.sh/docs/frameworks/symfony.html


This article is of course free, but there’s some on-going costs you’ll need to consider with Lambda. The few websites i’ve read regarding this seem to indicate it’s cheaper than running an EC2 instance (both from an actual cost and a time-cost in maintaining the thing), but of course you can do a lot of things with EC2!

The cost estimates i’m using come from US East (Ohio), and were taken on 8/Feb/2019;

  • Lambda (for your actual PHP server-side code)
    • $3.50/million requests – first 333 million requests/month
    • AWS Lambda – Compute Free Tier – 400,000 GB-Seconds – US East (Ohio)12.163 Lambda-GB-Second
    • AWS Lambda – Requests Free Tier – 1,000,000 Requests – US East (Ohio)
  • S3 (for storage of your packaged site, as well as any assets – css/images/js/uploaded files);
    • $0.005 per 1,000 PUT, COPY, POST, or LIST requests
    • $0.004 per 10,000 GET and all other requests
    • $0.023 per GB – first 50 TB / month of storage used
  • Some others include;
    • Bandwidth
    • CloudFront (for serving up your assets if you use it later on)
    • Relational Database Service (for a database if you need one)
    • Route 53 (for your DNS needs)
    • Simple Email Service (for sending emails)

Inspiration from this comes from this YouTube vid – well worth watching;

Reverting/resetting a GIT commit

If something gets committed to a GIT repo, the following command can be run to reverse it;

$ git reset HEAD~


$ git commit -m "Something terribly misguided" # (1)
$ git reset HEAD~ # (2)
<< edit files as necessary >> # (3)
$ git add ... # (4)
$ git commit -c ORIG_HEAD # (5)

If the commit has already been pushed to your external repo, you’ll need to add ‘–force’ next time you push if the commit is rejected (the repo is probably going to be ‘ahead’ of the commit you’re trying to push to it);

$ git push origin master --force

Ref; https://stackoverflow.com/questions/927358/how-to-undo-the-most-recent-commits-in-git

Symfony – forcing file download as attachment

The following forces the browser to download the file as an ‘attachment’, rather than inline (within the browser window);

(in this case, named ‘my-pdf-filename.pdf’)

$response = new Response($pdfData, 200, [
   'Content-Length' => strlen($pdfData),
   'Content-type' => 'application/pdf',
   'Content-Transfer-Encoding' => 'binary'

$disposition = $response->headers->makeDisposition(
$response->headers->set('Content-Disposition', $disposition);