Question

如何在Linux系统中很好地配置Spring Boot应用程序打包为可执行jar作为服务？这是推荐的方法，还是应该将此应用程序转换为war并安装到Tomcat中？

目前我可以从screen会话运行Spring启动应用程序，这很不错，但需要在服务器重启后手动启动。

我正在寻找的是一般建议/指导或示例init.d脚本，如果我使用可执行文件 jar 的方法是正确的。

Answer 1

以下适用于springboot 1.3及更高版本：

作为init.d服务

可执行jar具有通常的启动，停止，重启和状态命令。它还将在通常的/ var / run目录中设置一个PID文件，并默认登录到通常的/ var / log目录。

你只需将你的jar符号链接到/etc/init.d就像这样

sudo link -s /var/myapp/myapp.jar /etc/init.d/myapp

OR

sudo ln -s ~/myproject/build/libs/myapp-1.0.jar /etc/init.d/myapp_servicename

之后你可以做通常的

/etc/init.d/myapp start

然后根据需要在启动时启动/停止应用程序的任何运行级别设置链接。

作为系统服务

要运行安装在var / myapp中的Spring Boot应用程序，您可以在/etc/systemd/system/myapp.service中添加以下脚本：

[Unit]
Description=myapp
After=syslog.target

[Service]
ExecStart=/var/myapp/myapp.jar

[Install]
WantedBy=multi-user.target

<小时/> 参考

http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/html/deployment-install.html#deployment-service

Answer 2

以下是在Linux中将Java应用程序安装为系统服务的最简单方法。

假设您正在使用systemd（现在任何现代发行版都有）：

首先，在/etc/systemd/system中创建一个名为eg的服务文件。 javaservice.service有此内容：

[Unit]
Description=Java Service

[Service]
User=nobody
# The configuration file application.properties should be here:
WorkingDirectory=/data 
ExecStart=/usr/bin/java -Xmx256m -jar application.jar --server.port=8081
SuccessExitStatus=143
TimeoutStopSec=10
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

其次，通知systemd新服务文件：

systemctl daemon-reload

并启用它，因此它在启动时运行：

systemctl enable javaservice.service

最终，您可以使用以下命令启动/停止新服务：

systemctl start javaservice
systemctl stop javaservice
systemctl restart javaservice
systemctl status javaservice

如果您使用systemd，这是将Java应用程序设置为系统服务的最非侵入性和干净的方式。

我特别喜欢这个解决方案，因为您不需要安装和配置任何其他软件。随附的systemd为您完成所有工作，您的服务与任何其他系统服务一样。我现在在生产中使用它一段时间，在不同的发行版上，它只是按照你的预期工作。

另一个优点是，通过使用/usr/bin/java，您可以轻松添加jvm等-Xmx256m参数。

另请阅读官方Spring Boot文档中的systemd部分： http://docs.spring.io/spring-boot/docs/current/reference/html/deployment-install.html

Answer 3

你也可以使用supervisord这是一个非常方便的守护进程，它可以用来轻松控制服务。这些服务由简单的配置文件定义，这些配置文件定义了哪个用户在哪个目录中执行什么等等，有很多选项。 supervisord 具有非常简单的语法，因此它是编写SysV init脚本的一个非常好的替代方法。

这是您尝试运行/控制的程序的简单 supervisord 配置文件。（把它放入 /etc/supervisor/conf.d/yourapp.conf ）

/etc/supervisor/conf.d/yourapp.conf

[program:yourapp]
command=/usr/bin/java -jar /path/to/application.jar
user=usertorun
autostart=true
autorestart=true
startsecs=10
startretries=3
stdout_logfile=/var/log/yourapp-stdout.log
stderr_logfile=/var/log/yourapp-stderr.log

要控制应用程序，您需要执行 supervisorctl ，它会向您显示启动，停止和状态显示的提示。

CLI

# sudo supervisorctl
yourapp             RUNNING   pid 123123, uptime 1 day, 15:00:00
supervisor> stop yourapp
supervisor> start yourapp

