Ce guide pratique explique comment créer des microservices hexagonaux performants en PHP avec Symfony et gRPC. Il détaille les avantages de gRPC, comme la communication efficace entre microservices grâce à un format binaire compact et le support de HTTP/2 pour le multiplexage et le streaming bidirectionnel. Le tutoriel couvre l'installation de Symfony avec Docker et Roadrunner, la configuration de Docker Compose, et l'implémentation d'un serveur gRPC avec RoadRunner. Il inclut également des étapes pour créer un projet Symfony, installer les dépendances nécessaires, et configurer un conteneur Docker avec PHP et Roadrunner. Enfin, il montre comment exécuter la première application Symfony via Roadrunner et commencer à implémenter un serveur gRPC.

Cet article explique comment résoudre un problème courant avec les Value Objects en tant qu'identifiants d'entités dans Symfony et Doctrine. L'auteur propose une solution pour éviter la répétition de classes de types DBAL personnalisés en implémentant un type générique DBAL qui supporte ces objets de valeur ID. Le post détaille les étapes pour créer une entité identifiée par un Value Object, résoudre les erreurs de mapping, et enregistrer un type DBAL personnalisé pour gérer ces identifiants de manière efficace.

Cet article explique comment transformer des événements de domaine en webhooks HTTP pour une intégration avec des systèmes externes dans un ERP, en utilisant Symfony. L'auteur décrit l'utilisation d'une interface DomainEvent pour définir des événements, avec un attribut #[TriggerWebhook] pour marquer ceux qui doivent déclencher des webhooks. Les événements sont ensuite traités par un gestionnaire de messages qui envoie les webhooks correspondants, en utilisant les fonctionnalités de Symfony comme les tags de ressources et le composant Webhook. L'article simplifie le processus pour en faciliter la compréhension.

Ce tutoriel explique comment implémenter l'authentification multi-facteurs (MFA) basée sur les mots de passe à usage unique temporels (TOTP) dans Symfony 7, sans utiliser de bundles tiers. Il couvre les principes de fonctionnement du TOTP, la création d'un service TOTP personnalisé, la conception de la base de données pour le 2FA, les flux de configuration et de vérification, ainsi que l'application de l'authentification à deux facteurs basée sur les sessions via des abonnés d'événements. Le tutoriel inclut également la génération de codes QR pour une configuration facile et des composants d'interface utilisateur pour la configuration, la vérification et la désactivation du TOTP. Les prérequis incluent un projet Symfony 7.x avec l'authentification déjà configurée, Doctrine ORM et une compréhension de base de la sécurité Symfony.

Nicolas Jourdan explique comment combiner trois patterns de conception (Specification, Rule et Chain of Responsibility) pour gérer efficacement les règles métier complexes en PHP. L'article détaille d'abord le pattern Specification, qui transforme les conditions métier en objets réutilisables et testables, évitant ainsi les if imbriqués et le code dupliqué. Il présente ensuite une implémentation moderne de ce pattern avec une interface de base et des classes pour les opérations logiques (AND, OR, NOT). Cette approche permet de construire des conditions métier claires et modulaires, facilitant ainsi la maintenance et l'extensibilité du code.

Nicolas Jourdan explique comment créer des commandes personnalisées pour Symfony Console de manière professionnelle avec Symfony 7.4. L'article montre l'évolution des bonnes pratiques en partant d'une approche classique, puis en introduisant les commandes invocables et les attributs d'entrée pour un code plus propre et plus lisible. L'exemple concret d'une commande pour importer des avis clients depuis un fournisseur externe illustre ces améliorations.

Dans cet article, l'équipe de JoliCode décrit comment ils ont migré un petit projet en production de Symfony 7.3 vers la toute récente version 8.0, en passant d’abord par la 7.4 pour corriger l’ensemble des dépréciations : après avoir mis à jour les « recipes » via Symfony Flex, ajusté les dépendances (souvent en forçant les forks des bundles encore non compatibles), modifié les imports d’attributs (ex. @Route → #[Route]) et les appels aux contraintes (remplacement d’arguments de type tableau par des arguments nommés), ils ont finalement basculé sous PHP 8.4 et lancé Symfony 8 avec succès en production. Le bilan est positif : l’opération s’est révélée relativement simple pour un petit code-base — mais JoliCode rappelle que, pour un projet sérieux, rester sur Symfony 7.4 (version LTS) reste un choix plus prudent.

