Orleans – a “cloud native” runtime built for #azure

Orleans – A “cloud native”
Runtime Built for #Azure
By Alexandre Brisebois
@Brisebois http://bit.ly/1lc9W3Bbrisebois@outlook.com

Forget about 3-tier architectures
They don’t scale!
@Brisebois http://bit.ly/1lc9W3B brisebois@outlook.com

They don’t scale!
• Stateless frontends
• Stateless middle tier
• Storage is the bottleneck
• Latency
• Throughput
• Scalability

They don’t scale!
• Much better performance
• Lost semantics of storage
• Lost concurrency control

High-scale interactive services
demand high throughput with
low latency and high availability.

Servers != Services

Services != Servers

Meet Actors
They enable applications to attain high performance, reliability and scalability

Start thinking in terms of Actors
• Performance of cache
• Riche semantics
• Concurrency control
• Horizontal calls are natural
• OOP paradigm
• But there are still challenges

Challenges with Actor Model Frameworks
• Too low level
• App manages lifecycle of actors, exposed to distributed races
• App has to deal with actor failures, supervision trees
• App manages placement of actors – resource management
• Developer has to be a distributed systems expert

Welcome to Orleans
https://orleans.codeplex.com

• Virtual Actor model
• Location transparency
• Actors are .Net objects
• Messaging through .Net interfaces
• Asynchronous through async/await in C#
• Automatic error propagation
• Implicit activation & lifecycle management
• Coordinated placement
• Multiplexed communication
• Failure recovery

Actors are called Grains

Grains
#2,548,308
#2,031,769
Activation #1 @ 192.168.1.1
Activation #1 @ 192.168.1.5

Grains: Virtual actors
• Grain instances always exist, virtually
• Needn’t be created, looked up or deleted
• Code can always call methods the grain
• Grains never fail
• Activations are created on-demand
• If there is no existing activation, a message sent to it triggers instantiation
• Lifecycle is managed by the runtime
• Transparent recovery from server failures
• Runtime can create multiple activations of stateless grains (for performance)
• Location transparency
• Grains can pass references to one another around
• References can be persisted to cold-storage
http://bit.ly/1lc9W3B brisebois@outlook.com@Brisebois

Concurrency is hard!
Distribution, high throughput and
low-latency make it even harder
Grains are Single Threaded

Grain execution model
•Activations are single-threaded
• Optionally re-entrant
• Runtime schedules execution of methods
• Multiplexed across threads
•No shared state
• Avoid races
• No need for locks
•Cooperative multitasking
http://bit.ly/1lc9W3B brisebois@outlook.com@Brisebois

Grain Activations reside in Silos
Think of Silos as virtual memory (RAM)

http://bit.ly/Ry526A

Stateful Grain Instances reside in
cold storage
The Activation (state) can be persisted to cold storage

Hello World!

public interface IHello : IGrain
{
Task<string> SayHello(string greeting);
}
Grain interfaces
Marker interface to indicate
grain interfaces
All grain interface methods must
be asynchronous

public class HelloGrain : GrainBase, IHello
{
Task<string> SayHello(string greeting)
{
var resp = "You said: '" + greeting + "', I say: Hello!";
return Task.FromResult(resp);
}
}
Implementing the grain type

private async static Task SendMessage(long grainId)
{
IHello friend = HelloFactory.GetGrain(grainId);
string response = await friend.SayHello("Good morning!");
Console.WriteLine("Response: {0}", response);
}
Talking to grains
Factory Class is auto-generated at
compile time
Grain Id (long , GUID or String)

Give us an other example!

Azure & Orleans

Common characteristics
• Large numbers of independent actors
• Free-form relations
• High throughput/low latency
• These generally dictate stateful compute
• Fine-Grained partitioning is natural
• Cloud-based scale-out & elasticity
• Much broader developer audience
Orleans was built for…

What does Orleans bring to cloud services
in Azure?
• A powerful Virtual Actor concept
• Familiar programming model
• Smooth learning curve for developers new to asynchronous
programming

in Azure?
• Faster development through separation of concerns (OOP)
• Makes cloud-scale programming attainable

in Azure?
• Uncompromised performance
• Scalability by default
• Fewer concurrency hazard concerns and headaches
• Simplified failure handling through error propagation

Scalability by default??
• Near linear scaling to hundreds of
thousands of requests per second
• Efficient resource usage
• Location transparency simplifies
scaling up or down
• Complements Azure PaaS
• Easily adjust scale over time
Test Lab Numbers

Using Orleans to Build Halo 4’s
Distributed Cloud Services in Azure
http://bit.ly/1g6V5c3

Tackle Distribution, High Throughput
and Low-Latency with Orleans – A
“cloud native” Runtime Built
for #Azure
http://bit.ly/1og5ZOI

Orleans: Distributed Virtual
Actors for Programmability and
Scalability
http://bit.ly/1gkv43A

Orleans: Cloud Computing for
Everyone
http://bit.ly/QqiUik

Orleans: A Framework for Cloud
Computing
http://bit.ly/1hDX4j0

Scenarios

Devices send telemetry to the Cloud
Per-device actors process and
pre-aggregate incoming data
Multi-level aggregation by actors
Statistics, predictive analytics, fraud
detection, etc.
Control channel back to devices
Grouping by location, category, etc.
Elastically scales with # of devices
[Near] real-time analytics

Actors hold cache values
Semantic operation on values
Function shipping (method calls)
Coordination across multiple values
Transparent on-demand reactivation
Write-through cache with
optional batching
Intelligent cache

Scenario from Halo 4

Near-real-time processing
State is mostly in memory
Constantly evolving social graph
A fraction of total user base online
Very high throughput, low latency
Inherent races
Presence service

Orleans – a “cloud native” runtime built for #azure

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Orleans – a “cloud native” runtime built for #azure

Similar a Orleans – a “cloud native” runtime built for #azure (20)

Más de Brisebois

Más de Brisebois (6)

Último

Último (20)

Orleans – a “cloud native” runtime built for #azure