Latest / DevQuestions with Tim Corey / 196 Should I Build a Monolith or Microservices?

Transcript

196 Should I Build a Monolith or Microservices? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_00: Join us each episode as we tackle the questions you are asking about a career in software development, understanding the industry, and new technology.
• 0:12
  SPEAKER_00: If you're just starting out or you want to grow stronger as a developer, this is the place to get your questions answered.
• 0:19
  SPEAKER_00: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:25
  SPEAKER_02: Should I build a monolith or microservices?
• 0:29
  SPEAKER_02: This is a question I get a lot and one that has been a bit of a confusion for a while.
• 0:34
  SPEAKER_02: So I want to address it in today's episode of DevQuestions.
• 0:38
  SPEAKER_02: Now, this comes from the suggestion site.
• 0:41
  SPEAKER_02: So if you have a suggestion, go to suggestions.imtimcorey.com and ask it there.
• 0:46
  SPEAKER_02: Hopefully, you'll see your question answered in a future episode of DevQuestions.
• 0:51
  SPEAKER_02: So normally when you ask me a question, I say it depends.
• 0:57
  SPEAKER_02: And then I explain what I mean.
• 0:59
  SPEAKER_02: In this case, I'm going to give you more of a straight answer.
• 1:03
  SPEAKER_02: The answer, should I build a monolith or microservices, is almost always a monolith.
• 1:11
  SPEAKER_02: Now, for whatever reason, people feel like monoliths are this old technology that we shouldn't use anymore, and microservices are the future.
• 1:20
  SPEAKER_02: And that's just the opposite of true.
• 1:22
  SPEAKER_02: So let's talk about why.
• 1:24
  SPEAKER_02: Why should you choose a monolith over microservices?
• 1:29
  SPEAKER_02: So, number one, microservices have dozens of points of failure.
• 1:36
  SPEAKER_02: Now, the evangelists will say, yes, but they're so resilient we can have backups and all the rest.
• 1:42
  SPEAKER_02: Okay, but how many services do you have to depend on?
• 1:47
  SPEAKER_02: So in a very simple microservice environment, you have a database per microservice.
• 1:55
  SPEAKER_02: And typically it's not all the same type of database, even.
• 1:59
  SPEAKER_02: So now you're depending on, let's just pick a few: CosmosDB and MongoDB and SQL and a SQLite database.
• 2:09
  SPEAKER_02: Now there's four different databases you're depending on and the hosting for those.
• 2:14
  SPEAKER_02: And then you're going to use four different hosting plans or four different hosts for those four different microservices.
• 2:22
  SPEAKER_02: Again, they should be all self-contained.
• 2:24
  SPEAKER_02: You should not share, otherwise, it's not a microservice.
• 2:26
  SPEAKER_02: We'll talk about that later.
• 2:28
  SPEAKER_02: So now you're talking about four different web apps.
• 2:33
  SPEAKER_02: And then you're talking about, well, now you've got to have hosting for those four different web apps.
• 2:38
  SPEAKER_02: And what if they're on different servers?
• 2:41
  SPEAKER_02: And if now the servers are also points of failure.
• 2:45
  SPEAKER_02: And so you start adding up all these different points of failure.
• 2:49
  SPEAKER_02: And then you have your communication system like service bus.
• 2:53
  SPEAKER_02: Well, now you've got to make sure a service bus doesn't go down.
• 2:57
  SPEAKER_02: And then you start thinking through all these other things.
• 2:59
  SPEAKER_02: And if you just even have four microservices, you now have half a dozen to a dozen points of failure compared to if you have a monolith, typically you have one database, you have one web front end or desktop, but usually web front end, and maybe an API.
• 3:27
  SPEAKER_02: For a massive system, it could be a massive system.
• 3:30
  SPEAKER_02: And you say, well, yes, but there's a scalability issue.
• 3:33
  SPEAKER_02: No, there's not, but we'll talk about that in just a minute.
• 3:37
  SPEAKER_02: Number two, so number one, microservices have dozens of points of failure compared to a monolith.
