Retour du Symfony Live Paris, édition 2020

Nous ne pensions plus cela possible, mais ils l’ont fait. Malgré un report, la 11e édition du Symfony Live Paris s’est bien tenue cette année, à la Cité Internationale Universitaire ! Et nous y étions en tant que Sponsor.

Comme vous pouvez l’imaginer, elle s’est déroulée selon la nouvelle mode en vigueur (de jolis masques floqués de l’éléphant php, du gel hydroalcoolique à portée de main) et dans le respect des normes sanitaires ! Mais l’équipe qui organise la conférence avait tout mis en place pour qu’elle se passe dans les meilleures conditions possibles. Elle nous a chouchouté avec des lunch box gourmandes !

Concernant les conférences en elles-mêmes, les speakers étaient au rendez-vous malgré des stands plus clairsemés que d’habitude. Mais toujours de supers goodies (adaptés au goût du jour) !

J’ai trouvé les conférences orientées très architecture et pratique, avec l’accent mis sur l’amélioration des performances plus que dans les annonces fortes. C’est le signe que Symfony se stabilise (notamment depuis les changements majeurs introduits en 3.4) et développe davantage son écosystème.

Keynote de Fabpot

Cette conférence lance le top départ du Symfony Live ! Et sur les chapeaux de roues, avec la description de l’arrivée de Symfony 5.2. Qu’y a-t-il à l’intérieur ? Quelques améliorations, au niveau des traductions, des uid, du Notifier et du Mailer,.. Mais surtout une meilleure intégration de Php 8 et de ses nouveautés et un grand paradigme de ‘Less Code, More automation’. On retrouve cette idée dans toutes les dernières évolutions de Symfony. Cela passe souvent par la mise en place d’une configuration sémantique et de flex qui, selon la démonstration de Fabien Potencier, permet de monter un projet Symfony avec son système d’authentification en moins de 5 min. 

Ici s’illustre un autre axe fort porté par Symfony : la sécurité. Celle des utilisateurs et de la protection de leurs données, via l’authentification mais aussi le stockage de celle-ci. Ce point fait d’ailleurs l’objet de plusieurs conférences. 

Elle s’est terminée par l’appel lancé à contribuer à Symfony. L’idée derrière étant que la communauté est bienveillante et que tout développeur a le niveau pour se lancer !

Le cache, ça paye ! par Hubert LENOIR

Première conférence pleine d’humour (grosse référence musicale : « le cache, ça paye comme jamais…« ) par Hubert Lenoir. Il nous présente comment une bonne gestion de cache peut améliorer les performances jusqu’à + 80% sur l’affichage d’un site. Il part du cas concret d’un intranet riche de 300.000 utilisateurs au niveau mondial : cela permet de lisser la charge sur 24h. Mais en contrepartie, il n’y a aucun moment de creux pour intervenir sur l’application… 

Plusieurs possibilités : 

• une gestion côté navigateur mais alors on n’a pas vraiment la main dessus.  Au mieux on peut le forcer à s’actualiser.
• une gestion proxy, de type Varnish, entre le client et le serveur, qui permet de ne jamais interroger l’origine. Le cache est de ce fait partagé entre plusieurs utilisateurs. Du moins les ressources non-privées le sont. Plus efficace, mais l’authentification et les autorisations liées sont plus difficiles à gérer. En effet, il faut distribuer seulement les données autorisées aux bonnes personnes. 
• une gestion côté serveur, via Apcu, Redis… Cela présente de nombreux avantages : plus rapide ; une volumétrie stable ; le cache peut être reconstruit à la volée par n’importe quel utilisateur, quelque soit ses droits d’accès.

Cela permet un gap de performance mais demande une gestion fine des clés de cache. Le gros tips : 5 minutes maximum avant de régénérer le cache afin de limiter les données obsolètes. 

Lock et Semaphore : les gardiens de vos ressources par Jérémy DERUSSÉ 

Cette conférence aborde deux nouvelles fonctionnalités qui arrivent avec Symfony 5.2 : les locks et les sémaphores. Quelle utilisation et quelle différence ? 

Le lock permet de limiter l’accès à ma ressource à un process, tandis que le sémaphore limite à l’accès à ma ressource à N process. De ce fait, un lock est un sémaphore spécifique.

Ainsi, pourquoi deux composants ? Cela entraine pas mal de duplication de code, mais la création d’un composant spécifique dédié au lock permet qu’il soit beaucoup plus léger dans son exécution que le sémaphore.

Ils sont créés et managés au sein de stores, qui sont déjà prêts à être utilisés. Pour le moment, il n’y en a qu’un pour Sémaphore (Redis) mais une jolie liste pour Lock (Pdo, MongoDb, Redis…).

Migrer vers une architecture micro-services : points de contrôle pour une migration réussie par Alexandre SALOME

Une présentation très intéressante. Il a su mettre l’accent sur les points de limite du passage à une architecture de micro-services et sur les écueils à éviter. 