如果supervisord守护程序已在运行，并且您已添加了服务器的配置而未重新启动守护程序，则只需在{{1}中执行reread和update命令shell。

这确实为您提供了使用SysV Init脚本所具有的所有灵活性，但易于使用和控制。看看documentation。

Answer 4

我自己就是这样做的，所以以下是我目前在CentOS init.d服务控制器脚本方面的地方。到目前为止它工作得非常好，但我不是let Bash黑客，所以我确信还有改进的空间，所以欢迎改进它的想法。

首先，我为每个服务设置了一个简短的配置脚本/data/svcmgmt/conf/my-spring-boot-api.sh，用于设置环境变量。

#!/bin/bash
export JAVA_HOME=/opt/jdk1.8.0_05/jre
export APP_HOME=/data/apps/my-spring-boot-api
export APP_NAME=my-spring-boot-api
export APP_PORT=40001

我正在使用CentOS，所以为了确保在服务器重启后启动我的服务，我在/etc/init.d/my-spring-boot-api中有一个服务控制脚本：

#!/bin/bash
# description: my-spring-boot-api start stop restart
# processname: my-spring-boot-api
# chkconfig: 234 20 80

. /data/svcmgmt/conf/my-spring-boot-api.sh

/data/svcmgmt/bin/spring-boot-service.sh $1

exit 0

如您所见，它调用初始配置脚本来设置环境变量，然后调用我用来重新启动所有Spring Boot服务的共享脚本。共享脚本是可以找到它的全部内容的地方：

#!/bin/bash

echo "Service [$APP_NAME] - [$1]"

echo "    JAVA_HOME=$JAVA_HOME"
echo "    APP_HOME=$APP_HOME"
echo "    APP_NAME=$APP_NAME"
echo "    APP_PORT=$APP_PORT"

function start {
    if pkill -0 -f $APP_NAME.jar > /dev/null 2>&1
    then
        echo "Service [$APP_NAME] is already running. Ignoring startup request."
        exit 1
    fi
    echo "Starting application..."
    nohup $JAVA_HOME/bin/java -jar $APP_HOME/$APP_NAME.jar \
        --spring.config.location=file:$APP_HOME/config/   \
        < /dev/null > $APP_HOME/logs/app.log 2>&1 &
}

function stop {
    if ! pkill -0 -f $APP_NAME.jar > /dev/null 2>&1
    then
        echo "Service [$APP_NAME] is not running. Ignoring shutdown request."
        exit 1
    fi

    # First, we will try to trigger a controlled shutdown using 
    # spring-boot-actuator
    curl -X POST http://localhost:$APP_PORT/shutdown < /dev/null > /dev/null 2>&1

    # Wait until the server process has shut down
    attempts=0
    while pkill -0 -f $APP_NAME.jar > /dev/null 2>&1
    do
        attempts=$[$attempts + 1]
        if [ $attempts -gt 5 ]
        then
            # We have waited too long. Kill it.
            pkill -f $APP_NAME.jar > /dev/null 2>&1
        fi
        sleep 1s
    done
}

case $1 in
start)
    start
;;
stop)
    stop
;;
restart)
    stop
    start
;;
esac
exit 0

停止时，它将尝试使用Spring Boot Actuator执行受控关机。但是，如果Actuator未配置或未能在合理的时间范围内关闭（我给它5秒，实际上有点短），该过程将被终止。

此外，该脚本假设运行应用程序的java进程将是唯一一个在进程详细信息文本中带有“my-spring-boot-api.jar”的进程。这在我的环境中是一个安全的假设，意味着我不需要跟踪PID。

Answer 5

如果你想在Spring Boot Maven Plugin 1.3.0.M2中使用Spring Boot 1.2.5，这里有解决方案：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.5.RELEASE</version>
</parent>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>1.3.0.M2</version>
            <configuration>
                <executable>true</executable>
            </configuration>
        </plugin>
    </plugins>
</build>

<pluginRepositories>
    <pluginRepository>
        <id>spring-libs-milestones</id>
        <url>http://repo.spring.io/libs-milestone</url>
    </pluginRepository> 
</pluginRepositories>

然后编译为ususal：mvn clean package，创建一个符号链接ln -s /.../myapp.jar /etc/init.d/myapp，使其成为可执行文件chmod +x /etc/init.d/myapp并启动它service myapp start（使用Ubuntu Server）

