Shifting the Application to Microservices
Start course
2h 10m

In this advanced course, we take a legacy monolithic .Net application and re-architect it to use a combination of cloud services to increase scalability, performance, and manageability. 

Learning Objectives 

This course will enable you to:

  • Learn the principles and patterns associated with microservices
  • Understand the principles and patterns associated with Restful APIs
  • Learn important requirements to consider when migrating a monolithic application into a microservices architecture
  • Master the benefits of using microservices and associated software patterns and tools to build microservice-based applications at speed and scale
  • Understand tradeoffs between different architectural approaches
  • Become comfortable with modern open source technologies such as Dotnet Core, Docker, Docker Compose, Linux, Terraform, Swagger, React
  • Become familiar with Docker and Container orchestration runtimes to host and run containers, such as Docker Compose, Amazon ECS using Fargate, and Amazon EKS


  • A basic understanding of software development
  • A basic understanding of the software development life cycle
  • A basic understanding of DevOps and CICD practices
  • Familiarity with Dotnet and C#
  • Familiarity with AWS

Intended Audience

  • Software Developers and Architects
  • DevOps Practitioners interested in CI/CD implementation
  • Anyone interested in understanding and adopting Microservices and Restful APIs within their own organization
  • Anyone interested in modernizing an existing application
  • Anyone interested in Docker, and Containers in general
  • Anyone interested in container orchestration runtimes such as Kubernetes

Source Code


Welcome back. In this lecture we're gonna provide a brief overview of our microservices architecture that we're going to migrate towards. With our microservices architecture, we'll use modern technologies such as the .NET Core 2.1 framework and Doka for our runtime. We'll reuse the same front end, but this time the eCommerce store will be named Store2018 and we'll reuse the same business logic encapsulated in our services. So let's now take a look at the microservices architecture that we're going to go forward with. Let's cover off some of the key points in our microservices architecture. We're gonna use the .NET Core framework together with the ASP .NET Core version. .NET Core is a free and open source managed software framework for Windows, Mac or Linux. 

Microsoft has really adopted open source in recent years and it has been a successful strategy and one for which we'll use. The next point of interest is that we're decoupling the service components from the presentation layer component. We do so by firstly Web API enabling the service components thereby converting them to RESTful APIs. And then with our now presentation component, the Store2018 UI component, we'll remove the project references or dependencies. Instead the Store2018 component will make HTTP calls, request responses to each of the service components to get the data that it needs at runtime. So from this redesign we're quickly getting a couple advantages. 

Firstly the build and packaging is now done at the individual component layer and secondly now that we've web enabled our service components and given each of the AMA RESTful API, we can have other internal and/or external systems make use of those service components. And this is a great feature and benefit of a microservices architecture. As an example our Store2018 UI presentation component can store render itself, making HTTP calls to each of the service components. But we can also bring in mobility whereby mobile devices can make use of those components. Finally let's take a look at how the calling occurs between the components within our microservices redesign. So those can be seen here. 

The calling is much the same. However the Store2018 user interface component now makes HTTP calls to each of the service components whereas previously in the monolithic application those calls were made in process. So again the real benefit here by Web API enabling each of the service components is that we can have these other systems use HTTP which is a very common internet protocol to make use of the functionality embedded within these service components which is a very powerful thing. Very flexible, allowing other systems, other third parties to integrate with your service components. 

So from here we'll begin the redevelopment process whereby we'll use Visual Studio community edition running on a Mac to redesign our monolithic application into the microservices architecture that we've just discussed. So go ahead, close this lecture and we'll see you shortly in the next one.

About the Author
Learning Paths

Jeremy is a Content Lead Architect and DevOps SME here at Cloud Academy where he specializes in developing DevOps technical training documentation.

He has a strong background in software engineering, and has been coding with various languages, frameworks, and systems for the past 25+ years. In recent times, Jeremy has been focused on DevOps, Cloud (AWS, Azure, GCP), Security, Kubernetes, and Machine Learning.

Jeremy holds professional certifications for AWS, Azure, GCP, Terraform, Kubernetes (CKA, CKAD, CKS).