How to Run Symfony Console Command in AWS Lambda

Running PHP console application as microservice

Image by author

In the previous article, I have created a simple “Hello World” console application by using Symfony Console Component. Do read it if you aren’t aware of how to create the Symfony Console application.

In this article, I will try to deploy my console application in AWS Lambda to run as Cron job with Amazon EvenBridge.

Let’s try to understand AWS Lambda and see how we can deploy PHP applications in it.

AWS Lambda

This article is not about AWS Lambda, If you don’t know what is AWS Lambda, please go to the official documentation of AWS Lambda and read it.

You need to have an AWS account to deploy your application in AWS Lambda. Please register “https://aws.amazon.com/”.

Now I can assume that you have an AWS account and has access to the AWS lambda service.

Let’s open the AWS console and go to the AWS Lambda service and click on the “Create Function” button.

AWS Lambda create a function button

If we look in the AWS console it shows runtimes for many different languages but PHP is not on the list.

PHP is not the only missing language from the list because there are many other languages also missing, Like Rust, Erlang and others. In August 2020 AWS introduced a custom runtime to support any language user wants to deploy and run within AWS Lambda.

If you don’t know what is runtime, please read the official documentation to understand.

Lambda runtimes
Custom AWS Lambda runtimes

Amazon provides default runtime for specific languages and all others require custom runtimes.

Bref Plugin

PHP community introduced Bref plugin for a Serverless Framework which provides PHP custom runtimes for AWS Lambda for different types of applications.

We are going to deploy the console application and Bref has custom runtime for it. You can find all PHP custom runtimes here: https://runtimes.bref.sh/

How to install Bref and use it in the project

You need to install Bref and set up an AWS account to follow the instruction from the Bref official documentation. https://bref.sh/docs/installation.html

Now you can go to your console application or download my “Hello World” application from Github to continue this article.

PHP Console App: Github repository

Once you are in the project root directory, install the Bref package.

composer require bref/bref

Now Bref package has been installed and is ready to start initializing the serverless project.

Time to create a serverless project structure to deploy the application in AWS Lambda.

vendor/bin/bref init

Bref initialize command will ask you to create a type of Lambda function that your application is going to use.

In our case, we are going to create an “Event-driven function” because it will be invoked by the EventBridge event. Select the second option by typing 1 in the console.

It will add two new files in the project root directory.

index.php
serverless.yml

Index.php is the default handler of AWS Lambda and works the same as index.php works for apache in the public directory of the Symfony Web application.

serverless.yml is the file of serverless framework where we will tell the ‘AWS, where and how to deploy our application in the cloud.

Let’s look in detail and try to create our infrastructure as code in the serverless.yml file.

By default Bref will create the following structure, It’s a good start but not enough to push the console application to Lambda.

service: app

provider:
    name: aws
    region: us-east-1
    runtime: provided.al2

plugins:
    - ./vendor/bref/bref

functions:
    hello:
        handler: index.php
        description: ''
        layers:
            - ${bref:layer.php-81}

# Exclude files from deployment
package:
    patterns:
        - '!tests/**'

We need to understand every code block and change it according to our needs.

Give a name to the application.

service: php-console-app

We will use the same provider but change the region from “us-east-1” to “eu-west-1” because we are going to host our application in the Irland region.

provider:
    name: aws
    region: eu-west-1
    runtime: provided.al2

A plugin will be the same, so no need to change anything.

plugins:
    - ./vendor/bref/bref

Next is the most important part where we will configure our Lambda function and deploy the application.

Change function block with the following instructions.

functions:
    cron:
        handler: bin/console
        description: 'Hello world console command'
        layers:
            - ${bref:layer.php-81}
            - ${bref:layer.console}

As you can see we have changed our calling method from “hello” to “cron” and replaced handler index.php with bin/console. The reason is that, when EventBridge will call our command, our application entry point is bin/console not index.php.

We don’t need index.php in the application, so remove this by running the following command:

rm index.php

Next, we have added two different runtimes as layers to run our application:

functions:
    cron:
        layers:
            - ${bref:layer.php-81}
            - ${bref:layer.console}

After adding layers, the AWS Lambda function is ready to go live:

#serverless.yml
service: php-console-app

provider:
    name: aws
    region: eu-west-1
    runtime: provided.al2

plugins:
    - ./vendor/bref/bref

functions:
    cron:
        handler: bin/console
        description: 'Hello world console command'
        layers:
            - ${bref:layer.php-81}
            - ${bref:layer.console}

# Exclude files from deployment
package:
    patterns:
        - '!tests/**'

Let’s try to deploy and see how it looks:

serverless deploy

Serverless deploy command overview

As you can see, the application has been deployed successfully. Go to your Lambda console and find the function php-console-app.

You can see that Lambda added dev and cron at the end of the function name. It appends the environment (default is dev) and invokes the method name to the function name.

Click on the function name and open it:

Lambda function overview

You can see that the Lambda function has been created and it has two layers as defined in the serverless.yml file.

If you scroll down, you should be able to see your application code as well.

Application code in the Lambda runtime

If you see Lambda's overview, it is missing a trigger to invoke this function.

There are multiple ways to invoke the Lambda function but in our case, we are going to invoke this every minute like a cron job in Linux.

Amazon EventBridge or formally known as Amazon CloudWatch Events

Amazone EventBridge has two different rules to invoke the Lambda function.

1. Creating Amazon EventBridge rules that react to events
2. Creating an Amazon EventBridge rule that runs on a schedule

We will use the second rule to schedule our cron job. It has two ways to schedule an event, rate expression or cron expression.

Let’s configure the cron expression in our serverless.yml file as follows to run our command every minute:

functions:
        {.....} 
        events:
            - schedule:
                  rate: cron(* * * * ? *)
                  input: '"app:hello-world --verbose"'

You can find all cron rules from the official documentation page of EventBridge.

The final version of our serverless.yml is:

#serverless.yml
service: php-console-app

provider:
    name: aws
    region: eu-west-1
    runtime: provided.al2

plugins:
    - ./vendor/bref/bref

functions:
    cron:
        handler: bin/console
        description: 'Hello world console command'
        layers:
            - ${bref:layer.php-81}
            - ${bref:layer.console}
        events:
            - schedule:
                  rate: cron(* * * * ? *)
                  input: '"app:hello-world --verbose"'

# Exclude files from deployment
package:
    patterns:
        - '!tests/**'

Now deploy again and see if it works:

serverless deploy

To verify our EventBridge configuration, Open your Lambda function in the AWS console and see if EventBridge has been added as a trigger or not.

For me, it looks like added:

Lambda function with EventBridge as a trigger

Now we need to go to the logs of the Lambda function and see if it’s being called every minute or not.

There are a couple of ways to see logs from the AWS console. You can see logs within the Bref desktop application or directly in the Lambda function Monitor tab.

Logs from AWS Console:

Every minute Lambda invocations

If you click one of those logs, you should be able to see the output of the application command.

Logs view from AWS console

Or you can view the same logs from the Bref application. Open the Bref desktop application, select eu-west-1 region, and function php-console-app-dev.

Logs view from Bref Desktop application.

Now PHP console application is running every minute to perform its task.

I hope you have learned something from the post, If you have questions, please feel free to ask.

You can download the source code from the GitHub repository.