Actor Systems

Andreas Vilinski

ifm

Agenda

  • Woher kommt ein Aktor
  • Beweggründe
  • Was ist ein Aktor
  • Wann ist er nützlich
  • Was zu beachten
  • Vergleich der Implementierungen

Prähistorische Fakten

  • Vorgeschlagen 1973
    • Erlang 1986
    • Akka (JVM, Scala) 2009
    • Akka.NET (C#)
    • inzwischen in vielen Programmiersprachen

Herkunft

CPUs and shared memory

 

AXD-301

Beweggründe

  • das Ende der Moore’s Law-Periode
  • Amdal-Gesetzt muss berücksichtigt werden
  • Diskrepanz zw. OOP und Prozessen in der realen Welt
  • Programmiersprachen ohne OOP
  • Stateless - erstrebenswert, aber nicht immer möglich

Wachsende Anforderungen

  • Großes System 1995-2005
    • 10x servers
    • latency - seconds
    • maintenance stop 1-2h per month
    • Gigabytes
  • Großes System 2015-2021
    • 100x servers (cluster nodes)
    • latency - ms
    • maintenance stop - none
    • Petabytes

Moore Law

schwarze rauten - anzahl der Kerne

Amdal law

Amdahlsche Gesetz (WIKI)

OOP Diskrepanz

  • Modernes OOP = Klassenhierarchie

  • Alan Kay - “Mit OOP habe ich nicht C++ gemeint”

  • Alan Kay’s OOP - Messaging und Incapsulation

  • Modellierung der realen Welt des Puppentheaters

  • OOP Duck doesn’t quack

  • Viele Objekte, Zustände, asynchronen Aufrufe

  • Zustandverwaltung und Kommunikation-Koordinierung, Thread-Schutz

Zustandverwaltung


public enum SubscriptionState
{
    Created, DriverFound, DriverInitialized, BehaviorsInitialized,
    Ready, Starting, Stopping, Ok,
    ReceiveError, TransmitError, StartupError,
    Stopped, Disposed,
    ConnectionProblem, Connecting,
}

1. naive Ansatz - lock

public class TreeController {
  public Task MoveNode(Guid nodeId, Guid toNode) {
    lock (topologyTree) {
      // WORK ...
    }
  }
}
  • Locks doesn’t scale
    • mehrere service-instanzen == lock überflüssig
    • mehrere http-Requests == zu viele Resourcen sind eingefroren

2. Dedicated thread

Beispiel - IFM.SDK

  • 1 Device - 2 Threads
  • 1000 Devices - 2000 Threads
  • .NET Core thread pool - 250 threads per core
  • signifikante Zeit wird beim Warten verbraucht

3. Threads ausleihen

  • Objekte wachen auf, nur für kurze Zeit Berechnung
  • Zustand-Änderungen werden sequentiell gemacht und nur vom Objekt selbst
  • Lokalität beim Prozess-Nachvollziehen

Actor


Actor kann



  • (nur) mit PID identifiziert/adressiert werden (Ortstransparenz)
  • (nur) sein eigenes Zustand und Verhalten ändern
  • Sequentiell Nachrichten bearbeiten
  • Nachrichten an die anderen schicken
  • andere Aktoren starten und überwachen (supervise)

Aktor vs klassisches OOP

Objekt

  • sind nicht lebendig, gehören nicht sich selbst
  • Thread Besitzer (SubscriptionManager) - besitzt die Kontrolle (Subscription)

Aktor

  • fast immer schlafendes Prozess
  • kontrolliert (NUR) sein eigenes Zustand
  • kommuniziert asynchronen mit Nachrichten
  • “Tell, don’t Ask” Prinzip
  • schickt Nachrichten, (meistens) keine Anfragen
  • auf die möglicherweise eine Antwort folgt

Vorteile

  • message-driven design
  • funktionale Transformation: A -> f -> B
  • strenge Isolation und Entkopplung
  • kein manuelles Thread-Management
  • kein Schutzmechanismus für Public-Eigenschaften
  • keine Race-Conditions

Mögliche Einsatzbeispiele

Aktor als Entität

  • Device
  • Subscription
  • Eingeloggte User
  • Ticket
  • Element der Workflow

Aktor als Manager

  • Rohdatenaufzeichnung
  • DB provider - read/write
  • Notification-Sender
  • SignalR-Hub
  • Limit-Watcher

Hello world

public class Hello {
  public Hello(string who) => Who = who;
  public string Who { get; } // no setter
}
//public record Hello(string who);

public class HelloActor : IActor {
  public Task ReceiveAsync(IContext context) {
    object msg = context.Message;
    if (msg is Hello r)
      Console.WriteLine($"Hello {r.Who}");
    return Task.CompletedTask;
  }
}

Deklarative Props

var system = new ActorSystem(); // (1)

//var props = Props.FromFunc(c => {...});
var props = Props.FromProducer(() => new ParentActor()) // (2)
  .WithMailbox(mailbox)
  .WithContextDecorator(c => new LoggingDecorator(c))
  .WithHashMapping(Routing.ConsistentHashMapping akamai)
  .WithSenderMiddleware(next => {...})
  .WithChildSupervisorStrategy(
    new OneForOneStrategy(Decider.Decide, 1, null));

var pid = system.Root.Spawn(props); // (3)
system.Root.Send(pid, new Hello("ProtoActor")); // (4)

Aktor intern hat keine Info darüber

Behavior

public class Necromant : IActor {
  private Behavior _behavior = new Behavior(); // (1)

  public Necromant() {
      _behavior.Become(Resting); // (2)
  }

  public Task ReceiveAsync(IContext ctx) =>
      _behavior.ReceiveAsync(ctx); // (3)

  private Task Resting(IContext ctx) {...}
  ...
}

Behavior

public class Necromant : IActor {
  ...
  private Task Resting(IContext context) {...}
    switch (context.Message) {
      case SwordHit damage: // (1) Info von der Nachricht
        _health -= damage; // (2) Zustand
        var nextBehavior = (_health > 0.5) ? Fighting : Run;
        _behavior.Become(nextBehavior); // (3) Behavior
      case Touch _ :
        context.Respond("Cold"); // (4) Antwort an Sender
    }
    return Task.CompletedTask;
  }
  private Task Fighting(IContext ctx) { ... }

Tell, don't Ask

  • Einzige Kommunikationsweg - Nachrichten
  • Send - Tell by default
  • RequestAsync - Ask nur ven nicht anders geht.
    • z.B. HttpRequest
    • Empfang anhalten bis die Antwort kommt
    • thread bleibt reserviert
    • await ctx.RequestAsync(rcvPID);
    • ctx.Respond(new Answer(42));

Controller tell

[ApiController, Route("[controller]")]
public class ActorController : ControllerBase {
  [HttpPost]
  public ActionResult AddPanel(string name)
  { // synchron ist ok
    var msg = new AddPanelRequest(name);
    SystemActors.SignalRActor.Send(msg); // tell
    return Accepted();
  }
}

Controller ask

public ActorController(ActorSystem actorSystem) =>
  _sys = actorSystem;

[HttpPost]
public async Task<Guid> AddPanel(string name)
{
  var props = _sys.DI().PropsFor<RequestActor>(); // (1) DI
  var pid = _sys.Root.Spawn(props);
  var msg = new AddPanel(name);
  var timeout = TimeSpan.FromSeconds(10); // (2)
  var panel =
    await _sys.Root.RequestAsync<Added>(pid, msg, timeout);
  await _sys.Root.StopAsync(pid); // (3) Stop it
  return panel.Id;
}

Forward

Ask vs Forward

Stash

private Task Paused(IContext context) {
    switch (context.Message)
    {
        case Data _ :
          context.Stash(); // (1) not handling yet
        case Enough _:
          context.UnstashAll(); // (2) into inbox again
          _behavior.Become(Idle); // (3) don't collect anymore
          return Task.CompletedTask;
    }
    return Task.CompletedTask;
}

Performance

Developer Laptop, 1 000 000 calls

Method Zeit, s RPS msg/s
void Method 0.003 300 M/s
int Method 0.004 250M/s
Task Method 1.864 500K/s
Task<int> Method 1.790 500K/s
Akka.NET Tell 0.233 4M/s
Akka.NET Ask 6.395 150K/s

Benchmarks Actorsysteme

Lib Remote Inproc SkyNet
Erlang 200k/s 12 M/s 0.75s
Akka 110k/s 38 M/s 9.0s
Akka.NET 38k/s 30 M/s 12s
Proto.Actor Go 2.4M/s 120 M/s 1.5s
Proto.Actor C# 2.5M/s 125 M/s 0.8s
Proto.Actor Kotlin 2.7M/s 160 M/s 0.31s

Error handling

  • Widerstandsfähigkeit (resilience)
  • Überwachung (supervision)
  • Isolation
  • deklarativ statt try/catch
  • Fail-Fast Prinzip

Exceptions in C#

try
{
  connection.ExecuteCommand(cmd); // eigentliche Arbeit
}
catch (SqlException ex)
{
  // Retry ?
  // Recover db ?
  // wird die gleiche Connection woanders benutzt wird?
}
catch (Exception ex)
{
  // Alles andere abfangen?
}

Verzögerte Ausführung

queue.Subscribe(x => HandleMessage(x));

void HandleMessage(QueueMessage msg)
{
  Process(msg);
  msg.Ack();
}
catch (QueueException ex)
{
  // Reconnect? Unsubscribe? wir sind in anderem thread!
}

Exception handling

Exception handling considered harmful

Exception handling introduces a hidden, “out-of-band” control flow possibility at essentially every line of code.

Jason Patterson

Supervisor strategien

 

Supervisor strategien

  • Supervisor entschiedet was zu tun ist
    • Neustarten (default)
    • Weiterführen
    • Stoppen
    • Fehler weiter nach oben eskalieren

Beispiel

var strategy = Strategy.OneForOne((ex =>
  switch ex {
    case ArgumentNullException: return Stop;
    case ArgumentOutOfRangeException: return Restart;
    case ArgumentException: return Resume;
    default: return Escalate},
    3, TimeSpan.FromSeconds(10.0)));

var props = Props.FromProducer(...)
    .WithSupervisionStrategy(strategy);

Anwendung der Strategie

  • Exception im Receive - Aktor hält Arbeit an
  • Supervisor
    • wird informiert über Fehler und Aktor
    • entscheidet was zu tun ist, z.B. bei Neustart:
      • stoppt den Aktor, aber behält sein Mailbox
      • startet neue Instanz mit Props und Mailbox
    • oder
      • Weiterfahren wie nichts passiert
      • weiter nach oben eskalieren

Skalierung

Wenn sequentiell nicht genug ist

  • Round robin
  • smallest mailbox
  • consisten hashing
  • boradcast
  • scatter gather first completed
  • …
  • custom

Persistenz

Actor Persistenz

Persistenz

  • deklarativ über Props oder Attribute (MS Orleans)
  • Storage interface oder normale DbProvider
  • Funktionen nach event sourcing
  • Event journal entspricht dem CQRS
  • Traditionelle relationale DB für zusätzliche Anfragen

No silver bullet

  • Testen?
    • Leicht zu ersetzen/mocken, auch ohne Interfaces/Ableitungen
    • isolierte Logik - isolierte tests
  • Stack trace - limitiert auf ein Aktor
  • kein Interface, API nur über Message-Typen
  • kein Cluster mitglied - kein Nachrichten-Austausch
  • überflüssig ohne Zustand oder Verteilung
  • DI - langlebige Instanzen (vorsicht EF DB context)

Silver bullet

  • Parallele ausführung
  • Deklarative Kontrolle von Zustandsänderung
  • Reaktive systeme
  • Skalierbare verteilte systeme

Sprachen und Bibliotheken

  • Programmiersprachen
    • Erlang - Elixir - Pony - Scala(*)
  • Bibliotheken
    • Akka (java/scala)
    • Akka.NET, MS Orleans, Proto.Actor (C#/F#)
    • F# MailboxProcessor (in-prozess)

3 Varianten für .NET-Core

  • Petabridge Akka.NET
  • Microsoft Orleans
  • Asynkron Proto.Aktor

Petabridge Akka.NET

  • direkter Port Erlang -> JVM -> .NET
  • am meisten an Erlang orientiert
  • battle-tested
  • Akka.Streams
  • 166 NuGets

Akka.NET Beispiel

public class HomeController : Controller {
  [HttpPost]
  public async Task<ActionResult> SaveDashboard(string uri) {
    SystemActors.SignalRActor.Tell(d, ActorRefs.Nobody);
    return Accepted();
  }
  [HttpGet]
  public async Task<ActionResult> SendRequest(string uri) {
    var str = await SystemActors.SignalRActor.Ask(uri, TimeSpan.FromSeconds(1));
    return ContentResult() {Content = str};
  }
}

Petabridge Akka.NET Nachteile

  • Lebenszyklus-Verwaltung nötig
  • Umständliche Receive Definition
  • hacks in Netzwerk-Stack
  • andere Altlasten

Microsoft Orleans

  • kein Mailbox - verstecktes Messaging
  • kein PID - normale Objekt-References
  • kein Supervision - try/catch
  • keine Lebenszyklus-Verwaltung
    • max 30s Durchlauf
    • nach 30 min deaktivierung
  • Timers, Reminders
  • Cloud-First Objekte, cluster oder in-prozess
  • MSBuild Code-Generator
  • 286 NuGets

Microsoft Orleans

Wichtige Unterschiede

  • Virtual Actor - automatische Lebenszyklusverwaltung
  • Unique-ID - smart cache pattern

Orleans controller

public WeatherController(IClusterClient cluster) => _cluster

[HttpGet]
public async Task<AsyncResult> GetAsync(string city) {
  var city = _cluster.GetGrain<ICityGrain>(city);
  return await city.GetForecastAsync();
}

Deploy to k8s

Host.CreateDefaultBuilder(args)
  .UseOrleans((ctx, siloBuilder) => {
    if (ctx.HostingEnvironment.IsDevelopment()) // or singleprocess
    {
      siloBuilder.UseLocalhostClustering();
      siloBuilder.AddMemoryGrainStorage("definitions");
    }
    else
    {
      siloBuilder.UseKubernetesHosting();

      // use redis for clustering & persistence
      var redisAddress = "redis:6379";
      siloBuilder.UseRedisClustering(opt => opt.ConnectionString = redisAddress);
      siloBuilder.AddRedisGrainStorage("definitions", opt => opt.ConnectionString => redisAddress);
    }
  })

Microsoft Orleans Nachteile

  • MSBuild code generation
  • Überschreibung von default-Eigenschaften
  • Unerwünschte Aktivierungen möglich
  • Aktivierungen zu einem Node festnageln
  • Messagin versteckt hinter RPC-Semantic
  • Stärkere Kopplung durch Actor-Interfaces UND Argumente
  • OOP-Lastig: Vererbung, Interfaces, DI

Asynkron Proto.Actor

  • Lessons learned by Orleans and Akka
    • Roger Johansson von Akka.NET
  • .NET (C#, F#), JVM (Kotlin), Go
  • Flexibilität mit bewärten Technologien
    • C# Pattern matching
    • Identity - Redis
    • Culster management - Consul, k8s
    • Transport - JRPC, Protobuf
  • virtual actor wenn nötig
  • z.Z am schnellsten unter .NET
  • 45 NuGets
// reveal.js plugins