Reactive application with akka.NET & .NET Core
•Download as PPTX, PDF•
5 likes•1,402 views
使用 Akka.NET 與 .NET Core 建立響應式應用程式
Recommended
More Related Content
What's hot
What's hot (20)
Similar to Reactive application with akka.NET & .NET Core
Similar to Reactive application with akka.NET & .NET Core (20)
More from Chen-Tien Tsai
More from Chen-Tien Tsai (20)
Reactive application with akka.NET & .NET Core
- 3. 介紹 Reactive & Actor Model 展示 Akka.NET 與 .NET Core 分享 Akka.NET 的心得 介紹 Akka.NET
- 4. (blackie1019.github.io) .NET JAVASCRIPT • 2017 ~ Current Microsoft MVP • 大內攻城(Software Engineering in .NET) – Organizer • Study4.TW – Member • A Polyglot/Polytheism Programmer - Believes in the art of finding the right tool for the job
- 17. • 使用原子操作 (AO, Atomic Operations); • 使用不可變物件 (immutable objects)
- 19. https://www.reactivemanifesto.org/ Message Driven “Asynchronous message-passing” 達到模組隔離與委託處理提供負載 控制、彈性與流程控制 Responsive “SLA > Late Correct” 系統在任何情況下，都能及時響應 Resilient “Let it crash“ 系統在異常時，具有容錯性 Elastic “No central bottlenecks” 系統能依據需求彈性拓展
- 22. 什麼是 Actor Model – 是一種同時運算的概念模型
- 23. PRIVATE STATE Amount = $2 $10
- 25. ISOLATED ISOLATED ISOLATED 先進先出 IMMUATABLED DATA STRUCTURES 非同步 一次處理一個ADDRESS OF ACTOR 也可以傳送至非本機
- 26. 確認是否運行/活著 重啟
- 27. “Everything that exists is an object. Everything that happens is a function call.” - John Chambers
- 30. 達到二十年 99.9999999% (nine-nines, 九個九)的可用時間
- 35. 正式進入 Akka.NET
- 37. • Boeing • Bank of America • S&P Global • CitiGroup
- 38. 1973 Actor Model 發明此演算法 1987 Erlang 出現(未公開) 1997 Erlang 公開 2009 Akka(JVM) 出現 2015 Akka.NET v1.0 發佈 2017 Akka.NET v1.3.0 發佈 •Support .NET Core •Support .NET Standard 1.6 2018 Akka.NET v1.3.8 發佈 •Fully support Linux & .NET Core
- 39. *
- 44. Akka.NET 開發與應用
- 47. Akka dotnet add package Akka
- 49. 兩種 Actor 建構方式 - generic version ActorSystem system = ActorSystem.Create("my-first-akka"); IActorRef typedActor = system.ActorOf<MyTypedActor>(); IActorRef untypedActor = system.ActorOf<MyUntypedActor>(); }
- 50. 兩種 Actor 建構方式 - nongeneric version ActorSystem system = ActorSystem.Create("my-first-akka"); Props typedActorProps = Akka.Actor.Props.Create<MyTypedActor>(); Props untypedActorProps = Akka.Actor.Props.Create<MyUntypedActor>(); IActorRef typedActor = system.ActorOf(typedActorProps); IActorRef untypedActor = system.ActorOf(untypedActorProps); } Props props1 = Akka.Actor Props.Create(typeof(MyTypedActor)); Props props2 = Akka.Actor Props.Create(() => new MyTypedActor("arg")); Props props3 = Akka.Actor Props.Create<MyTypedActor>(); Props props4 = Akka.Actor Props.Create(typeof(MyTypedActor), "arg"); 使用 Props 可協助定義 SupervisionStrategy 其他 Props 建構方式：
- 51. 兩種繼承類型 - UntypedActor public class MyUntypedActor : UntypedActor { protected override void OnReceive(object message) { var greeting = message as GreetingMessage; if (greeting != null) { GreetingMessageHandler(greeting); } } private void GreetingMessageHandler(GreetingMessage greeting) { Console.WriteLine($"Received a greeting: {greeting.Greeting}"); } }
- 52. 兩種繼承類型 - ReceiveActor public class MyTypedActor : ReceiveActor { public MyTypedActor() { Receive<GreetingMessage>(message => GreetingMessageHandler(message)); } private void GreetingMessageHandler(GreetingMessage greeting) { Console.WriteLine($"Received a greeting: {greeting.Greeting}"); } }
- 61. akka://MyActorSystem/user/player-coordinator/John akka://MyActorSystem@localhost:8000/user/player-coordinator/John Protocol Actor system Address Path
- 62. MusicPlayerActor
- 63. • Resume 重新啟動並仍然保持其內部狀態 • Restart 重新啟動並但清空其內部狀態 • Stop 立即終止當前出問題的 Actor • Escalate 該層的 supervisor actor 自己會丟出錯誤，將問題再交由更上層的 Supervision 處理
- 71. • 在 CQRS 或是 Domain Driven Design https://getakka.net/articles/actors/routers.html#consistenthas hing
- 77. • 分散與去中心化 • 可以建立點對點通信 • 解決單點故障 • 進而提高吞吐量和容錯能力 帶來的幫助
- 95. 點到點整條線路都通順才是重點！
- 97. • Actors 不應該有任何阻擋(block)，善用 event- driven • 不要在actors 傳遞可變物件(mutable objects) • 避免在 Actors 透過傳遞信息(messages)時同時傳 遞行為(behavior) • Top-level actors 是最內層的錯誤核心(Error Kernel), 管理者，善用樹狀繼承能更有效進行故障排除與 處理 https://getakka.net/articles/concepts/actor-systems.html#actor-best- practices
- 100. “To me, it is exciting to see principles that work so well at the microscopic level (programming) to also work at the macroscopic level (architecture).”https://www.linkedin.com/pulse/microservices-return-unix-philosophy-kenneth- chai/
Editor's Notes
- 11:10 – 12:00 [1-2 mins] Opening & Self-briefing [3-5 mins] Why Distributed & Actor Pattern [35 mins] Akka.NET What is Key features Akka.NET basic concept [10 mins ]How it works Put it into REAL : Integrating with .NET Core(Console) Put it into REAL : How to test it [5 mins] Supervision [5 mins] Routers Put it into REAL : Integrating with HA [5 mins] Akka.Remote [5 mins] Akka.Cluster [5 mins] Akka.NET & MVC Akka.NET and Container Put it into REAL : Integrating with React & SignalR(Web) [10 mins] Others Real things Top tips Benefit and comparison
- 效能需求（performance requirement） 質量屬性（quality attribute） 對外介面（external interface） 約束（constraint） 原文網址：https://itw01.com/YBRRED3.html
- 把問題丟給台下
- While there are several approaches to implementing a multithreaded, concurrent, scalable, and distributed system, the actor model paradigm is recently (re)emerging. As we are going to see, this is not a new approach, but certainly a good one that is worth exploring. When building applications, we can now effectively concentrate on making systems in a different way compared to the past. Today we can effectively utilize resources to work together and constitute a single application platform. This obviously brings a lot of new opportunities, and with them some challenges—as usually nothing comes for “free.” Everything got bigger, distributed, and parallelized! Building concurrent system is hard Building distributed system is also hard Building robust resilient application is very hard.
- https://www.slideshare.net/GlobalLogicUkraine/take-a-look-at-akkajava-english-version
- https://yuchungchuang.wordpress.com/2018/07/24/c-%E5%A4%9A%E5%9F%B7%E8%A1%8C%E7%B7%923-%E4%BA%92%E6%96%A5%E9%8E%96-mutex/
- 執行緒安全是編程中的術語，指某個函數、函數庫在多執行緒環境中被調用時，能夠正確地處理多個執行緒之間的共享變量，使程序功能正確完成。 避免發生共用 使用可重入 (Reentrancy) 技術: 把靜態變數及全域變數全部改為區域變數 (區域變數通常放在 stack 區, 可以順利避免共用). 使用執行緒自身的儲存空間 (TLS, Thread Local Storage): 所以每一個執行緒都不同, 都有自己的一份拷貝. (C11 支援加上 keyword _Thread_local 來將變數移到 TLS; C++11 改用 keyword thread_local; gnu 或者其他 C++ compiler 則用 keyword __thread) 當無法避免共用時, 採用鎖定 (同步) 機制 使用互斥鎖 (Mutex, Mutual Exclusion): 利用序列化機制 (serialization) 來保證任一時間點都只有一個執行緒讀或寫共用資料. 但是多個 mutex 一起運作時需要小心仔細的對待, 不恰當的實作可能引起一些負作用, 如: deadlocks, livelocks, resource starvation. 使用原子操作 (AO, Atomic Operations): 在存取共用資料時禁止被其他執行緒打斷. 一般實作上需要一些新的硬體指令來支援, 它是實作執行緒鎖定的元件, 也是前一項 mutex 實作的基礎. 現代的多核 CPU (x86, MIPS, ARMv6 and later) 都至少有支援一對指令可以協助完成 AO 動作 (可能只支援部份 AO). 單核 CPU 在 OS 核心的部份可以用中斷鎖定 (disable/enable interrupt) 來支援 AO 的需求. 但是如果是在用戶空間 (user-space) 卻是不可以可能是不可行, 詳細請參考: Emulated atomic operations and real-time scheduling. 使用不可變物件 (immutable objects): 物件構建 (construct) 之後即無法改變內容. 要實作改變時, 是以重新構建 (re-construct) 來取代修改現有之內容.
- 轉換一下話題，來談談質量 響應式系統具備靈活性，鬆耦合和可擴展性。這使得它們更容易去開發、修改。而對 Error 與 Exception 有更大的容忍，並且當狀況發生時它們會更優雅地應對而不是讓直接系統崩潰。反應式系統有著高度的響應性，並會給用戶有效的交互反饋。 響應式系统是： Responsive 響應式(reacts to events at the speed of environment) 系統在任何情況下，都能及時響應，在可靠的時間(SLA)內提供訊息且有穩定品質的服務。 Resilient 韌性、堅固, 具有容錯性(Fault-tolerant) 系統在失敗時，發出對應的訊息．這可使系統仍然保有 Responsive 特性。這是由 replication (複製), containment (容忍), isolation (隔離)以及 delegation (委託)的方式達成的。系統的任何組件發生問題時，可以隔離此部份，並獨立恢復，過程中不會影響整個系統。 Elastic 彈性(Easy Scale up/down and out) 即時量測效能，可透過演算法增加或減少服務的資源分配，滿足不同工作負載量的系統要求。 Message Driven 訊息驅動(modular, pipelined, asynchronous) 組件之間透過非同步訊息傳遞方式互相溝通，用以確保 loose coupling (鬆耦合), isolation (隔離), location transparency (與區域無關)、failures as messages提供錯誤訊息的委託處理機制的特性。 能給予負載控制
- 一個訊息處理的演算法. 參與者模型推崇的哲學是「一切皆是參與者」，這與物件導向程式設計的「一切皆是物件」類似，但是物件導向程式設計通常是順序執行的，而參與者模型是並列執行的。 同時運算 => Concurrent Computation 概念模型 => Conceptual Model 1973 提出來的
- IMMUATABLED 不變資料 ACTOR ONLY PROCESS 1 MESSAGE AT A TIME
- 容錯 Fault Tolerance
- R語言的定義
- R語言的定義
- 參與者是一個運算實體，回應接受到的訊息，同時並列的： 傳送有限數量的訊息給其他參與者； 建立有限數量的新參與者； 指定接受到下一個訊息時的行為。 以上操作不含有順序執行的假設，因此可以並列進行。
- 訊息接收者是通過位址區分的，有時也被稱作「郵件位址」。因此參與者只能和它擁有位址的參與者通訊。它可以通過接受到的資訊取得位址，或者取得它建立的參與者的位址。 參與者模型的特徵是，參與者內部或之間進行平行計算，參與者可以動態建立，參與者位址包含在訊息中，互動只有通過直接的異步訊息通訊，不限制訊息到達的順序。 Erlang 曾在 AXD301 ATM 機器上達到二十年 99.9999999% (nine-nines, 九個九)的可用時間。更能在不關機的情況下，直接修正有錯誤的程式碼，而且不影響到正常使用的使用者
- https://www.brianstorti.com/the-actor-model/
- It is a Actor Model base, Distributed by Default and built-in Supervision & monitoring can build powerful concurrent & distributed applications for more Reactive. Akka.NET simplify the building of scalable, concurrent, high-throughput and low latency systems. An elite group of projects who joined .NET Foundation on 2017
- is a world leader in building distributed systems and distributed systems tools in the .NET ecosystem; we serve our customers by providing them with professional-grade open source software packages, proprietary tooling, consulting, training, and support. Founded in 2015 in Los Angeles, California, Petabridge has been rapidly growing over the past 3 years. In 2017 we relocated from Los Angeles to Houston, Texas. Our customers span the globe, ranging from Fortune 500 companies like Boeing, Bank of America, S&P Global, and CitiGroup to early stage startups; we help them succeed by developing better, more resilient systems on the backs of open source technologies we develop such as Akka.NET, NBench, and others.
- 2014 Early version of Akka.NET is development
- Simplify the building of scalable, concurrent, high-throughput and low latency systems. 開源(Open Source) 不用手動管理執行緒，技術架構與實體 CPU核心架構解耦 能實作更高層次的抽象層 actors, messages, FSMs Asynchronous 高效能* ~ 50 million messages per second per machine 1GB heap memory =~ 2. million actors Load balancing / routing requests to child actors 支援 Scaling up 支援 Scaling out Location transparency Remote deployment using configuration 支援容錯與彈性的錯誤處理 Self-healing Supervisory Hierarchies and fault isolation 可作為套件(package)、 框架 (framework) 或架構(Architecture) 使用
- Bank of America, SNL Financial, Schneider Electric, Boeing, and others. https://www.lightbend.com/case-studies/uks-online-gaming-leader-bets-big-on-reactive-to-drive-real-time-personalization
- Actor contains all the computations. Actors can communicate only through messages. Actors can change their state or behavior. Actors can send messages to other actors. Actors can create a finite number of child actors.
- Demo Features Akka.NET Hello world UntypedActor and ReceiveActor(TypeActor) Tell, Ask, Forward
- By using Props, we can define a SupervisionStrategy,
- By using Props, we can define a SupervisionStrategy,
- The difference in this case is that when the actor encounters this kind of message, an exception will be thrown (ActorKilledExeption). This can be pretty useful if we want to show in logs that the actor was terminated. The usage of this seems to be rare, but it’s good to know.
- PoisonPill是一種特殊的消息（系統消息），它指示演員在收到此類消息後自行關閉。但是，只有在接收PoisonPill消息之前執行作為郵箱一部分的所有消息後，actor才會停止。之後發出的消息（如果有的話）將拋出錯誤（因為實際上，actor不再存在） The difference in this case is that when the actor encounters this kind of message, an exception will be thrown (ActorKilledExeption). This can be pretty useful if we want to show in logs that the actor was terminated. The usage of this seems to be rare, but it’s good to know.
- Demo Features Actor LifeCycle Stop & GracefulStop Actor
- Protocol akka:// Defines the communication protocol Akka.NET uses to communicate between actors. This is especially useful when it comes to the remote deployments of actors. For instance, we can define the use of the tcp protocol, such as akka.tcp or akka.udp. Actor system my-first-akka The name of the ActorSystem to which the actor belongs. Address @localhost:8000 In case of remote deployment of actors (actors running on another system), there is a possibility to also add the address location of that system. Path player-coordinator/John Refers to the path of this actor in the hierarchy.
- ActorContext (or just Context, as this is how the actor base library exposes it) exposes contextual information for the actor and the current message. It provides more information, such as: factory methods to create child actors (in the same way the ActorSystem does), lifecycle monitoring, supervised children, and so on.
- Resume Resuming a subordinate means that the subactor will be restarted, but it still keeps its internal state. This means the actor, after resuming, will keep doing its work from the point it stopped. Resuming an actor also means resuming all of its own subordinates. This is a chained operation! Restart This would completely clear out any subordinate’s internal state. However, the messages that are in the queue remain intact! This also means all of the subordinates’ created actors will be restarted. Stop Stops the subordinate permanently. Escalate This means the supervisor actor is not handling the error itself, but the handling of it is escalated to the supervisor’s parent actor. The supervisor actor is failing itself!
- OneForOneStrategy: This strategy will apply the directive only to the failing actor that has thrown an error. No other actors are affected. AllForOneStrategy: This strategy applies the directive to all of its children. This is particularly useful if the children actors are dependent on each other, so that the failure of one brings the logical failure of others.
- Multiple Actor and Actor's data ActorSystem path Actor behavior - Become() Supervision
- 大部份Routing 策略 Pool 與 Group 兩種都支援
- ConsistentHash can be very useful when dealing with Commands in the sense of CQRS or [Domain Driven Design].
- Demo Features Round Robin Random routing Shortest Mailbox queue Consistent Hashing Broadcast
- Akka.NET remoting enables communication between ActorSystems deployed on different application processes. This might include a different process on a single machine, or a completely different server. By default, Akka.NET uses the DotNetty library for the TCP transport. The responsibilities of the transport in Akka.NET are as follows: IP addressing and ports: All Akka.NET endpoints (client and servers) have to be accessible by an IP address and port. Message delivery: Should enable the delivery of messages from ActorSystem A to ActorSystem B. Message framing: Distinguishes individual messages within a network stream. Disconnect and error reporting: Tells Akka.Remote when a disconnect or transport error occurred. Preserving message order (optimal): Some transports (like UDP) make no such guarantees, but in general, it's recommended that the underlying transport preserve the write order of messages on the read side. DNS resolution (optional): Be able to resolve the DNS.
- Demo Features Akka.Remote Akka Configuration(hocon file)
- 容錯：群集優雅地從故障（尤其是網絡分區）中恢復。 彈性：簇本身俱有彈性，可根據需要向上/向下擴展。 分散：可以在整個集群中同時運行給定微服務或應用程序狀態的多個相等副本 點對點：新節點可以聯繫現有對等體，獲得有關其他對等體的通知，並在不進行任何配置更改的情況下將自身完全集成到網絡中。 沒有單點故障/瓶頸：多個節點能夠為請求提供服務，從而提高吞吐量和容錯能力。 Fault-tolerant: clusters recover from failures (especially network partitions) elegantly. Elastic: clusters are inherently elastic, and can scale up/down as needed. Decentralized: it's possible to have multiple equal replicas of a given microservice or piece of application state running simultaneously throughout a cluster Peer-to-peer: New nodes can contact existing peers, be notified about other peers, and fully integrate themselves into the network without any configuration changes. No single point of failure/bottleneck: multiple nodes are able to service requests, increasing throughput and fault-tolerance.
- 容錯：群集優雅地從故障（尤其是網絡分區）中恢復。 彈性：簇本身俱有彈性，可根據需要向上/向下擴展。 分散：可以在整個集群中同時運行給定微服務或應用程序狀態的多個相等副本 點對點：新節點可以聯繫現有對等體，獲得有關其他對等體的通知，並在不進行任何配置更改的情況下將自身完全集成到網絡中。 沒有單點故障/瓶頸：多個節點能夠為請求提供服務，從而提高吞吐量和容錯能力。 Fault-tolerant: clusters recover from failures (especially network partitions) elegantly. Elastic: clusters are inherently elastic, and can scale up/down as needed. Decentralized: it's possible to have multiple equal replicas of a given microservice or piece of application state running simultaneously throughout a cluster Peer-to-peer: New nodes can contact existing peers, be notified about other peers, and fully integrate themselves into the network without any configuration changes. No single point of failure/bottleneck: multiple nodes are able to service requests, increasing throughput and fault-tolerance.
- Demo Features Actor.Cluster combine multiple Actor System Load Actor System and cluster setting from configuration(hocon file) Need Akka.Remote Use HOCON
- Demo Features Actor model integrate with ASP.NET Core
- Demo Features Client generate game data to Web from Akka.Remote Use Akka.Scheduler to fire game data when target interval ASP.NET Core build multiple Actors ASP.NET Core use IHostedService play as console Use SignalR push data to Client Change Akka.Serializer from Json.NET to Hyperion
- Akka: A free and open-source toolkit and runtime simplifying the construction of concurrent and distributed applications on the JVM. Kubernetes: An open-source system for automating deployment, scaling, and management of containers. Docker: Container building,shipping and running platform sbt: The interactive build tool for Scala Scala: A general-purpose programming language providing support for functional programming and a strong static type system.
- Disruptor使用1個線程1的消費者模型， 其中Actors使用N：M模型，也就是說，您可以擁有盡可能多的角色，並且他們將分佈在固定數量的線程中（通常每個核心1個）。 BatchHandler接口為onEndOfBatch()提供了額外的（非常重要的）回調。 這允許緩慢的消費者，例如那些進行I / O的用戶將事件一起分批以提高吞吐量。 可以在其他Actor框架中進行批處理，但是由於幾乎所有其他框架在批處理結束時都不提供回調，因此需要使用超時來確定批處理的結束，從而導致延遲較差。
- https://petabridge.com/blog/top-7-akkadotnet-stumbling-blocks/ Making message classes mutable Losing sleep over Disassociated messages Sending MASSIVE messages over Akka.Remote Executing long-running actions inside an actor’s Receive method Using ActorSelection instead of IActorRef Over-dependence on Dependency Injection frameworks Confusing the procedural async / awaitmodel with actors
- Actors should be like nice co-workers: do their job efficiently without bothering everyone else needlessly and avoid hogging resources. Translated to programming this means to process events and generate responses (or more requests) in an event-driven manner. Actors should not block (i.e. passively wait while occupying a Thread) on some external entity—which might be a lock, a network socket, etc.—unless it is unavoidable; in the latter case see below. Do not pass mutable objects between actors. In order to ensure that, prefer immutable messages. If the encapsulation of actors is broken by exposing their mutable state to the outside, you are back in normal .NET concurrency land with all the drawbacks. Actors are made to be containers for behavior and state, embracing this means to not routinely send behavior within messages. One of the risks is to accidentally share mutable state between actors, and this violation of the actor model unfortunately breaks all the properties which make programming in actors such a nice experience. Top-level actors are the innermost part of your Error Kernel, so create them sparingly and prefer truly hierarchical systems. This has benefits with respect to fault-handling (both considering the granularity of configuration and the performance) and it also reduces the strain on the guardian actor, which is a single point of contention if over-used.
- https://rogerjohansson.blog/2016/03/13/random-things-learned-building-akka-net-part-1/