Scaling software with akka
Upcoming SlideShare
Loading in...5
×
 

Scaling software with akka

on

  • 2,193 views

Scala Conference in Japan 2013

Scala Conference in Japan 2013

Statistics

Views

Total Views
2,193
Views on SlideShare
2,173
Embed Views
20

Actions

Likes
7
Downloads
63
Comments
0

3 Embeds 20

http://librosweb.es 13
https://twitter.com 6
https://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Scaling software with akka Scaling software with akka Presentation Transcript

  • Scaling software with Jonas Bonér CTO Typesafe Twitter: @jbonerAkka: ソフトウェアをスケールさせる
  • Scaling Scaling software withsoftware with
  • Scaling ScalingCopyright Ingeborg van Leeuwen software with software with
  • Selection of Akka Production Users
  • Manage System Overloadシステムの過負荷を管理する
  • Automatic Replication & Distribution for Fault-tolerance & Scalability耐障害性とスケーラビリティを自動的に実現
  • Program at a Higher Level高レベルプログラミング
  • Program at a Higher Level高レベルプログラミング
  • Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc.高レベルプログラミング
  • Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc. • Low level concurrency plumbing BECOMES SIMPLE WORKFLOW - you only think about how messages flow in the system高レベルプログラミング
  • Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc. • Low level concurrency plumbing BECOMES SIMPLE WORKFLOW - you only think about how messages flow in the system • You get high CPU utilization, low latency, high throughput and scalability - FOR FREE as part of the model高レベルプログラミング
  • Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc. • Low level concurrency plumbing BECOMES SIMPLE WORKFLOW - you only think about how messages flow in the system • You get high CPU utilization, low latency, high throughput and scalability - FOR FREE as part of the model • Proven and superior model for detecting and recovering from errors高レベルプログラミング
  • Distributable by Design生まれながらに分散化されている
  • Distributable by Design生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design• Scale UP and OUT for free as part of the model生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design• Scale UP and OUT for free as part of the model• You get the PERFECT FABRIC for the CLOUD生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design• Scale UP and OUT for free as part of the model• You get the PERFECT FABRIC for the CLOUD - elastic & dynamic生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design• Scale UP and OUT for free as part of the model• You get the PERFECT FABRIC for the CLOUD - elastic & dynamic - fault-tolerant & self-healing生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design• Scale UP and OUT for free as part of the model• You get the PERFECT FABRIC for the CLOUD - elastic & dynamic - fault-tolerant & self-healing - adaptive load-balancing, cluster rebalancing & actor migration生まれながらに分散化されている
  • Distributable by Design• Actors are location transparent & distributable by design• Scale UP and OUT for free as part of the model• You get the PERFECT FABRIC for the CLOUD - elastic & dynamic - fault-tolerant & self-healing - adaptive load-balancing, cluster rebalancing & actor migration - build extremely loosely coupled and dynamic systems that can change and adapt at runtime生まれながらに分散化されている
  • How can we achieve this?これをどうやって実現するか?
  • How can we achieve this?アクターを使おう
  • Let’s use Actors How can we achieve this?アクターを使おう
  • What is an Actor?コードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
  • What is an Actor? • Akkas unit of code organization is called an Actorコードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
  • What is an Actor? • Akkas unit of code organization is called an Actor • Actors helps you create concurrent, scalable and fault-tolerant applicationsコードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
  • What is an Actor? • Akkas unit of code organization is called an Actor • Actors helps you create concurrent, scalable and fault-tolerant applications • Like Java EE servlets and session beans, Actors is a model for organizing your code that keeps many “policy decisions” separate from the business logicコードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
  • What is an Actor? • Akkas unit of code organization is called an Actor • Actors helps you create concurrent, scalable and fault-tolerant applications • Like Java EE servlets and session beans, Actors is a model for organizing your code that keeps many “policy decisions” separate from the business logic • Actors may be new to many in the Java community, but they are a tried-and-true concept (Hewitt 1973) used for many years in telecom systems with 9 nines uptimeコードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
  • What can I use Actors for?スレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to:スレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a threadスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or componentスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listenerスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or serviceスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or poolスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool - a Java EE Session Bean or Message-Driven Beanスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool - a Java EE Session Bean or Message-Driven Bean - an out-of-process serviceスレッド、コンポーネント、コールバックなどの代替
  • What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool - a Java EE Session Bean or Message-Driven Bean - an out-of-process service - a Finite State Machine (FSM)スレッド、コンポーネント、コールバックなどの代替
  • So, what is the Actor Model?アクターモデルとは何か?
  • Carl Hewitt’s definition http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: - Create new Actors http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: - Create new Actors - Send messages to Actors it knows http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: - Create new Actors - Send messages to Actors it knows - Designate how it should handle the next message it receives http://bit.ly/hewitt-on-actors処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
  • 4 core Actor operations 0. DEFINE 1. CREATE 2. SEND 3. BECOME 4. SUPERVISEアクターの4つの主な仕事
  • 0. DEFINE case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) } }処理可能なメッセージ、振る舞いの定義
  • 0. DEFINE Define the message(s) the Actor should be able to respond to case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) } }処理可能なメッセージ、振る舞いの定義
  • 0. DEFINE Define the message(s) the Actor should be able to respond to Define the Actor class case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) } }処理可能なメッセージ、振る舞いの定義
  • 0. DEFINE Define the message(s) the Actor should be able to respond to Define the Actor class case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) } } Define the Actor’s behavior処理可能なメッセージ、振る舞いの定義
  • 1. CREATE • CREATE - creates a new instance of an Actor • Extremely lightweight (2.7 Million per Gb RAM) • Very strong encapsulation - encapsulates: -  state -  behavior -  message queue • State & behavior is indistinguishable from each other • Only way to observe state is by sending an actor a message and see how it reacts新規アクターの作成。強力なカプセル化。メッセージを送ってその反応を見て状態を観測する。
  • CREATE Actor case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) } } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter")ActorRef が返ってくる
  • CREATE Actor case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor system " + who) => log.info("Hello } } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter")ActorRef が返ってくる
  • CREATE Actor case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor system " + who) => log.info("Hello } Actor configuration } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter")ActorRef が返ってくる
  • CREATE Actor case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor system " + who) => log.info("Hello } Actor configuration } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter") Give it a nameActorRef が返ってくる
  • CREATE Actor case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor system " + who) => log.info("Hello } Actor configuration } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter") Create the Actor Give it a nameActorRef が返ってくる
  • CREATE Actor case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor system " + who) => log.info("Hello } Actor configuration } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter") Create the Actor You get an ActorRef back Give it a nameActorRef が返ってくる
  • Actors can form hierarchies Guardian System Actor階層構造を作ることができる
  • Actors can form hierarchies Guardian System Actor system.actorOf(Props[Foo], “Foo”)階層構造を作ることができる
  • Actors can form hierarchies Guardian System Actor Foo system.actorOf(Props[Foo], “Foo”)階層構造を作ることができる
  • Actors can form hierarchies Guardian System Actor Foo context.actorOf(Props[A], “A”)階層構造を作ることができる
  • Actors can form hierarchies Guardian System Actor Foo A context.actorOf(Props[A], “A”)階層構造を作ることができる
  • Actors can form hierarchies Guardian System Actor Foo Bar A A C E C B B D階層構造を作ることができる
  • Name resolution - like a file-system Guardian System Actor Foo Bar A A C E C B B Dファイルシステムのような名前解決
  • Name resolution - like a file-system Guardian System Actor /Foo Foo Bar A A C E C B B Dファイルシステムのような名前解決
  • Name resolution - like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A A C E C B B Dファイルシステムのような名前解決
  • Name resolution - like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A A C /Foo/A/B E C B B Dファイルシステムのような名前解決
  • Name resolution - like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A A C /Foo/A/B E C B B D /Foo/A/Dファイルシステムのような名前解決
  • 2. SEND非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • EVERYTHING is asynchronous and lockless非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • EVERYTHING is asynchronous and lockless • Everything happens Reactively非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • EVERYTHING is asynchronous and lockless • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • EVERYTHING is asynchronous and lockless • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor - Messages is the Kinetic Energy in an Actor system非同期でノンブロッキングなメッセージの送信
  • 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • EVERYTHING is asynchronous and lockless • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor - Messages is the Kinetic Energy in an Actor system - Actors can have lots of buffered Potential Energy but cant do anything with it until it is triggered by a message非同期でノンブロッキングなメッセージの送信
  • SEND messagecase class Greeting(who: String)class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) }}val system = ActorSystem("MySystem")val greeter = system.actorOf(Props[GreetingActor], name = "greeter")greeter ! Greeting("Charlie Parker")
  • SEND messagecase class Greeting(who: String)class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) }}val system = ActorSystem("MySystem")val greeter = system.actorOf(Props[GreetingActor], name = "greeter")greeter ! Greeting("Charlie Parker") Send the message
  • Full examplecase class Greeting(who: String)class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello " + who) }}val system = ActorSystem("MySystem")val greeter = system.actorOf(Props[GreetingActor], name = "greeter")greeter ! Greeting("Charlie Parker")
  • Load Balancing
  • Routers
  • Routers val router = system.actorOf( Props[SomeActor].withRouter( RoundRobinRouter(nrOfInstances = 5)))ルータを使う
  • Router + Resizer val resizer = DefaultResizer(lowerBound = 2, upperBound = 15) val router = system.actorOf( Props[ExampleActor1].withRouter( RoundRobinRouter(resizer = Some(resizer))))リサイザを加える
  • …or from config akka.actor.deployment { /path/to/actor { router = round-robin nr-of-instances = 5 } }config ファイルからも設定できる
  • …or from config akka.actor.deployment { /path/to/actor { router = round-robin resizer { lower-bound = 12 upper-bound = 15 } } }もしくは設定から
  • 3. BECOME動的にアクターの振る舞いを再定義振る舞いはスタックして push/pop することができる
  • 3. BECOME • BECOME - dynamically redefines Actor’s behavior動的にアクターの振る舞いを再定義振る舞いはスタックして push/pop することができる
  • 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message動的にアクターの振る舞いを再定義振る舞いはスタックして push/pop することができる
  • 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message • In a type system analogy it is as if the object changed type - changed interface, protocol & implementation動的にアクターの振る舞いを再定義振る舞いはスタックして push/pop することができる
  • 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message • In a type system analogy it is as if the object changed type - changed interface, protocol & implementation • Will now react differently to the messages it receives動的にアクターの振る舞いを再定義振る舞いはスタックして push/pop することができる
  • 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message • In a type system analogy it is as if the object changed type - changed interface, protocol & implementation • Will now react differently to the messages it receives • Behaviors are stacked & can be pushed and popped動的にアクターの振る舞いを再定義振る舞いはスタックして push/pop することができる
  • Why would I want to do that?例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • Why would I want to do that? • Let a highly contended Actor adaptively transform itself into an Actor Pool or a Router例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • Why would I want to do that? • Let a highly contended Actor adaptively transform itself into an Actor Pool or a Router • Implement an FSM (Finite State Machine)例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • Why would I want to do that? • Let a highly contended Actor adaptively transform itself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • Why would I want to do that? • Let a highly contended Actor adaptively transform itself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation • Spawn up (empty) generic Worker processes that can become whatever the Master currently needs例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • Why would I want to do that? • Let a highly contended Actor adaptively transform itself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation • Spawn up (empty) generic Worker processes that can become whatever the Master currently needs • Other: Use your imagination!例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • Why would I want to do that? • Let a highly contended Actor adaptively transform itself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation • Spawn up (empty) generic Worker processes that can become whatever the Master currently needs • Other: Use your imagination! • Very useful once you get the used to it例) 輻輳時にアクターをルータへ変身、FSM の実装など
  • becomecontext become { // new body case NewMessage => ...}
  • Failure Recovery in Java/C/C# etc.従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with:従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with: • Error handling TANGLED with business logic従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with: • Error handling TANGLED with business logic • SCATTERED all over the code base従来のリカバリはスレッドを用いたもの
  • Failure Recovery in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with: • Error handling TANGLED with business logic • SCATTERED all over the code base We can do better than this!!!従来のリカバリはスレッドを用いたもの
  • Just LET IT CRASHクラッシュさせろ
  • クラッシュさせろ
  • 4. SUPERVISEアクターの故障時は上司の Supervisor が通知され、対応する。通常処理とエラー処理が分離できる。
  • 4. SUPERVISE • SUPERVISE - manage another Actor’s failuresアクターの故障時は上司の Supervisor が通知され、対応する。通常処理とエラー処理が分離できる。
  • 4. SUPERVISE • SUPERVISE - manage another Actor’s failures • Error handling in actors is handle by letting Actors monitor (supervise) each other for failureアクターの故障時は上司の Supervisor が通知され、対応する。通常処理とエラー処理が分離できる。
  • 4. SUPERVISE • SUPERVISE - manage another Actor’s failures • Error handling in actors is handle by letting Actors monitor (supervise) each other for failure • This means that if an Actor crashes, a notification will be sent to his supervisor, who can react upon the failureアクターの故障時は上司の Supervisor が通知され、対応する。通常処理とエラー処理が分離できる。
  • 4. SUPERVISE • SUPERVISE - manage another Actor’s failures • Error handling in actors is handle by letting Actors monitor (supervise) each other for failure • This means that if an Actor crashes, a notification will be sent to his supervisor, who can react upon the failure • This provides clean separation of processing and error handlingアクターの故障時は上司の Supervisor が通知され、対応する。通常処理とエラー処理が分離できる。
  • Fault-tolerant onion-layered Error Kernel玉ねぎのように階層化された耐障害性
  • ErrorKernel
  • ErrorKernel
  • ErrorKernel
  • ErrorKernel
  • ErrorKernel
  • ErrorKernel
  • Node 1 Node 2ErrorKernel
  • SUPERVISE Actor Every single actor has a default supervisor strategy. Which is usually sufficient. But it can be overridden.デフォルトの Supervisor 戦略をオーバーライドできる
  • SUPERVISE Actor Every single actor has a default supervisor strategy. Which is usually sufficient. But it can be overridden. class Supervisor extends Actor { override val supervisorStrategy = (maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate }デフォルトの=Supervisor 戦略をオーバーライドできる val worker context.actorOf(Props[Worker])
  • SUPERVISE Actor class Supervisor extends Actor { override val supervisorStrategy = (maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate } val worker = context.actorOf(Props[Worker]) def receive = { case n: Int => worker forward n } }デフォルトの Supervisor 戦略をオーバーライドできる
  • Manage failure class Worker extends Actor { ... override def preRestart( reason: Throwable, message: Option[Any]) { ... // clean up before restart } override def postRestart(reason: Throwable) { ... // init after restart } }故障の管理
  • Remoting
  • Remote deployment Just feed the ActorSystem with this configuration akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } } }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } } }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } } }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } Define Remote Path } }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = akka:// } } Define Remote Path } Protocol }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = akka://MySystem } } Define Remote Path } Protocol Actor System }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = akka://MySystem@machine1 } } Define Remote Path } Protocol Actor System Hostname }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = akka://MySystem@machine1:2552 } } Define Remote Path } Protocol Actor System Hostname Port }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote deployment Just feed the ActorSystem with this configuration Zero code changes Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = akka://MySystem@machine1:2552 } } Define Remote Path } Protocol Actor System Hostname Port }リモート配備: ActorSystem にこの設定を渡すだけ
  • Remote Lookup val greeter = system.actorFor( "akka://MySystem@machine1:2552/user/greeter")リモートアクターを探す
  • Can you see the problem?問題に気付いたかな?
  • Fixed Addresses akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = akka://MySystem@machine1:2552 } } } } val greeter = system.actorFor( "akka://MySystem@machine1:2552/user/greeter")アドレスが決め打ちされている
  • Akka Cluster
  • Features • Gossip-based Cluster Membership • Leader determination • Accrual Failure Detector • Cluster DeathWatch • Cluster-Aware RoutersGossip-based なクラスタ・メンバーシップ
  • Enable clustering akka { actor { provider = "akka.cluster.ClusterActorRefProvider" ... }    cluster { seed-nodes = [ "akka://ClusterSystem@127.0.0.1:2551", "akka://ClusterSystem@127.0.0.1:2552" ]   auto-down = on } }クラスタを使う
  • Configure a clustered router akka.actor.deployment  {    /statsService/workerRouter  {        router  =  consistent-­‐hashing        nr-­‐of-­‐instances  =  100        cluster  {            enabled  =  on            max-nr-of-instances-per-node = 3            allow-­‐local-­‐routees  =  on        }    } }クラスタ化されたルータの設定
  • ...we have much much more
  • ...we have much much more TestKit FSM Pub/SubDurable Mailboxes IO Camel EventBus Pooling Typed ChannelsMicrokernel SLF4J TypedActor ZeroMQ Dataflow Transactors Agents Extensions
  • get it and learn more http://akka.io http://letitcrash.com http://typesafe.com
  • E0F