Une architecture en micro-services présente plusieurs applications. Elles portent chacune une responsabilité aux frontières marquées : elle permet ainsi une séparation par responsabilité, avec des services indépendants. Mais elle nécessite pour sa mise en place un bouleversement de l’organisation. Pas seulement au niveau du seul projet, mais bien souvent de l’entreprise tout entière ! Plusieurs équipes transverses sont concernées. Il est donc nécessaire de prendre du temps pour s’organiser. Il faut pouvoir appréhender correctement le métier et contractualiser les échanges de données avant même de commencer à coder. Et surtout, elle demande également l’implication de réels experts, à la fois côté métier et compréhension du besoin mais également côté technique (des DevOps notamment). Le but est d’éviter que cette transition, qui peut durer plusieurs années, ne se transforme en cauchemar.

Un changement en profondeur de pensée et d’organisation donc. Mais elle doit pouvoir être remise en cause à tout moment du développement. En effet, le découpage des services peut être questionné à n’importe quelle étape : il est ainsi nécessaire d’être fortement agilisé. 

Le challenge technique est très motivant. Mais il peut se révéler être une catastrophe économique si le changement n’est pas perçu dans sa globalité ou s’il n’est pas organisé depuis le haut, avec une implication et une volonté forte de tous les participants.

La compilation JIT, le fil rouge vers PHP 8 par Valentine BOISNEAU

Une conférence très technique présentée par la dynamique Valentine Boisleau. Elle passe en revue les optimisations de PHP. L’historique est complet : de l’idée de mettre en place un cache (opcache depuis 5.5) à aujourd’hui, en passant par l’optimisation de l’Opcode et de nombreux acronymes (ASR, SSA et DFA). De nos jours, Php 8 tend vers la compilation dite JIT ou « Just In Time ». Elle permet une compilation de portions de code au moment de l’exécution. Ainsi le code est transformé en opcode. Il pourrait être compilé puis exécuté directement par la machine hôte et non par une machine virtuelle Php. 

Cela permettrait, en théorie, une exécution bien plus rapide du code. 

Cependant, dans la réalité, sur une application WordPress par exemple, le gain de temps d’exécution est … quasi nul. 

De ce fait, une question se pose. Pourquoi l’implémenter, alors que le gain de performance reste très limité, et que cela complexifie énormément PHP ? La réponse apportée est que cela va dans le sens de l’évolution de PHP. Il ne s’agit que d’une étape parmi d’autres. Séparément, elles paraissaient inutiles mais en s’empilant, elles font sens et vont vers une optimisation globale de la vitesse du langage.

Monolithe Modulaire : Pourquoi ? Comment ? par Timothée BARRAY

Une réflexion pratique apportée qui est très intéressante. Le postulat de départ est le suivant : si j’ai une petite équipe, et que mon projet est au départ peu dimensionné, l’intérêt de se lancer dans une architecture micro-services est moindre. En revanche, rien ne m’empêche de monter une architecture dite en « monolithe modulaire ». Si je le souhaite, elle me permettra à l’avenir de basculer « simplement » en micro-services. 

Elle apporte de l’autonomie aux modules, aux décisions et aux équipes. Mais elle impose de se préparer aux mêmes changements de fond que ceux nécessités par la bascule en micro-services. Lesquels sont réfléchir en équipe et poser des frontières entre les modules pour les déterminer, puis décrire les contrats qui permettront de contrôler les ouvertures entre chaque modules, via des API. 

Le choix de cette architecture ne doit pas être poussé par une volonté d’apporter un gain de performance, ça ne sera pas le cas ! En revanche, le challenge technique et l’autonomie acquise entre les équipes sont réels.

Redis, ce n’est pas que pour le cache par Grégoire PINEAU

Présentation de Redis et de ses possibilités nombreuses. De ses datas structures, à ses commandes, jusqu’à son intégration dans Symfony. Une présentation pratique avec des exemples concrets d’application.

Mettre la cryptographie au service de vos apps Symfony par Nicolas GREKAS

Une conférence lumineuse et très pratique sur le pourquoi de la cryptographie et ses limites, dans une course effrénée entre : 

• d’un côté les hackers, qui utilisent des cpu de plus en plus puissants et construisent des BDD dédiées au décodage de mots de passe.
• de l’autre les développeurs au sens large, qui essaient tant bien que mal de complexifier toujours davantage les algorithmes de cryptage.

La cryptographie sert à hasher des mots de passe (à sens unique) ou à les chiffrer (réversible). On s’en sert pour vérifier l’intégrité de données, de documents, et pour leur maintenir leur confidentialité. 

C’est maintenant une obligation légale des entreprises, avec la RGPD. Tout le monde doit s’en soucier pour rendre le web plus sûr ! D’autant que Symfony intègre des features permetttant de hasher automatiquement les mots de passes, notamment le MigratingPasswordEncoder. Il permet d’évoluer vers de nouveaux algorithmes tout en conservant les anciens. L’upgrade de la BDD se réalise de façon transparente à chaque fois qu’un utilisateur tape son mot de passe pour se loguer. 

