So führen Sie eine Spring Boot-Anwendung in Docker aus

So führen Sie eine Spring Boot-Anwendung in Docker aus

In den letzten Tagen habe ich gelernt, wie man Spring Boot-Anwendungen in Docker ausführt. Früher gab es ein Maven-Plugin, mit dem man direkt einen Docker-Ordner in src/main und eine neue Dockerfile-Datei erstellen konnte. Nach dem Kompilieren und Verpacken kann man das Docker-Plugin direkt ausführen, was dem Ausführen docker build . Es erstellt die aktuelle Anwendung direkt in einem Spiegel und führt sie dann aus, was sehr praktisch ist. Nach persönlichen Tests habe ich jedoch festgestellt, dass dieses Plugin nicht stabil ist und der Docker-Ordner möglicherweise nicht jedes Mal in den Zielordner eingefügt wird, sodass dieses Plugin bei der Ausführung nicht sehr nützlich ist.

Als ich die Spring Boot-Anwendung später in einen Spiegel eingebaut habe, habe ich daher nicht mehr das bereitgestellte Docker Maven-Plugin verwendet, sondern eine neue Dockerfile-Datei im Stammverzeichnis des aktuellen Projekts erstellt. Nachdem die Anwendung geschrieben war, habe ich den Befehl zum Einbau der Anwendung in einen Spiegel wie folgt manuell ausgeführt.

Springboot-Anwendung

pom.xml

In der Datei pom.xml müssen Sie hier mehrere Repositories angeben und mehrere Plug-Ins bereitstellen, und zwar wie folgt:

<Projekt xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>cn.com</groupId>
 <artifactId>springbootweb</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>Glas</packaging>

 <Name>Spring :: Boot :: Web</Name>

 <übergeordnetes Element>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.4.1.RELEASE</version>
  <relativerPfad/>
 </übergeordnet>

 <Eigenschaften>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <docker.image.prefix>springio</docker.image.prefix>
  <docker.version>0.3.8</docker.version>
  <java.version>1.8</java.version>
 </Eigenschaften>

 <Abhängigkeiten>
  <Abhängigkeit>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </Abhängigkeit>
 </Abhängigkeiten>



 <Repositorys>
  <Repository>
   <id>Frühlings-Schnappschüsse</id>
   <url>http://repo.spring.io/snapshot</url>
   <Schnappschüsse>
    <aktiviert>wahr</aktiviert>
   </Schnappschüsse>
  </Repository>
  <Repository>
   <id>Meilensteine ​​des Frühlings</id>
   <url>http://repo.spring.io/milestone</url>
   <Schnappschüsse>
    <aktiviert>wahr</aktiviert>
   </Schnappschüsse>
  </Repository>
 </Repositorys>

 <pluginRepositories>
  <pluginRepository>
   <id>Frühlings-Schnappschüsse</id>
   <url>http://repo.spring.io/snapshot</url>
  </pluginRepository>
  <pluginRepository>
   <id>Meilensteine ​​des Frühlings</id>
   <url>http://repo.spring.io/milestone</url>
  </pluginRepository>
 </pluginRepositories>


 <Bauen>
  <Plugins>
   <Plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>Maven-Compiler-Plugin</artifactId>
    <version>3.2</version>
    <Konfiguration>
     <compilerArgument>-Parameter</compilerArgument>
     <Quelle>1.8</Quelle>
     <target>1,8</target>
     <Kodierung>UTF-8</Kodierung>
    </Konfiguration>
   </plugin>
   <Plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18.1</version>
    <Konfiguration>
     <skipTests>wahr</skipTests>
    </Konfiguration>
   </plugin>

   <Plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>Maven-Ressourcen-Plugin</artifactId>
    <version>2.6</version>
    <Konfiguration>
     <Kodierung>UTF-8</Kodierung>
    </Konfiguration>
   </plugin>
   <Plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>Spring-Boot-Maven-Plugin</artifactId>
    <!--<version>${spring.boot.version}</version>-->
    <Konfiguration>
     <mainClass>cn.com.SpringBootWebApplication</mainClass>
     <layout>ZIP</layout>
    </Konfiguration>
    <Hinrichtungen>
     <Ausführung>
      <Ziele>
       <Ziel>
        neu verpacken
       </Ziel>
      </Ziele>
     </Ausführung>
    </Ausführungen>
   </plugin>
  </plugins>
 </bauen>

 <Profile>
  <Profil>
   <id>JDK1.8</id>
   <Aktivierung>
    <activeByDefault>wahr</activeByDefault>
   </Aktivierung>
   <Eigenschaften>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <Kodierung>UTF-8</Kodierung>
   </Eigenschaften>
  </Profil>
 </profile>