Answer 6

我知道这是一个较老的问题，但我想提出另一种方式appassembler-maven-plugin。这是我的POM中的相关部分，其中包含我们认为有用的许多其他选项值：

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>appassembler-maven-plugin</artifactId>
    <configuration>
        <generateRepository>true</generateRepository>
        <repositoryLayout>flat</repositoryLayout>
        <useWildcardClassPath>true</useWildcardClassPath>
        <includeConfigurationDirectoryInClasspath>true</includeConfigurationDirectoryInClasspath>
        <configurationDirectory>config</configurationDirectory>
        <target>${project.build.directory}</target>
        <daemons>
            <daemon>
                <id>${installer-target}</id>
                <mainClass>${mainClass}</mainClass>
                <commandLineArguments>
                    <commandLineArgument>--spring.profiles.active=dev</commandLineArgument>
                    <commandLineArgument>--logging.config=${rpmInstallLocation}/config/${installer-target}-logback.xml</commandLineArgument>
                </commandLineArguments>
                <platforms>
                    <platform>jsw</platform>
                </platforms>
                <generatorConfigurations>
                    <generatorConfiguration>
                        <generator>jsw</generator>
                        <includes>
                            <include>linux-x86-64</include>
                        </includes>
                        <configuration>
                            <property>
                                <name>wrapper.logfile</name>
                                <value>logs/${installer-target}-wrapper.log</value>
                            </property>
                            <property>
                                <name>wrapper.logfile.maxsize</name>
                                <value>5m</value>
                            </property>
                            <property>
                                <name>run.as.user.envvar</name>
                                <value>${serviceUser}</value>
                            </property>
                            <property>
                                <name>wrapper.on_exit.default</name>
                                <value>RESTART</value>
                            </property>
                        </configuration>
                    </generatorConfiguration>
                </generatorConfigurations>
                <jvmSettings>
                    <initialMemorySize>256M</initialMemorySize>
                    <maxMemorySize>1024M</maxMemorySize>
                    <extraArguments>
                        <extraArgument>-server</extraArgument>
                    </extraArguments>
                </jvmSettings>
            </daemon>
        </daemons>
    </configuration>
    <executions>
        <execution>
            <id>generate-jsw-scripts</id>
            <phase>package</phase>
            <goals>
                <goal>generate-daemons</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Answer 7

作为WINDOWS服务

如果您希望在Windows机器上运行，请从

下载winsw.exe

 http://repo.jenkins-ci.org/releases/com/sun/winsw/winsw/2.1.2/

之后将其重命名为jar文件名（例如： your-app .jar）

winsw.exe -> your-app.exe

现在创建一个xml文件 your-app.xml 并将以下内容复制到该

<?xml version="1.0" encoding="UTF-8"?>
<service>
     <id>your-app</id>
     <name>your-app</name>
     <description>your-app as a Windows Service</description>
     <executable>java</executable>
     <arguments>-jar "your-app.jar"</arguments>
     <logmode>rotate</logmode>
</service>

确保 exe 和 xml 以及 jar 位于同一文件夹中。

在Administrator previlege 中打开命令提示符后，将其安装到Windows服务中。

your-app.exe install eg -> D:\Springboot\your-app.exe install

如果失败

Error: Registry key 'Software\JavaSoft\Java Runtime Environment'\CurrentVersion' has value '1.8', but '1.7' is required.

然后尝试以下方法：

Delete java.exe, javaw.exe and javaws.exe from C:\Windows\System32

多数民众赞成:)。

在Windows中卸载服务

your-app.exe uninstall

查看/运行/停止服务： win + r 并输入管理工具，然后从中选择服务。然后右键单击选择选项 - 运行/停止

Answer 8

我的Centos 6 / RHEL的SysVInit脚本（还不理想）。此脚本需要ApplicationPidListener。

/etc/init.d/app

的来源

#!/bin/sh
#
# app Spring Boot Application 
#
# chkconfig:   345 20 80
# description: App Service
#           

