Wie führe ich eine ausführbare Spring Boot-JAR-Datei in einer Produktionsumgebung aus?

Die bevorzugte Bereitstellungsmethode von Spring Boot ist eine ausführbare JAR-Datei, die Tomcat enthält.

Es wird mit einem einfachen begonnen java -jar myapp.jar.

Jetzt möchte ich dieses JAR auf meinem Linux-Server unter EC2 bereitstellen. Fehlt mir etwas oder muss ich wirklich ein Init-Skript erstellen, um die Anwendung ordnungsgemäß als Daemon zu starten?

Wenn ich einfach anrufe, java -jarstirbt die Anwendung beim Abmelden.

Ich könnte es auf dem Bildschirm oder in Nohup starten, aber das ist nicht sehr elegant und ein Neustart auf meinem Server würde mich zwingen, mich anzumelden und den Prozess manuell zu starten.

Gibt es also schon etwas für die Aufgabe im Frühjahrsstiefel?

Bitte beachten Sie, dass Sie seit Spring Boot 1.3.0.M1 vollständig ausführbare Jars mit Maven und Gradle erstellen können.

Fügen Sie für Maven Folgendes hinzu pom.xml:

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <executable>true</executable>
    </configuration>
</plugin>

Fügen Sie für Gradle den folgenden Ausschnitt zu Ihrem hinzu build.gradle:

springBoot {
    executable = true
}

Die vollständig ausführbare JAR-Datei enthält ein zusätzliches Skript am Anfang der Datei, mit dem Sie Ihre Spring Boot-JAR-Datei einfach init.dmit einem systemdSkript verknüpfen oder ein Skript verwenden können.

init.d Beispiel:

$ln -s /var/yourapp/yourapp.jar /etc/init.d/yourapp

Auf diese Weise können Sie Ihre Anwendung wie folgt starten, stoppen und neu starten:

$/etc/init.d/yourapp start|stop|restart

Oder verwenden Sie ein systemdSkript:

[Unit]
Description=yourapp
After=syslog.target

[Service]
ExecStart=/var/yourapp/yourapp.jar
User=yourapp
WorkingDirectory=/var/yourapp
SuccessExitStatus=143

[Install]
WantedBy=multi-user.target

Weitere Informationen unter folgenden Links:

• Installation als init.dService
• Installation als systemdService

Die mit Abstand einfachste und zuverlässigste Möglichkeit, Spring Boot-Anwendungen in der Produktion auszuführen, ist Docker. Verwenden Sie Docker Compose, Docker Swarm oder Kubernetes, wenn Sie mehrere verbundene Dienste verwenden müssen.

Hier ist eine einfache AnleitungDockerfile aus dem offiziellen Spring Boot Docker-Handbuch :

FROM frolvlad/alpine-oraclejdk8:slim
VOLUME /tmp
ADD YOUR-APP-NAME.jar app.jar
RUN sh -c 'touch /app.jar'
ENV JAVA_OPTS=""
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar" ]

Hier ist eine Beispielbefehlszeile zum Ausführen des Containers als Daemon:

docker run \
  -d --restart=always \
  -e "SPRING_PROFILES_ACTIVE=prod" \
  -p 8080:8080 \
  prefix/imagename

Meine Spring-Boot-Anwendung verfügt über zwei Initialisierer. Eine für die Entwicklung und eine für die Produktion. Für die Entwicklung verwende ich die Hauptmethode wie folgt:

@SpringBootApplication
public class MyAppInitializer {

    public static void main(String[] args) {
        SpringApplication.run(MyAppInitializer .class, args);
    }

}

Mein Initializer für die Produktionsumgebung erweitert den SpringBootServletInitializer und sieht folgendermaßen aus:

@SpringBootApplication
public class MyAppInitializerServlet extends SpringBootServletInitializer{
    private static final Logger log = Logger
            .getLogger(SpringBootServletInitializer.class);
    @Override
    protected SpringApplicationBuilder configure(
            SpringApplicationBuilder builder) {
        log.trace("Initializing the application");
        return builder.sources(MyAppInitializerServlet .class);
    }

}