</Projekt>

Hier werden mehrere Warehouse-Adressen bereitgestellt. Der Grund dafür ist, dass, wenn die Springboot-Anwendung in diesem Artikel in Docker eingefügt wird, der Quellcode direkt eingefügt und dann zum Ausführen darin kompiliert und verpackt wird. Wenn die Warehouse-Adresse zum Herunterladen des JAR-Pakets nicht angegeben wird, werden die Abhängigkeiten aus dem zentralen Warehouse abgerufen, was sehr langsam ist und zu einem Pull-Timeout führt, wodurch die Anwendung unbrauchbar wird. Daher werden mehrere andere Warehouse-Adressen zum Herunterladen von Abhängigkeiten bereitgestellt. Darüber hinaus gibt es hier ein Plug-In. Nachdem Sie dieses Plug-In verwendet haben, können Sie die Anwendung direkt in Form von mvn spring-boot:run ausführen. Daher habe ich mich nicht entschieden, java -jar xxx.jar zum Ausführen der Anwendung zu verwenden.

Anwendung und Verantwortlicher

Diese SpringBoot-Anwendung ist recht einfach und bietet einen einfachen Controller mit einer Schnittstelle ähnlich „Hello World“ wie folgt:

Paket cn.com.controllers;

importiere org.springframework.web.bind.annotation.RequestMapping;
importiere org.springframework.web.bind.annotation.RestController;

importiere java.util.HashMap;
importiere java.util.Map;

/**
 * Erstellt von xiaxuan am 16.11.27.
 */
@RestController
öffentliche Klasse IndexController {

  @RequestMapping(Wert = "/index", ergibt = "Anwendung/json;Zeichensatz=utf-8")
  öffentlicher Objektindex() {
    Map<String, Objekt> Ergebnis = neue HashMap<String, Objekt>();
    result.put("msg", "hallo Welt");
    Ergebnis zurückgeben;
  }
}

Stellen Sie eine einfache Helloworld-Methode bereit.

Folgendes ist die Startklasse der Anwendung:

paketcn.com;

importiere org.springframework.boot.SpringApplication;
importiere org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Erstellt von xiaxuan am 16.11.27.
 */
@SpringBootAnwendung
öffentliche Klasse SpringBootWebApplication {

  öffentliche statische void main(String[] args) {
    SpringApplication.run(SpringBootWebApplication.class, args);
  }
}

Bei einem normalen Spring Boot-Start ist es ganz einfach. Starten Sie einfach die Startklasse SpringBootWebApplication. Wenn Sie es jedoch in einem Docker-Container ausführen, ist es nicht so einfach. Sehen Sie sich die Dockerfile-Datei unten an.

Docker-Datei

Auch die Dockerfile-Datei ist relativ einfach aufgebaut und sieht wie folgt aus:

# Basisbild
VON java:8

# Betreuer
WARTUNGSBEDIENER bingwenwuhen [email protected]

# Pakete aktualisieren und Maven installieren

LAUFEN \
 export DEBIAN_FRONTEND=nichtinteraktiv && \
 sed -i 's/# \(.*multiverse$\)/\1/g' /etc/apt/sources.list && \
 apt-get update && \
 apt-get -y Upgrade && \
 apt-get install -y vim wget curl maven

# Datenträger anhängen
VOLUME /vol/Entwicklung


# Arbeitsverzeichnis erstellen
RUN mkdir -p /vol/entwicklung
RUN mkdir -p /vol/development/src
ARBEITSVERZEICHNIS /vol/entwicklung

KOPIEREN ./src /vol/development/src/
KOPIEREN ./pom.xml /vol/development/

# Maven-Exec
CMD ["mvn", "sauber", "installieren", "spring-boot:run"]

Das Dockerfile verwendet Java8 als Basisimage und Maven muss separat im Basisimage installiert werden. Denn in unserem Dockerfile wird der gesamte Quellcode in das Image eingegeben und hier wird nur das generierte JAR nicht in das Image eingegeben. Das ist also das, was ich zuvor gesagt habe, nämlich dass das Warehouse in pom.xml angegeben werden muss. Wenn das Warehouse nicht angegeben ist, werden beim Abrufen von Abhängigkeiten im Image die Abhängigkeiten aus dem zentralen Warehouse abgerufen, was sehr langsam sein wird. Ich habe es zuvor mehrmals versucht und der grundlegende Abrufvorgang ist abgelaufen und fehlgeschlagen. Geben Sie daher hier das Warehouse an, um die Abhängigkeiten abzurufen.

