Building Highly Scalable Web Applications in Azure

This course is for existing .NET web developers who want to learn the specifics of scalable web application design and its implementation details on Azure cloud.
Course info
Rating
(291)
Level
Intermediate
Updated
Aug 4, 2015
Duration
2h 23m
Table of contents
Getting Started
Components of Scalable Applications
Minimizing Storage Locking
Caching
Asynchrony
Queuing and Isolation
Redundancy and Fault Tolerance
Wrapping Up
Description
Course info
Rating
(291)
Level
Intermediate
Updated
Aug 4, 2015
Duration
2h 23m
Description

This course introduces ASP.NET web developers to the rationale and implementation details of highly-scalable web applications. The scalable applications have to be architected to avoid bottlenecks, single points of failure, and synchronous couplings. This course will show how Azure cloud helps web developers by providing several platform characteristics that allow for building scalability without having to start from scratch.

About the author
About the author

Edin Kapic is a SharePoint MVP, Architect, Tinker and Geek in Spenta consulting, and the MCT Regional Lead for Spain.

More from the author
Taming Asynchronous .NET Code with Rx
Intermediate
1h 27m
Dec 5, 2016
Human Behavior for Technical People
Beginner
3h 17m
Jun 16, 2014
Section Introduction Transcripts
Section Introduction Transcripts

Components of Scalable Applications
Hi. I'm Edin Kapic from Pluralsight. Now that we are familiar with the concept of scalability because of its importance and after having carefully weighed the pros and cons of designing for high scalability, in this module I will show you the pieces that are commonly found in scalable applications. After that, I will show you how the sample application architecture lacks all of them. I will just skim over the parts of this module because each component will have its own module later where we will see all the details and how they fit in our Ticketer sample application.

Minimizing Storage Locking
Hello. This is Edin Kapic from Pluralsight. In this module I will cover storage complications such as locking in depth. We will see how we can mitigate these complications and what _____ we have to make in order to do so. You should remember from the first module the data storage is one of the most important bottlenecks in our application architecture. At one level or another, almost web applications have some kind of storage in place to read from or to write to. Usually it has the form of a relational database that sits in one of the server in the application deployment farm. If you recall your past web application projects, think how many of them had some kind of database as the ultimate repository for the application data. Of course, the need for persistent storage is obvious. We just need to be able to store information that will survive between user interactions. If our user logs out and then logs in one month after, she will expect her data to be there, just as if she hasn't logged at all. However, in this module I will hopefully convince you that although storage is necessary, relational database may not be. Even if you are not convinced at the end, I think that you will take away valuable information to be able to be able to understand the tradeoffs involved when using relational databases.

Caching
Hello. This is Edin Kapic from Pluralsight. In this module I will cover the technique of caching, an approach that can help us easily and cheaply increase the scalability of our application; however, it introduces additional liabilities such as stale data, which will make us rethink our approach to data access in the application.

Asynchrony
Hello. This is Edin Kapic from Pluralsight. In this module I will show you how to avoid idle threats that wait for background operations with the use of asynchronous code. In this way our threads can be squeezed for the maximum of their performance.

Queuing and Isolation
Hello. This is Edin Kapic from Pluralsight. In this module we will introduce the concept of load coupling between application components. When all the components in a single application are tightly connected and waiting for the results from one to another, any single error can throw all the requests away. By isolating the code that issues the issues the request from the code that serves the request and by communicating them asynchronously with queues, we gain important scalability wins for our application.

Redundancy and Fault Tolerance
Hello. This is Edin Kapic from Pluralsight. In this module we will introduce the concept of redundancy and fault tolerance. One of the basic tenants of highly scalable applications is the fault tolerance that is achieved with having redundant parts throughout the architecture. By eliminating a single point of failure, our application components can be replicated as needed, in order to ensure that the application is always performant.