Hizmet olarak Spring Boot uygulaması

Linux sisteminde bir Hizmet olarak yürütülebilir kavanoz olarak paketlenmiş güzel Spring Boot uygulaması nasıl yapılandırılır? Bu önerilen yaklaşım mı, yoksa bu uygulamayı savaşa dönüştürmeli ve Tomcat'e yüklemeli miyim?

Şu anda, screengüzel ama sunucu yeniden başlatıldıktan sonra manuel başlatma gerektiren oturumdan Spring boot uygulamasını çalıştırabilirim .

Aradığım şey init.d, yürütülebilir jar ile yaklaşımım uygunsa , genel tavsiye / yön veya senaryo örneğidir .

Springboot 1.3 ve üstü için aşağıdakiler çalışır:

İnit.d servisi olarak

Yürütülebilir kavanoz olağan başlatma, durdurma, yeniden başlatma ve durum komutlarına sahiptir. Ayrıca olağan / var / run dizininde bir PID dosyası kurar ve varsayılan olarak normal / var / log dizininde oturum açar.

Sadece kavanozunuzu /etc/init.d içine sembolize etmeniz yeterlidir.

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

VEYA

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

Bundan sonra her zamanki gibi yapabilirsiniz

/etc/init.d/myapp start

Ardından, istenirse uygulamanın önyüklemede başlatılmasını / durdurulmasını istediğiniz çalışma seviyesinde bir bağlantı oluşturun.

Bir sistem hizmeti olarak

Var / myapp üzerine kurulu bir Spring Boot uygulamasını çalıştırmak için /etc/systemd/system/myapp.service dosyasına aşağıdaki komut dosyasını ekleyebilirsiniz:

[Unit]
Description=myapp
After=syslog.target

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

[Install]
WantedBy=multi-user.target

Not: Bu yöntemi kullanıyorsanız, jar dosyasının kendisini çalıştırılabilir yapmayı unutmayın (chmod + x ile), aksi takdirde "İzin reddedildi" hatasıyla başarısız olur.

Referans

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

Aşağıda, bir Java uygulamasını Linux'ta sistem hizmeti olarak yüklemenin en kolay yolu gösterilmektedir.

Diyelim systemdki (bugünlerde herhangi bir modern dağıtımın yaptığı):

Öncelikle, /etc/systemd/systemörneğin javaservice.servicebu içeriğe sahip adlı bir hizmet dosyası oluşturun :

