Architectural Building Blocks
Azure Functions, AKS, Blob Storage, Virtual Machines, ... There are so many resources available in Azure.
In this module we'll look at the key components for designing an architecture in Azure.
- Applications: Web Sites, APIs, Jobs, Triggers
- Data: Structured and Unstructured Data
- Communication: REST, gRPC, Message Brokers
An architecture will look very different depending on what you're focusing. Do you want it to be fast or reliable or cheap?
You can't have it all, but you can optimize for more than one thing. These considerations will be drive decisions in all following topics.
- Considerations: Availability, Resiliency, Performance, Cost, ...
- Decision Making and Impact on Architecture
- LAB: Calculating Availability
By splitting up a monolith into bite-size microservices, you make your application a lot more suitable for the cloud.
Although this is not a must, most systems will consist out of various running applications that will need to communicate.
- Dealing with Evolution in an Application
- Benefits and Drawbacks
- Communication: client-service, service-service
- Data Isolation
Scaling an Application
Scaling an application has many benefits: Your application becomes more reliable, faster and handle more throughput.
There are many options on how to scale an application in the cloud. In this module, we'll take a look at key benefits and drawbacks of each one.
- Using an App Service Plan
- Using an Orchestrator
- Load Balancing
- Azure Resources: Traffic Manager, Front Door, Load Balancer, Application Gateway
- LAB: Going Serverless with Azure Functions
SQL versus NoSQL
So, which one is better? Well, both can be great, but unknown is unloved. In this module we'll explore the key differences.
- Schemas and Relations
- Data Consistency
- Read and Write Performance
- Partitioning and Scaling
- Azure Resources: Azure SQL, Cosmos DB
- LAB: Designing a NoSQL Database
Scaling a Database
Choosing a bad scaling strategy for data can turn out really expensive. In this module, we'll learn how to avoid that.
- Vertical versus Horizontal Scaling
- Partitioning and Sharding
- Azure Resources: Azure SQL, Cosmos DB
Scaling is great and all. But can become quite complex and costly.
In this module you will learn about various techniques to boost performance without requiring scaling.
- Azure Redis Cache
- Cache-Aside Pattern
- Read-Through and Write-Through
- Materialized View Pattern
- Valet Key Pattern
- Azure CDN
- LAB: Combining Azure CDNs with SAS Tokens
This module focusses on direct communication between applications. This means using things like REST or gRPC.
We'll take a look at some patterns to improve resiliency and reduce complexity.
- Retry and Circuit Breaker
- Bulkhead Pattern
- Ambassador Pattern
- LAB: Using the Circuit Breaker Pattern
Asynchronous communication much more reliable than synchronous communication.
In this module, you'll learn which common problems it solves, some useful patterns and
clarify some of the confusing terminology often used with this type of communication.
- Queue-Based Load Leveling
- Event-Based Communication
- Messages, Events and Commands
- Azure Resources: Service Bus, Event Grid, Storage Queue
- LAB: Event-Based Communication with Event Grid
Scaling a Message Broker
Not overwhelming your message broker is always a good idea. You can achieve this by scaling the message broker or by avoiding
sending too many messages all together.
- Claim-Check Pattern
- Azure Resources: Event Grid, Event Hub
- LAB: Implementing the Claim-Check Pattern
Most likely, not all of your data will end up into a single normalized database.
Chances that your data will be scattered all over the place is much higher.
So, how do you keep things consistent? And what if something fails?
Don't worry, my friend, this module will explain all.
- Strong Consistency
- CAP Theorem
- Eventual Consistency
- Outbox Pattern
- Compensating Transaction Pattern
- LAB: Implementing Eventual Consistency
CQRS and Event Sourcing
CRUD is the norm but has its limitations. This includes performance and consistency.
By separating read and update operations CQRS can overcome these limitations.
- The Problem with CRUD
- Read and Write Models
- Event Store
- LAB: Implementing a Ticketing System
There are many concerns when communicating to the external world.
Most of them have to do with security, but also the fact that protocols are usually restricted to HTTP can be a problem.
- API Gateway
- Backend for Frontends
- Asynchronous Request-Reply
- Azure Resources: Front Door, Application Gateway, API Management
Every developer knows about authentication and authorization. But there are other security concerns when deploying to the cloud.
- Options for Storing Sensitive Data
- Azure Key Vault and Managed Identity
- Service Authentication
- Security on Infrastructural Level: Virtual Networks, Firewalls, ...
- GateKeeper Pattern