• 3:45
  SPEAKER_02: Number two, microservices add incredible complexity.
• 3:50
  SPEAKER_02: I used to be an IT director, and one of my roles was to oversee all of our networking, all of our firewalls, all of our servers, all of like Active Directory, and all these other things that were all under my purview.
• 4:07
  SPEAKER_02: With microservices, one of the things we've done is create Kubernetes or things like it.
• 4:14
  SPEAKER_02: And now Kubernetes really is that entire server room, the entire networking, the firewalls, all that stuff in text files.
• 4:26
  SPEAKER_02: All that management, all those services you have to know about in order to manage Kubernetes.
• 4:34
  SPEAKER_02: That's not your actual code, that's the infrastructure that you add underneath your code that sits on top of other infrastructure that you also have to manage.
• 4:47
  SPEAKER_02: So the level of complexity is much, much higher.
• 4:51
  SPEAKER_02: As a monolith, if you're hosting on, let's just pretend we're hosting everything on Azure.
• 4:57
  SPEAKER_02: Well, you have to handle Azure SQL, let's say.
• 5:00
  SPEAKER_02: Okay.
• 5:01
  SPEAKER_02: That's one thing to learn.
• 5:03
  SPEAKER_02: You have to know about Azure Web Apps.
• 5:05
  SPEAKER_02: That's two things.
• 5:07
  SPEAKER_02: And you need to know how to use Azure Deploy or GitHub Actions or something similar, Azure DevOps pipelines.
• 5:18
  SPEAKER_02: You have to know those three things in order to manage your application.
• 5:24
  SPEAKER_02: With microservices, that list might be 20 or 30 different things.
• 5:29
  SPEAKER_02: That's an incredible level of complexity.
• 5:33
  SPEAKER_02: Number three, and this is the one that people really don't want to believe me on, but it's absolutely true.
• 5:40
  SPEAKER_02: Most companies don't have the scale to justify.
• 5:46
  SPEAKER_02: So when you're thinking about a microservice solution, you say, well, we need to scale.
• 5:52
  SPEAKER_02: We need to scale.
• 5:53
  SPEAKER_02: How big do you need to scale?
• 5:56
  SPEAKER_02: Because with a monolith, you can handle hundreds of thousands, if not millions, of people.
• 6:05
  SPEAKER_02: Is your business larger than that?
• 6:08
  SPEAKER_02: Almost certainly not.
• 6:10
  SPEAKER_02: Now, there are a few that are, and you could probably still scale the monolith to that point.
• 6:16
  SPEAKER_02: So you need to think about what's the justification?
• 6:20
  SPEAKER_02: What complex, what scale do we need to hit in order to justify the additional complexity and points of failure that microservices brings.
• 6:31
  SPEAKER_02: And you might say, well, Tim, no website can scale that large.
• 6:35
  SPEAKER_02: Absolutely they can.
• 6:37
  SPEAKER_02: We didn't have microservices back in the day, and we scaled just fine.
• 6:40
  SPEAKER_02: That's you know, old Tim talking.
• 6:42
  SPEAKER_02: But part of this is that we're not talking about the ability to do things like having multiple versions of your website, for example.
• 6:54
  SPEAKER_02: You can have that.
• 6:55
  SPEAKER_02: You can have the ability to scale out, meaning having redundant servers or having a round robin system to send to different servers, even around the country, around the globe, in order to load balance your site.
• 7:08
  SPEAKER_02: You can still have that with a monolith.
• 7:11
  SPEAKER_02: So you can scale to very, very large capacities with a monolith.
• 7:17
  SPEAKER_02: You don't have to have a microservice in order to do that.
• 7:21
  SPEAKER_02: And then number four, this is one people don't think about, is most organizations do not have a staff to manage the infrastructure.
• 7:31
  SPEAKER_02: Again, going back to my days of being IT director, I had a network administrator, I had a database administrator, and I had a server administrator working underneath me, and I was understaffed.
• 7:46
  SPEAKER_02: You're talking about typically what happens is that all falls on one person.
