CloudAcademy
  1. Home
  2. Training Library
  3. Amazon Web Services
  4. Courses
  5. .Net Microservices - Refactor and Design - Course One

Shifting the Application to Microservices

The course is part of this learning path

Refactoring a Monolithic .Net Application to use Cloud Services
course-steps 4 certification 2 lab-steps 6
play-arrow
Start course
Overview
DifficultyAdvanced
Duration2h 13m
Students106

Description

Introduction
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

Prerequisites

  • 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

Transcript

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

Students5701
Labs6
Courses41
Learning paths8

Jeremy is a Cloud Researcher and Trainer at Cloud Academy where he specializes in developing technical training documentation for security, AI, and machine learning for both AWS and GCP cloud platforms.

He has a strong background in development and coding, and has been hacking with various languages, frameworks, and systems for the past 20+ years.

In recent times, Jeremy has been focused on Cloud, Security, AI, Machine Learning, DevOps, Infrastructure as Code, and CICD.

Jeremy holds professional certifications for both AWS and GCP platforms.