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://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

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