AkkashipsPrimeros pasos con Akka:Olvídate de los threads

Codemotion Madrid 2015 Juanjo López MartínMiguel Ángel Fernández Díaz

ÍndicePresentación

Introducción

Ideas generales

Actores

Entornos distribuidos

Akkaships

Hora de programar

¡A jugar!

Bajando el telón

PresentaciónJuanjo López Martín

Desarrollador (o algo así) de Big Data en StratioBD: Crossdata team.

Sufridor de Scala.

+ 10 años desarrollando Software.

Akka beginner! (or believer, I’m not sure)

Ingeniero Superior en Informática: UVA

@Orcrsit

Miguel Ángel Fernández Díaz2 años como Arquitecto Big Data en StratioBD: Crossdata team.

2 años de experiencia en el campo del HPC: UAX.

3 años como programador Java: Iberia L.A.E.

Akka beginner!

Ingeniero Superior en Informática: URJC

@miguel_afd

Introducción

Una aplicación cualquieraIngentes cantidades de eventos en poco tiempo

Entornos distribuidos

Alta concurrencia

Paralelización

Llamadas no bloqueantes

Asincronismo

Tolerancia a fallos

Alta disponibilidad

Escalabilidad

Robustez

¿Qué es Akka?Framework para el paso de mensajes de forma local o remota entre

entidades.

Modelo de actores

Futuros

Asincronismo

Ligero

Arquitectura P2P

Extensible

Modelo ”let it crash”

Scala & Java API

Licencia Apache

¿Por qué Akka mola?Transacciones en tiempo real: 50 millones de mensajes por segundo /

máquina

Efectivo y ligero para una máquina, potente y robusto para entornos distribuidos

2.5 millones de actores → 1GB de memoria

Out-of-the-box vs Customizable

Paraleliza de forma transparente

Jerarquías de supervisión

Diferentes paradigmas de concurrencia

Asincronía “de gratis” (evita bloqueos)

Escala bajo demanda

Comunidad activa

Casos de usoFrameworks con comunicación distribuida:

Apache Spark

Play Framework

Gatling

Stratio Crossdata

Comercio online:Amazon

Ebay

Medios de comunicación:The guardian

BBC

BancaCredit Suisse

Ideas Generales

Sistema de actoresLos actores son objetos que contienen un estado y un

comportamiento, y se comunican a través de mensajes que se almacenan en sus buzones.

Organización con tareas, que se dividen en subtareas para ser asignadas a las diferentes personas.

Jerarquías para que otras personas actúen en caso de fallo de aquellas personas a las que supervisan.

Es una estructura pesada con 1...N hilos, ¡así que crea sólo uno por aplicación!

Los actores deben tener tareas independientes y dirigidos por eventos.

¡No pases objetos mutables!

Evita llamadas bloqueantes si es posible.

val system = ActorSystem(“HelloSystem”, config)val helloActor = system.actorOf(Props[HelloActor])

Actor Reference & Actor PathUn actorRef representa a un Actor y es una referencia para que otros actores le envíen mensajes y, además, se utiliza para que cada mensaje tenga un sender

helloActor ! Welcome(“Hello”)helloActor ! “Bienvenido”

Actor Selection

La operación actorSelection es la forma de conseguir el ActorRef de un Actor a partir de su ActorPath.

Para ello, hacemos uso del valor context, que es implícito en cada Actor.

val stallone = context.actorSelection(“akka.tcp://gymSystem@10.0.0.1:4321/user/silvester”)stallone ! Combate(“A muerte”)

Supervisión y Tolerancia a fallos class Odin extends Actor

override val supervisorStrategy = OneForOneStrategy() {

case _: FatalException => Stopcase _: OverheadException =>

Escalatecase _: AccessException => Restartcase _: ReachabilityException =>

Resume}

val thor = context.actorOf(Props[MiHijo])

}

Actores

¿Qué es un actor?Un actor es un agente que solo sabe hacer 3 cosas:

Crear otros actores

Enviar y recibir mensajes

Actuar ante cada mensaje recibido

Procesamiento atómico

El actor transita de un estado a otro

Contento Triste

Mensaje = “Ya no te quiero para mi película”Sender = Spielberg

Procesamiento atómicoAcción1 = Llamo a mi representanteAcción2 = Encargo comida china

TomCruise TomCruise

class PingPongJugador extends Actor {def receive = {

case "Ping" => sender ! “Pong” case GolpeGanador() => CaraDeDecepcion()

}}

Mirando WhatsApp Mirando WhatsApp

Akka PropsClase proporcionada por Akka

orientada a la creación de actores mediante el paso de opciones que contienen información de configuración.

Es como una receta inmutable para crear actores con información asociada al despliegue del mismo.

object TomCruise {def props(edad: Int): Props =

Props(new TomCruise(edad))} class TomCruise(age: Int) extends Actor {def receive = { case _: String =>

sender() ! edad}} class SpielbergMovie extends Actor {context.actorOf(TomCruise.props(53),

"principal")}

