Question

我知道从Akka 2.4.16开始，Reactive Streams没有“远程”实现。该规范侧重于在单个JVM上运行的流。

但是，考虑用例涉及另一个JVM进行某些处理，同时保持背压。我们的想法是拥有一个主应用程序，它提供运行流的用户界面。例如，此流有一个阶段执行一些应该在不同机器上运行的繁重计算。我对以分布式方式运行流的方式感兴趣 - 我发现了一些指出一些想法的文章：

使用Akka HTTP（Stackoverflow）
在一定程度上用动脉简化它（Stackoverflow，Akka Blog）
将演员合并为一个流（Answer from Viktor Klang，Akka Docs）

还有其他选择吗？以上是否有任何重大缺点？有什么特殊要考虑？

更新：此问题不仅限于一个用例。我通常对在分布式环境中使用流的所有可能方法感兴趣。这意味着，例如它只能涉及一个流与.mapAsync或{在通过Akka HTTP进行通信的两台机器上可能有两个独立的流。唯一的要求是必须在所有组件中强制执行背压。

Answer 1

嗯......似乎我必须为此添加一个例子。您需要了解的一件事是BackPressure由GraphStages中的AsyncBoundries处理。它实际上与其他地方存在的组件无关。此外......它不依赖于Artery，它只是新的远程运输。

这是一个可能是最简单的跨jvm流的例子，

第一次申请，

import akka.actor.{Actor, ActorLogging, ActorSystem, Props}
import akka.actor.Actor.Receive
import com.typesafe.config.{Config, ConfigFactory}

class MyActor extends Actor with ActorLogging {
  override def receive: Receive = {
    case msg @ _ => {
      log.info(msg.toString)
      sender() ! msg
    }
  }
}

object MyApplication extends App {

  val config = ConfigFactory.parseString(
    """
      |akka{
      |  actor {
      |    provider = remote
      |  }
      |  remote {
      |    enabled-transports = ["akka.remote.netty.tcp"]
      |    untrusted-mode = off
      |    netty.tcp {
      |      hostname="127.0.0.1"
      |      port=18000
      |    }
      |  }
      |}
    """.stripMargin
  )

  val actorSystem = ActorSystem("my-actor-system", config)

  var myActor = actorSystem.actorOf(Props(classOf[MyActor]), "my-actor")

}

第二次申请......实际上＆＃34;运行＆＃34;在第一个应用程序中使用actor的流。

import akka.actor.{ActorPath, ActorSystem}
import akka.stream.ActorMaterializer
import akka.stream.scaladsl.{Flow, Keep, Sink, Source}
import akka.pattern.ask
import com.typesafe.config.ConfigFactory

import scala.language.postfixOps
import scala.concurrent.duration._

object YourApplication extends App {

  val config = ConfigFactory.parseString(
    """
      |akka{
      |  actor {
      |    provider = remote
      |  }
      |  remote {
      |    enabled-transports = ["akka.remote.netty.tcp"]
      |    untrusted-mode = off
      |    netty.tcp {
      |      hostname="127.0.0.1"
      |      port=19000
      |    }
      |  }
      |}
    """.stripMargin
  )

  val actorSystem = ActorSystem("your-actor-system", config)

  import actorSystem.dispatcher

  val logger = actorSystem.log

  implicit val implicitActorSystem = actorSystem
  implicit val actorMaterializer = ActorMaterializer()

  val myActorPath = ActorPath.fromString("akka.tcp://my-actor-system@127.0.0.1:18000/user/my-actor")

  val myActorSelection = actorSystem.actorSelection(myActorPath)

  val source = Source(1 to 10)

  // here this "mapAsync" wraps the given T => Future[T] function in a GraphStage
  val myRemoteComponent = Flow[Int].mapAsync(2)(i => {
    myActorSelection.resolveOne(1 seconds).flatMap(myActorRef => 
      (myActorRef.ask(i)(1 seconds)).map(x => x.asInstanceOf[Int])
    )
  })

  val sink = Sink.foreach[Int](i => logger.info(i.toString))

  val stream = source.via(myRemoteComponent).toMat(sink)(Keep.right)

  val streamRun = stream.run()

}

Answer 2

在Akka 2.5.10及更高版本中，您现在可以使用StreamRefs。 StreamRef是为此用例设计的，因此它们特别适用于远程工作队列，因为它们会承受压力，直到本地连接到它们的流可以接受更多工作为止。

如何在Akka Streams中维持涉及多个JVM的压力

2 个答案: