Scaling software with akka
-
Upload
scalaconfjp -
Category
Documents
-
view
2.490 -
download
1
description
Transcript of Scaling software with akka
Jonas BonérCTO Typesafe
Twitter : @jboner
Scaling software with
Akka: ソフトウェアをスケールさせる
Scaling software withScaling software with
Scaling software withScaling software with
Copyright Ingeborg van Leeuwen
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?
アクターを使おう
How can we achieve this?
Let’s use Actors
アクターを使おう
What is an Actor?
コードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
What is an Actor?• Akka's unit of code organization is called an Actor
コードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
What is an Actor?• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and fault-tolerant applications
コードを分割して、並行性、スケーラビリティ、耐障害性の高いアプリケーションを支援する
What is an Actor?• Akka's 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?• Akka's 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 theActor Model?
アクターモデルとは何か?
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- The fundamental unit of computation that embodies:
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- The fundamental unit of computation that embodies:
- Processing
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- The fundamental unit of computation that embodies:
- Processing
- Storage
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
- 3 axioms - When an Actor receives a message it can:
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
- 3 axioms - When an Actor receives a message it can:
- Create new Actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- 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
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
- 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
処理、記憶、通信を行う基礎単位。受信時の 3公理:新規作成、他のアクターとの通信、次のメッセージ処理の指定
4 core Actor operations
0. DEFINE1. CREATE2. SEND3. BECOME4. 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. DEFINEDefine 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. DEFINEDefine 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) }}
Define the Actor class
処理可能なメッセージ、振る舞いの定義
0. DEFINEDefine 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) }}
Define the Actor class
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 Actorcase 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 Actorcase 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")
Create an Actor system
ActorRef が返ってくる
CREATE Actorcase 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")
Create an Actor system Actor configuration
ActorRef が返ってくる
CREATE Actorcase 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")
Give it a name
Create an Actor system Actor configuration
ActorRef が返ってくる
CREATE Actor
Create the 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")
Give it a name
Create an Actor system Actor configuration
ActorRef が返ってくる
CREATE Actor
Create the 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")
Give it a nameYou get an ActorRef back
Create an Actor system Actor configuration
ActorRef が返ってくる
Guardian System Actor
Actors can form hierarchies
階層構造を作ることができる
Guardian System Actor
system.actorOf(Props[Foo], “Foo”)
Actors can form hierarchies
階層構造を作ることができる
Foo
Guardian System Actor
system.actorOf(Props[Foo], “Foo”)
Actors can form hierarchies
階層構造を作ることができる
Foo
Guardian System Actor
context.actorOf(Props[A], “A”)
Actors can form hierarchies
階層構造を作ることができる
A
Foo
Guardian System Actor
context.actorOf(Props[A], “A”)
Actors can form hierarchies
階層構造を作ることができる
A
B
BarFoo
C
BE
A
D
C
Guardian System Actor
Actors can form hierarchies
階層構造を作ることができる
A
B
BarFoo
C
BE
A
D
C
Guardian System Actor
Name resolution - like a file-system
ファイルシステムのような名前解決
A
B
BarFoo
C
BE
A
D
C
/Foo
Guardian System Actor
Name resolution - like a file-system
ファイルシステムのような名前解決
A
B
BarFoo
C
BE
A
D
C
/Foo
/Foo/A
Guardian System Actor
Name resolution - like a file-system
ファイルシステムのような名前解決
A
B
BarFoo
C
BE
A
D
C
/Foo
/Foo/A
/Foo/A/B
Guardian System Actor
Name resolution - like a file-system
ファイルシステムのような名前解決
A
B
BarFoo
C
BE
A
D
C
/Foo
/Foo/A
/Foo/A/B
/Foo/A/D
Guardian System Actor
Name resolution - like a file-system
ファイルシステムのような名前解決
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 can't do anything with it until it is triggered by a message
非同期でノンブロッキングなメッセージの送信
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")greeter ! Greeting("Charlie Parker")
SEND message
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")greeter ! Greeting("Charlie Parker")
SEND message
Send the message
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")greeter ! Greeting("Charlie Parker")
Full example
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 の実装など
become
context become { // new body case NewMessage => ... }
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!!!
Failure Recovery in Java/C/C# etc.
従来のリカバリはスレッドを用いたもの
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
ErrorKernel
Node 1 Node 2
SUPERVISE ActorEvery single actor has a
default supervisor strategy.Which is usually sufficient.But it can be overridden.
デフォルトの Supervisor 戦略をオーバーライドできる
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 }}
SUPERVISE ActorEvery single actor has a
default supervisor strategy.Which is usually sufficient.But it can be overridden.
デフォルトの Supervisor 戦略をオーバーライドできる
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 }}
SUPERVISE Actor
デフォルトの Supervisor 戦略をオーバーライドできる
class Worker extends Actor { ... override def preRestart( reason: Throwable, message: Option[Any]) { ... // clean up before restart } override def postRestart(reason: Throwable) { ... // init after restart }}
Manage failure
故障の管理
Remoting
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
For the Greeter actor
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
Define Remote Path
For the Greeter actor
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
Define Remote Path Protocol
For the Greeter actor
akka://
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
Define Remote Path Protocol Actor System
For the Greeter actor
akka://MySystem
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
Define Remote Path Protocol Actor System Hostname
For the Greeter actor
akka://MySystem@machine1
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configuration
Configure a Remote Provider
Define Remote Path Protocol Actor System Hostname Port
For the Greeter actor
akka://MySystem@machine1:2552
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /greeter { remote = } } }}
Just feed the ActorSystem with this configurationZero code changes
Configure a Remote Provider
Define Remote Path Protocol Actor System Hostname Port
For the Greeter actor
akka://MySystem@machine1:2552
Remote deployment
リモート配備: ActorSystem にこの設定を渡すだけ
Remote Lookup
val greeter = system.actorFor( "akka://MySystem@machine1:2552/user/greeter")
リモートアクターを探す
Can you see the problem?
問題に気付いたかな?
Fixed Addressesakka { 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 Routers
Gossip-based なクラスタ・メンバーシップ
Enable clusteringakka { actor { provider = "akka.cluster.ClusterActorRefProvider" ... } cluster { seed-nodes = [ "akka://[email protected]:2551", "akka://[email protected]: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
Dataflow
...we have much much moreFSM
Transactors
Pub/Sub
ZeroMQ
Microkernel
IO
TestKit
Agents
SLF4J
Durable Mailboxes
EventBus CamelPooling
TypedActor
Extensions
Typed Channels
get it and learn morehttp://akka.io
http://typesafe.comhttp://letitcrash.com
E0F