Presentation sur une implementation de CQRS et event sourcing lors de la devconMRU

1. Zehreen Soogun / zehreen@extension-interactive.com
Jihad Sahebdin / jihad@extension-interactive.com
S y m f o n y 3
31/03/2017
C Q R S e t E v e n t s o u r c i n g

2. 2
Who Am I
SOOGUN Bibi Zehreen
¬ Chef de Projet Technique
¬ Extension Interactive
Je suis #Zehreen
Find me on :-
https://twitter.com/bzehreens
https://mu.linkedin.com/in/bibi-zehreen-soogun-53115190

3. 3
Speakers / Présentation intervenants
Zehreen
¬ CQRS
¬ ES
Jihad
¬ Cas réel
¬ MEP CQRS et ES dans un projet SF 3.

4. 4
1. CQRS
1. Introduction
2. Avantages
3. Désavantages
4. Utilisation
2. Event Sourcing
3. Architecture
4. Conclusions

5. 5
CQRS / Introduction
Command
Query
Responsibility
Segregation
Pioneer de CQRS
¬ Greg Young
Origine de CQRS
¬ Bertrand Meyer - CQS

6. 6
CQRS / Command
Contexte boutique : Je valide ma commande
Contexte Symfony : Je lance une commande via console
¬ php bin/console c:c

7. 7
CQRS / Command
Nom d’une tâche
¬ Temps impératif
Données requises pour effectuer la tâche
a.k.a
¬ Mutators
¬ Modifiers
Contrast avec CRUD
¬ Point de données
openCustomerAccountCommand

8. 8
CQRS / Query
Types de requêtes classiques
¬ Insert
¬ Select
¬ Update
¬ Delete
ReadOnly
¬ Récupération des données
Constraste avec CRUD
¬ TOUTES les opérations VS Lecture seule

9. 9
CQRS & CQS
Similarités
¬ Utilisation commandes (modification) et requêtes (récupération)
 Différence
¬ Write Model
¬ Read Model

10. 10
CQRS / Avantages
Performance
¬ Plus de lecture que d’écriture
Evolution

11. 11
CQRS / Désavantages
Complexité
Réduction de productivité

12. 12
CQRS / Utilisation
Environnement collaborative
Données en simultanés
Applications haute performance
Système complèxe
¬ Bounded Context
BankSystem
Pas nécessaire d’appliquer CQRS dans
l’intégralité d’un système

13. 13
CQRS / A éviter
Système simple
Système statique
Système non-collaboratif
Système avec zéro logique métier

14. 14
CQRS / Faire notre choix
Découpler Read et Write / Coûteux
Réfléchir en terme de DDD et non CRUD

15. 15
1. CQRS
1. Introduction
2. Avantages
3. Désavantages
4. Utilisation
2. Event Sourcing
3. Architecture
4. Conclusions

16. 16
Event Sourcing
Evènements
¬ a.k.a Domain Event
CustomerAccountOpened
Pas de suppréssion

17. 17
CQRS + Event Sourcing

18. 18
1. Architecture
1. Aperçu
2. Mise en place
3. Bonnes pratiques
4. Sécurité
5. CORS

19. 19
Aperçu
Application de type API/UI
Enregistrement dans 2 bases de données
¬ Write model
¬ Read model
La UI envoie des requêtes sur l’API et récupère les
données depuis Firebase
UI
API Firebase

20. 20
Le Domain Model
Système de gestion:
Une business unit emploie des salaries qui vont travailler
sur des contrats liés à des clients
Business Units
Salariés Contrats
Clients

21. 21
1. Architecture
1. Aperçu
2. Mise en place
3. Bonnes pratiques
4. Sécurité
5. CORS

22. 22
Architecture

23. 23
Bounded context
Le Domain Model s’organise en morceaux
Chaque morceau correspond à:
¬ un métier
¬ Un composant métier
¬ Une problématique métier qu’il propose de solutionner
Morceau = Bounded Context
Exemple:
¬ Un context RH qui s’occupe de gérer les employés
¬ Un context Contrat qui s’occupe de gérer ses clients et ses
ressources