• 7:53
  SPEAKER_02: All the things that I did with three people, you're now doing one person, and that's not their full-time job.
• 7:59
  SPEAKER_02: Really, what happens in a lot of companies is they say, we need to do Kubernetes, and so that's part of the developer's job is to also manage Kubernetes.
• 8:09
  SPEAKER_02: So what you're doing is adding the complexity, you're adding the points of failure, you are scaling for no reason, and you're saying we're going to do all of this without adding any people, which means that what you're doing instead is taking away development resources, taking away the time they could spend on new features or making your app better in order to spend it on infrastructure and site management and risk mitigation and all the other stuff that comes with doing infrastructure.
• 8:46
  SPEAKER_02: So you gotta think about those costs as well.
• 8:50
  SPEAKER_02: There's a lot of reasons why microservices are not the right call.
• 8:56
  SPEAKER_02: Now, I get asked the question: what about monoliths that utilize microservices?
• 9:04
  SPEAKER_02: Meaning it's mostly a monolith, but we have some microservices on our monolith.
• 9:09
  SPEAKER_02: And today I say be very careful.
• 9:13
  SPEAKER_02: You do not want a distributed monolith.
• 9:18
  SPEAKER_02: So if you have to deploy your microservices with your monolith, you don't have microservices, you have a distributed monolith.
• 9:28
  SPEAKER_02: If your database schema changes for your monolith and you that affects your microservices, you have a distributed monolith.
• 9:37
  SPEAKER_02: If your microservices share code with your monolith, you have a distributed monolith.
• 9:43
  SPEAKER_02: That's a major problem.
• 9:46
  SPEAKER_02: It makes things worse.
• 9:48
  SPEAKER_02: So but why?
• 9:49
  SPEAKER_02: Why are distributed monoliths so bad?
• 9:51
  SPEAKER_02: Well, number one, they have all the downsides of microservices.
• 9:55
  SPEAKER_02: They have added complexity, they have add points of failure, and so on.
• 10:00
  SPEAKER_02: But they also have all the downsides of monoliths.
• 10:05
  SPEAKER_02: They're harder to deploy because you have to deploy to the entire thing, they're harder to change because it affects everybody, and so on.
• 10:12
  SPEAKER_02: So you're taking on all the downsides of microservices and adding the mic the downsides of monoliths and saying, hey, that's better.
• 10:20
  SPEAKER_02: You don't want to do that.
• 10:21
  SPEAKER_02: Now, there are ways to utilize microservices with a monolith.
• 10:29
  SPEAKER_02: But the way to do it is to make an independent piece.
• 10:34
  SPEAKER_02: So maybe there's a certain area or a certain thing that happens that can be independent that itself needs to scale in a way the rest of your monolith does not.
• 10:47
  SPEAKER_02: So really easy example is a college doing registration.
• 10:53
  SPEAKER_02: Maybe open registration on a certain date.
• 10:56
  SPEAKER_02: Well, that's gonna get slammed with a lot of people applying.
• 11:00
  SPEAKER_02: Because on that certain date, everyone wants to rush to get in on time and rush to be in in line.
• 11:08
  SPEAKER_02: Well, maybe the registration piece could be its own microservice.
• 11:13
  SPEAKER_02: It could have its own database, it could have its own setup, its own deployment schedule, it could have nothing shared with the monolith.
• 11:22
  SPEAKER_02: And then it could scale in a way the rest of the application doesn't have to.
• 11:27
  SPEAKER_02: Because registration page, yeah, it's gonna get hit really hard all at once in a concentrated time frame.
• 11:35
  SPEAKER_02: But the rest of the application is gonna just putter along as normal because we don't have that rush of on this date.
• 11:44
  SPEAKER_02: That could be a use case for a microservice that supports and helps your monolith.
• 11:50
  SPEAKER_02: Because your monolith then wouldn't have to scale as high.
• 11:54
  SPEAKER_02: Your microservice could be a thing that could be scaled up very quickly and to a larger height than the rest of your application, saving you money.