[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

İkinci olarak, systemdyeni hizmet dosyasını bilgilendirin :

systemctl daemon-reload

ve etkinleştirin, böylece önyüklemede çalışır:

systemctl enable javaservice.service

Sonunda, yeni hizmetinizi başlatmak / durdurmak için aşağıdaki komutları kullanabilirsiniz:

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

Kullandığınız takdirde systemd, bu bir Java uygulamasını sistem hizmeti olarak ayarlamanın en müdahaleci ve temiz yoludur.

Bu çözüm hakkında özellikle sevdiğim şey, başka bir yazılım yüklemenize ve yapılandırmanıza gerek olmamasıdır. Gönderilen systemdtüm işleri sizin için yapar ve hizmetiniz diğer tüm sistem hizmetleri gibi davranır. Bir süredir üretimde, farklı dağıtımlarda kullanıyorum ve beklediğiniz gibi çalışıyor.

Başka bir artı, kullanarak /usr/bin/java, jvmgibi parametreler kolayca ekleyebilirsiniz -Xmx256m.

systemdResmi Spring Boot belgelerindeki bölümü de okuyun : http://docs.spring.io/spring-boot/docs/current/reference/html/deployment-install.html

Ayrıca , hizmetleri kolayca kontrol etmek için kullanılabilecek çok kullanışlı bir arka plan programı olan süpervizörü de kullanabilirsiniz . Bu hizmetler, hangi kullanıcının hangi dizinde vb. Çalıştırılacağını tanımlayan basit yapılandırma dosyalarıyla tanımlanır ve bir milyon seçenek vardır. süpervizörün çok basit bir sözdizimi vardır, bu nedenle SysV başlangıç ​​komut dosyaları yazmak için çok iyi bir alternatif yapar.

Burada çalıştırmaya / kontrol etmeye çalıştığınız program için basit bir yönetici yapılandırma dosyası. (bunu /etc/supervisor/conf.d/yourapp.conf içine koyun )

/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

Uygulamayı kontrol etmek için , size başlayabileceğiniz, durdurabileceğiniz, durumunuzu bildirebileceğiniz bir istem sunacak olan supervisorctl'i çalıştırmanız gerekir .

CLI

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

Eğer supervisordcin zaten çalışıyor ve size sadece yapabileceği cini yeniden başlatmadan olmadan sunumlarına ulaşmaktasınız yapılandırmasını ekledik rereadve updatekomutunu supervisorctlkabuğu.

Bu size SysV Init betiklerini kullanarak sahip olabileceğiniz tüm flexibilitleri verir, ancak kullanımı ve kontrolü kolaydır. Belgelere bir göz atın .

Bunu kendim yapmak için geldim, bu yüzden bir CentOS init.d hizmet denetleyicisi komut dosyası açısından şimdiye kadar olduğum yer. Şimdiye kadar oldukça güzel çalışıyor, ama ben leet Bash hacker değilim, bu yüzden iyileştirme için yer olduğundan eminim, bu yüzden iyileştirme hakkındaki düşünceler açıktır.

Her şeyden önce, /data/svcmgmt/conf/my-spring-boot-api.shortam değişkenleri ayarlar her hizmet için kısa bir yapılandırma komut dosyası var .

#!/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

Bir sunucu yeniden başlatıldıktan sonra hizmetlerimin başlatılmasını sağlamak için CentOS kullanıyorum, içinde bir hizmet denetim komut dosyası var /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

Gördüğünüz gibi, bu, ortam değişkenlerini ayarlamak için ilk yapılandırma komut dosyasını çağırır ve ardından tüm Spring Boot hizmetlerimi yeniden başlatmak için kullandığım paylaşılan bir komut dosyasını çağırır. Bu paylaşılan senaryo, her şeyin etinin bulunduğu yerdir:

#!/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

Durduğunda, kontrollü bir kapatma gerçekleştirmek için Spring Boot Aktüatörü kullanmaya çalışacaktır. Ancak, Aktüatörün makul bir süre içinde yapılandırılmaması veya kapanmaması durumunda (5 saniye veriyorum, bu gerçekten biraz kısa), işlem öldürülecek.

Ayrıca, komut dosyası, uygulamayı çalıştıran java işleminin, işlem ayrıntıları metninde "my-spring-boot-api.jar" olan tek işlem olacağını varsayar. Bu, çevremdeki güvenli bir varsayımdır ve PID'leri takip etmeme gerek olmadığı anlamına gelir.

Spring Boot 1.2.5'i Spring Boot Maven Plugin 1.3.0.M2 ile kullanmak istiyorsanız, işte çözüm:

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

Daha sonra olağan olarak derleyin:, mvn clean packagebir sembolik bağlantı yapın ln -s /.../myapp.jar /etc/init.d/myapp, yürütülebilir yapın chmod +x /etc/init.d/myappve başlatın service myapp start(Ubuntu Sunucusu ile)

Bunun daha eski bir soru olduğunu biliyorum, ama appassembler-maven-eklentisi olan başka bir yol sunmak istedim . İşte POM'umdan faydalı bulduğumuz birçok ek seçenek değeri içeren ilgili bölüm:

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

WINDOWS HİZMETİ OLARAK

Bu windows makine çalıştırmak istiyorsanız winsw.exe indirmek

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

Bundan sonra dosya adını kavanoz adı olarak yeniden adlandırın (örneğin: uygulamanız .jar)

winsw.exe -> your-app.exe

Şimdi bir app.xml dosyanız xml dosyası oluşturun ve aşağıdaki içeriği buna kopyalayın

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

Emin olun exe ve xml ile birlikte kavanoza bir aynı klasörde.

Bundan sonra Yönetici önyüklemesinde açık komut istemi ve Windows hizmetine yükleyin.

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

Eğer başarısız olursa

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

Ardından aşağıdakileri deneyin:

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

bu kadar :) .