Ich benutze gradle und meine build.gradle Datei gilt ‚ WAR ‘ Plugin. Wenn ich es in der Entwicklungsumgebung ausführe , verwende ich die Bootrun- Task. Wo wie zum Beispiel, wenn ich es für die Produktion bereitstellen möchte, verwende ich Assemble- Task, um die WAR zu generieren und bereitzustellen.

Ich kann wie eine normale Federanwendung in der Produktion laufen, ohne die Vorteile des eingebauten Kater während der Entwicklung zu vernachlässigen. Hoffe das hilft.

In einer Produktionsumgebung möchten Sie, dass Ihre App bei einem Neustart des Computers usw. erneut gestartet wird. Erstellen Sie ein Skript /etc/init.d/ und verknüpfen Sie es mit dem entsprechenden Runlevel, um es zu starten und zu stoppen. Dies ist der richtige Ansatz. Spring Boot wird sich nicht darauf erstrecken, da es sich um ein betriebssystemspezifisches Setup handelt und es unzählige andere Optionen gibt. Möchten Sie, dass es in einem Chroot-Gefängnis ausgeführt wird, muss es vor einer anderen Software gestoppt / gestartet werden usw.

Sie können die Anwendung Supervisor verwenden . In der Supervisor-Konfiguration können Sie mehrere Dienste und Möglichkeiten zur Ausführung derselben definieren.

Für Java- und Spring-Boot-Anwendungen wäre der Befehl java -jar springbootapp.jar.

Es können Optionen bereitgestellt werden, um die Anwendung immer am Laufen zu halten. Wenn der EC2 neu gestartet wird, startet Supervisor Ihre Anwendung neu

Ich fand Supervisor einfach zu bedienen, verglichen mit dem Einfügen von Startskripten in /etc/init.d/. Die Startskripte würden hängen bleiben oder im Fehlerzustand in den Wartezustand versetzt werden.

Wenn Sie gradle verwenden, können Sie dies einfach zu Ihrem build.gradle hinzufügen

springBoot {
    executable = true
}

Sie können Ihre Anwendung dann ausführen, indem Sie ./your-app.jar eingeben

Außerdem finden Sie hier eine vollständige Anleitung zum Einrichten Ihrer App als Dienst

56.1.1 Installation als init.d-Dienst (System V)

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

Prost

Unter Windows ohne Dienst.

start.bat

@ECHO OFF
call run.bat start

stop.bat:

@ECHO OFF
call run.bat stop

run.bat

@ECHO OFF
IF "%1"=="start" (
    ECHO start myapp
    start "myapp" java -jar -Dspring.profiles.active=staging myapp.jar
) ELSE IF "%1"=="stop" (
    ECHO stop myapp
    TASKKILL /FI "WINDOWTITLE eq myapp"
) ELSE (
    ECHO please, use "run.bat start" or "run.bat stop"
)
pause

Ich starte Anwendungen, die dauerhaft oder zumindest semipermanent ausgeführt werden sollen, über den Bildschirm -dmS NAME / path / to / script. Soweit ich informiert bin, ist dies die eleganteste Lösung.

Dies ist ein einfaches Plugin für Spring Boot Maven, mit dem Sie die Code-Bereitstellung abschließen können.

die Plugin-Konfiguration wie:

<plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <jvmArguments>-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=${debug.port}
                    </jvmArguments>
                    <profiles>
                        <profile>test</profile>
                    </profiles>
                    <executable>true</executable>
                </configuration>
            </plugin>

Und das jvmArtumentsist für Sie jvm hinzufügen. profileswählt ein Profil aus, um Ihre App zu starten. executablekann Ihre App trocken laufen lassen.

und wenn Sie mvnwIhrem Projekt hinzufügen oder wenn Sie ein Maven-Enveriment haben. Sie können einfach ./mvnw spring-boot:runfür mvnw oder mvn spring-boot:runfür maven anrufen.