24. 24
Bounded context / Composants autonomes
Un bounded context peut être composé d’un ou de
plusieurs composants autonomes.
Les composants apportent une solution aux
problématiques identifiés dans un bounded context.
Exemple:
¬ On va s’occuper de la gestion des business units dans le
composant Business Units management

25. 25
Bounded context / Composants autonomes
3 bounded contexts:
¬ Business units
¬ Human Resource
¬ Contracts
Business Unit
Human
Resource
Contract

26. 26
Bounded context / Composants autonomes
Fonctionnement
¬ Un composant reçoit des messages en provenance du
MessageBus:
- Soit par l’intermédiaire de ses CommandHandlers s’il s’agit de
commandes
- Soit par l’intermédiaire de ses ProcessManagers s’il s’agit
d’évènements

27. 27
Bounded context / Structure

28. 28
Commands
Commands:
¬ Les ordres données au Domain Model
¬ Sources diverses:
- Application web
- Application mobile
- Ligne de commandes
¬ Format json
¬ Construction d’un objet Command à partir des données
Domain
Model
Application
Web
Application
mobile
Ligne de
commande

29. 29
Commands
Exemple:
¬ La classe HireEmployeeCommand
class HireEmployeeCommand
{
public $employeeId;
public $employerId;
public $employeeFirstName;
public $employeeLastName;
public $employeeCivility;
public $employeeJobTitle;
public $employeeEmail;
public $requestedBy;
}

30. 30
Commands
Controller:
¬ HRManagementController
- hireEmployeeAction
use pathtoCommandingCommandsHireEmployeeCommand;
class HRManagementController extends Controller
{
/**
* @Route("/hire-employee", name="hire_employee")
*/
public function hireEmployeeAction(Request $request)
{
$commandBus = $this->get('command_bus');
$hireEmployeeCommand = new HireEmployeeCommand();
//Populate command data
$commandBus->handle($hireEmployeeCommand);
return new Response("Employee hired");
}
}

31. 31
SimpleBus bundle
http://simplebus.github.io/SymfonyBridge/
Auteur: Matthias Noback
class AppKernel extends Kernel
{
public function registerBundles()
{
$bundles = array(
...
new SimpleBusSymfonyBridgeSimpleBusEventBusBundle()
)
...
}
...
}

