Printemps de Démarrage de l'application en tant que Service

Ce qui suit est la façon la plus simple d'installer une application Java en tant que service système sous Linux.

Supposons que vous êtes à l'aide de systemd (qui de toute moderne distro ne nos jours):

Tout d'abord, créez un fichier de service dans /etc/systemd/system nommé par exemple javaservice.service avec ce contenu:

[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

Deuxièmement, informer systemd du nouveau service du fichier:

systemctl daemon-reload

et de l'activer, de sorte qu'il s'exécute au démarrage:

systemctl enable javaservice.service

Finalement, vous pouvez utiliser les commandes suivantes pour démarrer/arrêter votre nouveau service:

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

À condition que vous utilisiez systemd, c'est de la plupart des non-intrusive et propre façon de mettre en place une application Java en tant que système-service.

Ce que j'aime en particulier à propos de cette solution est le fait que vous n'avez pas besoin d'installer et de configurer n'importe quel autre logiciel. Le expédiés systemd fait tout le travail pour vous, et de votre service se comporte comme n'importe quel autre système de service. Je l'utilise en production pour un certain temps maintenant, sur les différentes distributions, et il fonctionne exactement comme vous le souhaitez.

Un autre avantage est que, en utilisant /usr/bin/java, vous pouvez facilement ajouter jvm paramètres tels que -Xmx256m.

Également lire les systemd partie dans l'officiel du Printemps de Démarrage de la documentation:
http://docs.spring.io/spring-boot/docs/current/reference/html/deployment-install.html

J'ai juste eu le temps de le faire moi-même, donc la suite est là où je suis à présent en termes de CentOS init.d contrôleur de service de script. Ça fonctionne assez bien jusqu'à présent, mais je ne suis pas leet Bash hacker, donc je suis sûr qu'il y a de la place pour de l'amélioration, de sorte que les pensées sur l'amélioration sont les bienvenues.

Tout d'abord, j'ai un court script config /data/svcmgmt/conf/my-spring-boot-api.sh pour chaque service, qui permet de définir des variables d'environnement.

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

J'utilise CentOS, de façon à ce que mes services sont démarrés après un redémarrage du serveur, j'ai un service de script de contrôle dans /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

Comme vous pouvez le voir, qui appelle la première config script pour définir des variables d'environnement et appelle ensuite partagé un script que j'utilise pour le redémarrage de tous mes Printemps de Démarrage des services. Qui a partagé le script est l'endroit où la viande de celui-ci peuvent tous être trouvés:

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

Lors de l'arrêt, il va tenter d'utiliser le Printemps de Démarrage de l'Actionneur pour effectuer un arrêt contrôlé. Toutefois, dans le cas de l'Actionneur n'est pas configuré ou ne parvient pas à arrêter, dans un délai raisonnable (je lui donne 5 secondes, ce qui est un peu court en fait), le processus sera tué.

Aussi, le script fait l'hypothèse que le processus java de l'exécution de l'appllication sera le seul avec "my-spring-boot-api.jar" dans le texte de l'détails du processus. C'est une hypothèse sûre dans mon environnement et les moyens que je n'ai pas besoin de garder une trace des Pid.

Je sais que c'est une vieille question, mais je voulais présenter encore une autre façon qui est la appassembler-maven-plugin. Voici la partie pertinente de mon POM qui comprend beaucoup plus de valeurs d'option, nous avons trouvé utile:

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

Voici un script qui déploie un exécutable jar comme un service systemd.

Il crée un utilisateur pour le service et l' .service fichier et placez le fichier jar dans /var, et permet à certains de base verrouiller des privilèges.

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

Exemple:

EN TANT QUE SERVICE WINDOWS

Si vous le souhaitez exécuter en machine windows, télécharger le winsw.exe de

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

Après que le renommer en pot de nom de fichier (ex: votre application.jar)

winsw.exe -> your-app.exe

Maintenant créer un fichier xml your-app.xml et de copier le contenu suivant que

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

Assurez-vous que le exe et xml avec pot dans un même dossier.

Après cette ouverture invite de commande en Administrateur previlege et l'installer sur le service windows.

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

Si elle ne parvient pas à

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

Essayez les solutions suivantes:

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

c'est tout 🙂 .

Pour désinstaller le service dans windows

your-app.exe uninstall

Pour voir/exécuter/arrêter le service:
win+r et le type outils d'Administration puis sélectionnez le service de que. Puis clic droit choisir le option - run /stop

Je ne sais pas d'un "standard" rétrécir façon de le faire avec une application Java, mais il est certainement une bonne idée (vous voulez bénéficier de la garder en vie et les capacités de surveillance du système d'exploitation si elles sont là). C'est sur la feuille de route de fournir quelque chose à partir du Printemps de Démarrage de l'outil de support (maven et gradle), mais pour l'instant, vous allez probablement avoir à déployer votre propre. La meilleure solution que je connaisse actuellement est Contremaître, qui a une approche déclarative et une ligne de commandes pour l'emballage des scripts d'initialisation pour diverses standard de l'OS formats (monit, sys V, arriviste, etc.). Il existe également des preuves de personnes ayant mis des trucs avec gradle (par exemple ici).

J'ai fini par faire systemd service pour la GUERRE/JAR disposition

Je vais appeler java-jar car il est plus souple. On a aussi essayé de mettre le ExecStart=spring-mvc.à la guerre, mais même s'il est exécutable, je les ai Exec, une erreur de format'

De toute façon ces jours-ci, systemd est présent sur toutes les distros, et offre une belle solution pour rediriger les logs(syserr est important lorsque vous service n'a même pas commencer à log4j emplacement du fichier est vide 🙂 ).

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 - redirection syslog d'entrée à partir de l'app spécifiques de dossier/fichier

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
}

Dans systemd unité de fichiers, vous pouvez définir des variables d'environnement de répertoire ou par l'intermédiaire d'un EnvironmentFile. Je souhaiterais vous proposer de faire les choses de cette façon puisque ça semble être le moins de friction.

Unité d'échantillonnage du fichier

$ 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

Puis l'installation d'un fichier sous /etc/sysconfig/hello-world qui comprend en majuscules les noms de vos Printemps variables de Démarrage. Par exemple, une variable appelée server.port de suivre la forme SERVER_PORT comme une variable d'environnement:

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

Le mécanisme être exploité ici est que le Printemps applications de Démarrage prendra la liste des propriétés et ensuite les traduire, rendant le tout en majuscules, et en remplaçant les points par des caractères de soulignement. Une fois que le Ressort de Démarrage de l'app va par le biais de ce processus, il se penche ensuite pour les variables d'environnement qui correspondent, et utilise toute trouvée en conséquence.

C'est examinée plus en détail dans ce Q&Un intitulé: Comment définir un Printemps de Démarrage de la propriété avec un trait de soulignement dans son nom via des Variables d'Environnement?

Références

• La partie IV. Printemps de Démarrage caractéristiques - 24. Extériorisés De Configuration