The course is part of this learning path
Store2008 Review - Overview of the .Net Monolithic Code
Store2018 - Refactor and Redesign
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.
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
- 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
About the Author
Jeremy is the DevOps Content Lead at Cloud Academy where he specializes in developing technical training documentation for DevOps.
He has a strong background in software engineering, and has been coding with various languages, frameworks, and systems for the past 20+ years. In recent times, Jeremy has been focused on DevOps, Cloud, Security, and Machine Learning.
Jeremy holds professional certifications for both the AWS and GCP cloud platforms.
Hello and welcome to this Cloud Academy course. Dotnet Microservices Refactor and Redesign. In this lecture, we'll introduce you to the course agenda and learning objectives. This training course begins with an introduction to both monolithic and microservice based architectures. Here, we'll discuss the pros and cons of each architecture and how in recent times, application development has gravitated towards microservices. The course then quickly proceeds by taking you through the following hands on demonstrations.
Demonstration one. We introduce you to the Store2008 e-commerce store version. Architected as a Windows 2008 IIS hosted ASP.Net monolithic application. Demonstration two. We review the ASP.Net monolithic application code, packaging and deployment. Demonstration three. We introduce you to our Store2018 e-commerce store version, which is redesigned to use microservices, implementing restful API backing services. Demonstration four. We introduce you to Visual Studio Community Edition for MEG.
The Dotnet core framework in our basic ASP.Net core microservices project structure. Demonstration five. We start to decouple our monolithic structures creating and exposing restful API microservices for our backing datasets and perform some basic debugging within Visual Studio. Demonstration six. We continue refactoring past monolithic structures embedded within the code. This time we convert the presentation layer to make backing synchronous calls to our restful API backing microservices. Demonstration seven.
We begin containerizing our Store2018 microservices application using docket as our preferred container technology of choice. We introduce you to Docket Compose, which we use to orchestrate a localized runtime of our complete containerized microservices application. Demonstration eight. We introduce you to the open source Swagger framework. Used to generate API documentation amongst many other capabilities for our restful API backing microservices. We integrate Swagger directly into our microservices code base.
Which will allow us to generate corresponding API documentation on the fly at runtime. Demonstration nine. In the second generation of our microservices implementation, we introduce additional performance capabilities and stability. Through the use of embedding an Nginx based reverse proxy directly into our containers and manage their uptime using a process supervisor called Supervisor D. And finally, demonstration 10. We introduce you to BitBucket as our preferred cloud hosted version control platform.
We proceed to set up in version control our full Store2018 microservices based code base using GIT. By completing this course, you will understand the important differences between monolithic and microservice based architectures. Understand the pros and cons associated with either architecture. Understand and be able to identify a Dotnet monolithic application, how it is typically packaged and deployed. Understand how to decouple monolithic applications and expose services within as restful API endpoints.
Become familiar with open source tooling for building, deploying and maintaining a Dotnet based microservice application. Understand and become familiar with the opensource Dotnet core framework and, in particular, ASP.Net core for building web based microservices. And finally, understand and become familiar with Docker and Docker components for containerizing and application. Okay, the course introduction has now been completed. Go ahead and close this lecture, and we'll see you shortly in the next one.