Ciclo de vida de un Actor def preStart(): Unit = ()

def postStop(): Unit = () def preRestart(reason: Throwable,

message: Option[Any]): Unit = { context.children foreach { child ⇒

context.unwatch(child) context.stop(child) } postStop()}

def postRestart(reason: Throwable): Unit = { preStart()}

MailboxesEstructura donde se acumulan los mensajes pendientes de ser

procesados por un actor.

Normalmente, 1 actor = 1 mailbox, pero hay estrategias donde varios instancias del mismo actor pueden compartir el mismo mailbox.

Puedes implementar tu propio mailbox.

Akka ofrece varios tipos de mailbox donde las 2 características más determinantes es si son Unbounded o no y si son Blocking o no.

UnboundedMailboxMailbox por defectoImplementado con

java.util.concurrent.ConcurrentLinkedQueue

Blocking: NoBounded: No

BoundedPriorityMailboxLos mensajes de mayor prioridad tienen preferenciaImplementado con java.util.PriorityQueueBlocking: NoBounded: Si

Ask, Tell & ForwardA la hora de enviar un mensaje a un actor, podemos seguir 3 estrategias:

Ask (?): Send-And-Receive-Future (hay una variante bloqueante)Tell (!): Fire-forgetForward: Es unTell ya que el actor que envía este mensaje actúa como

mediador, dado que para el destinatario de este mensaje, el sender será aquel que envió el mensaje al mediador.

implicit val timeout = Timeout(5 seconds)val futuro = actor ? msg val resultado = Await.result(futuro, timeout.duration)

implicit val timeout = Timeout(5 seconds)val futuro = actor ? msg futuro onSuccess { case “ACK” => println(“¡Bien hecho!”) }futuro onComplete { case Success(resultado) => guardarInfo(resultado)

case Failure(error) => registrarError(error) }futuro onFailure { case e: Exception => println(“Error: ¡Otra vez será!”) }

Tell Forward

Tell

RoutersUn Router actúa como enrutador de una serie de actores.

El Router contiene el único mailbox y reparte las tareas entre los routees.

Puedes implementar tu propio Router aunque Akka ya proporciona varias implementaciones.

El Router supervisa a sus hijos y puede crear 2 tipos de estructuras:Pool: El Router crea los routees como hijos y los elimina según acaban sus tareas.

Group: Los routees son creados externamente y el Router envía los mensajes a estos routees mediante actorSelection y sin vigilar su terminación.

val emergencias: ActorRef = context.actorOf(RoundRobinPool(5).props(Props[Medico]), "hospital")

val suscriptores = List("/user/suscriptor/cliente1", "/user/suscriptor/cliente2")val periodico: ActorRef = context.actorOf(BroadcastGroup(suscriptores).props(), "LaComunidad")

Entornos distribuidos

Akka ClusterUn cluster está formado por uno o más nodos.

Tiene que haber al menos un nodo semilla.

Para que un nodo se una al cluster, debe conocer el host y el puerto de al menos de una de las semillas (Es aconsejable que se conozca más de una).

Organización descentralizada basada en servicios de suscripción sin único punto de fallo ni único cuello de botella.

Puede haber varios nodos en una misma máquina (hostname:port:uid).

Uno nodo semilla actúa como líder para la convergencia del cluster.

Protocolo Gossip para enviar información sobre el cluster.

Estados de un nodo

Akkaships

https://github.com/jjlopezmAkkaships-Exercisegit clone https://github.com/jjlopezm/Akkaships-Exercise.git

Hora de programar

Player

Ship Ship Ship

RouterBoard

Statistics Statistics

Server

Discover Server

Autodiscover Board

NewPlayerDiscover Players

Autodiscover Statistics

PlayerPlayer

Router

Statistics

NewPlayer

Inicio del juego

Player

Ship Ship Ship

Router

Board

Statistics

Router

Statistics Statistics

shot

shot shotshot

shot/ship statistics

BoardUpdate

statistics statistics statistics

PlayerPlayer

Disparando

Board

Statistics

Router

Statistics Statistics

Fin de partida

FinishBattleScore

ScoreScoreResult

ScoreResult ¿Todos los barcos hundidos?Player

PlayerPlayer

Fin de la partida

¡A jugar!

Bajando el telón

RecomendacionesCurso

https://www.coursera.org/course/reactive

Libros“Akka in Action” de Raymond Roestenburg y Rob Bakker“Akka Concurrency” de Derek Wyatt“Reactive Design Patterns” de Roland Kuhn y Jamie Allen

Soportehttps://groups.google.com/forum/#!forum/akka-user

http://doc.akka.io/docs/akka/2.4.0/scala.html

http://letitcrash.com/

http://orionsword.no-ip.org/

¡Gracias!