{"id":13370,"date":"2018-05-14T15:26:50","date_gmt":"2018-05-14T13:26:50","guid":{"rendered":"https:\/\/touk.pl\/blog\/?p=13370"},"modified":"2022-08-02T13:07:02","modified_gmt":"2022-08-02T11:07:02","slug":"when-distributed-monolith-may-work-for-you","status":"publish","type":"post","link":"https:\/\/touk.pl\/blog\/2018\/05\/14\/when-distributed-monolith-may-work-for-you\/","title":{"rendered":"When distributed monolith may work for you"},"content":{"rendered":"

The Distributed Monolith term surely has a bad press. When you read through blogs and conference talks I\u2019m sure you\u2019d better build a \u201ctraditional\u201d monolith rather that a distributed one. If you go with the latter, it means you tried to build microservices but you failed. And now your life is sad and full of pain ;) In this post I\u2019d like to describe our case, when we built something like distributed monolith intentionally, with quite a pleasant final experience.<\/p>\n

In my opinion the key to microservices is in the Conway\u2019s Law<\/strong>. Looking from that perspective you\u2019d think that primary use-case for microservices is large organizations<\/strong> with in-house IT department<\/strong> with many small teams<\/strong>, working independently<\/strong>, with large control<\/strong> over their part ot the system. But this doesn\u2019t cover the full spectrum of software development market ;)<\/p>\n

When you are a software house you deal with various type of projects. This includes maintenance, rewrite part of a large system and – last but not least – developing new systems from scratch. But the development process is much different than in-house IT: we use small, versatile teams (up to 10 people), not tight stick to roles like webdev, tester (developers, not programmers). There are no two identical projects for us: every customer has its own needs, tools, infrastructure, procedures, etc. (see http:\/\/ericsink.com\/No_Programmers.html<\/a>)<\/p>\n

If you plan your system architecture you often try to do some checklist that can help you make the best choice<\/a>. I think the most interesting question from it is:<\/p>\n

Is there a part of the system that a single person, or small team, operates independently inside of?<\/p><\/blockquote>\n

The usual response for a software house is \u201cHmm\u2026 No\u201d<\/em>. So are we forced to always build monoliths?<\/p>\n

The good parts of monolith<\/h1>\n

Let\u2019s think first what could be the good parts of monolithic architecture, especially for a small team inside a software house:<\/p>\n

Simple communication model<\/h3>\n

When you want to deliver fast, you have to reduce overhead. If your customer ask for a feature, telling him that you first have to investigate how to make your microservices talk to each other could be not acceptable. Also, having less service-to-service communication, makes monitoring and debugging in production a lot easier. It\u2019s different when you build a large microservice stack for a big organization – you surely convinced business owners that you need some time to invest in tools and infrastructure and they have to wait for it to be done before features arrive ;)<\/p>\n

Single repository<\/h3>\n

At software houses, we usually have a lot of freedom choosing CI\/CD tooling, some team go with full-stack Gitlab, some prefer Gerrit + Jenkins, some work on customer\u2019s infrastructure. We don\u2019t have repeatable, complicated build pipeline for every project – usually just running tests, make some static code analysis (with Sputnik), sometimes push Docker images somewhere. It\u2019s just easy to have just one repository, not having to setup multiple independently.<\/p>\n

Single data source<\/h3>\n

This is also not constant across projects, but most of them need just one data source, possibly just RDBMS (Postgres) to store business data. It\u2019s easy to administer, manage, migrate. If you want a bit less coupling between parts of the system, separate database schemas for a start could be enough.<\/p>\n

Simple deployment infrastructure<\/h3>\n

Just like above, from deployment perspective, the simplest – the better. Your customer doesn\u2019t want you to spend 3 weeks setting up a Kubernetes cluster. If you can go with plain Docker without dedicated orchestration – go with it. For us – AWS ECS<\/a> with some home-made automation worked really fine.<\/p>\n

The good parts of microservices<\/h1>\n

On the other hand, while building monolith may have many good parts, it can also be really painful. I think that there are numerous advantages you\u2019ll get from splitting the whole system into few smaller parts. The key is having multiple deployment units, which really gives you benefits:<\/p>\n

Resource separation<\/h2>\n

Bugs happen. It is obvious that your system will someday fail on production. The real question is what happens then? How your system deals with errors? If you use shared resources like database or http client connection pools, one, even not critical part of your system, may cause a full system outage. That\u2019s why splitting your system into few smaller applications matters. You (and your customers) can probably live even if one of the minor functionalities fails.<\/p>\n

