Implementing reliable PHP-based microservices

@junior_grossi IMPLEMENTING RELIABLE PHP-BASED MICROSERVICES or at least, how they
should be ;-)

@junior_grossi hey, I'm Junior Grossi twitter.com/junior_grossi github.com/jgrossi grossi.dev

@junior_grossi

@junior_grossi https://github.com/corcel/corcel

@junior_grossi PHPMG Conference 2019 21/09/2019 - Belo Horizonte, Brazil https://conf.phpmg.com

@junior_grossi I do love #elephpants https://elephpant.me/herd/junior_grossi

@junior_grossi remote-ﬁrst company php / golang / java / js
https://glofox.com/careers

@junior_grossi / 2004 php / 2016 / 2019 relocated to
Ireland...

@junior_grossi ... to this perfect weather! I live in Galway,
that's a bit worse

@junior_grossi let's talk about microservices

@junior_grossi I WILL BE: sharing what I've learned ~1.5 year
sharing what I'm learning

@junior_grossi Implementing reliable PHP-based microservices

@junior_grossi PART 1 Implementing reliable PHP-based microservices

@junior_grossi microservices? again? 1-minute tutorial

@junior_grossi "microservices" is an architectural style it will not solve
problems you don't have yet! (you may never have those problems)

@junior_grossi what's a monolith?

@junior_grossi

@junior_grossi what's microservice architecture?

@junior_grossi USING MICROSERVICES need clear implementations share implementation issues from
monoliths

@junior_grossi "don't use microservices if you don't need them"

@junior_grossi RELIABILITY communication logging responsibility productivity

@junior_grossi COMMUNICATION sync / HTTP, gRPC async / event-oriented

@junior_grossi SYNC COMMUNICATION

@junior_grossi ASYNC COMMUNICATION Frontend API Gateway Queue Service A Service
B Service C book for a class BOOKING_REQUEST 202 (listening to B_R event) GET /v2/bar {"bar":"123"} BOOKING_CONFIRMED results via websockets if required (listening to B_C event) Send notification

@junior_grossi ASYNC COMMUNICATION a service subscribes to an event use
the data (payload) to do something // event identifier "BOOKING_REQUEST" // event payload { "userId": "1234567890", "classId": "2345", "classStartDate": "20200514T15:19:21+00:00" }

@junior_grossi BUG INVESTIGATION Frontend API Gateway Queue Service A Service
B Service C book for a class BOOKING_REQUEST 202 (listening to B_R event) GET /v2/bar {"bar":"123"} BOOKING_CONFIRMED results via websockets if required (listening to B_C event) Send notification

@junior_grossi DON'T SKIMP ON LOGS log all requests sent and
received log all responses sent and received log all data from ﬁred events log all data from received events log all important decisions "in microservices, logging is like a very close friend."

@junior_grossi

@junior_grossi RESPONSIBILITY each service needs a reason to exists it's
allowed to duplicate code, but not data don't you have some data? ask another service! think twice before synchronizing/copying data

@junior_grossi WHAT TO AVOID: 2 or more services sharing the
same DB (which service changed the data?) partial domain implementations (when you have related logic splitted in 2+ services)

@junior_grossi PRODUCTIVITY avoid the "language soup" (pick 2 or 3
max) you hired Jane. she's good in PHP she starts a new service in Scala she keeps maintaining that service Jane leaves the company you need now PHP + Scala engineers

@junior_grossi PRODUCTIVITY use similar software architecture and patterns easier to
move between projects easier to move between languages easier to maintain easier to integrate "DDD/Clean Architecture" are a perfect ﬁt!

@junior_grossi PRODUCTIVITY share processes along services share Git/VCS conventions/ﬂows docker
conventions share CI/CD practices share deployment processes

@junior_grossi TOPICS software architecture design patterns PHP execution

@junior_grossi SOFTWARE ARCHITECTURE we need something ﬂexible we need something
organized we need quality we need power

@junior_grossi Robert C. Martin "The goal of software architecture is
to minimize the human resources required to build and maintain the required system."

@junior_grossi changing the architecture is very expensive!

@junior_grossi LAYERED ARCHITECTURE "leave options opened" (believe me, they do
change) independent layers independent use cases independent commands

@junior_grossi DOMAIN-DRIVEN DESIGN Implementing Domain-Driven Design Vaughn Vernon

@junior_grossi HEXAGONAL ARCHITECTURE "Hexagonal Architecture - Message-Oriented Software Design" Matthias
Noback - @matthiasnoback https://youtu.be/K1EJBmwg9EQ

@junior_grossi ABOUT YOUR ARCHITECTURE: framework independent (framework-as-a-tool) testable without any
external element UI independent (Web / Console) database independent independent of any external agent

@junior_grossi CLEAN ARCHITECTURE

@junior_grossi Clean Architecture Robert C. Martin (Uncle Bob)

@junior_grossi SCREAMING ARCHITECTURE "the architecture says by itself" what is
your service about? (answer by reading the code!) payments? bookings? authentication? or an app written in Laravel, Slim or Symfony?