Hizmeti pencerelerden kaldırmak için

your-app.exe uninstall

See / run / stop hizmetini görmek için: win + r ve Yönetimsel araçlar yazın, ardından hizmeti seçin . Sonra sağ tıklayın seçeneği seçin - çalıştır / durdur

Centos 6 / RHEL için SysVInit betiğim (henüz ideal değil). Bu komut dosyası için ApplicationPidListener gerekir .

Kaynağı /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 $?

Örnek yapılandırma dosyası /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

Yürütülebilir bir kavanozu bir systemd hizmeti olarak dağıtan bir komut dosyası.

Hizmet ve .service dosyası için bir kullanıcı oluşturur ve jar dosyasını / var altına yerleştirir ve bazı temel ayrıcalıkları kilitler.

#!/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

Misal:

Sonunda tacked sıkıştırılmış bir java uygulaması ile "init.d" tarzı kabuk komut dosyası olarak sunulan springboot uygulamaları yapmaya çalışıyorum

Bu komut dosyalarını /etc/init.d/spring-app 'den /opt/spring-app.jar' e bağlayarak ve kavanozu çalıştırılabilir hale getirerek "/etc/init.d/spring-app başlangıcı yapmak mümkündür. "" /etc/init.d/spring-app stop "ve durum çalışması gibi diğer olasılıklar

Muhtemelen, springboot'tan init.d stili komut dosyaları, gerekli sihirli dizelere sahip olduklarına ( # Default-Start: 2 3 4 5chkconfig) "hizmet" olarak ekleyebilecek gibi görünüyor

Ama systemd ile çalışmasını istedim

Bu işi yapmak için yukarıdaki diğer cevaplardaki tariflerin çoğunu denedim, ancak hiçbiri benim için Springboot 1.3 ile Centos 7.2'de işe yaramadı.

Sonunda, /etc/init.d bağlantısı da yerinde olduğunda aşağıdakilerin benim için çalıştığını buldum. Aşağıdakine benzer bir dosya şu şekilde kurulmalıdır:/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

WAR / JAR düzeni için systemd hizmeti yaptım

Java -jar diyorum çünkü daha esnek. Ayrıca ExecStart = spring-mvc.war koyarak çalıştı ama yürütülebilir olsa da, 'Exec format hatası' var

Her neyse, bu günlerde, tüm dağıtımlarda systemd mevcuttur ve günlükleri yeniden yönlendirmek için güzel bir çözüm sunar (hizmetiniz log4j dosyası konumu bile boş kalmayacaksa syserr önemlidir :)).

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 girişini uygulamadan belirli bir klasöre / dosyaya yönlendir

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
}

Bu soruda, @PbxMan'ın cevabı başlamalı:

Linux'ta Java Uygulamasını Hizmet Olarak Çalıştırma

Düzenle:

Yeniden başlatma sırasında cron kullanarak bir işlemi başlatmanın başka, daha az güzel bir yolu var:

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

Bu çalışır, ancak uygulamanız için size güzel bir başlatma / durdurma arabirimi vermez. killYine de basitçe yapabilirsiniz ...

