6 ms·
Why can't you split up your code into libraries? API doesn't have to mean "HTTP API", you're free to pick a different IPC layer.
by StavrosK 10y ago
Why can't you split up your code into libraries? API doesn't have to mean "HTTP API", you're free to pick a different IPC layer.
- eej71 10y agoI think the popular counterpoint has been - microservices _forces_ consideration of a good API because you are now on the network even if its just localhost.
- falcolas 10y agoI'd counter that they also force a lot of additional networked API boilerplate, and all new code is a potential source of bugs. Perhaps it's better to break it into libraries with well defined APIs, and then break those libraries out into services when necessary. Jumping straight to the latter is going to create more room for problems than it solves.
- dsmithatx 10y agoWell we are rebuilding from scratch into micro services as we have the man power and money to do it. Why not just go with libraries? Here are the top five reasons off of the top my head. The current monolith is requires vagrant and doesn't mimick production nearly as well as smaller containers. This design will be easier to understand and with dev turnover that means bringing new devs up to speed faster. This is especially important when working with outside development firms which we do. Deployments and scaling will be much faster. If one endpoint goes down it wont affect others. We are working to ensure one endpoint is not dependent on another. When change is required in a certain part of the application, only the related service can be modified and redeployed. No long-term commitment to a single technology stack
- tekklloneer 10y agoThis is like looking into a mirror.
- acdha 10y agoThat sounds like most of the benefits you're describing simply due to redesigning the system with the benefit of experience and the much deeper knowledge about the problem which you learned building it the first time. Almost every point on your list could be restated in the opposite direction: > The current monolith is requires vagrant and doesn't mimick production nearly as well as smaller containers. The decision to require use has nothing to do with microservice/monolith and you'd get the same consistency benefits if you deployed a large single application in a container as well, plus you'd have the added simplicity and debugging benefits from not needing to run additional applications for things like orchestration or service discovery. > This design will be easier to understand and with dev turnover that means bringing new devs up to speed faster. This is especially important when working with outside development firms which we do. Easier to understand is an aesthetic choice but it generally means things like a clean design, organization, good documentation, etc. which can be done in a monolith as well. Smaller services can encourage that but they don't necessarily – I've seen plenty of gnarly interdependencies and under-documented schemas – and they have a hard up-front cost that now all of your new developers will need to be able to start, reload, and debug many separate services and understand any interdependencies. If your culture and tooling can manage that well, it almost certainly could maintain a clean larger codebase following the same principles. > Deployments and scaling will be much faster. If one endpoint goes down it won't affect others. We are working to ensure one endpoint is not dependent on another. This is certainly the appeal but many places find that the scaling benefits are less than predicted because the business logic requires things which are harder than expected to separate or scale independently, and there's a cost to separation if that means that you're now forced to implement something like distributed transactions or locking on top of your own custom services. Again, I think a team with the experience and support which can do this well in one model is also likely to have similar results with the other. > When change is required in a certain part of the application, only the related service can be modified and redeployed. If you have a well-defined automated deployment process, this is a relatively minor benefit in either case. Assuming you weren't just running a single instance of the previous app, you need a way to handle things like blue-green deployment, managing schema updates, etc. no matter which design philosophy you pick. > No long-term commitment to a single technology stack This is one of the strongest arguments, but there is also a cost involved to having to learn and support multiple stacks. Again, I think that's more a function of culture and resources — I've seen places which were too conservative until they couldn't find developers at any price as well as places which had severe “Oooh, shiny” problems where every module was written in the latest thing the "lead" developer had seen that week. Again, I'm not saying one approach is right or wrong but rather that it's too narrow a view to look at one practice in isolation. The microservice idea has been around for decades but it hasn't become universal because quality of implementation matters a lot and it's not optimal for all problems — I'm pretty sure the team at Oracle which built the deeply horrible business application I had to support about a decade ago used many of the same arguments to pitch the benefit of their enterprise Java web service architecture, which turned simple database queries into thousands of calls to services on a dozen servers. It's not that the concept was right or wrong but that it wasn't a silver bullet.
- Chyzwar 10y agoBut your networked API is language agnostic, your library is not. It depends but microservices are in many cases better where your application is large. Examples: AWS, Uber. Monolith is better if your application smaller and cover just single problem. Examples: Slack, Trello, Jira
- flukus 10y agoI've also seen them be he source of some awful n+1 bugs where network boundaries were being crossed thousands of times to fetch some relatively simple data. The wall time might be tiny on it's own but it can add up. I've also worked on an app where we removed/combined the api layer into the main web process for an instant 30% performance boost. Crossing the network boundary, serializing, etc was taking up a full third of the wall time that included server side html rendering and database access.
- acdha 10y agoI think those issues are orthogonal: if the environment wouldn't discourage a hasty library API, it seems unlikely that it would discourage a similarly-poor network service. The part I would try to focus on is the culture for things like review and what your threshold is for treating something as a reusable service rather than an internal detail for one app.
- maxxxxx 10y agoI think if you are not capable of designing a decent API you won't be able to design good microservices either. Both require some level of competence and discipline.
- bpicolo 10y agoIf you do that your testing and deployment stacks remain monolithic, running tests / deploying becomes increasingly slower and more expensive. With a lot of developers on a big app and good CI practices a company might spend hundreds/thousands of compute dollars a day just running tests for one monolithic app.
- eropple 10y agoWhy does one imply the other? I regularly build applications out of composable libraries that are wired together with bog-standard dependency injection systems and each separate library handles its own testing and can be kicked off in its own CI process. (I could even add in the boilerplate and performance hit of microservices, if I wanted to--just launch each library with its own thin HTTP layer. But I don't and don't need to.)
- djsumdog 10y agoUnless you have a system to show when all your project have out of date libraries (both local jars that own own and remote dependencies), this can grow to be maintainable. Even with REST enpoints you still often have "client libraries" that need to be updated to take advantage of new functions. If you're not careful with dependencies and coupling, you can get into situations where you can't upgrade a service without touching n other services; and you have to be sure to deploy them in order.
- UK-AL 10y ago"If you're not careful with dependencies and coupling, you can get into situations where you can't upgrade a service without touching n other services; and you have to be sure to deploy them in order. " Why aren't you versioning your api?
- jose_zap 10y agoHow does versioning an API solve the problem of having to deploy interdependent services in the right order? For a change involving two services that need changing, Service A calling Service B, you still need to deploy B before A.
- UK-AL 10y agoBecause you obviously need to add that feature to service b before anyone can use it. This goes for anything in software, libraries, products, APIs etc. Ideally that feature should be developed indepedently by the team looking after that service. It could however be a feature request by another team. Once the feature is ready, you deploy it and then advertise this feature is now available. If it's a breaking change, you version it so it doesn't effect existing services. Then the team for service a can now start integrating that feature into their service. You don't need complicated orchestrated deployments. The time from service/team b advertising that the feature is available, to service a acutally consuming it may be weeks. You just treat the microservices as separate products exposing a API, which operate on different timelines. Other teams may request features, but the team maintaining the service determine the how and the timeline. Obviously higher priority items get developed first.
- rubber_duck 10y agoThe same reason you want to put stuff in to multiple processes: clear boundaries forcing separation and isolation, allowing you to use different technology stacks for different things, letting you limit access/allocate resources to specific parts of the app, etc. I agree with regards to HTTP not being the only IPC layer but it's also the most commonly used and there is so much tooling built around it, everything speaks it - so I would say unless you have a good reason not to you should default to it.
- mikeryan 10y agoWe do both. We have domain based services based on nodejs which tend to be smaller for example a content management service is separate from our notification service which is separate from our user authentication service which is actually provided by a third party (Auth0). In fact being able to use third party services in place of homegrown is one of the big benefits we've found of a microservice architecture. Particularly when creating prototypes and trial apps for clients. The goal is in initial launch we leverage third parties as much as we can then pull back and replace with internal services as we need. But we also have a suite of npm modules which can be shared across the services for common tasks (our ORM models being a primary use case). Maintaining the libs can be a bit of a pain point and making sure we have solid tests is crucial to making sure we don't break other services but it works pretty well.
- danudey 10y agoNot to mention that if you have hard, effectively physical boundaries between services (i.e. completely separate processes in completely separate projects) it makes it easier to scale them independently. For example, when we started out we had a few servers running all of our stuff. When one service grew more, we scaled it out to its own services. Because we used Django's ORM, all of a given service's tables are restricted to a given prefixed schema (e.g. 'systemname_servicename'), which is easy to migrate separately to a new service without risking breaking interconnections ('oh, we have this one query that uses that one table') etc.