
Cela n'échappe pas à ceux qui s'intéressent au sujet, mais la mise en place d'applications (ou de fonctions) sur un mode serverless est une tendance de fond qui se confirme jour après jour.
Dans cet article, nous allons tenter de faire le point à ce sujet, mais surtout de vous présenter comment, de façon tout à fait pragmatique et avec des exemples de la vraie vie il est possible de mettre en place une solution serverless avec PHP et Symfony.
Serverless, c'est quoi ?
Serverless, c'est l'étape d'après du Cloud :)
Si vous faites du Web depuis un petit moment, vous pouvez constater l'évolution de la partie hébergement comme ceci. Au fil du temps, nous sommes passés :
- D'un serveur physique
- à un serveur virtuel
- à des serveurs de plus en plus virtuels (cloud & co)
- à des serveurs virtuels dans des serveurs virtuels (Docker / Kubernetes & co)...
- D'exécuter du code (AWS Lambda)
- De servir des assets (AWS S3)
- D'une base de données (AWS RDS)
Le site serverless-stack.com résume bien les choses :
L’architecture serverless est un modèle dans lequel le fournisseur de services cloud (AWS, Azure ou Google Cloud) est responsable de l’exécution d’un morceau de code en allouant de manière dynamique les ressources.
Et il ne facture que la quantité de ressources utilisées pour exécuter le code. Le code est généralement exécuté dans des conteneurs sans état pouvant être déclenchés par divers événements, notamment des requêtes http, des événements de base de données, des services de file d’attente, des alertes de surveillance, des téléchargements de fichiers, des événements planifiés (tâches cron), etc. Le code envoyé au fournisseur de cloud pour l’exécution est généralement sous la forme d’une fonction.
Par conséquent, serverless est parfois appelé “Functions as a Service” ou “FaaS”.
Déployons Symfony et API Platform en serverless
Bien. Maintenant que nous savons tout cela, cet article va vous présenter comment déployer Symfony et API Platform sur le service Serverless d'Amazon, à savoir AWS Lambda.
Qu'allons nous mettre en place ?

