Java >> Java Tutorial >  >> Tag >> Spring

So stellen Sie die Spring Boot-Anwendung auf Docker bereit – Teil IX

Spring

In diesem Beitrag zeige ich, wie eine Spring-Anwendung in einem Docker-Container bereitgestellt wird.

Was ist Docker

Docker ist eine Containerplattform, die von einem Unternehmen namens „Docker Inc.“ bereitgestellt wird. Docker kann von Entwicklern, Betreibern und Unternehmensbenutzern verwendet werden, um verpackte Software bereitzustellen und zu verwenden. Docker hat einen sogenannten Container. Ein Container kann für Laien eine virtuelle Maschine (VM) sein, unterscheidet sich aber dennoch ein wenig von einer VM. Container enthält verpackte Software, die so bereitgestellt wird, dass sie isoliert auf einem gemeinsam genutzten Betriebssystem ausgeführt werden kann. Gemäß der offiziellen Definition – Im Gegensatz zu VMs bündelt der Container kein vollständiges Betriebssystem – es werden nur Bibliotheken und Einstellungen benötigt, die erforderlich sind, damit die Software funktioniert.

In dieser Demo verwenden wir unsere Spring-Boot-Anwendung, die von Teil I bis Teil VIII erstellt wurde.

Ich verwende die Windows Platform Toolbox für Docker, um meine Docker-Container zu erstellen.

Wir werden einen Container mit bereitgestellter MySQL-Datenbank und einen weiteren Container erstellen, in dem wir die Spring-Boot-Anwendung bereitstellen. Dieser Spring-Boot-Anwendungscontainer stellt zur Laufzeit eine Verbindung zum MySQL-Datenbankcontainer her. Der Prozess ist ein wenig kompliziert, aber sobald Sie den Docker-Container in die Hände bekommen, wird es sehr einfach zu verstehen. Auch in diesem Beitrag werde ich nichts über die Anwendung von Spring Boot erklären. Sie sollten alle vorherigen Beiträge lesen, die ich geschrieben habe, um zu erklären, wie man eine Spring-Boot-Anwendung auf einem eingebetteten Tomcat erstellt und bereitstellt.

Sobald wir uns mit Docker auskennen, ist es einfach, eine Anwendung in Docker bereitzustellen.

Erstellen eines Docker-Containers mit MySQL

Ein paar Dinge, an die Sie sich erinnern sollten

  1. Stellen Sie sicher, dass Ihre Spring-Boot-Anwendung mit der MySQL-Datenbank funktioniert, bevor Sie einen Container erstellen.
  2. Wenn Ihre Anwendung eine Benutzerverwaltung und ein Passwort enthält, stellen Sie sicher, dass Sie einen Superadministrator haben, dessen Passwort Sie mit password_hash in die Datenbank einfügen können. Dies gilt insbesondere für die Anwendung, die wir im Docker-Container bereitstellen werden.

Für die meisten Standardanwendungen (wie MySQL, Java 8, Spring-Boot) sind im Docker-Hub eine Reihe von Images verfügbar. Wenn wir unseren Docker-Container für die Datenbank ausführen, ruft die Docker-Shell die Version dieser Anwendung vom Hub ab, um einen Container zu erstellen. Wir werden kein neues oder leeres Docker-Image erstellen. Um einen Docker-Container mit MySQL-Version 5.6 auszuführen, verwenden wir den folgenden Befehl.



docker run --name benefitsmysql -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -e MYSQL_DATABASE=benefitsmysql -p 3308:3306 -d mysql:5.6

  • Der Name unseres Docker-Containers ist benefitmysql.
  • Wir verwenden kein Passwort. Dies wird für Produktionscode nicht empfohlen, ich mache das nur zu Demozwecken.
  • Der Datenbankname ist benefitmysql.
  • Auch diese Datenbank läuft auf Port 3308 bis 3306 des lokalen Host-Rechners.
  • -d um Docker anzuweisen, den Container zu dämonisieren und ihn am Laufen zu halten.
  • mysql:5.6 um das MySQL 5.6-Server-Image aus dem öffentlichen Docker-Repository herunterzuladen

Sobald dies gestartet ist, gibt es mehrere Möglichkeiten, um zu überprüfen, ob wir eine Verbindung zu dieser Datenbank herstellen können oder nicht.

Rufen Sie die IP-Adresse dieses Containerhosts mit dem Befehl docker-machine ip ab . Greifen Sie jetzt in der MySQL-Administrator-Workbench mit der IP-Adresse und dem Port 3308 auf den MySQL-Server zu und prüfen Sie, ob Sie auf die Datenbank zugreifen können.

Ein anderer Weg im Docker-Shell-Terminal – verwenden Sie diesen Befehl docker exec -it benefitsmysql -l , dies verbindet Sie als Root mit der Shell, in der mysql installiert ist. Und dann können Sie mysql verwenden als regulärer Befehl für den Zugriff auf mysql.

Um unsere Spring-Boot-Anwendung erfolgreich auszuführen, erstellen Sie nach dem Zugriff auf mysql die folgenden Tabellen:



use benefitsmysql;

