I’ve been doing a lot of work on ASP.NET Core recently and wanted to really get my head into microservices which seems a hot topic at the moment. So, I decided to purchase Building Microservices with .NET Core 2.0 and give it a read. This post is a short review on this book.

Contents

Chapter 1 - Introduction

This chapter goes through what microservices are, where the term came from and why the architecture is great! The chapter goes through how the architecture differs from a monolithic and a Service-Oriented Architecture (SOA) architectures.

Chapter 2 - Implementing Microservices

This chapter goes through high level factors when breaking a system up into microservices and tactics for doing so. It covers the characteristics of what a good serive is in order to acheive vertical isolation. It goes through a nice example implementation using Visual Studio 2017, ASP.NET Core 2.0, EF Core and SQL Server.

Chapter 3 - Integration Techniques and Microservices

The third chapter focuses on how the microservices communicate with each other in addition to how external systems can communicate with the system as a whole. The chapter goes through synchronous and asynchronous communication types as well as the concept of a API gateway. In terms of code, it goes through an example of implementing and interacting with a service bus queue in Azure.

Chapter 4 - Testing Microservices

This chapter starts by identifying the challenges of testing microservices. It then goes on to how to tackle those challenges covering all the areas in the classic testing pyramid. The chapter ends with going through a working example of different types of tests using Visual Studio 2017, ASP.NET Core 2.0, xUnit and moq.

Chapter 5 - Deploying Microservices

Chapter five starts by reminding us of the challenges of deploying monolithic systems. It then goes on to cover best practices when deploying microservices focusing on isolation which is a key factor for success. It also covers how microservices fit in with continuous integration and continuous delivery. The chapter finishes with a step by step example of deploying a microservice using Docker.

Chapter 6 - Securing Microservices

This chapter starts by identifying how microservice security is different to securing a monolithic system. It goes on to cover how we can secure microservices using OAuth 2.0 and OpenID Connect. The working example in the chapter goes through securing a microservice with Azure AD.

Chapter 7 - Monitoring Microservices

This chapter goes through how to add instrumentation and telemetry to microservices. As you might imagine, debugging a transaction spanning multiple microservices is challenging - this chapter covers approaches for making this easier.

Chapter 8 - Scaling Microservices

Chapter 8 explores how we can scale microservices which is a key advantage of the microservices approach. It covers how we can design our microservices to scale and make them fault tolerant.

Chapter 9 - Introduction to Reactive Microservices

This chapter starts by explaining what a “reactive” microservice is and goes through a working ASP.NET Core example.

Chapter 10 - Creating a Complete Microservice Solution

The final chapter starts by summarising some of the key microservices concepts covered in the previous chapters and goes through a high level design of sample bookstore system.

Conclusion

Personally I thought the book was really good. It started from the basics and was easy to understand - the diagrams thoughout the book were fantastic for my understanding!

I liked how the chapters went through the theory followed by relevant realistic code examples.

The book is a quick read as well at just under 300 pages.

So, if you’re a .NET developer and interested in learning about microservices then this book is a great start point.