Erstellen des Images

Führen Sie nun den Befehl im Verzeichnis docker build -t="bingwenwuhen/springboot01" . Erstellen Sie das Image wie folgt:

Nach dem Spiegeln führen Sie
docker run -d --name springboot01 -p 8080:8080 bingwenwuhe/spingboot01
Der obige Befehl generiert einen Container zum Ausführen des Images, der Port 8080 zuordnet und den Namen springboot01 trägt.

docker logs xxxxx um die Containerprotokolle anzuzeigen:

Jetzt läuft der Container.

Anforderungsschnittstelle

Bevor Sie die Schnittstelle anfordern, müssen Sie die IP-Adresse der virtuellen Docker-Maschine überprüfen. Die IP-Adresse dieser Maschine lautet 192.168.99.100. Der Befehl zum Anfordern der Schnittstelle lautet:

Locken http://192.168.99.100:8080/index

Die Antwort lautet:

{
  "msg":"hallo Welt"
}

Die Anforderung ist erfolgreich. Die Springboot-Anwendung wird erfolgreich im Docker ausgeführt.

Frage

  • Wenn der Quellcode in das Image eingefügt und mvn clean install kompiliert und ausgeführt wird, werden zu viele JAR-Pakete heruntergeladen und die Wartezeit ist zu lang, was leicht zu Unterbrechungen führen kann. Daher wird diese Vorgehensweise nicht empfohlen.
  • Der Quellcode sollte grundsätzlich nicht im Image enthalten sein, lediglich das laufende JAR-Paket muss im Image enthalten sein.

Quellcode

Ich habe den Quellcode auf GitHub hochgeladen. Sie können ihn bei Bedarf herunterladen.

Quellcode herunterladen

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.

Das könnte Sie auch interessieren:
  • Verwenden Sie Dockercompose, um eine Springboot-MySQL-Nginx-Anwendung zu erstellen
  • Implementierung der Spring Boot-Anwendungsveröffentlichung in Docker
  • Detaillierte Schritte zum Dockerisieren von Spring Boot-Anwendungen
  • Detaillierte Erläuterung der Docker-Container-Spring-Boot-Anwendung
  • Beispiel für die Bereitstellung einer Spring Boot-Anwendung mit Docker
  • Spring Boot-Anwendungen verwenden Docker zum Erstellen, Ausführen und Freigeben von Prozessen
  • So stellen Sie eine Spring-Boot-Maven-Anwendung mit Docker bereit
  • Detaillierte Erklärung zum Ausführen von Spring Boot-Anwendungen in Docker-Containern

<<:  Beispielcode zur Implementierung des Verlaufs in Vuex

>>:  Beispiel für die Konvertierung von Spark RDD in einen Dataframe und das Schreiben in MySQL

Artikel empfehlen

So verwenden Sie das Videowiedergabe-Plugin DPlayer.js

Das Videoplayer-Plugin DPlayer.js ist einfach zu ...

Vorschläge zur Optimierung der Webseiten-Kopfzeile

Logo-Optimierung: 1. Das Logobild sollte so klein...

React Native realisiert den Auf- und Ab-Pull-Effekt der Überwachungsgeste

React Native implementiert die Überwachungsgeste ...

Vue echarts realisiert die dynamische Anzeige von Balkendiagrammen

In diesem Artikel wird der spezifische Code von V...

Beispiel für den schnellen Aufbau eines Redis-Clusters mit Docker

Was ist Redis Cluster? Redis Cluster ist eine von...

Einführung in lokale Komponenten in Vue

In Vue können wir lokale Komponenten selbst defin...

Abrufen der Erstellungszeit einer Datei unter Linux und ein praktisches Tutorial

Hintergrund Manchmal müssen wir den Erstellungsze...

Lösen Sie das Problem des Startfehlers von PHPStudy MySQL unter Windows

Einen Fehler melden Der Apache\Nginx-Dienst wurde...

Tutorial zur Installation von RabbitMQ mit Yum auf CentOS8

Geben Sie den Ordner /etc/yum.repos.d/ ein Erstel...