Independent scaling<\/h2>\n

It is also good when your system can scale. It\u2019s better when you can scale parts of your system independently. Some of features are massively used and business critical – and you want to run them in high-available mode with possibility to add instances on the fly when traffic increases. But also you have some other parts (e.g. backoffice) that is not heavily used with often zero traffic after working hours. With multiple applications instead of monolith it\u2019s easier to achieve independent scaling.<\/p>\n

Network separation<\/h2>\n

Usually parts of a big system are used from different places. You have some public services (e.g. mailing service), othen with both sides communication (with webhooks). On the other hand – a back-office part shouldn\u2019t be exposed publicly, best hidden in a VPN to a customer\u2019s office. Having these parts separated makes it easier to put them in different networks and then setup a particular policy of each part.<\/p>\n

Separate configuration<\/h2>\n

Defining proper authentication configuration for Java (even in Spring) app could be hard. I guess that defining multiple authentication models (e.g. logged users, internal features for call-center people and public service calls) for different parts of a monolithic application could be a hell. Splitting a monolith into several deployment units, each with separate authentication configuration, may save you many hours of debugging magical untestable code provided by your framework.<\/p>\n

Technology experiments<\/h2>\n

It\u2019s really bad for a project if you\u2019re stick to a legacy technology. Having thousands of lines written in 90\u2019s Javascript framework could be really demotivating for developers. When you have few smaller deployment units, it\u2019s much easier to play with technology experiments. You can either write the whole small part in some crazy technology (we use Elm for a small frontend piece) or try to upgrade some important library just in one place (we switched to 4.x Redux router in smaller application before upgrading the bigger one).<\/p>\n

Taking best from two worlds<\/h1>\n

In our case, we think that we took the best from two approaches. We had small team (in peak 8 people), working on a single Git repository<\/strong>. We delivered 10 separate applications<\/strong>, all using the same datasource<\/strong> (Postgres). We used Kotlin + Spring Boot<\/strong> on backend, and React<\/strong> for frontend. We used Gradle modules<\/strong> to split the backend code into reusable parts, and Spring Boot apps just picked the needed pieces.<\/p>\n

\"\"<\/p>\n

We packed the apps into Dockers<\/strong>, built with Gitlab CI pipelines<\/strong> and used Amazon ECS<\/strong> for container orchestration (with a small API gateway based on Nginx and Consul<\/strong>).<\/p>\n

\"\" There was no inter-process (HTTP etc.) communication between the apps – we just used modules API<\/strong> for synchronous calls (mostly queries) and Quartz tasks<\/strong> for asynchronous commands. We also had ELK stack<\/strong> for logging and tracing.<\/p>\n

To be honest, we were 90% happy. The remaining 10% of things that didn\u2019t work well included:<\/p>\n

    \n
  • many small modules – we had some performance problems with Intellij at the beginning with indexing all the small modules<\/li>\n
  • cyclic dependencies – sometimes we discovered cycling dependencies between these modules; on the other hand – it helped us to remove some flaws from our design<\/li>\n
  • tight coupling – our apps were designed by API (consumer) perspective, rather than clean DDD, bounded context thinking; but separate modules could help with this – e.g. a new delivery system was developed as separate part, with its own database schema<\/li>\n
  • \u201call-at-once\u201d deployment – and yes, having just 1 database, we often had to deploy multiple applications at once.<\/li>\n<\/ul>\n

    Having said that, I think that we managed a good balance between two worlds. We didn\u2019t struggle with massive infrastructure and tooling, working with different repositories and data sources. We were able to go as fast as we built a single-repository monolith application. But we had some parts separated, with their own configuration\/boilerplate, ready to be deployed and scaled independently.<\/p>\n","protected":false},"excerpt":{"rendered":"The Distributed Monolith term surely has a bad press. When you read through blogs and conference talks I\u2019m…\n","protected":false},"author":5,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11],"tags":[637,549,556,537],"class_list":{"0":"post-13370","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-development-design","7":"tag-architecture","8":"tag-docker","9":"tag-kotlin","10":"tag-shell"},"_links":{"self":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/13370","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/comments?post=13370"}],"version-history":[{"count":14,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/13370\/revisions"}],"predecessor-version":[{"id":14838,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/13370\/revisions\/14838"}],"wp:attachment":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/media?parent=13370"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/categories?post=13370"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/tags?post=13370"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}