DEV Community: Rahimie Ahmad

Morphing a monolithic app to microservices oriented with Exedra

Rahimie Ahmad — Tue, 15 Oct 2019 11:16:39 +0000

What is exedra

In short exedra is a PHP microframework that focuses on nested URI routing.

So down into the business

One of the hardest thing about going for a future-proof development is, you ain't gonna know at first how far the current design of your app can go, and how big your product can be in the future. Often you begin with something simple, and deep inside you want this the development/product to scale with ease at one point.

So first, let's visualize some app with this kind of routing.

GET   /
GET   /about-us
GET   /contact-us
GET   /careers
GET   /apis/users
POST  /apis/users
GET   /apis/users/:id
PATCH /apis/users/:id
GET   /apis/products
POST  /apis/products
GET   /apis/products/:id
PATCH /apis/products/:id
GET   /images/users/:id/avatar
GET   /images/products/:id

Now you have a simple app that serve some frontend page, have some user and products APIs, and some images processing routing. So it's all served/hosted through a single service let's say www.nexty.app.

So you have something like this with exedra :

$app->provider->add(RoutellerProvider::class);

$app->map['web']->any('/')->group(WebController::class);
$app->map['apis']->any('/apis')->group(ApisController::class);
$app->map['images']->any('/images')->group(ImagesController::class);

Many moons later. Your app grows to hundred of routes. It serves hundred of thousands of requests a day. And you realized it's bottlenecked by this single monolithic webservice. Yes, you can scale this service horizontally by increasing the cpu power and memory, but deep inside you know you want something much better. You want to break this big fat monolithic service.

You want break it into something like:

www.nexty.app to serve the frontend only
apis.nexty.app to serve the APIs
images.nexty.app to serve processed images alone

You want to break it fast without breaking your code.

You don't want to have different repos for difference services altogether, and a lot of people think that monorepo and monolithic are mutually the same. They think you need to break your repo, your development and everything you once knew into the services you want to have, and that includes breaking a shared codes/model that once depends on each other. Now you have one major problem.

But all you want is a multi-services that just work without breaking everything.

With Exedra, you can do it through a domain based routing through a complete URI.

$app->map['web']->uri('https://www.nexty.app')->group(WebController::class);
$app->map['apis']->uri('https://apis.nexty.app')->group(ApisController::class);
$app->map['images']->uri('https://images.nexty.app')->group(ImagesController::class);

Make sure you provide along with the URI scheme (http/https) so it recognizes the host information of the URI.

But at the same time, you don't want to complicate your local/dev environment. So how would you do this with exedra?

You can externalize the URIs through your environment variables.

// assuming that the `env` values is loaded from dotenv if we're using dotenv
$env = $app->config->get('env');

$app->map['web']->uri($env['WEB_URL'])->group(WebController::class);
$app->map['apis']->uri($env['APIS_URL'])->group(ApisController::class);
$app->map['images']->uri($env['IMAGES_URL'])->group(ImagesController::class);

Without complete URI (without scheme, and port number), it'll not register the host information. For example if you give it 'localhost' alone, it'll register as /localhost path instead. It utilizes the parse_url php function.

So you'll have some .ENV config like below for your development (assuming that you use dotenv)

WEB_URL=/
APIS_URL=/apis
IMAGES_URL=/images

So, that's it with Exedra! Then all you need to do is to have a config server and some proper deployment pipeline configured maybe. I am not sure, maybe you can share with me your solution on environment config deployment for microservices. ;)

I am not sure how other modern frameworks do this, maybe you can share with me if it's also possible to do a domain based routing without going through some URI rewrite.

Until then, thank you!

SRP violation in MVC

Rahimie Ahmad — Mon, 07 Oct 2019 06:25:20 +0000

How does it not concern anyone on how often the Controller in MV(C) violates the SRP in (S)OLID principle. They're often written as a bag of actions/handlers but the more people tried to make it seems like a real functioning object, (with dependency injection etc) the less sense it makes about this wholly accepted concept.

Exedra - Nested Routing PHP microframework

Rahimie Ahmad — Tue, 25 Jun 2019 08:48:44 +0000

Introduction

A PHP microframework with focus to do nested/grouped routing while being able to attach a middleware contextually. Nest level is infinite.

Imagine having uris like :

GET    /apis/users
POST   /apis/users
GET    /apis/users/:user-id
PATCH  /apis/users/:user-id
GET    /apis/users/:user-id/friends
DELETE /apis/users/:user-id/friends/:friend-id

In this case you would do something like

use Exedra\Routing\Group;
use Exedra\Runtime\Context;

require_once __DIR__ .'/vendor/autoload.php';

$app = new \Exedra\Application(__DIR__);

$app->map['apis']->any('/apis')->group(function(Group $apis) {
  $apis['users']->any('/users')->group(function(Group $users) {
    $users['list']->get('/')->execute(function(Context $context){});
    $users['add']->post('/')->execute(function(){});
    $users['user']->any('/:user-id')->group(function(Group $user) {
      $user['get']->get('/')->execute(function(){});
        $user['update']->patch('/')->execute(function(){});
        $user['friends']->group(function(Group $friends) {
          $friends['list']->get('/')->execute(function(){});
          $friends['delete']->delete('/:friend-id')->execute(function(){});
        });
      });
  });
});

And running a symfony console command will give you something like

Showing list of routes :
+--------------------------------+--------+-----+---------------------------------+
| name                           | method | tag | uri                             |
+--------------------------------+--------+-----+---------------------------------+
| apis.users.list                | get    |     | /apis/users                     |
| apis.users.add                 | post   |     | /apis/users                     |
| apis.users.user.get            | get    |     | /apis/users/:user-id            |
| apis.users.user.update         | patch  |     | /apis/users/:user-id            |
| apis.users.user.friends.list   | get    |     | /apis/users/:user-id            |
| apis.users.user.friends.delete | delete |     | /apis/users/:user-id/:friend-id |
+--------------------------------+--------+-----+---------------------------------+

The raw sample might look complicated as it goes deeper. In this case you might want to use a class based routing controller as the group pattern. Related docs

Documentation

Head over to http://exedra.rosengate.com or http://github.com/rosengate/exedra-web if the site is dead one day

Why another framework

I just need a router that can do a very nested routing. So, I wrote one back in 2016, yet haven't really released as 1.0.0 (now at 0.9.4) and never really to public. Been using in number of personal projects before, but it's been 4 years, I think I just wanna be done and complete it for good. Since it's a microframework, it wouldn't need much components as there're tons of other great packages out there, not mentioning Symfony packages.

The basic component it has currently is php session, annotation based routing controller, path, url factory and some other things I might have forgot.

Why nested routing

Separating concerns primarily. Imagine having 200 routes for your app, and everything happened in a flat registry, maintaining them would be quite a nightmare. Another thing about having a dedicated group of routing is, that you can attach some sort of middleware (or authentication layer) for a group anonymously.

And secondly, a lot of framework/microframeworks out there maps their route to action/controller explicitly, and to me managing both routing and controller/actions class separately introduces cognitive burden as the routing grows bigger. So I build a annotation based routing controller dedicated to handle both routing and action in the same place.

Thank you

I am planning to release it as 1.0.0 once and for all once I've done some unit tests on routing controller later.

Any feedback is welcome. Thank you.