The latest argument that we’re having again, is how we should deploy our systems, and we’re asking “micro services” or “monolith”.
Now, I’ll try to skip past what we mean by all of those things (because it’s covered better elsewhere), but in essence, we’re asking “does our software live in 80 repos or 1 repo?”.
TL;DR How about we aim for 8?
What does good deployment/development look like
In an ideal world, we’d have the following properties in our deployment:
- It would have appropriate tests and automation, so deployment is easy and doesn’t feel risky
- The potential impact to a deployment should be predictable, something over shouldn’t impact something over here
- It should be clear where to look to change code
Problems with Micro-services
- If you go properly granular, it can be difficult to know which repo code resides in – if you pick up a ticket, you should need to spend 15 minutes to identify where that codes live
- Deployment of related services may need to be coordinated more closely than you’d like, ensuring that downstream components are ready to accept any new messages/API calls when they arrive
- Setting up deployment for each new component can be time-consuming (Although with things like CDK/Terraform etc, it should be possible to template much of this to a config file for the deployment system)
Problems with Monoliths
- Code can potentially leak into production more easily – requiring more robust feature-flagging to hide non-live code. While this is good practice, it becomes a requirement in larger repos – you can avoid this by ‘dev’ deployments not being in trunk, but that’s a different kind of deployment complexity
- Spinning up another instance of “the system” for testing of a single component may be more expensive and fiddlier than duplicating an individual component
- The impact of a deployment may not be known, you may need to assess if other commits included in what you’re putting live could break things, this may increase deployment friction
How about Service Cluster Deployments
In a prior engagement, we built what was really a task management system.
- Messages would arrive which could potentially make new tasks for the system, or update existing tasks: these were handled by the
task-viewerwould access the database of tasks, cross reference with other services, and create a unified view of the task list
- An automation component would use the output of of
task-viewerto initiate actions to resolve the tasks, which would ultimately result in more messages arriving, which then updated the task database
In our deployment, these components were all in 3 different projects, the micro service model. And it worked, but is also an example of where these 3 components could be combined into one functional service repo.
This makes sense to me because the 3 services are closely coupled, especially between the
task-creator-and-updater and the
task-viewer. So maybe they could have been in a combined repo
With this setup I could still feel safe doing a deployment on a Friday afternoon to one component, because even if the task management system failed entirely, the manual processes were in place to allow recovery until the system could be rolled back.
Meanwhile another one of our components, the cost of a failed deployment was so high, and even if it was recovered the time-critical nature, meant we only deployed during ‘off-peak’ periods of the week. Could it have been made more robust? Probably, but it was also a relatively static system – that effort was better spent on other components that were more ‘active’.
Your deployment should work for your team. It should be based on templated conventions that allow easy configuration of new deployments, and it should be as granular as makes sense.
Instead of worrying about being “truly micro-services” or “fire & forget monolith” find the smallest number of functional groups to keep your code in. That way you can have scope-limited deployments, without having hundreds of repos.
just-name-your-repos-like-this, it’s funny at first giving things amusing names, but honestly,
kitchen-cooking-oven is far more supportable than
the-name-of-a-dragon because it gets really hot.