So stellen Sie Spring Boot mit Docker bereit

Die Entwicklung der Docker-Technologie bietet eine bequemere Umgebung für die Implementierung von Microservices. Es ist eigentlich sehr einfach, Spring Boot mit Docker bereitzustellen. Lassen Sie uns in diesem Artikel kurz darüber lernen.

Erstellen Sie zunächst ein einfaches Spring Boot-Projekt, fügen Sie dann Docker-Unterstützung zum Projekt hinzu und stellen Sie schließlich das Projekt bereit.

Ein einfaches Spring Boot-Projekt

Verwenden Sie in pom.xml Spring Boot 2.0-bezogene Abhängigkeiten

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

Web- und Testabhängigkeiten hinzufügen

<Abhängigkeiten>
   <Abhängigkeit>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  </Abhängigkeit>
  <Abhängigkeit>
    <groupId>org.springframework.boot</groupId>
    <artifactId>Spring-Boot-Starter-Test</artifactId>
    <scope>Test</scope>
  </Abhängigkeit>
</Abhängigkeiten>

Erstellen Sie einen DockerController mit einer index()-Methode, die zurückgibt: Hallo Docker!

@RestController
öffentliche Klasse DockerController {
  
  @RequestMapping("/")
  öffentlicher Stringindex() {
    returniere "Hallo Docker!";
  }
}

Startup-Klasse

