4 ms·
a) If the time and complexity to deploy 3,10,100 microservices as opposed to 1 monolith is significant then your build pipeline is flawed. Simple as that. b) M
by threeseed 11y ago
a) If the time and complexity to deploy 3,10,100 microservices as opposed to 1 monolith is significant then your build pipeline is flawed. Simple as that.
b) Maybe the commenter has only worked on small applications but I've worked on enough million line code monstrosities to know that one change can have far reaching consequences. It is simply too easy to couple components together e.g. be reusing a shared utility or service class and your code coverage will always be lacking in some way.
c) Microservices enable far more resiliency and scalability simply because you can deploy more of the ones that are critical or non performant. A sensible service discovery strategy can make this a one button, trivial exercise. Doing so on a complex monolith is often far from trivial.
d) This idea that your entire system goes down if a microservice goes down indicates your architecture is flawed. You should be able to still operate in a degraded state or at least provide some functionality.
e) If you can't test your service independently then your testing strategy is flawed. You should be able to trivially mock/stub out any dependencies and if you can't then you need to rethink your API design and the nature of your coupling.
- zobzu 11y agoThe reality of things is, though, that at many (most?!) companies the pipeline IS indeed flawed BUT must work. In other words for various reasons it's been built flawed. Speed, idiocy, politics, whatever. At some point, you have various choices to pay your technical debt: - actually pay it(50%+- work force full time on this, forever - hey, it works long term, but only short term gains means bonus pay check, and making things square isn't as fun as building new stuff) - patch shit up so it kinda works and hope to leave before it's too horrible (what most do) - dissolve the company/product (eventually happens, almost inevitable over long enough periods of time - specially when people got tired of the shit and rebuilt everything anew - then the cycle starts again) This blog post uses the 2nd solution (the most common).
- coldtea 11y ago>a) If the time and complexity to deploy 3,10,100 microservices as opposed to 1 monolith is significant then your build pipeline is flawed. Simple as that. Hardly. The actual issue is that, since the 3,10,100 microservices are all needed for the core offering, then having 3,10,100 microservices is not any different than 1 well designed monolith. With the exception that you've replaced method calls with REST and what have you, and have all the BS that comes with a distributed system, for few of the benefits.
- dave_ops 11y agoThis is one of the things I love about the Erlang ecosystem (Erlang, Elixir, Lisp-flavored Erlang). Since the whole thing was designed to be an OS unto itself, it has the concept of "Applications" and "Releases" that come from OTP. It's trivially easy to make things properly decoupled by dividing logical functionality into "Applications" and making a game-time call about whether or not they should be bundled in the release and consumed sorta like a library or run on a completely different VM/node and consumed like a service. You're architecturally incentivized to make "microservices", but fully able to couple or decouple them at will while maintaining the same semantics in how you consume them.
- crdoconnor 11y ago>Microservices enable far more resiliency and scalability simply because you can deploy more of the ones that are critical or non performant. You can horizontally scale and set up failovers for non-microservices too. The main difference is that you need fewer load balancers, your architecture is simpler and you have fewer points of failure.