### BEGIN INIT INFO
# Provides: App
# Required-Start: $local_fs $network
# Required-Stop: $local_fs $network
# Default-Start: 3 4 5 
# Default-Stop: 0 1 2 6
# Short-Description: Application
# Description:      
### END INIT INFO

# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

exec="/usr/bin/java"
prog="app"
app_home=/home/$prog/
user=$prog

[ -e /etc/sysconfig/$prog ] && . /etc/sysconfig/$prog

lockfile=/var/lock/subsys/$prog    
pid=$app_home/$prog.pid

start() {

    [ -x $exec ] || exit 5
    [ -f $config ] || exit 6
    # Check that networking is up.
    [ "$NETWORKING" = "no" ] && exit 1
    echo -n $"Starting $prog: "
    cd $app_home
    daemon --check $prog --pidfile $pid --user $user $exec $app_args &
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    killproc -p $pid $prog
    retval=$?
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {
    stop
    start
}

reload() {
    restart
}

force_reload() {
    restart
}

rh_status() {
    status -p $pid $prog
}

rh_status_q() {
    rh_status >/dev/null 2>&1
}

case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
        restart
        ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload}"
        exit 2
esac
exit $?

示例配置文件/etc/sysconfig/app：

exec=/opt/jdk1.8.0_05/jre/bin/java

user=myuser
app_home=/home/mysuer/

app_args="-jar app.jar"

pid=$app_home/app.pid

Answer 9

我正在尝试将springboot应用程序呈现为＆＃34; init.d＆＃34;最后添加了压缩java应用程序的样式shell脚本

通过将这些脚本从/etc/init.d/spring-app符号链接到/opt/spring-app.jar并chmod使jar可执行，可以使＆＃34; / etc / init.d / spring-app start＆＃34; ＆＃34; /etc/init.d/spring-app stop＆＃34;和状态工作等其他可能性

据推测，由于springboot的init.d样式脚本看起来他们有必要的魔术字符串（如# Default-Start: 2 3 4 5），chkconfig可以将其添加为＆＃34;服务＆＃34;

但我想让它与systemd一起使用

为了完成这项工作，我尝试了上面其他答案中的许多收件人，但没有一个对我有用在Centos 7.2上使用Springboot 1.3主要是他们会启动服务但是无法跟踪pid

最后，当发现/etc/init.d链接时，我发现以下内容对我有用。应将类似于下面的文件安装为/usr/lib/systemd/system/spring-app.service

[Unit]
Description=My loverly application
After=syslog.target 

[Service]
Type=forking
PIDFile=/var/run/spring-app/spring-app.pid
ExecStart=/etc/init.d/spring-app start
SuccessExitStatus=143

[Install]
WantedBy=multi-user.target

Answer 10

这是一个将可执行jar部署为systemd服务的脚本。

它为服务和.service文件创建一个用户，并将jar文件放在/ var下，并对权限进行一些基本锁定。

#!/bin/bash

# Argument: The jar file to deploy
APPSRCPATH=$1

# Argument: application name, no spaces please, used as folder name under /var
APPNAME=$2

# Argument: the user to use when running the application, may exist, created if not exists
APPUSER=$3

# Help text
USAGE="
Usage: sudo $0 <jar-file> <app-name> <runtime-user>
If an app with the name <app-name> already exist, it is stopped and deleted.
If the <runtime-user> does not already exist, it is created.
"

# Check that we are root
if [ ! "root" = "$(whoami)" ]; then
    echo "Must be root. Please use e.g. sudo"
    echo "$USAGE"
    exit
fi