Pour mener à bien ce projet, nous aurons donc besoin :
C'est parti !
Mise en place du projet Symfony / API Platform
Nous ne nous attarderons pas sur la mise en place du projet avec Symfony / API Platform, car le coeur de cet article ne se situe pas là. Vous pouvez jeter un oeil au code source que nous avons publié sur Github, accessible à la fin de cet article.$ symfony new the-office-api-quotes
$ cd the-office-api-quotes
$ composer req api debug maker
$ bin/console make:entity Quotes --api-resource
$ symfony serve
Et voilà ! Vous devriez avoir une API prête à servir des citations de The Office à l'URL https://127.0.0.1:8001/api/quotes
Adaptons Symfony au serverless
Symfony est presque prêt à être déployé tel quel. Il est nécessaire d'apporter une modification mineure pour faire en sorte que les fichiers decache
et de log
soient générés dans le dossier /tmp
, seul répertoire accessible par défaut en écriture
// src/Kernel.php
public function getLogDir()
{
// When on the lambda only /tmp is writeable
if (getenv('LAMBDA_TASK_ROOT') !== false) {
return '/tmp/log/';
}
return parent::getLogDir();
}
public function getCacheDir()
{
// When on the lambda only /tmp is writeable
if (getenv('LAMBDA_TASK_ROOT') !== false) {
return '/tmp/cache/'.$this->environment;
}
return parent::getCacheDir();
}
Bref. Il faut déployer Symfony en Serverless
Maintenant que notre API tourne en local, nous allons la déployer sur AWS Lambda, afin que celle-ci soit exécutée en tant que fonction.
Nous allons pour cela nous appuyer sur trois outils : bref
, serverless
et aws
.
-
serverless est un framework qui permet de déployer son code. Pour nous, il s'agira essentiellent d'un outil en ligne de commande et d'un fichier de configuration en
yaml
. - bref est une solution complète qui rend possible l'exécution de code PHP sur AWS Lambda (via un runtime PHP qui n'existe pas nativement). Bref est également un package installable via composer et qui permet entre autre de disposer un cli qui permet d'invoquer votre application.
- aws est un outil en ligne de commande qui permet d'interragir avec les services d'AWS
Premier déploiement avec Serverless / Bref
Installation des outils
$ npm install -g serverless # ou brew install serverless
# récupérer vos clés AWS (https://bref.sh/docs/installation/aws-keys.html)
$ serverless config credentials --provider aws --key --secret
# BREF
$ composer require bref/bref
Mise en place du fichier serverless.yml
Maintenant que les outils sont installés, nous allons créer un fichier serverless.yml
à la racine du projet, qui va décrire ce dont nous avons besoin. Voici le fichier ci-dessous
service: acseo-the-office-api
provider:
name: aws # Car nous utilisons AWS :)
region: eu-west-3 # Paris
runtime: provided # Car nous utilisons le runtime PHP de Bref
environment: # Variables d'environement Symfony
APP_ENV: prod
plugins:
- ./vendor/bref/bref # Plugin bref installé avec composer
package:
exclude: # Fichier exclus car non nécessaires pour
- node_modules/** # l'exécution de notre fonction
- tests/**
functions:
website: # Première fonction exposée
handler: public/index.php # Point d'entrée
timeout: 28 # en secondes (timeout de 29s chez AWS)
layers: # Runtime utilisé
- ${bref:layer.php-73-fpm} # liste ici : https://bref.sh/docs/runtimes/index.html
events:
- http: 'ANY /' # Evènements écoutés
- http: 'ANY /{proxy+}'
console: # Bonus, la console est aussi exposée
handler: bin/console
timeout: 120 # in seconds
layers:
- ${bref:layer.php-73} # PHP
- ${bref:layer.console} # The "console" layer
Maintenant que ce fichier est créé, il ne nous reste plus qu'à déployer notre code !
Déployer son code Symfony sur Lambda
Le déploiement du code s'effectue très simplement :
$ serverless deploy
Serverless: Packaging service...
Serverless: Excluding development dependencies...
Serverless: Uploading CloudFormation file to S3...
Serverless: Uploading artifacts...
Serverless: Uploading service acseo-the-office-api.zip file to S3 (16.05 MB)...
Serverless: Validating template...
Serverless: Updating Stack...
Serverless: Checking Stack update progress...
....................
Serverless: Stack update finished...
Service Information
service: acseo-the-office-api
stage: dev
region: eu-west-3
stack: acseo-the-office-api-dev
resources: 15
api keys:
None
endpoints:
ANY - https://xxx.execute-api.eu-west-3.amazonaws.com/dev
ANY - https://xxx.execute-api.eu-west-3.amazonaws.com/dev/{proxy+}
functions:
website: acseo-the-office-api-dev-website
console: acseo-the-office-api-dev-console
layers:
None
Serverless: Removing old service artifacts from S3...
Serverless: Run the "serverless" command to setup monitoring, troubleshooting and testing.
Et voilà ! Vous avez déployé votre premier code PHP / Symfony sur Lambda. Mais ce n'est pas encore fini...

Envoi des assets sur AWS S3
Lambda n'est en effet pas fait pour servir des assets. En revanche, S3 est un parfait candidat pour stocker et rendre disponible ces derniers.
Création d'un storage et envoi des assets
Nous allons créer un espace de stockage puis synchroniser le dossier public
dans celui-ci .
$ aws s3 mb s3://acseo-the-office-api-assets --region eu-west-3
$ aws s3 sync public s3://acseo-the-office-api-assets --delete --acl public-read
Paramétrage de Symfony pour pointer sur S3
Il ne nous reste plus qu'à éditer la configuration du projet pour pointer sur ces assets en production
# config/prod/assets.yaml
framework:
assets:
base_urls:
- '%env(PROD_ASSET_URL)%'

Une fois le code redéployé avec serverless deploy
,
c'est maintenant beaucoup mieux !
Mais il reste encore un problème : nous n'avons pas de données...
Ajout et connexion à une base de données
Dernière étape, et non des moindres, il faut maintenant ajouter une base de données reliée à notre Lambda.
Pour rester sur les services AWS, nous allons donc instancier une base de données de type MariaDB sur les services AWS
Une fois de plus, la documentation fournie par Bref à ce sujet est d'une excellente qualité et largement suffisante pour comprendre comment faire. A notre niveau, nous retiendrons que la bonne pratique consiste à ajouter notre fonction Lambda dans le même groupe de Virtual Private Cloud afin que fonction et base de données puissent se voir
Lien entre la base de données et la fonction Lambda
Nous éditerons donc notre fichier serverless.yml
de la façon suivante :
# serverless.yml
functions:
website:
handler: public/index.php
timeout: 28
layers:
- ${bref:layer.php-73-fpm}
events:
- http: 'ANY /'
- http: 'ANY /{proxy+}'
vpc: # Infos trouvées dans l'onglet
securityGroupIds: # Connectivité et sécurité
- sg-xxxx # de votre instance RDS
subnetIds: #
- subnet-xxxx #
- subnet-xxxx #
- subnet-xxxx #
Activation de pdo_mysql dans le Layer Bref
L'extension pdo_mysql
n'est pas activée par défaut dans le Layer fourni par bref. Fort heureusement, il est très facile de pouvoir l'activer,
en créant le fichier php/conf.d/php.ini
à la racine de votre projet.
# php/conf.d/php.ini
extension=pdo_mysql
Pour en savoir plus sur les extensions activées et activables : https://bref.sh/docs/environment/php.html
Il ne nous reste plus qu'à éditer le fichier .env.prod
pour configerer l'accès à notre base de données :
Et pour finir...
Pour résumer, nous avons :
- Configuré serverless pour déployer notre code Symfony sur Lambda
- Déployé les assets sur S3
- Créé puis lié une base de données à notre fonction Lambda
Une fois un dernier déploiement effectué, le résultat tant attendu apparait :
Ca y est, nous disposons d'une API Symfony / API Platform déployée sur Lambda !
Conclusion
Comme le montre cet article, il n'est pas très compliqué de pouvoir utiliser Symfony tout en utilisant des solutions "modernes" ou en tout cas "hype". L'utilisation du framework serverless offre une solution pertinente dans un nombre de cas avérés, et il est toujours utile de la garder dans un coin de sa tête.
Pour aller plus loin, il est important de rappeler que l'utilisation de solution serverless entraine une notion de coût variable, qu'il est important d'encadrer et de maitriser dès le départ. Un article écrit par nos amis de JoliCode aborde également ce sujet.
Le code source de l'application Symfony de démo, ainsi que les fichiers de configuration, peuvent être consultés sur notre dépot Github : https://github.com/acseo/symfony-lambda-demo. Ce dépot contient également un dump SQL avec plus d'une centaines de citation de la série.
Vous recherchez des experts Symfony, Contactez nous !
Une idée, un projet ? Nous sommes à votre disposition pour discuter.