On peut également crypter ses secrets, ses données en cache Redis, ses entités Doctrine (via DoctrineEncryptBundle) ou même les objets (paragonie/halite).

API : Spécifications, Sécurité et Monitoring par Danielle KAYUMBI BONKOTO

Un point sur l’utilité et la conception des APIs aujourd’hui. Les APIs représentent actuellement 83 % du trafic web actuel. Cela amène à s’interroger sur l’importance qu’elles ont prise au sein de nos applications. Plus globalement, nous nous dirigeons (ou nous sommes déjà) vers la 4e Révolution Industrielle. Elle est celle du  numérique et de l’échange de données.

Stream processing : un autre type d’architecture par Samuel ROZE

Samuel Roze nous propose ici de penser une nouvelle architecture possible pour nos applications. Elle est bien éloignée de nos habitudes traditionnelles qui sont d’APIser les échanges de données. Il nous propose de faire du « stream processing » via l’utilisation de message bus. Il nous présente ici l’implémentation qui peut en être réalisée et ses intérêts. 

Retour d’expérience sur l’optimisation de performance de la stack Symfony par Bastien JAILLOT

Un retour d’expérience très concret nous est présenté ici :  un projet Symfony « classique » avec Api, Doctrine, configuration en YAML. Il tourne sur Docker mais subit de gros ralentissements au fur et à mesure de son développement. Quelle est la méthodologie à adopter afin d’y remédier ?

Bastien Jaillot nous décrit pas à pas comment il a mis en place des outils d’aide à la recherche d’améliorations (BlackFire notamment). Il détaille également son plongeon dans le ventre de Symfony pour le rendre plus performant, au travers de nombreuses Pull-Requests.

Le frontend pragmatique pour les développeurs backend par Titouan GALOPIN

Une conférence axée sur une question fondamentale, surtout pour un développeur Back-end : Pourquoi le front-end ? Et surtout pourquoi toujours le complexifier ?

Une réponse est apportée au travers de constats historiques.   Depuis le début, le frontend veut d’abord aider l’utilisateur à interagir avec une page web, et essaie en même temps de se standardiser (notamment par le W3C). 

Il nous propose ici une voie intermédiaire entre une single page App et du No.JS. Un entre-deux pragmatique qui contiendrait du javascript basique, avec du HTML. Il y aurait également quelques bouts de React / VueJs, là où ils pourraient apporter un réel gain. Le maître mot étant de rester le plus simple possible, et de ne pas complexifier l’application outre mesure.

WebAuthn – Technologie et intégration dans un projet Symfony par Stefan RICHTER

« Webauthn is a unicorn, it decreases user friction and increases security » , Nick Steele. 

Encore une fois, l’idée est que nous pouvons tous ensemble participer à l’amélioration de la sécurité du web. Cette fois en utilisant WebAuthn. Cela consiste à gérer l’authentification d’un utilisateur via une signature digitale, à l’aide d’une clé dite asymétrique. Cette clé est associée à plusieurs authenticators possibles, via roaming (un jeton usb) ou une plateforme (un lecteur d’empreintes digitales). Stefan Richter nous présente son implémentation à la fois en Javascript et côté back. Il expose également les bundles déjà disponibles pour le faire (madwizard/webauthn-bundle, web-auth/webauthn-symfony-bundle ).

Cette technologie est encore très nouvelle et n’est pas encore utilisée sur beaucoup de sites. Mais elle permet de s’extraire des problématiques liées au mot de passe et à son stockage. Plus d’informations sur https://webauthn.guide.

HYPERmedia : tirer parti d’HTTP/2 pour créer des API mieux conçues et plus rapides, par Kévin Dunglas

Le problème d’architecture traité ici est celui des performances en termes d’échanges de données. Comment échanger des données qui ont déjà été présélectionnées, et qui correspondent exactement à ce que le client attend ? Comment ne pas envoyer la moitié de notre BDD pour une donnée d’un objet (over-fetching) ? A contrario, comment éviter d’en envoyer trop peu et de devoir alors lancer x requêtes avant de pouvoir afficher sa page (under-fetching) ?

Ces problématiques, auxquelles GraphQl a essayé tant bien que mal d’apporter des réponses, ont été en partie résolues par HTTP/2+. C’est un protocole d’échanges conçu pour améliorer les performances des applications web et des APIs, notamment via la technologie de server push. Il peut être associé à Vulcain, qui est une convention réseau pour les APIs web. Elle permet via la mise à disposition de 2 en-têtes de sélectionner très finement les données à envoyer et leur format. 

Tout cela sera intégré dans un futur proche à Caddy Server, pour un déploiement simplifié et intégré avec Symfony.

Cette nouvelle édition du Symfony Live s’est ainsi très bien déroulée, malgré des conditions sanitaires compliquées. Grâces à des aménagements adaptés, la communauté a pu se retrouver malgré tout.

Hâte d’être à l’année prochaine !

Les slides des conférences sont déjà disponibles pour la plupart à cette adresse : https://github.com/SymfonyLive/paris-2020-talks