create table companyprofile (id int not null auto_increment, establisheddate date, status varchar(50),corporationtype varchar(50), primary key(id));

create table company(id int not null auto_increment, name varchar(255), statusid int, type varchar(255), ein varchar(50), companyprofileid int, primary key(id), foreign key(companyprofileid) references company(id));

create table userprofile(id int not null auto_increment, dob date, doh date, maritalstatus varchar(50),sex varchar(50),ssn varchar(50),weight varchar(50), height varchar(50),employmentstatus varchar(50), terminationdate date, primary key(id));

create table user(id int not null auto_increment, createdate date, email varchar(255),firstname varchar(255), middlename varchar(255), lastname varchar(255),username varchar(100),jobtitle varchar(255),password_hash text,enabled tinyint(4), userprofileid int, primary key(id), foreign key(userprofileid) references userprofile(id));

create table role(id int not null auto_increment, role varchar(255), primary key(id));

create table user_role(user_id int not null, role_id int not null, primary key(user_id, role_id));

Erstellen eines Docker-Images für die Spring Boot-Anwendung zusammen mit mysql

Um meine Spring-Boot-Anwendung anzudocken, verwenden wir ein Maven-Plugin, um ein Docker-Image zu erstellen.


<plugin>
		<groupId>com.spotify</groupId>
            	<artifactId>docker-maven-plugin</artifactId>
            	<version>1.0.0</version>
            	<configuration>
                	<imageName>${docker.image.prefix}/benefits</imageName>
                	<dockerHost>https://192.168.99.100:2376</dockerHost>
                	<dockerCertPath>C:\Users\Yogesh Mali\.docker\machine\machines\default</dockerCertPath>
                	<dockerDirectory>src/main/docker</dockerDirectory>
                	<resources>
                    	<resource>
                        	<targetPath>/</targetPath>
                        	<directory>${project.build.directory}</directory>
                        	<include>${project.build.finalName}.jar</include>
                    	</resource>
                	</resources>
            	</configuration>
	</plugin>

Ich übergebe dockerDirectory, wo Dockerfile gespeichert wird, um unser Image zu erstellen. Eine weitere Änderung, die ich an meiner ursprünglichen Pom-Datei vorgenommen habe, ist, dass ich eine Verpackung als Glas hinzugefügt habe.


<groupId>com.betterjavacode</groupId>
	<artifactId>Benefits</artifactId>
	<packaging>jar</packaging>
	<version>0.0.1-SNAPSHOT</version>
  .................
  <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <configuration>
          <mainClass>com.betterjavacode.benefits.Application</mainClass>
      </configuration>
      <executions>
          <execution>
              <goals>
                 <goal>repackage</goal>
              </goals>
          </execution>
      </executions>
  </plugin>

Ich habe auch in meinen application.properties geändert, um auf den MySQL-Datenbankcontainer zu verweisen, indem ich die Datenbank-URL mit der IP-Adresse des Docker-Containers aktualisiert habe.

spring.datasource.url=jdbc:mysql://192.168.99.100:3308/benefitsmysql

Mein Dockerfile zum Erstellen eines Docker-Images lautet wie folgt:


FROM java:8
VOLUME /tmp
ADD Benefits.jar Benefits.jar
EXPOSE 8443
RUN bash -c 'touch /Benefits.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/Benefits.jar"]

Im Grunde wird dies eine Benefits.jar-Datei mit Java 8 erstellen und Port 8443 verfügbar machen, über den ich auf meine Anwendung zugreifen kann.

Erstellen Sie nun ein neues Docker-Container-Image, indem Sie das Maven-Ziel als

verwenden

mvn clean package docker:build

So führen Sie die Anwendung aus

docker run -p 8443:8443 --name benefits --link benefitsmysql:mysql -d containerid

Dadurch wird das in diesem Container erstellte JAR ausgeführt. Wichtig zu beachten ist hier --link da es andere Container verknüpft, in denen wir mysql-Server bereitgestellt haben. Wir verknüpfen also zwei Container und rufen die Datenbank aus unserem Spring-Boot-Anwendungscontainer auf. Derselbe Befehl kann etwas anders verwendet werden, um das detaillierte Ausführungsprotokoll wie unten zu sehen

docker run -p 8443:8443 --name benefits --link benefitsmysql:mysql -it containerid

Anwendung ausführen

Sobald die Anwendung erfolgreich gestartet wurde, greifen wir mit der URL https://192.168.99.100:8443/home auf unsere Anwendung zu , sieht dies wie folgt aus:

Ein weiterer Hinweis – Stellen Sie sicher, dass Sie die IP-Adresse in allen eckigen js-Referenzen aktualisieren.

In diesem Beitrag haben wir gezeigt, wie wir eine mit MySQL verbundene Spring Boot-Anwendung in einem Docker-Container bereitstellen können. Der Code für diesen Beitrag wird hier im GitHub-Repository verfügbar sein

Referenzen

Um meinen Beitrag zu schreiben, habe ich die folgenden Referenzen verwendet

  1. Docker
  2. Verbindung abgelehnt
  3. Spring Boot-Andockfenster


Java-Tag