Before we proceed with the concepts to implement microservices, it is worth mentioning the core concepts, languages, and tools that we're using to implement these microservices. In this chapter, we will get an overview of these topics.

C# is a programming language developed by Microsoft. The current release at the time of writing this book is C# 7.0. The language appeared in 2002. This language is an object-oriented language and component-oriented. The current version has various new features such as ValueTuple, Deconstructors, pattern matching, the switch statement local function, and so on.

We are not going into details of these features as it's beyond the scope of this book. Refer to https...

Before we start building our microservices, we should be clear about a few of their basic aspects, such as what factors to consider while sizing our microservices and how to ensure their isolation from the rest of the system.

As the name suggests, microservices should be micro. A question arises: what is micro? Microservices are all about size and granularity. To understand this better, let's consider the application discussed in Chapter 1, An Introduction to Microservices.

We wanted the teams working on this project to stay synchronized at all times with respect to their code. Staying synchronized is even more important when we release the complete project. We needed to first decompose our application/specific parts into smaller functionalities/segments of the main service. Let's discuss the factors that need to be considered for the high-level...

Before microservices were conceptualized, whenever we thought of enterprise application integration, middleware looked like the most feasible option. Software vendors offered Enterprise Service Bus (ESB), and it was one of the best options for middleware.

Besides considering these solutions, our main priority should be inclined toward the architectural features. When microservices arrived, middleware was no longer a consideration. Rather, the focus shifted to contemplation of business problems and how to tackle those problems with the help of the architecture.

In order to make a service that can be used and maintained easily by developers and users, the service must have the following features (we can also consider these as characteristics of good services):

• Standard data formats: Good services should follow standardized data formats while exchanging...

Domain-Driven Design (DDD) is a methodology and a process of designing complex systems. In these sections, we will briefly discuss DDD and how it is important in the context of microservices.

The main objective of domain design is to understand the exact domain problems and then draft a model that can be written in any language or set of technologies. For example, in our Flix One bookstore application, we need to understand Order Management and Stock Management.

Here are a few characteristics of the domain-driven model:

• A domain model should focus on a specific business model and not multiple business models
• It should be reusable
• It should be designed so that it...

At the very core of microservices lies the capability to work on a specific functionality in isolation from the rest of the system. This translates into all the advantages discussed earlier, such as reduced module dependency, code reusability, easier code maintenance, and better deployment.

In my opinion, the same attributes that were attained with the implementation of microservices should be maintained during the process of implementation. Why should the whole process of moving monoliths to microservices be painful and not be as rewarding as using the microservices themselves? Just remember that the transition can't be done overnight and will need meticulous planning. Many capable solution architects have differed in their approaches while presenting their highly capable teams. The answer lies not just in the points already mentioned, but in the risk...

In the preceding section, we separated our Order module into Order services and discussed how we can break down the foreign key relationship between ORDER and PRODUCT tables.

In a monolithic application, we have a single repository that queries the database to fetch the records from both ORDER and PRODUCT tables. However, in our upcoming microservice application, we will segregate repositories between Order service and Product service. With each service having its respective database, each one would access its own database only. Order service would only be able to access order Database, whereas Product service would be able to access product Database only. Order service should not be allowed to access product Database and vice versa.

In the preceding chapter, we looked at an example of an imaginary company, Flix One Inc., operating in the e-commerce domain and having its own .NET monolithic application: the Flix One bookstore. We have already discussed the following:

• How to segregate the code
• How to segregate the database
• How to denormalize the database
• How to begin transitioning
• The available refactoring approaches

In the next sections, we will start writing/transitioning .NET monolith to a microservice application.

We will use the following tools and technologies while transitioning our monolithic application to microservice-style architecture:

• Visual Studio 2017 update 3 or later
• C# 7.0
• ASP.NET Core...

In this chapter, we discussed the different factors that can be used to identify and isolate microservices at a high level. We also discussed the various characteristics of a good service. When talking about DDD, we learned its importance in the context of microservices.

Furthermore, we analyzed how we can correctly achieve the vertical isolation of microservices through various parameters in detail. We tried to draw on our previous understanding of the challenges posed by a monolithic application and its solution in microservices, and we learned that we can use factors such as module interdependency, technology utilization, and team structure to identify seams and perform the transition from a monolithic architecture to microservices in an organized manner.

It became apparent that the database can pose a clear challenge in this process. However, we identified how we can...