wake-up-neo.com

Wie führe ich eine ausführbare JAR-Datei für Spring Boot 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 Java -jar myapp.jar Gestartet.

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

Wenn ich einfach Java -jar Rufe, stirbt die Anwendung, wenn ich mich auslogge.

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 Vorgang manuell zu starten.

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

90

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

Fügen Sie für Maven einfach Folgendes in Ihren pom.xml Ein:

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

Fügen Sie für Gradle das folgende Snippet zu Ihrem build.gradle Hinzu:

springBoot {
    executable = true
}

Die voll ausführbare JAR-Datei enthält ein zusätzliches Skript am Anfang der Datei, mit dem Sie Ihre Spring Boot-JAR-Datei einfach mit init.d Verknüpfen oder ein systemd 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 benutze ein systemd Skript:

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

83
corleone

Die mit Abstand einfachste und zuverlässigste Methode, 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 ein einfaches Dockerfile aus dem offiziellen Spring Boot Docker-Handbuch , um Ihnen den Einstieg zu erleichtern:

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, um den Container als Daemon auszuführen:

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

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 folgende Hauptmethode:

@SpringBootApplication
public class MyAppInitializer {

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

}

My Initializer for Production Environment erweitert das 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 wendet ' WAR ' Plugin an. Wenn ich es in der Entwicklungsumgebung starte, benutze ich bootrun task. Wo und wann ich es für die Produktion bereitstellen möchte, verwende ich assemblieren task, um die WAR zu generieren und bereitzustellen.

Ich kann wie eine normale Federanwendung in der Produktion arbeiten, ohne die Vorteile des eingebauten Tomcat bei der Entwicklung zu vernachlässigen. Hoffe das hilft.

3
O-OF-N

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, mit denen die Anwendung immer ausgeführt wird. Wenn der EC2-Neustart durchgeführt wird, startet Supervisor die Anwendung neu

Ich fand Supervisor benutzerfreundlich im Vergleich zum Einfügen von Startskripten in /etc/init.d/. Die Startskripten hingen oder versetzten sich im Fehlerfall in den Wartezustand.

2
unnik

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 deckt dies nicht ab, 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.

2
spstorey

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

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

2
isijara

Ich starte Anwendungen, die ich dauerhaft oder zumindest semipermanent ausführen möchte, über den Bildschirm -dmS NAME/path/to/script. Soweit ich informiert bin, ist dies die eleganteste Lösung.

1
Scrayos

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

die Plugin Konfiguration wie folgt:

<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 jvmArtuments wird für Sie jvm hinzugefügt. profiles wählt ein Profil aus, um Ihre App zu starten. Mit executable kann Ihre App problemlos ausgeführt werden.

und wenn Sie Ihrem Projekt mvnw hinzufügen, oder wenn Sie eine Vielzahl von Möglichkeiten haben. Sie können einfach anrufen./mvnw spring-boot:run für mvnw oder mvn spring-boot:run für Maven.

0
BeeNoisy