Microsoft Orleans Deep Dive Course

[JorgeCandeias]

Hi folks. Time for a bit of shameless self advertising.

I'm now running a live Microsoft Orleans "Deep Dive" two-day group training course with the fine people at NobleProg.

Here's the agenda. It's not visible yet on the NobleProg catalogue but this is how it has been going:

• Set-up Requirements:
  • Visual Studio Community 2022 - .NET Workload - Database Workload
• Training Materials:
  • https://github.com/JorgeCandeias/ImpulseCompletedLabs
• Prerequisites:
  • .NET programming experience
  • Comfortable with the TPL
• Audience:
  • .NET Developers

Overview:

Microsoft Orleans is an easy to use framework for building high-performance distributed applications in .NET.
This instructor-led, live training (online or onsite) is aimed at .NET developers who wish to make the best of Microsoft Orleans, while knowing what's happening under the hood.
This is a fast-paced, theory-heavy course, covering beginner to advanced topics, including internals, primers on integrating with other tools, performance optimizations and advanced design patterns.

By the end of this training, participants will be able to:

• Set up Orleans for different architectures.
• Develop a full-featured Orleans application.
• Use distributed tracing to track requests.
• Ensure code quality and measure performance of the application.
• Apply performance optimizations.
• Understand advanced design patterns for Orleans applications.

Format of the Course:

• Interactive lecture and discussion.
• High amount of internals and protocol theory.
• Labs to perform at one's own pace, during or after the course.
• Hands-on implementation in a live-lab environment.

Course Outline:

• Introduction

  • Sample App Tour
  • Scaling Headaches
  • The Orleans Solution
  • Development Model

• Internals

  • Cluster Membership Design
  • Cluster Recovery Protocol
  • Distributed Messaging Internals

• Development

  • Solution Architecture Options (Classic, Cohost, Mixed)
  • Solution Project Structure Options (Simple, DDD-Style)
  • Creating a Silo
    • Clustering Providers
    • Orleans Dashboard
  • Creating a Client
  • Creating a Grain
    • Grain Identity
    • Grain Key
    • Grain Interface
    • Grain Class
    • Calling Grain Methods
      • Timeout & Exception Protocols
    • Lifecycle Hooks
  • Implementing Grain Persistence
  • Implementing Streaming
  • Implementing Timers
  • Implementing Reminders

• Distributed Tracing

  • Using the RequestContext
  • Using Grain Call Filters
  • Integrating w/ OpenTelemetry

• Quality

  • Unit Testing w/ Orleans Test Host
  • Load Testing w/ NBomber
  • Configuring the Orleans ADO.NET providers w/ SSDT

• Performance Optimizations

  • Per-Method Interleaving
  • Full Reentrancy

• Advanced Design Patterns

  • Stateless Worker Pools
  • Cadence Pattern
  • Aggregator Pattern
  • Reduce Pattern
  • Reactive Caching Protocol
  • Reactive Caching Pattern

I also want to give a shout out to @rallets for linking me up with this opportunity to further fanboying for Orleans.

[MarcelWouters]

Hi @JorgeCandeias,

I was reading your article https://jorgecandeias.github.io/2019/05/26/latency-adaptive-real-time-with-reactive-caching-on-microsoft-orleans/. Is the mentioned repository AdHocReactiveCaching still somewhere available?

[ReubenBond]

It exists in the 3.x branch: https://github.com/dotnet/orleans/tree/3.x/Samples/2.3/AdHocReactiveCaching

[JorgeCandeias]

If you want to look at other examples of reactive caching, here's two:

In this simple example, the ChannelGlobalStatsReplicaGrain establishes a timer-based long polling loop against ChannelGlobalStatsGrain to propagate some statistics in real-time to all nodes that need it.

In this advanced example, the OrderProviderReplicaGrain establishes an aggressive long polling loop against the OrderProviderGrain to propagate collection differentials as needed, and as fast as possible.