# Check arguments
if [ "$#" -ne 3 -o ${#APPSRCPATH} = 0 -o ${#APPNAME} = 0 -o ${#APPUSER} = 0 ]; then
    echo "Incorrect number of parameters."
    echo "$USAGE"
    exit
fi

if [ ! -f $APPSRCPATH ]; then
    echo "Can't find jar file $APPSRCPATH"
    echo "$USAGE"
    exit
fi

# Infered values
APPFILENAME=$(basename $APPSRCPATH)
APPFOLDER=/var/javaapps/$APPNAME
APPDESTPATH=$APPFOLDER/$APPFILENAME

# Stop the service if it already exist and is running
systemctl stop $APPNAME >/dev/null 2>&1

# Create the app folder, deleting any previous content
rm -fr $APPFOLDER
mkdir -p $APPFOLDER

# Create the user if it does not exist
if id "$APPUSER" >/dev/null 2>&1; then
    echo "Using existing user $APPUSER"
else
    adduser --disabled-password --gecos "" $APPUSER
    echo "Created user $APPUSER"
fi

# Place app in app folder, setting owner and rights
cp $APPSRCPATH $APPDESTPATH
chown $APPUSER $APPDESTPATH
chmod 500 $APPDESTPATH
echo "Added or updated the $APPDESTPATH file"

# Create the .service file used by systemd
echo "
[Unit]
Description=$APPNAME
After=syslog.target
[Service]
User=$APPUSER
ExecStart=/usr/bin/java -jar $APPDESTPATH
SuccessExitStatus=143
[Install]
WantedBy=multi-user.target
" > /etc/systemd/system/$APPNAME.service
echo "Created the /etc/systemd/system/$APPNAME.service file"

# Reload the daemon
systemctl daemon-reload

# Start the deployed app
systemctl start $APPNAME
systemctl status $APPNAME

实施例：

Answer 11

在这个问题中，来自@PbxMan的答案应该让你开始：

Run a Java Application as a Service on Linux

编辑：

使用cron：

还有另一种不太好的启动重启过程的方法

@reboot user-to-run-under /usr/bin/java -jar /path/to/application.jar

这样可行，但不会为您的应用程序提供良好的启动/停止界面。无论如何，你仍然可以简单kill ......

Answer 12

你在使用Maven吗？然后你应该尝试AppAssembler插件：

Application Assembler Plugin是一个Maven插件，用于生成启动java应用程序的脚本。 ...所有工件（依赖项+项目中的工件）都会添加到生成的bin脚本中的类路径中。

支持的平台：

Unix的变体

Windows NT（不支持Windows 9x）

Java Service Wrapper（JSW）

请参阅：http://mojo.codehaus.org/appassembler/appassembler-maven-plugin/index.html

Answer 13

我不知道使用Java应用程序执行此操作的“标准”收缩包装方式，但这绝对是一个好主意（您希望受益于操作系统的保持活动和监视功能，如果它们在那儿）。它是在路线图中提供Spring Boot工具支持（maven和gradle）的东西，但是现在你可能不得不自己动手了。我现在知道的最好的解决方案是Foreman，它有一个声明式方法和一个用于打包各种标准操作系统格式（monit，sys V，upstart等）的初始化脚本的行命令。还有证据表明人们已经设置了gradle（例如here）。

Answer 14

我最终为WAR / JAR布局提供了systemd服务

我称它为Java -jar是因为它更灵活。试图也把ExecStart = spring-mvc.war放进去，但是即使它是可执行的，我也遇到了“ Exec格式错误”

无论如何，如今，所有发行版中都存在systemd，并且它提供了一种重定向日志的好方法（当您甚至不启动log4j时，syserr就很重要，log4j文件位置将为空:)）。

cat /etc/systemd/system/spring-mvc.service 
[Unit]
Description=Spring MVC Java Service

[Service]
User=spring-mvc
# The configuration file application.properties should be here:
WorkingDirectory=/usr/local/spring-mvc


# Run ExecStartPre with root-permissions
PermissionsStartOnly=true

ExecStartPre=-/bin/mkdir -p /var/log/spring-mvc


ExecStartPre=/bin/chown -R spring-mvc:syslog /var/log/spring-mvc
ExecStartPre=/bin/chmod -R 775 /var/log/spring-mvc



#https://www.freedesktop.org/software/systemd/man/systemd.service.html#ExecStart=
ExecStart=/usr/bin/java \
        -Dlog4j.configurationFile=log4j2-spring.xml \
        -DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector \
        -Dspring.profiles.active=dev \
        -Denvironment-type=dev \
        -XX:+UseConcMarkSweepGC \
        -XX:CMSInitiatingOccupancyFraction=80 \
        -XX:NewSize=756m \
        -XX:MetaspaceSize=256m \
        -Dsun.net.inetaddr.ttl=5 \
        -Xloggc:/var/log/spring-mvc/gc.log \
        -verbose:gc \
        -verbosegc \
        -XX:+DisableExplicitGC \
        -XX:+PrintGCDetails \
        -XX:+PrintGCDateStamps \
        -XX:+PreserveFramePointer \
        -XX:+StartAttachListener \
        -Xms1024m \
        -Xmx1024m \
        -XX:+HeapDumpOnOutOfMemoryError \
        -jar spring-mvc.war

SuccessExitStatus=143
StandardOutput=journal
StandardError=journal


KillSignal=SIGINT
TimeoutStopSec=20
Restart=always
RestartSec=5
StartLimitInterval=0
StartLimitBurst=10

LimitNOFILE=500000
LimitNPROC=500000

#https://www.freedesktop.org/software/systemd/man/systemd.exec.html#LimitCPU=
#LimitCPU=, LimitFSIZE=, LimitDATA=, LimitSTACK=, LimitCORE=, LimitRSS=, LimitNOFILE=, LimitAS=, LimitNPROC=, LimitMEMLOCK=, LimitLOCKS=, LimitSIGPENDING=, LimitMSGQUEUE=, LimitNICE=, LimitRTPRIO=, LimitRTTIME=¶

SyslogIdentifier=spring-mvc

[Install]
WantedBy=multi-user.target


# https://www.freedesktop.org/software/systemd/man/journalctl.html
#check logs --- journalctl -u spring-mvc -f -o cat

rsyslog-将syslog输入从应用程序重定向到特定的文件夹/文件

cat /etc/rsyslog.d/30-spring-mvc.conf 
if $programname == 'spring-mvc' then /var/log/spring-mvc/spring-mvc.log
& stop

logrotate

cat /etc/logrotate.d/spring-mvc.conf 
/var/log/spring-mvc/spring-mvc.log
{
    daily
    rotate 30
    maxage 30
    copytruncate
    missingok
    notifempty
    compress
    dateext
    dateformat _%Y-%m-%d_%H-%M
    delaycompress
    create 644 spring-mvc syslog
    su spring-mvc syslog
}

logrotate gc

cat /etc/logrotate.d/spring-mvc-gc.conf 
/var/log/spring-mvc/gc.log
{
    daily
    rotate 30
    maxage 30
    copytruncate
    missingok
    notifempty
    compress
    dateext
    dateformat _%Y-%m-%d_%H-%M
    delaycompress
    create 644 spring-mvc syslog
    su spring-mvc syslog
}

Answer 15

跟进Chad的优秀答案，如果您收到错误“错误：无法找到或加载主类” - 您花了几个小时尝试对其进行故障排除，无论您执行的是shell脚本启动你的java应用程序或从systemd本身启动它 - 你知道你的类路径100％正确，例如手动运行shell脚本以及运行systemd execstart中的内容。确保您正在以正确的用户身份运行！在我的情况下，我尝试了不同的用户，经过一段时间的故障排除 - 我终于有了预感，把root作为用户 - 瞧，应用程序正确启动。确定它是一个错误的用户问题后，我chown -R user:user文件夹和子文件夹以及应用程序作为指定的用户和组正确运行，因此不再需要以root身份运行它（安全性差）。

Answer 16

在systemd单位文件中，您可以设置环境变量目录或通过EnvironmentFile来设置。我建议以这种方式进行操作，因为这似乎是最少的摩擦。

样本单位文件

$ cat /etc/systemd/system/hello-world.service
[Unit]
Description=Hello World Service
After=systend-user-sessions.service

[Service]
EnvironmentFile=/etc/sysconfig/hello-world
Type=simple
ExecStart=/usr/bin/java ... hello-world.jar

然后在/etc/sysconfig/hello-world下设置一个文件，其中包含Spring Boot变量的大写名称。例如，名为server.port的变量将以SERVER_PORT的形式作为环境变量：

$ cat /etc/sysconfig/hello-world
SERVER_PORT=8081

这里利用的机制是Spring Boot应用程序将获取属性列表，然后对其进行转换，将所有内容变为大写，并用下划线替换点。 Spring Boot应用程序完成此过程后，它将查找匹配的环境变量，并使用相应找到的任何环境变量。

在此SO问答中，标题为How to set a Spring Boot property with an underscore in its name via Environment Variables?

对此进行了详细说明。

参考文献

Part IV. Spring Boot features - 24. Externalized Configuration

Answer 17

Spring Boot项目的build.gradle文件中需要以下配置。

build.gradle

jar {
    baseName = 'your-app'
    version = version
}

springBoot {
    buildInfo()
    executable = true   
    mainClass = "com.shunya.App"
}

executable = true

这是在unix系统（Centos和Ubuntu）上制作完全可执行的jar所必需的

创建.conf文件

如果要配置自定义JVM属性或Spring Boot应用程序运行参数，则可以创建一个与Spring Boot应用程序名称相同的.conf文件，并将其与jar文件平行。

考虑到your-app.jar是您的Spring Boot应用程序的名称，那么您可以创建以下文件。

JAVA_OPTS="-Xms64m -Xmx64m"
RUN_ARGS=--spring.profiles.active=prod
LOG_FOLDER=/custom/log/folder

此配置将为Spring Boot应用程序设置64 MB内存，并激活产品配置文件。

在Linux中创建新用户

为了增强安全性，我们必须创建一个特定用户以将Spring Boot应用程序作为服务运行。

创建一个新用户

sudo useradd -s /sbin/nologin springboot

在Ubuntu / Debian上，如下修改上述命令：

sudo useradd -s /usr/sbin/nologin springboot

设置密码

sudo passwd springboot

使springboot成为可执行文件的所有者

chown springboot:springboot your-app.jar

防止修改jar文件

chmod 500 your-app.jar

这将配置jar的权限，以使其无法写入，并且只能由其所有者springboot读取或执行。

您可以选择使用change attribute（chattr）命令使jar文件不可变。

sudo chattr +i your-app.jar

还应该为相应的.conf文件设置适当的权限。 .conf只需读取访问权限（Octal 400），而不是读取+执行（Octal 500）访问

chmod 400 your-app.conf

创建系统服务

/etc/systemd/system/your-app.service

[Unit]
Description=Your app description
After=syslog.target

[Service]
User=springboot
ExecStart=/var/myapp/your-app.jar
SuccessExitStatus=143

[Install]
WantedBy=multi-user.target

如果进程被操作系统杀死，将自动重启

附加以下两个属性（Restart和RestartSec）以在失败时自动重新启动进程。

/etc/systemd/system/your-app.service

[Service]
User=springboot
ExecStart=/var/myapp/your-app.jar
SuccessExitStatus=143
Restart=always
RestartSec=30

此更改将使Spring Boot应用程序在发生故障的情况下重新启动，并延迟30秒。如果使用systemctl命令停止该服务，则不会重新启动。

系统启动时安排服务

要标记应用程序在系统启动时自动启动，请使用以下命令：

在系统启动时启用Spring Boot应用程序

sudo systemctl enable your-app.service

启动停止服务

systemctl可在Ubuntu 16.04 LTS和18.04 LTS中用于启动和停止该过程。

开始该过程

sudo systemctl start your-app

停止流程

sudo systemctl stop your-app

参考

https://docs.spring.io/spring-boot/docs/current/reference/html/deployment-install.html

Answer 18

创建一个名称为your-app.service（rest-app.service）的脚本。我们应该将此脚本放在/ etc / systemd / system目录中。这是脚本的示例内容

[Unit]
Description=Spring Boot REST Application
After=syslog.target

[Service]
User=javadevjournal
ExecStart=/var/rest-app/restdemo.jar
SuccessExitStatus=200

[Install]
WantedBy=multi-user.target

下一步：

 service rest-app start

参考

enter link description here

Answer 19

对于 SpringBoot 2.4.4，除了说明 @ismael

我的 maven pom.xml 中有以下内容以使其成为可执行的 jar

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>               
            <configuration>
                <executable>true</executable>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Spring Boot应用程序即服务

19 个答案:

/etc/supervisor/conf.d/yourapp.conf

CLI

样本单位文件

参考文献