This document discusses building cloud-native applications using microservices architecture on the .NET platform. It covers topics like leveraging containers and container orchestrators like Kubernetes, implementing common microservices patterns for communication, resiliency, and health checks. It also promotes the 12 factor app methodology and references resources for getting started with microservices on .NET including sample code. Case studies are provided of companies successfully using microservices at scale like Netflix, Uber, and WeChat.

1. Building Cloud-Native Apps
Nish Anil – Sr. PM .NET Platform, Microsoft
@nishanil
Swaminathan Vetri – Technical Architect, Maersk
@svswaminathan

2. Developers.. Developers.. Developers..
Visual Studio Code Visual Studio Visual Studio for Mac
Tools for AzureXamarinTypeScript

3. http://dot.net/architecture http://github.com/dotnet-architecture

4. Free eBooks
Coming Soon
.. and more @ http://dot.net/architecture

5. • .NET Platform
• Cloud-Native philosophy
• Microservices Architecture
• Leveraging containers & orchestrators
• Getting Started with Microservices
• Key Patterns for Microservices
• Communication
• Resiliency – Designing for failure
• Healthcheck

6. DESKTOP WEB CLOUD MOBILE GAMING IoT AI
.NET

7. Just a few of our millions of .NET customers…
dot.net/customers

8. • Build and run scalable applications in modern, dynamic environments
• Containers, service meshes, microservices, immutable infrastructure, and declarative APIs exemplify this
approach.
• Enables loosely coupled systems resilient, manageable, and observable
• Enables engineers to make high-impact changes frequently and predictably with minimal toil.
Company Experience
Netflix Has 600+ services in production. Deploys a hundred times per day.
Uber Has 1,000+ services stored in production. Deploys several thousand
builds each week.
WeChat Has 300+ services in production. Makes almost 1,000 changes per
day.
*CNCF definition
Key: Speed, Agility, & Scalability

9. The 12-Factor Application – A methodology to adopt for cloud-native apps
1. Codebase
2. Dependencies
3. Configurations
4. Backing Services
5. Build, Release, Run
6. Processes
7. Port Binding
8. Concurrency
9. Disposability
10. Dev/Prod Parity
11. Logging
12. Admin Process
https://12factor.net/
https://content.pivotal.io/blog/beyond-the-twelve-factor-app

14. Leveraging containers for Microservices
A container is a standard unit of software that packages up code and
all its dependencies, so the application runs quickly and reliably from
one computing environment to another.

16. Azure Container Registry (ACR)
Use familiar, open-
source Docker CLI tools
Azure Container Registry
geo-replication
Manage images for all
types of containers
Manage a Docker private registry as a first-class Azure resource

18. Scheduling Affinity/anti-
affinity
Health
monitoring
Failover
Scaling Networking Service
discovery
Coordinated
app upgrades
Azure Kubernetes Service (AKS)
The elements of orchestration

19. https://github.com/dotnet-architecture/eShopOnContainers

21. Key Patterns for Microservices
1. API Gateway vs. Direct communication
- API Gateways implementation with Ocelot / Azure API Management
2. Resilient cloud applications
- Retries with exponential backoff plus Circuit breaker policy
3. HealthCheck
…

22. Direct communication vs the API Gateway pattern
Direct communication to microservices
(“NO API Gateway usage”)
Using the API Gateway pattern

24. https://github.com/dotnet-architecture/eShopOnContainers

29. Building resilient cloud applications

30. Retries with exponential backoff

31. Retries with exponential backoff

33. Service Mesh tools:
• Envoy from Lyft Engineering
• Linkerd from https://buoyant.io
• Traefik from https
For example, Service Fabric Mesh uses Envoy out-of-the-box and “transparently”:
You can also use with Kubernetes but you need to implement/deploy it:
These tools provide features such as:
• Retry
• Circuit-breaking
• Latency and other metrics
• Failure- and latency-aware load balancing
• Distributed tracing
• Protocol upgrade
• Version-aware routing
• Cluster failover, etc
If using those, you don’t need an implementation of retries and circuit breaker as part of every microservice.
Instead, you will be using one as a sidecar pattern or host proxy.
Moving resilient patterns to the platform (Retries/Circuit-Breaker):

34. Other Considerations..
• Communication Patterns
• Asynchronous messaging patterns
• Event driven architecture
• Data Management
• CQRS
• Deployment patterns
• Cross Cutting Concerns
• Externalized Configurations
• Service Discovery
….

35. Questions Thank you