Bir Java uygulaması ile bunu yapmak için "standart" shrink-sarılmış bir yol bilmiyorum, ama kesinlikle iyi bir fikir (eğer varsa, işletim sisteminin canlı ve izleme yeteneklerinden yararlanmak istiyorum) . Spring Boot aracı desteğinden (maven ve gradle) bir şey sağlamak için yol haritasında bulunuyor, ancak şimdilik muhtemelen kendinizinkini yuvarlamanız gerekecek. Şu anda bildiğim en iyi çözüm , çeşitli standart işletim sistemi biçimleri (monit, sys V, uptart vb.) İçin init komut dosyalarını paketleme için bildirici bir yaklaşıma ve bir satır komutuna sahip Foreman'dır . Ayrıca, insanların çakılla doldurduklarını gösteren kanıtlar da vardır (örneğin burada ).

Maven kullanıyor musunuz? O zaman AppAssembler Eklentisini denemelisiniz:

Application Assembler Eklentisi, java uygulamalarını başlatmak için komut dosyaları oluşturmak için bir Maven eklentisidir. ... Tüm yapay nesneler (bağımlılıklar + projedeki yapay nesneler) oluşturulan bin komut dosyalarındaki sınıfyoluna eklenir.

Desteklenen platformlar:

Unix varyantları

Windows NT (Windows 9x desteklenmez)

Java Servis Paketleyicisi (JSW)

Bkz. Http://mojo.codehaus.org/appassembler/appassembler-maven-plugin/index.html

Spring Boot projelerinde build.gradle dosyasında aşağıdaki yapılandırma gereklidir.

build.gradle

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

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

yürütülebilir = doğru

Unix sisteminde (Centos ve Ubuntu) tamamen çalıştırılabilir bir kavanoz yapmak için bu gereklidir

Bir .conf dosyası oluşturun

Özel JVM özelliklerini veya Spring Boot uygulaması çalıştırma bağımsız değişkenlerini yapılandırmak istiyorsanız, Spring Boot uygulama adıyla aynı ada sahip bir .conf dosyası oluşturabilir ve jar dosyasına paralel olarak yerleştirebilirsiniz.

App.jar dosyanızın Spring Boot uygulamanızın adı olduğu göz önüne alındığında, aşağıdaki dosyayı oluşturabilirsiniz.

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

Bu yapılandırma Spring Boot uygulaması için 64 MB ram ayarlayacak ve prod profilini etkinleştirecektir.

Linux'ta yeni bir kullanıcı oluşturun

Gelişmiş güvenlik için, Spring Boot uygulamasını bir hizmet olarak çalıştırmak üzere belirli bir kullanıcı oluşturmalıyız.

Yeni bir kullanıcı oluştur

sudo useradd -s /sbin/nologin springboot

Ubuntu / Debian'da yukarıdaki komutu aşağıdaki gibi değiştirin:

sudo useradd -s /usr/sbin/nologin springboot

Şifreyi belirle

sudo passwd springboot

Yürütülebilir dosyanın springboot sahibi yap

chown springboot:springboot your-app.jar

Jar dosyasının değiştirilmesini önle

chmod 500 your-app.jar

Bu, kavanozun izinlerini yazılamayacak ve yalnızca sahibinin yaylı önyüklemesi tarafından okunabilecek veya yürütülecek şekilde yapılandırır.

Değiştir özniteliği (chattr) komutunu kullanarak jar dosyanızı isteğe bağlı olarak değiştirilemez hale getirebilirsiniz.

sudo chattr +i your-app.jar

İlgili .conf dosyası için de uygun izinler ayarlanmalıdır. .conf, read + execute (Octal 500) erişimi yerine yalnızca okuma erişimi (Octal 400) gerektirir

chmod 400 your-app.conf

Systemd hizmeti oluştur

/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

İşletim sistemi tarafından öldürülürse işlemi otomatik olarak yeniden başlat

Hata durumunda işlemi otomatik olarak yeniden başlatmak için aşağıdaki iki özelliği (Restart ve RestartSec) ekleyin.

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

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