@junior_grossi

@junior_grossi https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html

@junior_grossi THE DEPENDENCY RULE "source code dependencies must point only
inward, toward higher-level policies" nothing from "inside" should know anything concrete about "outside".

@junior_grossi ﬁne, but how do I do that? using interfaces/abstractions!

@junior_grossi "code is not reusable. abstractions are." Marco Pivetta (@Ocramius)

@junior_grossi

@junior_grossi USE CASE: CREATE USER Command Handler Pattern (UseCase)

@junior_grossi 1. CONTROLLER ACTION POST /users UsersController::create() (SRP!!!) CreateUserController

@junior_grossi final class CreateUserController { private CreateUserHandler $handler; public function
__construct(CreateUserHandler $handler) { $this>handler = $handler; } public function __invoke(RequestInterface $request): ResponseInterface { $body = json_decode((string) $request>getBody()); $userId = $this>handler>handle( new CreateUserCommand( $body['email'], $body['firstName'], $body['lastName'], $body['password'], ) ); return new JsonResponse(compact('userId'), 201);

@junior_grossi 2. COMMAND class that stores the data to execute
the action (handler). (immutable class!)

@junior_grossi final class CreateUserCommand { private string $email; private string
$firstName; private string $lastName; private string $password; public function __construct( string $email, string $firstName, string $lastName, string $password ) { $this>email = $email; $this>firstName = $firstName; $this>lastName = $lastName; $this>password = $password; } // Getters: getEmail(), getFirstName(), getLastName(), getPassword() }

@junior_grossi 3. HANDLER it's the logic of our use case
receives the data as a Command class

@junior_grossi final class CreateUserHandler implements HandlerInterface { private UserRepositoryInterface $userRepository;
private PasswordEncrypterInterface $passwordEncrypter; public function __construct( UserRepositoryInterface $userRepository, PasswordEncrypterInterface $passwordEncrypter ) { $this>userRepository = $userRepository; $this>passwordEncrypter = $passwordEncrypter; } public function handle(CreateUserCommand $command): Uuid { return $this>userRepository>add( new User( Uuid::uuid4(), $command>getEmail(), $command>getFirstName(), $command>getLastName(), $this>passwordEncrypter>encrypt( $command>getPassword() ),

@junior_grossi "UI independent (web/console)" after creating a new studio create
a new admin user event-oriented (async) running in CLI

@junior_grossi STUDIO_CREATED Command Bus Event A Event B StudioCreatedEvent.php Listener
1 Listener 2 Listener 3 CreateAdminUserListener.php Listener 4

@junior_grossi final class CreateAdminUserListener implements ListenerInterface { private CreateUserHandler $handler;
public function __construct(CreateUserHandler $handler) { $this>handler = $handler; } public function execute(StudioCreatedEvent $event): void { $this>handler>handle( new CreateUserCommand( // use the payload from $event ) ); } }

@junior_grossi PHP EXECUTION leaving the comfort zone

@junior_grossi "NodeJS is better for microservices"

@junior_grossi Coroutine based Async PHP programming framework Build high-performance, scalable,
concurrent TCP, UDP, Unix Socket, HTTP, WebSocket services with PHP and ﬂuent Coroutine API. https://www.swoole.co.uk/

@junior_grossi how PHP naturally works php-fpm / "blocking I/O" CPU
I/O

@junior_grossi how Swoole & Node.js work "non-blocking I/O" / async
CPU I/O

@junior_grossi > pecl install swoole built-in async, coroutine support, multiple
threads I/O modules async/await yield

@junior_grossi

@junior_grossi Master Reactor Reactor Reactor Timer Manager TaskWorker TaskWorker TaskWorker
Worker Worker Worker

@junior_grossi

@junior_grossi Initialisation Execute Task Clean up PHP-FPM Execute Task Swoole

@junior_grossi ADVICE use it for new services only (it's not
a good idea for that legacy API you have)

@junior_grossi COMMON PITFALLS variable scope / DI container (singleton) exception
handling static content

@junior_grossi https://docs.mezzio.dev/mezzio-swoole/ https://github.com/mezzio/mezzio-swoole

@junior_grossi http://roadrunner.dev/

@junior_grossi // install RoadRunner $ make // psrworker.php while ($request
= $psr7>acceptRequest()) { $response = new \Zend\Diactoros\Response(); $response>getBody()>write("hello world"); $psr7>respond($response); } // config file http: address: :8080 workers: command: "php psrworker.php" pool: numWorkers: 4 // run $ ./rr serve v d

@junior_grossi Coroutine Based Concurrency with PHP and Swoole Bruce Dou
| @doubaokun Feb 2020 PHPUK2020 https://speakerdeck.com/doubaokun/coroutine-based-concurrency-with-php-and-swoole

@junior_grossi THANK YOU! search on youtube for "grossi-code" http://twitter.com/junior_grossi http://speakerdeck.com/jgrossi

Implementing reliable PHP-based microservices

Implementing reliable PHP-based microservices

More Decks by Junior Grossi

Other Decks in Programming

Featured

Transcript