@SpringBootAnwendung
öffentliche Klasse DockerApplication {

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

Starten Sie das Projekt nach dem Hinzufügen. Öffnen Sie nach dem erfolgreichen Start den Browser: http://localhost:8080/. Die Seite gibt „Hallo Docker!“ zurück, was darauf hinweist, dass das Spring Boot-Projekt normal konfiguriert ist.

Spring Boot-Projekt fügt Docker-Unterstützung hinzu

Fügen Sie den Docker-Image-Namen in pom.xml-properties hinzu

<Eigenschaften>
  <docker.image.prefix>springboot</docker.image.prefix>
</Eigenschaften>

Fügen Sie das Docker-Build-Plugin in den Plugins hinzu:

<Bauen>
  <Plugins>
    <Plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>Spring-Boot-Maven-Plugin</artifactId>
    </plugin>
    <!-- Docker-Maven-Plugin -->
    <Plugin>
      <groupId>com.spotify</groupId>
      <artifactId>Docker-Maven-Plugin</artifactId>
      <version>1.0.0</version>
      <Konfiguration>
        <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
        <dockerDirectory>src/main/docker</dockerDirectory>
        <Ressourcen>
          <Ressource>
            <Zielpfad>/</Zielpfad>
            <Verzeichnis>${project.build.directory}</Verzeichnis>
            <include>${project.build.finalName}.jar</include>
          </Ressource>
        </Ressourcen>
      </Konfiguration>
    </plugin>
    <!-- Docker-Maven-Plugin -->
  </plugins>
</bauen>

Erstellen Sie eine Dockerfile-Datei im Verzeichnis src/main/docker. Die Dockerfile-Datei wird verwendet, um zu erklären, wie das Image erstellt wird.

VON openjdk:8-jdk-alpine
VOLUMEN /tmp
ADD spring-boot-docker-1.0.jar app.jar
EINSTIEGSPUNKT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Dieses Dockerfile ist sehr einfach. Es erstellt die JDK-Basisumgebung und fügt dem Image das Spring Boot Jar hinzu. Hier ist eine kurze Erklärung:

• FROM bedeutet, dass die JDK8-Umgebung als Basisimage verwendet wird. Wenn das Image nicht lokal ist, wird es von DockerHub heruntergeladen.
• VOLUME, VOLUME zeigt auf ein /tmp-Verzeichnis. Da Spring Boot den integrierten Tomcat-Container verwendet, verwendet Tomcat standardmäßig /tmp als Arbeitsverzeichnis. Die Auswirkung dieses Befehls ist: Erstellen Sie eine temporäre Datei im Verzeichnis /var/lib/docker des Hosts und verknüpfen Sie sie mit dem Verzeichnis /tmp im Container
• ADD, kopiere die Datei und benenne sie um
• ENTRYPOINT: Um die Startzeit von Tomcat zu verkürzen, fügen Sie die Systemeigenschaft java.security.egd hinzu, um auf /dev/urandom als ENTRYPOINT zu verweisen.

Damit ist das Hinzufügen der Docker-Abhängigkeiten zum Spring Boot-Projekt abgeschlossen.

Erstellen einer Verpackungsumgebung

Wir benötigen eine Docker-Umgebung, um das Spring Boot-Projekt zu verpacken. Da es mühsam ist, eine Docker-Umgebung unter Windows zu erstellen, werde ich Centos 7 als Beispiel verwenden.

Docker-Umgebung installieren

Installieren

yum installiere Docker

Nachdem die Installation abgeschlossen ist, starten Sie den Docker-Dienst mit dem folgenden Befehl und richten Sie ihn so ein, dass er beim Booten gestartet wird:

Dienst Docker starten
chkconfig Docker ein

#LCTT-Anmerkung: Hier wird die alte Sysv-Syntax verwendet. Die neue, in CentOS 7 unterstützte Systemd-Syntax lautet beispielsweise wie folgt:
systemctl starte docker.service
systemctl aktiviere docker.service

Verwenden von Docker China Accelerator

vi /etc/docker/daemon.json

#Nach dem Hinzufügen:
{
  "Registrierungsspiegel": ["https://registry.docker-cn.com"],
  "Live-Wiederherstellung": wahr
}

Docker neu starten

systemctl Neustart Docker

Geben Sie die Docker-Version ein. Wenn die Versionsinformationen zurückgegeben werden, war die Installation erfolgreich.

Installieren Sie JDK

yum -y installiere java-1.8.0-openjdk*

Konfigurieren Sie Umgebungsvariablen. Öffnen Sie vim /etc/profile und fügen Sie den folgenden Inhalt hinzu

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-0.b14.el7_4.x86_64 
export PATH=$PATH:$JAVA_HOME/bin 

Nachdem die Änderung abgeschlossen ist, machen Sie sie wirksam

Quelle /etc/Profil

Wenn bei der Eingabe von „java -version“ die Versionsinformationen zurückgegeben werden, war die Installation erfolgreich.

MAVEN installieren

Herunterladen: http://mirrors.shu.edu.cn/apache/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz

## Entpacken Sie tar vxf apache-maven-3.5.2-bin.tar.gz
## Verschieben Sie mv apache-maven-3.5.2 /usr/local/maven3

Ändern Sie die Umgebungsvariablen und fügen Sie die folgenden Zeilen zu /etc/profile hinzu

MAVEN_HOME=/usr/local/maven3
exportiere MAVEN_HOME
export PATH=${PATH}:${MAVEN_HOME}/bin

Denken Sie daran, die Quelle /etc/profile auszuführen, damit die Umgebungsvariablen wirksam werden.

Geben Sie mvn -version ein. Wenn die Versionsinformationen zurückgegeben werden, war die Installation erfolgreich.

Damit ist die Konfiguration der gesamten Build-Umgebung abgeschlossen.

Bereitstellen eines Spring Boot-Projekts mit Docker

Kopieren Sie das Spring-Boot-Docker-Projekt auf den Server und geben Sie den Projektpfad zum Verpacken und Testen ein.

#Verpackung MVN-Paket
#Starten Sie java -jar target/spring-boot-docker-1.0.jar

Nach dem Betrachten des Spring Boot-Startprotokolls zeigt es, dass es kein Problem mit der Umgebungskonfiguration gibt. Als Nächstes verwenden wir DockerFile, um das Image zu erstellen.

MVN-Paket Docker:Build

Der erste Build kann etwas langsam sein. Der Build ist erfolgreich, wenn Sie Folgendes sehen:

...
Schritt 1: VON openjdk:8-jdk-alpine
 ---> 224765a6bdbe
Schritt 2: VOLUME /tmp
 ---> Cache verwenden
 ---> b4e86cc8654e
Schritt 3: ADD spring-boot-docker-1.0.jar app.jar
 ---> a20fe75963ab
Zwischenbehälter entfernen 593ee5e1ea51
Schritt 4: ENTRYPOINT java -Djava.security.egd=file:/dev/./urandom -jar /app.jar
 ---> Wird ausgeführt in 85d558a10cd4
 ---> 7102f08b5e95
Zwischenbehälter entfernen 85d558a10cd4
Erfolgreich erstellt 7102f08b5e95
[INFO] Springboot/Spring-Boot-Docker erstellt
[INFO] -------------------------------------------------------------------
[INFO] ERFOLG AUFBAUEN
[INFO] -------------------------------------------------------------------
[INFO] Gesamtzeit: 54.346 s
[INFO] Beendet am: 2018-03-13T16:20:15+08:00
[INFO] Endgültiger Speicher: 42M/182M
[INFO] -------------------------------------------------------------------

Verwenden Sie den Befehl „Docker Images“, um das erstellte Image anzuzeigen:

Docker-Bilder
REPOSITORY TAG BILD ID ERSTELLT GRÖSSE
springboot/spring-boot-docker latest 99ce9468da74 vor 6 Sekunden 117,5 MB

springboot/spring-boot-docker ist das Image, das wir erstellt haben. Der nächste Schritt besteht darin, das Image auszuführen.

docker run -p 8080:8080 -t springboot/spring-boot-docker

Nachdem der Start abgeschlossen ist, verwenden wir Docker PS, um das laufende Image anzuzeigen:

Docker PS
CONTAINER ID BILD BEFEHL ERSTELLT STATUS PORTS NAMEN
049570da86a9 springboot/spring-boot-docker "java -Djava.security" vor 30 Sekunden Aktiv 27 Sekunden 0.0.0.0:8080->8080/tcp determined_mahavira

Sie können sehen, dass der von uns erstellte Container ausgeführt wird. Besuchen Sie den Browser: http://192.168.0.x:8080/ und kehren Sie zurück

Hallo Docker!

Dies zeigt, dass das Spring Boot-Projekt erfolgreich mit Docker bereitgestellt wurde!

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.