13

首选方式是在远程 Linux 服务器上部署 Scala 应用程序。

这是在远程服务器上部署 Scala 应用程序的一种相当简单但有限的方法（非常适合快速测试不太敏感的项目）：

  1. 从远程服务器，我从 git 中提取我的源代码
  2. 使用sbt-assembly插件我在服务器上构建了一个 jar

  3. 然后我使用 nohup 运行 Scala 应用程序，它允许您在不终止进程的情况下退出远程会话：

    nohup java -jar myapp.jar > myapp.log 2> myapp.err < /dev/null &

首先，考虑到它正在使用数据库等资源，一旦进程运行，停止进程的最佳方法是什么。我只是查找java进程ID并对其进行核对吗？

其次，在重新启动时自动启动 java 应用程序的最佳方法是什么。我记得过去使用过 init.d，但记得因为它是一个 java 应用程序，所以遇到了一些困难。

更新：

我错过了这里房间里的大象。我正在使用 Spray 库，该库又使用 Akka，因此提供了许多有趣的选项。

4

2 回答 2

17

给猫剥皮的方法有很多种...

您可以使用 sbt-start-script https://github.com/sbt/sbt-start-script甚至 sbt-native-packager https://github.com/sbt/sbt-native-packager

您可以将 Spray 的 Boot 示例脚本包装在一个简单的 init.d 脚本中，该脚本调用 sbt，如本答案https://stackoverflow.com/a/17399574/155689中所述，或者只使用普通的nohupjava 命令。

您可以创建更大的守护进程感知类和脚本，或者使用使用 Jsvc http://commons.apache.org/proper/commons-daemon/jsvc.html或 Java Service Wrapper的 init.d 脚本扩展这些类和脚本。http://wrapper.tanukisoftware.com/

守护进程和应用程序类的示例：

package com.example.myapplication.server

import akka.actor.{Props, ActorSystem}
import spray.can.Http
import akka.io.IO
import com.example.myapplication.api.MyServiceActor
import org.apache.commons.daemon._

trait ApplicationLifecycle {
  def start(): Unit
  def stop(): Unit
}

abstract class AbstractApplicationDaemon extends Daemon {
  def application: ApplicationLifecycle

  def init(daemonContext: DaemonContext) {}

  def start() = application.start()

  def stop() = application.stop()

  def destroy() = application.stop()
}

class ApplicationDaemon() extends AbstractApplicationDaemon {
  def application = new Application
}

object ServiceApplication extends App {

  val application = createApplication()

  def createApplication() = new ApplicationDaemon

  private[this] var cleanupAlreadyRun: Boolean = false

  def cleanup(){
    val previouslyRun = cleanupAlreadyRun
    cleanupAlreadyRun = true
    if (!previouslyRun) application.stop()
  }

  Runtime.getRuntime.addShutdownHook(new Thread(new Runnable {
    def run() {
      cleanup()
    }
  }))

  application.start()
}


class Application() extends ApplicationLifecycle with Logging {

  private[this] var started: Boolean = false

  private val applicationName = "MyApplication"

  implicit val actorSystem = ActorSystem(s"$applicationName-system")

  def start() {
    logger.info(s"Starting $applicationName Service")

    if (!started) {
      started = true

      val myService = actorSystem.actorOf(Props[MyServiceActor], "my-service")

      IO(Http) ! Http.Bind(myService, interface = "0.0.0.0", port = 8280)
    }
  }

  def stop() {
    logger.info(s"Stopping $applicationName Service")

    if (started) {
      started = false
      actorSystem.shutdown()
    }
  }

}

如果您在 中部署 jar（对 fat jar 使用 sbt-assembly） ，请/opt/myapplication/myapplication.jar在文件夹中添加一些外部配置/etc/mycompany，然后您可以将其包装在/etc/init.d/myapplication脚本中，例如使用 Jsvc：

#!/bin/sh
### BEGIN INIT INFO
# Provides:          myapplication
# Required-Start:    $local_fs $remote_fs $network
# Required-Stop:     $local_fs $remote_fs $network
# Should-Start:      $named
# Should-Stop:       $named
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Control myapplication
# Description:       Control the myapplication daemon.
### END INIT INFO

set -e

if [ -z "${JAVA_HOME}" ]; then
        JAVA_HOME=$(readlink -f /usr/bin/java | sed "s:/bin/java::")
fi
JAVA_OPTS="-Xms512m -Xmx1024m"

APP=myapplication

PID=/var/run/${APP}.pid
OUT_LOG=/var/log/myapplication/${APP}_out.log
ERR_LOG=/var/log/myapplication/${APP}_err.log

DAEMON_USER=yourserviceuser

APP_LOG_CONFIG=/etc/mycompany/${APP}_logback.xml
APP_CONFIG=/etc/mycompany/${APP}.conf
APP_HOME=/opt/${APP}
APP_CLASSPATH=$APP_HOME/${APP}.jar
APP_CLASS=com.example.myapplication.server.ApplicationDaemon

if [ -n "$APP_LOG_CONFIG}" ]; then
        JAVA_OPTS="-Dlogback.configurationFile=${APP_LOG_CONFIG} ${JAVA_OPTS}"
fi

DAEMON_ARGS="-home ${JAVA_HOME} -Dconfig.file=${APP_CONFIG} ${JAVA_OPTS} -pidfile ${PID} -user ${DAEMON_USER} -outfile ${OUT_LOG} -errfile ${ERR_LOG} -cp ${APP_CLASSPATH} ${APP_CLASS}"

. /lib/lsb/init-functions

case "$1" in
        start)
                log_daemon_msg "Starting ${APP}"
                cd ${APP_HOME} && jsvc ${DAEMON_ARGS}
                log_end_msg 0
                ;;
        stop)
                log_daemon_msg "Stopping ${APP}"
                cd ${APP_HOME} && jsvc -stop ${DAEMON_ARGS}
                log_end_msg 0
                ;;
        *)
                log_success_msg "Usage:  {start|stop}"
                echo "Usage:  {start|stop}"
                exit 1
                ;;
esac

exit 0

有了这个，你现在可以sudo service myapplication start|stop

如果如前所述，您希望它在启动时自动启动，然后运行此命令

sudo update-rc.d myapplication defaults

这种守护进程方法适用于我拥有的 Spray 应用程序。

于 2014-03-18T12:51:41.990 回答
0

如果maven合适，可以使用以下插件： http: //evgeny-goldin.com/wiki/Sshexec-maven-plugin

可能它可以很容易地移植到sbt

于 2013-03-12T15:01:04.790 回答