Ce billet explore le concept de Carbon Aware Computing pour réduire l'empreinte carbone des sites web. L'auteur critique le greenwashing courant (badges verts, modes sombres) et propose une approche technique concrète. Il explique comment il utilise les données en temps réel de RTE (Réseau de Transport d'Électricité) pour adapter la consommation énergétique de son site. Un service Symfony, le CarbonAwareService, récupère ces données et gère les cas de défaillance via un mode dégradé. Selon l'intensité carbone du réseau, le site active des modes "Éco" ou "Critique", modifiant subtilement l'interface utilisateur pour informer et adapter la consommation.

JoliMediaBundle est un nouveau bundle Symfony développé par JoliCode pour la gestion des médias dans vos projets. Inspiré par une expérience personnelle avec une image de mauvaise qualité, ce bundle répond à des besoins récurrents comme l'upload, le stockage, l'organisation, la transformation, l'optimisation, la diffusion, la sélection et l'affichage des médias. Il offre des fonctionnalités telles que le glisser-déposer, la sélection multiple, le suivi de l'upload, et une gestion flexible du stockage (local ou cloud). Idéal pour les sites vitrines, les plateformes eCommerce ou les applications métier, JoliMediaBundle simplifie la gestion des contenus multimédias.

L'article explore quatre modèles avancés pour résoudre des défis architecturaux complexes en utilisant Symfony 7.x et PHP 8.x. Il aborde des problèmes tels que la gestion des API lentes, la communication avec de multiples endpoints, la création de logs d'audit et le téléchargement de fichiers volumineux. L'auteur illustre ces concepts avec des exemples pratiques, notamment l'utilisation de Symfony Messenger pour découpler les tâches non critiques des interactions utilisateur, améliorant ainsi l'expérience utilisateur. L'article est une ressource précieuse pour les développeurs cherchant à optimiser leurs applications avec Symfony.

Le Model Context Protocol (MCP) est un standard open-source qui simplifie la connexion des modèles de langage (LLM) à vos applications, comme Symfony et PHP. Il agit comme une interface universelle, permettant à n'importe quelle IA compatible d'accéder à vos données en temps réel via un serveur MCP. Cela élimine la nécessité de coder des intégrations spécifiques pour chaque modèle, réduit le "Glue Code", et transforme les LLM en agents autonomes capables d'exécuter des outils. Le MCP offre également une meilleure sécurité et un contrôle accru sur l'accès aux données. L'architecture client-serveur du MCP définit trois primitives principales : Ressources, Prompts et Outils. Avec des bibliothèques comme symfony/mcp-bundle, l'intégration dans Symfony est simplifiée, permettant d'exposer facilement des services Symfony comme des outils MCP via des attributs PHP.

Ce partage explique comment utiliser Symfony 7 et Mercure pour créer une session live réactive sans WebSocket. L'auteur, Jean-Sébastien Christophe, explore l'intégration de Mercure, un protocole de Server-Sent Events (SSE), pour gérer des états de session en temps réel, comme la présence des utilisateurs, sans nécessiter de requêtes répétées ou de boucles côté client. Il détaille la stack technique utilisée (Symfony 7.3, PHP 8.4, Docker, PostgreSQL, MailCatcher) et les avantages de Mercure pour des applications temps réel, tout en prévoyant une future intégration avec FrankenPHP pour optimiser les performances et la sécurité.

Un bundle Symfony pour utiliser les Google Fonts sans enfreindre le RGPD

Cet article explique comment Symfony utilise la classe ReflectionClass de PHP pour offrir sa flexibilité et son automatisation. Voici les points clés :

• Injection de dépendances : Symfony inspecte les constructeurs des classes via ReflectionClass pour identifier et injecter automatiquement les dépendances typées, sans configuration manuelle.
• Routing et contrôleurs : Grâce à la réflexion, Symfony lit les attributs de route (comme #[Route]) et injecte dynamiquement les arguments des méthodes de contrôleur (ex. : récupération d’une entité depuis la base via le ParamConverter).
• Sérialisation : Le composant Serializer utilise la réflexion pour découvrir les propriétés et leurs types, permettant une conversion automatique entre objets et formats comme JSON/XML.

En résumé, la Reflection API est au cœur de la magie de Symfony, rendant possible l’injection de dépendances, le routage intelligent et la manipulation des données sans configuration statique.

Cet article présente une approche pragmatique pour construire une application SaaS multi-tenant avec Symfony, en utilisant une base de données partagée et une seule codebase pour plusieurs clients (tenants). L’article s’appuie sur l’expérience de l’auteur, qui a développé une plateforme pour des marques de retail, chacune ayant ses propres magasins, utilisateurs et règles d’accès.

Points clés :

• Résolution du tenant : Identification du client actif via la session (back-office) ou le sous-domaine (front-office), stockée dans un service TenantContext accessible partout dans l’application.
• Isolation des données : Toutes les entités liées à un client incluent un brand_id, et les requêtes sont automatiquement filtrées par ce contexte.
• Contrôle d’accès (ACL) : Gestion des fonctionnalités et permissions par client via des listes de contrôle d’accès (ACL) et des voters Symfony, permettant d’activer/désactiver des fonctionnalités par marque.
• Architecture unifiée : Le même TenantContext est utilisé pour le back-office (session) et le front-office (domaine), garantissant une cohérence et une sécurité optimale.

L’article insiste sur la simplicité, la maintenabilité et l’évolutivité de cette solution, idéale pour les SaaS nécessitant une isolation des données sans complexité infrastructurelle.

Cet article explique comment construire un serveur Model Context Protocol (MCP) pour une application Symfony, permettant à des assistants IA comme Claude d’interagir directement avec vos données et fonctionnalités via des requêtes en langage naturel.

Le tutoriel propose un exemple concret : une application de gestion de clients avec Symfony, où l’on ajoute un serveur MCP pour permettre à l’IA de rechercher des clients, consulter leurs commandes, analyser des statistiques, etc. Il détaille les étapes clés : installation du SDK MCP, création de "tools" (outils) en PHP avec des attributs, configuration d’un serveur MCP, et intégration avec Claude Desktop. Le projet utilise une base SQLite avec des entités Customer, Order, OrderItem et Product, et fournit des exemples de requêtes possibles (recherche par nom, ville, top dépensiers, etc.).

Le code source est disponible sur GitHub, et le tutoriel inclut des captures d’écran de l’interface. Une bonne ressource pour les développeurs PHP/Symfony souhaitant connecter leurs applications à des assistants IA via MCP.

Symfony propose AssetMapper, une solution radicalement simple pour gérer les assets (JS, CSS, images) sans recourir à Node.js ou à des outils de build complexes comme Webpack. Basé sur la technologie native des navigateurs importmap, AssetMapper permet d’utiliser directement les imports ES6 dans le navigateur, sans étape de compilation. Il génère automatiquement une balise <script type="importmap"> qui mappe vos dépendances et vos fichiers locaux, et gère le versionnage des assets pour un cache busting efficace. L’installation se fait via Composer, et une simple commande (bin/console importmap:require) suffit pour ajouter une bibliothèque JS, qui est ensuite téléchargée depuis un CDN et stockée localement. En production, une commande (asset-map:compile) copie et versionne les fichiers dans public/assets/, avec option de pré-compression Gzip. Pour la minification, le bundle sensiolabs/minify-bundle s’intègre parfaitement. Résultat : zéro build, zéro npm, et une gestion des assets simplifiée et performante, idéale pour les applications Symfony classiques ou utilisant Hotwire/Stimulus. Une approche minimaliste et efficace pour ceux qui veulent éviter la complexité du frontend moderne.

L’article met en lumière l’impact des attributs PHP 8 sur l’écosystème Symfony, remplaçant progressivement les annotations et le YAML pour une configuration plus moderne et unifiée (routes, sécurité, Doctrine, DTOs). Il souligne aussi des innovations comme les Property Hooks de PHP 8.4 avec Doctrine 3.4, qui simplifient la gestion des getters/setters, ainsi que l’introduction des Live Components et Twig Components, permettant une approche plus réactive et typée du front-end, sans JavaScript. Une évolution majeure pour les développeurs Symfony, vers plus de simplicité et de puissance.

Cet article explique comment résoudre les erreurs CORS liées aux requêtes OPTIONS dans Symfony 7, un problème fréquent lors du développement d'applications modernes avec des architectures microservices ou SPA. L'erreur survient lorsque le navigateur envoie une requête OPTIONS (preflight) pour vérifier si une requête cross-origin est autorisée, mais Symfony ne la gère pas correctement, provoquant une erreur "Access-Control-Allow-Origin".

La solution proposée consiste à créer un Event Subscriber (CorsSubscriber) qui intercepte les requêtes OPTIONS avant qu'elles n'atteignent le routeur. Ce subscriber renvoie une réponse HTTP 200 avec les en-têtes CORS nécessaires (Access-Control-Allow-Origin, Access-Control-Allow-Methods, etc.), empêchant ainsi Symfony de chercher une route inexistante ou de générer une erreur. L'article détaille le code à implémenter, l'importance de la priorité élevée (9999) pour bloquer l'exécution du routeur, et souligne l'utilité de cette approche pour garantir la compatibilité des APIs Symfony avec les applications frontend modernes. Une solution propre, performante et indépendante des routes spécifiques.

L’article de Bohdan Pastukh critique l’approche souvent enseignée par la documentation Symfony, qui pousse vers un Anemic Domain Model : les entités (comme User) se réduisent à des conteneurs de données avec des getters/setters, tandis que la logique métier est déplacée vers des services externes (ex : ContactDataService). L’auteur souligne que cette pratique, bien que courante dans les tutoriels, conduit à un code moins cohésif et moins orienté objet. Il encourage à privilégier les Rich Models, où la logique métier est encapsulée directement dans les entités, pour un design plus robuste et maintenable.

Exemple critiqué :

class User {
    private string $contactType;
    private string $contact;
    public function setContactType(string $contactType): void { ... }
    public function setContact(string $contact): void { ... }
}
class ContactDataService {
    public function changeContactData(string $contactType, string $contact): void { ... }
}

Alternative suggérée : Intégrer la validation et la logique dans l’entité User elle-même.