• 12:02
  SPEAKER_02: And if it saves you money and maybe even reduces some complexities while adding others, then it could be worth it.
• 12:11
  SPEAKER_02: Now, the other thing you can do is you can make your monolith more modular, meaning more loosely coupled.
• 12:18
  SPEAKER_02: Maybe it's not one big blob, maybe it's two or three monoliths that again are independent.
• 12:26
  SPEAKER_02: They're more easy to be deployed separately, where you have a little bit more options to not take everyone down when you deploy or not affect everyone, or or so on.
• 12:38
  SPEAKER_02: You can do some looser coupling in order to make life easier there.
• 12:44
  SPEAKER_02: So that's a possibility, but you gotta be very careful not to slip into distributed monolith.
• 12:54
  SPEAKER_02: So the question comes out then, is there ever a time when microservices is the right answer?
• 13:03
  SPEAKER_02: And the answer is yes, but it's rare.
• 13:08
  SPEAKER_02: And you probably aren't the exception.
• 13:11
  SPEAKER_02: I get this a lot where people say, well, is there ever a time?
• 13:14
  SPEAKER_02: And I say, well, yeah, there's there's a time.
• 13:15
  SPEAKER_02: They go, cool, that's me.
• 13:18
  SPEAKER_02: It probably isn't.
• 13:19
  SPEAKER_02: You're not Google.
• 13:21
  SPEAKER_02: So that's why I'd say be very careful taking on microservices.
• 13:25
  SPEAKER_02: If you're already there, you do what you gotta do.
• 13:28
  SPEAKER_02: But really, microservices is not the golden ticket to a better solution.
• 13:35
  SPEAKER_02: Writing better code in a more modular way probably is the better choice there.
• 13:41
  SPEAKER_02: So the bottom line is this microservices sound fun and they can make for some great demos.
• 13:47
  SPEAKER_02: In fact, you may see people who build out awesome demos with microservices.
• 13:53
  SPEAKER_02: And you know what?
• 13:53
  SPEAKER_02: I might even do some microservices type stuff once in a while because there are benefits.
• 13:59
  SPEAKER_02: But be very careful because often what they'll say is here's the benefits, and they'll start talking about an example of who uses it.
• 14:07
  SPEAKER_02: And look who they're talking about.
• 14:09
  SPEAKER_02: They're often talking about multi-million, multi-billion dollar companies.
• 14:14
  SPEAKER_02: They're not talking about, you know, a single website for a single company, or even a company for a hundred thousand people.
• 14:23
  SPEAKER_02: They're talking about massive companies.
• 14:27
  SPEAKER_02: So building monoliths will almost always be the best choice for you.
• 14:32
  SPEAKER_02: You can scale a monolith to hundreds of thousands or even millions of users.
• 14:38
  SPEAKER_02: Often people write poor code and it doesn't scale well.
• 14:43
  SPEAKER_02: And they say, well, see, monoliths don't work.
• 14:45
  SPEAKER_02: I need to have microservices.
• 14:48
  SPEAKER_02: If you write poor code in monoliths, you're gonna write poor code in microservices.
• 14:53
  SPEAKER_02: And you're just gonna pay more money in order to try and get more scale because you wrote poorly optimized code.
• 14:59
  SPEAKER_02: Write better code.
• 15:00
  SPEAKER_02: Optimize your code better.
• 15:03
  SPEAKER_02: So unless you're already maxing out your capacity in the cloud, you probably don't need microservices.
• 15:11
  SPEAKER_02: So something to think about, but I would encourage you.
• 15:14
  SPEAKER_02: Yes, it's cool for demos, yes, it could be you know for one-off situations, but the reality is monoliths are almost always the way to go when you build an application.
• 15:27
  SPEAKER_02: All right, thanks for listening.
• 15:28
  SPEAKER_02: As always, I am Tim Corey.
• 15:31
  SPEAKER_01: Thank you for joining us for this episode of Def Questions.
• 15:34
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 15:37
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 15:45
  SPEAKER_01: You can also send your questions to questions at IamTimcore.com.
• 15:50
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 15:57
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.