Start course
2h 11m
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:
  • Understand the principles and patterns associated with microservices
  • Understand the principles and patterns associated with Restful APIs
  • Understand important requirements to consider when migrating a monolithic application into a microservices architecture
  • Understand 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 familiar and 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 CICD implementation
  • Anyone interested in understanding and adopting Microservices and Restful APIs within their own organisation
  • Anyone interested in modernising an existing application
  • Anyone interested in Docker, and Containers in general
  • Anyone interested in container orchestration runtimes such as Kubernetes

Source Code


Welcome back. Before we finish, let's do a quick review of what we have learnt during this course. We gained an understanding of how to leverage Bitbucket Pipelines for CICD practices. We gained an understanding of how to leverage AWS's ECS Fargate managed service to host our Store2018 microservices-based e-commerce store. We gained an understanding of how to use Terraform to automate the provisioning of an AWS ECS Fargate cluster. We gained an understanding of how to use React to create client side HTML-rendered web pages capable of making Ajax calls to our backend microservice-based APIs. We gained an understanding of how to use AWS's API Gateway Service together with VPC Private links and NLBs to proxy and route API calls. We gained an understanding of AWS's EKS-managed service for Kubernetes and how easy it was to deploy our microservices-based application with zero modifications. 

And finally, we provided a quick review of where additional improvements could be made to the Store2018 microservices-based solution going forward. Finally, let's provide a quick list of some potential changes we might consider to improve on our current microservices design. One, consider using the .NET Core command to directly create a React-enabled web app for us using the .NET new react -o project-name command. Two, introduce Webpack into the Bitbucket CICD pipeline to transpile the React JSX at build time and perform additional modification and bundling of the CSS and JavaScript files. 

Three, consider implementing a CDN for serving of static assets. Four, run our Docker containers a non-root user. Five, use a private Docker registry instead of the current use of Docker Hub. Six, refactor out the Nginx reverse proxy into it own container meaning the remaining containers are able to run as a single process only. And seven, consider testing and running the Store2018 microservice-enabled application on GCP's Google Kubernetes Engine platform to again assess portability and measure comparative performance of the runtime. Okay, that concludes part two of the .NET monolithic to microservices migration. Go ahead and close this course and we'll see you shortly in the learning path review.

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).