Değişiklik 30 saniyelik bir gecikmeyle arıza durumunda Spring Boot uygulamasını yeniden başlatır. Hizmeti systemctl komutunu kullanarak durdurursanız, yeniden başlatma gerçekleşmez.

Sistem başlangıcında zamanlama hizmeti

Uygulamayı sistem önyüklemesinde otomatik olarak başlayacak şekilde işaretlemek için aşağıdaki komutu kullanın:

Sistem başlangıcında Spring Boot uygulamasını etkinleştir

sudo systemctl enable your-app.service

Hizmeti Durdurma

systemctl, işlemi başlatmak ve durdurmak için Ubuntu 16.04 LTS ve 18.04 LTS'de kullanılabilir.

İşlemi başlat

sudo systemctl start your-app

İşlemi durdurun

sudo systemctl stop your-app

Referanslar

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

Chad'ın mükemmel cevabını takip ederek, "Hata: Ana sınıf bulunamadı veya yüklenemedi" hatası alıyorsanız ve java uygulamanızı başlatan veya başlatan bir kabuk betiği çalıştırıyor olsanız da, sorunu gidermek için birkaç saat harcıyorsunuz systemd'nin kendisinden - ve sınıf yolunuzun% 100 doğru olduğunu biliyorsunuz, örneğin kabuk betiğini manuel olarak çalıştırmak ve systemd execstart öğesinde olanı çalıştırmak gibi. klasör ve alt klasörler ve uygulama belirtilen kullanıcı ve grup olarak doğru bir şekilde çalıştığından, artık root olarak çalıştırılması gerekmez (kötü güvenlik).İşleri doğru kullanıcı olarak çalıştırdığınızdan emin olun ! Benim durumumda, sorun giderme bir süre sonra farklı kullanıcılar denedim - nihayet bir önsezi vardı, kullanıcı olarak kök koymak - voila, uygulama doğru başladı. Yanlış bir kullanıcı sorunu olduğunu belirledikten sonra,chown -R user:user

Systemd birim dosyalarında ortam değişkenleri dizinini veya bir EnvironmentFile. En az sürtünme miktarı olduğu için işleri bu şekilde yapmayı öneriyorum.

Örnek birim dosyası

$ 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

Ardından /etc/sysconfig/hello-world, Spring Boot değişkenlerinizin büyük harfli adlarını içeren bir dosya oluşturun. Örneğin, çağrılan bir değişken server.port, formu SERVER_PORTortam değişkeni olarak izler :

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

Burada kullanılan mekanizma, Spring Boot uygulamalarının özellik listesini alıp bunları çevirecek, her şeyi büyük harf yapacak ve noktaları alt çizgi ile değiştirecek olmasıdır. Spring Boot uygulaması bu işlemden geçtikten sonra, eşleşen ortam değişkenlerini arar ve uygun olanı kullanır.

Bu, bu SO Soru-Cevap başlıklı başlıkta daha ayrıntılı bir şekilde vurgulanmıştır: Çevre Değişkenleri aracılığıyla adında alt çizgi olan bir Spring Boot özelliği nasıl ayarlanır?

Referanslar

• Bölüm IV. Yay Önyükleme özellikleri - 24. Harici Yapılandırma

Ubuntu'daki Systemd hizmeti kullanılarak yapılabilir

[Unit]
Description=A Spring Boot application
After=syslog.target

[Service]
User=baeldung
ExecStart=/path/to/your-app.jar SuccessExitStatus=143

[Install] 
WantedBy=multi-user.target

Daha ayrıntılı açıklama ve bunu yapmanın farklı yolları için bu bağlantıyı takip edebilirsiniz. http://www.baeldung.com/spring-boot-app-as-a-service

Your-app.service (rest-app.service) adında bir komut dosyası oluşturun. Bu komut dosyasını / etc / systemd / system dizinine yerleştirmeliyiz. İşte betiğin örnek içeriği

[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

Sonraki:

 service rest-app start

Referanslar

bağlantı açıklamasını buraya girin