32. 32
Command Handlers
HireEmployeeCommandHandler
¬ Handle
Service
hire_employee_command_handler:
class: pathtoCommandingCommandHandlersHireEmployeeCommandHandler
tags:
- {
name: command_handler,
handles: pathtoCommandingCommandsHireEmployeeCommand
}
namespace pathtoCommandingCommandHandlers;
class HireEmployeeCommandHandler
{
public function handle(HireEmployeeCommand $command)
{

33. 33
Command Handlers
Reconstruction de l’agrégat à partir de son historique
Enregistrement des évènements
public function handle(HireEmployeeCommand $command)
{
$employeeId = $command->employeeId;
$history = $this->eventStore->getHistoryFor($employeeId);
$employeeAggregate = employeeAggregate::reconstituteFrom($employeeId, $history);

34. 34
Command Handlers
On passe les données à l’agrégat
$employeeAggregate->hireEmployee(
$command->employeeId,
$command->employerId,
$command->employeeFirstName,
$command->employeeLastName,
$command->employeeCivility,
$command->employeeJobTitle,
$command->employeeEmail,
$command->requestedBy,
$command->requestedOn
);

35. 35
Command Handlers
Enregistrement des évènements
Dispatch de l’évènement
foreach ($events as $event) {
$this->eventBus->handle($event);
}
$events = $this->eventStore->save($employeeAggregate);

36. 36
Agrégats
Contient la logique du Domain model
Validation sémantique des commandes
Reçoit les commandes du MessageBus
Emet un ou plusieurs évènements relatant l’opération
qu’il vient d’executer
¬ employeeHiredEvent

37. 37
Agrégats
Validation des commandes
¬ Un agrégat peut réfuser d’éxécuter une commande
- Exemple:
› Par exemple, si HRManagementAggregate reçoit la commande
HireEmployeeCommand pour une BU donnée, si la BU n’existe pas, il doit
renvoyer une exception
class HRManagementAggregate
{
public function hireEmployee($employeeId, $employerId, $employeeFirstName, $employeeLastName)
{
$this->isBusinessUnitIdValid($employerId);
$this->recordThat(new EmployeeHiredEvent($employeeId, $employerId, $employeeFirstName,
$employeeLastName));
}
private function isBusinessUnitIdValid($businessUnit)
{
if (!$businessUnit instanceof BusinessUnit) {
throw new BusinessUnitIdIsNotValidException('This business Unit is not valid');
}
return;
}
}

38. 38
Domain Events
Domain Events
¬ Les évènements métiers produits par les aggrégats
¬ Exemple:
- L’évènement EmployeeHiredEvent émis par l’agrégat
HRManagementAggregate
namespace pathtoAggregatesDomainEvents;
class EmployeeHiredEvent
{
/**
* @Type("string")
*/
private $employeeId;
public function __construct($employeeId)
{
$this->employeeId = $employeeId;
}
public function getEmployeeId()
{
return $this->employeeId;
}
}

39. 39
Bounded context / Récapitulatif
Récapitulatif:
¬ On a donc réussi à construire une commande à partir d’une
requête venant de l’extérieur
¬ Le command handler s’est chargé de le communiquer à
l’agrégat
¬ L’agrégat valide la commande, l’éxécute et génère un
évènement
¬ L’évènement est stocké dans l’event store puis dispatché a
l’event bus

40. 40
Bounded context / Suite
L’évènement peut alors être:
¬ Propagé dans la UI par le biais des denormalizers
¬ Capté par les process managers.

41. 41
Denormalizers

42. 42
Denormalizers
Problème
¬ Données pas exploitable pour la UI
{
"employee_id":"4731ab33-1db8-4570-bc27-e3f4ec0f4feb",
"employer_id":"123a3256-2345-1243-a231-a123c1567b12",
"employee_first_name":"Jihad",
"employee_last_name":"Sahebdin",
"employee_civility":"M",
"employee_job_title":"Developer",
"employee_email":"jihad@sahebdin.com",
"requested_by":"f54d197b-9647-47f8-bfa6-d3acedd54556",
"requested_on":"20170222 18:40:41 +0400"
}

43. 43
Firebase
https://console.firebase.google.com

44. 44
Firebase
Avantages
¬ L’authentification est gérée ‘in-built’ par Google
¬ Base de données en temps réel
¬ Firebase et Angular JS
¬ Permet de déployer une application (UI) par ligne de commande
- > firebase deploy
Inconvenients
¬ On fait confiance à Google concernant la securité des données

45. 45
Firebase
Utilisation dans symfony
¬ Bundle
- https://github.com/ktamas77/firebase-php
¬ Utilisation
const DEFAULT_URL = 'https://kidsplace.firebaseio.com/';
const DEFAULT_TOKEN = 'MqL0c8tKCtheLSYcygYNtGhU8Z2hULOFs9OKPdEp';
const DEFAULT_PATH = '/firebase/example';
$firebase = new FirebaseFirebaseLib(DEFAULT_URL, DEFAULT_TOKEN);
// --- storing an array ---
$test = array(
"foo" => "bar",
"i_love" => "lamp",
"id" => 42
);
$dateTime = new DateTime();
$firebase->set(DEFAULT_PATH . '/' . $dateTime->format('c'), $test);

46. 46
Firebase
Utilisation dans symfony
¬ Evènement EmployeeHiredEvent
class UpdateEmployeesListDenormalizer
{
public function notify(EmployeeHiredEvent $event)
{
$path = '/users/list/'.$event->getEmployeeId();
$firebase->set($path.'/buId', $event->getEmployerId());
$firebase->set($path.'/id', $event->getEmployeeId());
$firebase->set($path.'/civility', $event->getEmployeeCivility());
$firebase->set($path.'/email', $event->getEmployeeEmail());
$firebase->set($path.'/firstname', $event->getEmployeeFirstName());
$firebase->set($path.'/lastname', $event->getEmployeeLastName());
$firebase->set($path.'/job_title', $event->getEmployeeJobTitle());
}
}

47. 47
Firebase
Utilisation dans symfony
¬ Evènement EmployeeHiredEvent
¬ Service
- Un denormalizer va souscrire à l’évènement
update_employees_list_denormalizer:
class: pathtoDenormalizersUpdateEmployeesListDenormalizer
tags:
- { name: event_subscriber,
subscribes_to: pathtoAggregatesDomainEventsEmployeeHiredEvent,
method: notify }

48. 48
Process Managers
a.k.a Saga
Ecoute des évènements et dispatch de nouvelles
commandes
Utile pour coordonner les actions entre les bounded
contexts
Exemple
¬ HRManagement et BusinessUnitManagement
¬ Combien de salariés possède une BU?
- Informer l’agrégat BU pour qu’il incrémente/décrémente son
nombre de salariés à chaque fois qu’une personne est embauche
pour cette BU.
- Solution: Création d’un service qui souscrit à l’évènement
EmployeeHiredEvent

49. 49
Process Managers
Exemple (suite)
¬ ChangeNumberOfEmployeesInBusinessUnitCommand
¬ AddEmployeeToBusinessUnitSaga
class changeNumberOfEmployeesInBusinessUnitCommand
{
public $businessUnitId;
}
class AddEmployeeToBusinessUnitSaga
{
public function notify(EmployeeHiredEvent $event)
{
$command = new changeNumberOfEmployeesInBusinessUnitCommand();
$command->businessUnitId = $event->getEmployerId();
$this->commandBus->handle($command);
}
}

50. 50
Conclusion
Complexe à mettre en oeuvre
Difficile à faire en CRUD
¬ Opérations de lecture et d’écriture sont dissosiées
¬ Pas de conflits dans le cas où plusieurs utilisateurs mettent à jour
le même objet
¬ Enregistrement des actions et des données sur une entité
¬ Historique des évènements possible
¬ Restauration du read model à partir du write model
+ Restauration à partir d’un évènement
¬ Séparation de l’implementation plus facile

51. 51
1. Architecture
1. Aperçu
2. Mise en place
3. Bonnes pratiques
4. Sécurité
5. CORS

52. 52
Bonnes pratiques
Le nom des méthodes est important
¬ Le nom doit reflécter au maximum l’objectif ce que
l’utilisateur veut faire
¬ Exemple:
- HireEmployeeCommand
- EmployeeHiredEvent
- EmployeeLastNameChanged
- ContractTransferredToOtherDirectorEvent
- RessourceAddedToContractEvent
- AccountUpdated / AccountModified
Les commandes sont au présent, les évènements sont
au passé

53. 53
Bonnes pratiques
Un évènement ne peut/doit pas être modifié
¬ Pas de setters dans les classes Event
Un évènement est idempotent
¬ Exemple:
- FireEmployeeCommand sur une même personne n fois
- L’état de l’agrégat ne changera pas après la première fois
- L’agrégat de contentera d’ignorer la commande (et ne pas
renvoyer d’exception)
Valider les commandes

54. 54
Bonnes pratiques
Les bounded contexts doivent être identifiés dès le
début
¬ Division du problème initial en sous-problèmes (bounded
contexts)
¬ Division des bounded contexts en composants autonomes
Identifier le langage du domain expert
Personne
Employé
(RH)
Ressource
(Contrat)
Collaborateur
(Business Unit)

55. 55
1. Architecture
1. Aperçu
2. Mise en place
3. Bonnes pratiques
4. Sécurité
5. CORS

56. 56
Sécurité
Restriction sur la méthode
¬ Autoriser uniquement les POST
¬ MethodListener
app.method_listener:
class: AppBundleListenerMethodListener
arguments: ['POST']
tags:
- { name: kernel.event_listener,
event: kernel.controller,
method: onKernelController,
}

57. 57
Sécurité
Restriction sur la méthode (suite)
¬ Autoriser uniquement les POST
¬ onKernelController
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
if ($controller[0] instanceof Controller){
$request = $event->getRequest()->getMethod();
if (!in_array($request, $this->method)){
$event->stopPropagation();
throw new MethodNotAllowedHttpException(
array('POST'),
'Method Not Allowed‘
);
}
}
}

58. 58
Sécurité
Authentifier les requêtes grâce aux headers
d’authentificatiom
JWT = Json Web Token
¬ Encodage de la requête et insertion dans le header
¬ Composé de troix parties
- header
- payload
- signature

59. 59
Sécurité / JWT
Header
¬ Type
¬ Algorithme de cryptage
¬ Base64
{
"typ": "JWT",
"alg": "HS256"
}
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

60. 60
Sécurité / JWT
Payload
{
"employee_id":"4731ab33-1db8-4570-bc27-e3f4ec0f4feb",
"employer_id":"123a3256-2345-1243-a231-a123c1567b12",
"employee_first_name":"Jihad",
"employee_last_name":"Sahebdin",
"employee_civility":"M",
"employee_job_title":"Developer",
"employee_email":"jihad@sahebdin.com",
"requested_by":"f54d197b-9647-47f8-bfa6-d3acedd54556",
"requested_on":"20170222 18:40:41 +0400"
}

61. 61
Sécurité / JWT
Signature
¬ Header
¬ Payload
¬ Crypter en HMAC256 avec un secret
var encodedString = base64UrlEncode(header) + "." +
base64UrlEncode(payload);
HMACSHA256(encodedString, 'secret');

62. 62
Sécurité
Côté API
¬ TokenListener
¬ Récupération du header
¬ Décryptage du token
app.token.token_listener:
class: AppBundleListenerTokenListener
arguments: ['@app.token_authenticator']
tags:
- { name: kernel.event_listener, event: kernel.request,
method: onKernelRequest }
$header = $request->headers->get('authorization');
try {
$decoded = JWT::decode($token, $secret, array('HS256'));
}
catch (Exception $e) {
return Response::HTTP_FORBIDDEN;
}

63. 63
Sécurité / Nonce
Nonce = Number used ONCE
Insertion dans la requête pour l’encodage
Vérification de l’unicité du nonce avec les nonces déjà
utilisés

64. 64
Sécurité / UUID
UUID = Universally Unique Identifier
Utilisé comme:
¬ identifiant d’une entité
¬ nonce
Version 4
¬ Génère une uuid aléatoire
¬ 123e4567-e89b-12d3-a456-426655440000

65. 65
1. Architecture
1. Aperçu
2. Mise en place
3. Bonnes pratiques
4. Sécurité
5. CORS

66. 66
Sécurité / CORS
Modification de la request
¬ Dans un event listener: onKernelRequest
public function onKernelRequest(GetResponseEvent $event)
{
$request = $event->getRequest();
if ($request->headers->has("Access-Control-Request-Headers")
&& $request->headers->has("Access-Control-Request-Method"))
{
$response = new Response();
//enable CORS - return the requested methods as allowed
$response->headers->add(
array(
'Access-Control-Allow-Headers' => $request->headers->get("Access-
Control-Request-Headers"),
'Access-Control-Allow-Methods' => $request->headers->get("Access-
Control-Request-Method"),
'Access-Control-Allow-Origin' => '*'));
$event->setResponse($response);
}

67. 67
Un mot sur la UI
Données stockés sur Firebase
¬ Correspondance entre l’arborescence des données et les urls
(pages) de la UI
¬ Utilisation d’un resolve avant le chargement de la page
resolve: {
listEmployees : function(firebaseService) {
return firebaseService.get('/users/list');
},

68. 68
Références
Bundles existants
¬ Broadway
- https://github.com/broadway/broadway
¬ LiteCqrs
- https://github.com/beberlei/litecqrs-php
Auteurs
¬ Gregory Young
- Simple CQRS example: https://github.com/gregoryyoung/m-r
¬ Matthias Noback
- https://php-and-symfony.matthiasnoback.nl/
¬ Benjamin Eberlei
- https://beberlei.de/
¬ Martin Fowler
- https://martinfowler.com/bliki/CQRS.html
¬ Daniel Whittaker
- http://danielwhittaker.me/

69. extension interactive
14, avenue des Lataniers
72238 Quatre Bornes
Merci