Scaling software with akka

Scaling
software with

Jonas Bonér
CTO Typesafe
Twitter: @jboner

Akka: ソフトウェアをスケールさせる

Scaling
Scaling
software with
software with

Scaling
Scaling
Copyright 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

高レベルプログラミング

• Never think in terms of shared state, state
visibility, threads, locks, concurrent collections,
thread notiﬁcations etc.


• Low level concurrency plumbing BECOMES
SIMPLE WORKFLOW - you only think about how
messages ﬂow in the system


• You get high CPU utilization, low latency, high
throughput and scalability - FOR FREE as part of
the model


• 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

生まれながらに分散化されている

• 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


- elastic & dynamic

- fault-tolerant & self-healing


- elastic & dynamic


- adaptive load-balancing, cluster rebalancing & actor migration


- elastic & dynamic


- 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

アクターを使おう

Let’s use Actors

How

アクターを使おう

What is an Actor?

コードを分割して、並行性、スケーラビリティ、
耐障害性の高いアプリケーションを支援する

What is an Actor?
• Akka's unit of code organization is called an Actor


What is an Actor?
• Actors helps you create concurrent, scalable and
fault-tolerant applications


What is an Actor?

• 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?

• 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?

スレッド、コンポーネント、コールバックなどの代替

In different scenarios, an Actor may be an
alternative to:


alternative to:
- a thread


alternative to:
- a thread

- an object instance or component


alternative to:
- a thread


- a callback or listener


alternative to:
- a thread



- a singleton or service


alternative to:
- a thread




- a router, load-balancer or pool


alternative to:
- a thread





- a Java EE Session Bean or Message-Driven Bean


alternative to:
- a thread






- an out-of-process service


alternative to:
- a thread






- an out-of-process service

- a Finite State Machine (FSM)


So, what is the
Actor Model?

アクターモデルとは何か?

Carl Hewitt’s deﬁnition

http://bit.ly/hewitt-on-actors

処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定

- The fundamental unit of computation that embodies:



- Processing



- Processing

- Storage



- Processing

- Storage

- Communication



- Processing

- Storage

- Communication

- 3 axioms - When an Actor receives a message it can:



- Processing

- Storage

- Communication

- Create new Actors



- Processing

- Storage

- Communication

- Create new Actors

- Send messages to Actors it knows



- Processing

- Storage

- Communication

- Create new Actors

- Send messages to Actors it knows

- Designate how it should handle the next message it receives



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
Deﬁne the message(s) the Actor
should be able to respond to


def receive = {
}
}


0. DEFINE

Deﬁne the Actor class

def receive = {
}
}


0. DEFINE

Deﬁne the Actor class

def receive = {
}
}

Deﬁne 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

def receive = {
}
}

val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")

ActorRef が返ってくる

CREATE Actor

def receive = {
case Greeting(who) Create an Actor system " + who)
=> log.info("Hello
}
}



CREATE Actor

def receive = {
=> log.info("Hello
}
Actor conﬁguration
}



CREATE Actor

def receive = {
=> log.info("Hello
}
}


Give it a name


CREATE Actor

def receive = {
=> log.info("Hello
}
}


Create the Actor Give it a name


CREATE Actor

def receive = {
=> log.info("Hello
}
}


Create the Actor
You get an ActorRef back Give it a name


Actors can form hierarchies
Guardian System Actor

階層構造を作ることができる


system.actorOf(Props[Foo], “Foo”)



Foo system.actorOf(Props[Foo], “Foo”)



Foo

context.actorOf(Props[A], “A”)



Foo

A context.actorOf(Props[A], “A”)



Foo Bar

A
A C

E C
B
B
D


Name resolution - like a ﬁle-system

Foo Bar

A
A C

E C
B
B
D

ファイルシステムのような名前解決


/Foo

Foo Bar

A
A C

E C
B
B
D



/Foo

Foo Bar

/Foo/A
A
A C

E C
B
B
D



/Foo

Foo Bar

/Foo/A
A
A C

/Foo/A/B

E C
B
B
D



/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
• Asynchronous and Non-blocking - Fire-forget


2. SEND
• EVERYTHING is asynchronous and lockless


2. SEND
• Everything happens Reactively


2. SEND
- An Actor is passive until a message is sent to it, which
triggers something within the Actor


2. SEND

- Messages is the Kinetic Energy in an Actor system


2. SEND

- 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


SEND message

def receive = {
}
}

greeter ! Greeting("Charlie Parker")

SEND message

def receive = {
}
}


Send the message

Full example

