loading...

Symfony on a lambda: first deployment

hyoa profile image Matsounga Jules Originally published at julesmatsounga.com Updated on ・5 min read

Symfony on a lambda: first deployment

English isn't my first language, help me improve my posts by pointing my mistakes

We can run serveless on many platforms, and same goes for cloud functions. As Bref only support AWS, we will focus on this platform.

As mentioned, we will use Bref. It help run PHP on a AWS Lambda.

We will use it with Symfony, a popular PHP framework.

If you are lost, you can find the project on Github: link
Each branch will match a chapter.

Requirements

  • Have the requirements to run Symfony on your computer (PHP and some extensions)

  • Have an AWS account(you can create one here: registration). We will stay below free tier limit, so no worries for your wallet.

  • Create an access key:

    • Create a new user here
    • Add a user name
    • Enable Programmatic access
    • Click Attach existing policies directly, search for **AdministratorAccess **and select it.

    Warning: it is recommended to only select right that you really need. But too keep this presentation simple, we will use a full access key.

    • Finish creating the user
    • Take note of keys generated, we will need them after
  • Install serverless: npm install -g serverless

  • Create the configuration of serverless: serverless config credentials --provider aws --key <key> --secret <secret> where key and secret are from the keys generated earlier

Symfony

We now have everything we need to start our development. Let's go !

Installation of Symfony

In your terminal, type the following command at the root of your projects composer create-project symfony/website-skeleton [my_project_name] (remember to replace [my_project_name] with yours)

Once the installation done, you can go in the folder where is your Symfony application.

We can now install Bref, which is required to deploy PHP on a lambda. To do so, once in the project, type composer require bref/bref

Creation of the serverless.yml

This file will define the architecture that we will deploy on AWS, that will be called CloudFormation. It's in this file that we will define services and resources and their configurations that we want on AWS.

To create this file, Bref give us a command that will help init a project. Type vendor/bin/bref init et select HTTP application.

The command create our serverless.yml file and an index.php file at the root of our project. You can delete index.php we wont use it.

The serverless.yml should look like this:

service: app #Name of your application

provider:
    name: aws #Provider used by Serverless
    region: us-east-1 #Region where you will deploy your CloudFormation
    runtime: provided

plugins:
    - ./vendor/bref/bref

functions:
    api: #Name of the function
        handler: index.php
        description: ''
        timeout: 28 # in seconds (API Gateway has a timeout of 29 seconds)
        layers:
            - ${bref:layer.php-73-fpm}
        events:
            -   http: 'ANY /'
            -   http: 'ANY /{proxy+}'

The most interesting part is functions where we will be able to define our functions that we need (it can be commands, apis, crons, etc...).

  • handler: the php file used by the lambda
  • description: well, a description ?
  • timeout: maximum execution time of the function
  • layers: Layers are environment used by the lambda to run, you can have multiple layers to add other extensions, dependencies etc. Here, we use the layer of Bref, that run PHP with the layer of Node (more on layers)
  • events: events that will trigger the function. On this function, the HTTP event will trigger the lambda, but there is a lot of other events triggered by AWS that we can listen. We will see an other one later

Now that we have a better understanding of our file, lets changed it to run Symfony.

service: cloud-project

provider:
    name: aws
    region: eu-west-2
    runtime: provided
    stage: dev
    environment:
        APP_ENV: prod
plugins:
    - ./vendor/bref/bref

functions:
    website:
        handler: public/index.php
        timeout: 28
        layers:
            - ${bref:layer.php-73-fpm}
        events:
            -   http: 'ANY /'
            -   http: 'ANY /{proxy+}'

    console:
        handler: bin/console
        timeout: 120
        layers:
            - ${bref:layer.php-73}
            - ${bref:layer.console}

Not too many change. I changed the name of the application in cloud-project (you can put whatever you want). I also add a stage that define the environment publish.
In environment we have the environment variables used by our functions.
I also create 2 functions:

  • website that is the same than the api function we had in the file. We only change the handler that now target the index.php of Symfony.
  • console used to run Symfony command

Symfony configuration

We will have to change some files in Symfony to make it work on a lambda.

System file is readonly except /tmp, we have to change where are stored cache and logs.
In src/Kernel.php, we need to add 2 methods:

// src/Kernel.php
...

public function getLogDir(): string
{
  if (getenv('LAMBDA_TASK_ROOT') !== false) {
    return '/tmp/log/';
  }

  return parent::getLogDir();
}

public function getCacheDir(): string
{
  if (getenv('LAMBDA_TASK_ROOT') !== false) {
    return '/tmp/cache/'.$this->environment;
  }

  return parent::getCacheDir();
}

We also need to change index.php.

Once deployed, the lambda that use API Gateway have a domain that is created and that end with th stage deployed (ex: https://lamnda/dev). It can create some issue with PHP framework. You can easily solve this by creating a custom domain that get ride of this suffix (more information](https://bref.sh/docs/environment/custom-domains.html)). But to keep this presentation accessible, we won't do it.
We have to change some servers variables so the Symfony routing wont break.

// public/index.php

$_SERVER['SCRIPT_NAME'] = '/dev/index.php';
if (strpos($_SERVER['REQUEST_URI'], '/dev') === false) {
    $_SERVER['REQUEST_URI'] = '/dev'.$_SERVER['REQUEST_URI'];
}

You need to put this line before new Kernel(...). /dev is the stage defined in serverless.yml. If you create your own application, you should really create your own domain. It can be a bit long (propagation of DNS) but otherwise it's quite simple.

We don't need anything else. Let's code a bit.

Building a homepage

We will create a simple landing page si we have something to deploy. But we will keep it simple:

Create a file HomeController in src/Controller

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class HomeController extends AbstractController
{
    /**
     * @Route("/", name="home")
     */
    public function homeAction(): Response
    {
        return $this->render('home/index.html.twig');
    }
}

Create a file index.html.twig in templates/home

{% extends 'base.html.twig' %}

{% block body %}
    <h1>Symfony and lambdas</h1>
{% endblock %}

Yes, it's really simple but we don't really need anything else.

To see if it's working, type: php bin/console server:run and go to the url displayed. You should see your page.

Now, let's deploy it !

Deploy in the cloud

It might disappoint you, but you just need to run serverless deploy. The command will package your project, create the required resources on AWS. After few minutes, the endpoints of your function will be displayed. Use the first one, and you should see your site deployed !

You can see your CloudFormation on AWS here. You can also see the resources created by selecting Model then Display in Designer.


We now have a Symfony application running on AWS. Of course we are only at the beginning, but we will discover more in the next chapters.

In the next chapter we will talk about assets. Because without assets, there is no CSS or JS !

Discussion

pic
Editor guide