An architectural approach to developing a single application as a suite of small individually deployable services.

- Wiki
14 articles, 8 books. Go to books ↓

Switching to a microservices architecture creates exciting opportunities in the marketplace for companies. For system architects and developers, it promises an unprecedented level of control and speed as they deliver innovative new web experiences to customers. But at such a breathless pace, it can feel like there’s not a lot of room for error. In the real world, you can’t stop developing and deploying your apps as you retool the processes for doing so. You know that your future success depends on transitioning to a microservices architecture, but how do you actually do it?

You are told that microservices make the whole thing so much easier, and each component is so small that you don’t need to put the same amount of care into it. Is that true? No, it isn’t.

A wish to make systems more resilient was at the heart of the “Fallacies of Distributed Computing”, originally penned by L Peter Deutsch in 1994 when he was at Sun Microsystems, and augmented by a few others since then.

Distributed transactions are icebergs because it’s easy to not see them, even when they’re right in front of you, and if you run into one, it’s got a great potential to sink your ship.

Let’s say you want to adopt a microservices architecture for your application. You want to break your application down into a number of smaller services which you can scale and deploy independently of each other. You also want to do this without directly managing the infrastructure (either physical boxes or virtual machines). Service Fabric may be a good option.

In this post I will walk you through the steps needed to create a simple microservice using ASP.NET Core with a data access that uses Marten to save and retrieve information from a PostgreSQL.

For a profession that stresses the importance of naming things well, we’ve done ourselves a disservice with microservices. The problem is that that there is nothing inherently “micro” about microservices. Microservices do not have to be small. Some are, but size is relative and there’s no standard of unit of measure across organizations.

When you spend time looking at a lot of microservices, across many different organizations, you really begin to get a feel for the ones who have owners / stewards that are thinking about the bigger picture. When people are just focused on what the service does, and not actually how the service will be used, the Github repos tend to be cryptic, out of sync, and don’t really tell a story about what is happening.

Does open source, .NET Core, distributed system, Docker and other cool words sound good to you? If that’s the case, stick with me and let me guide you through the world (or at least part of it) of microservices. This is going to be the very first article (an introduction) of the upcoming series.

OK, maybe not technically a microservice, but that's a hot buzzword these days, right? By the end I was able to cut my container size in half.

The goal of microservice architecture is to help engineering teams ship products faster, safer, and with higher quality. Decoupled services allow teams to iterate quickly and with minimal impact to the rest of the system.

The whole idea of using a microservices platform is being able to spend your time building a great microservices application and not stitching together disparate systems that will be difficult to use and operate.

Airbnb managed the complexity of splitting a monolith, which the company called Monorail, by phasing the migration, comparing Monorail functionality with that of the new services. They would take 1% of the load in new world, and compared the results down both paths. They progressively increased the load towards the services, until comparison is clean against 100% of load.