def receive = {
}
}


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 conﬁg
akka.actor.deployment {
/path/to/actor {
router = round-robin
nr-of-instances = 5
}
}

conﬁg ファイルからも設定できる

…or from conﬁg
akka.actor.deployment {
/path/to/actor {
router = round-robin
resizer {
lower-bound = 12
upper-bound = 15
}
}
}

もしくは設定から

3. BECOME

動的にアクターの振る舞いを再定義
振る舞いはスタックして push/pop することができる

3. BECOME
• BECOME - dynamically redeﬁnes Actor’s behavior


3. BECOME
• Triggered reactively by receive of message


3. BECOME
• In a type system analogy it is as if the object changed
type - changed interface, protocol & implementation


3. BECOME
• Will now react differently to the messages it receives


3. BECOME
• Will now react differently to the messages it receives
• Behaviors are stacked & can be pushed and popped

Why would I want to do that?

例) 輻輳時にアクターをルータへ変身、FSM の実装など

• 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!




• Other: Use your imagination!
• Very useful once you get the used to it

become

context become {
// new body
case NewMessage =>
...
}

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


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


single thread
• This leads to DEFENSIVE programming with:


single thread
• Error handling TANGLED with business logic


single thread
• SCATTERED all over the code base


single thread
• 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


4. SUPERVISE
• Error handling in actors is handle by letting Actors
monitor (supervise) each other for failure


4. SUPERVISE
• This means that if an Actor crashes, a notiﬁcation
will be sent to his supervisor, who can react upon
the failure


4. SUPERVISE
• This means that if an Actor crashes, a notiﬁcation
will be sent to his supervisor, who can react upon
the failure
• This provides clean separation of processing and
error handling


Fault-tolerant
onion-layered
Error Kernel

玉ねぎのように階層化された耐障害性

SUPERVISE Actor
Every single actor has a
default supervisor strategy.
Which is usually sufﬁcient.
But it can be overridden.

デフォルトの Supervisor 戦略をオーバーライドできる

SUPERVISE Actor
Every single actor has a
default supervisor strategy.
Which is usually sufﬁcient.
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
}
}

故障の管理

Remote deployment
Just feed the ActorSystem with this conﬁguration

akka {
actor {
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote =
}
}
}
}

リモート配備: ActorSystem にこの設定を渡すだけ

Remote deployment

Conﬁgure a Remote Provider
akka {
actor {
deployment {
/greeter {
remote =
}
}
}
}


Remote deployment

akka {
For the Greeter actor {
actor
deployment {
/greeter {
remote =
}
}
}
}


Remote deployment

akka {
actor
deployment {
/greeter {
remote =
}
}
Deﬁne Remote Path
}
}


Remote deployment

akka {
actor
deployment {
/greeter {
remote = akka://
}
}
Deﬁne Remote Path
} Protocol
}


Remote deployment

akka {
actor
deployment {
/greeter {
remote = akka://MySystem
}
}
Deﬁne Remote Path
} Protocol Actor System
}


Remote deployment

akka {
actor
deployment {
/greeter {
remote = akka://MySystem@machine1
}
}
Deﬁne Remote Path
} Protocol Actor System Hostname
}


Remote deployment

akka {
actor
deployment {
/greeter {
remote = akka://MySystem@machine1:2552
}
}
Deﬁne Remote Path
} Protocol Actor System Hostname Port
}


Remote deployment
Zero code changes
akka {
actor
deployment {
/greeter {
}
}
Deﬁne Remote Path
} Protocol Actor System Hostname Port
}


Remote Lookup

val greeter = system.actorFor(
"akka://MySystem@machine1:2552/user/greeter")

リモートアクターを探す

Can you see the problem?

問題に気付いたかな?

Fixed Addresses
akka {
actor {
deployment {
/greeter {
}
}
}
}

val greeter = system.actorFor(
"akka://MySystem@machine1:2552/user/greeter")

アドレスが決め打ちされている

Features
• Gossip-based Cluster Membership
• Leader determination
• Accrual Failure Detector
• Cluster DeathWatch
• Cluster-Aware Routers

Gossip-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
}
}

クラスタを使う

Conﬁgure 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
TestKit FSM
Pub/Sub
Durable Mailboxes
IO
Camel
EventBus
Pooling
Typed Channels
Microkernel
SLF4J
TypedActor
ZeroMQ Dataﬂow Transactors
Agents Extensions

get it and learn more
http://akka.io
http://letitcrash.com
http://typesafe.com

Scaling software with akka

More Related Content

Scaling software with akka