Erstellen Sie mit Docker für Mac Teil2 eine Entwicklungsumgebung für Java-Webanwendungen

Einführung

In part1 habe ich sogar Tomcat mit Docker verschoben. Dieses Mal möchte ich mit der Bereitstellung und dem Debuggen der Webanwendung (Krieg) fortfahren.

Dieses Mal werden wir die folgenden vier Dinge tun. Verwenden Sie Maven, um Krieg aufzubauen und einzusetzen. Verwenden Sie IntelliJ IDEA zum Debuggen.

1. [Aktivieren Sie den Webanwendungsmanager von Tomcat für die Bereitstellung. ](# Tomcats Webanwendungsmanager für die Bereitstellung aktivieren)
2. [Erstellen Sie einen Beispielkrieg für die Bereitstellung. ](#Erstellen Sie einen Beispielkrieg für die Bereitstellung)
3. [Krieg einsetzen. ](Deploy #war)
4. [Verbinden Sie den Debugger mit der bereitgestellten Webanwendung und beenden Sie den Vorgang. ](# Verbinden Sie den Debugger mit der bereitgestellten Webanwendung und beenden Sie den Vorgang.)

Aktivieren Sie den Webanwendungsmanager von tomcat für die Bereitstellung

Sie müssen den Webanwendungsmanager von Tomcat aktivieren, um den Krieg bereitzustellen. Dazu müssen Sie die Tomcat-Konfigurationsdatei "tomcat-users.xml" ändern, um Benutzer und Kennwörter zu definieren.

Wenn Sie Docker verwenden, scheint es gut zu sein, die geänderte Einstellungsdatei auf dem Container zu mounten und zu lesen, ohne das Image zu ändern, wenn Sie die Einstellungsdatei usw. ändern.

Extrahieren Sie die Tomcat-Konfigurationsdatei

Finden Sie den Containernamen von Tomcat heraus, der auf Docker ausgeführt wird

console

$ docker ps

CONTAINER ID        IMAGE                           COMMAND                  CREATED             STATUS              PORTS                                                                           NAMES
1bf4ec739fab        tomcat:8.0-jre8                 "catalina.sh jpda run"   31 minutes ago      Up 16 minutes       0.0.0.0:8000->8000/tcp, 0.0.0.0:9090->9090/tcp, 8080/tcp                        qiitadockertomcat8_tomcat_1
96067c3ea144        codekitchen/dinghy-http-proxy   "/app/docker-entry..."   3 months ago        Up About an hour    0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 19322/tcp, 0.0.0.0:19322->19322/udp   http-proxy

In diesem Fall ist `` `qiitadockertomcat8_tomcat_1``` der Name des Containers, in dem Tomcat ausgeführt wird.

Geben Sie den Container ein und überprüfen Sie den Pfad der Tomcat-Konfigurationsdatei

Nachdem wir den Containernamen kennen, gehen wir in den Container und sehen uns dessen Inhalt an, um herauszufinden, von welchem Pfad kopiert werden soll.

console

$ docker exec -it qiitadockertomcat8_tomcat_1 bash

root@1bf4ec739fab:/usr/local/tomcat# ls -la
total 128
drwxr-sr-x 1 root staff  4096 Apr  3 20:02 .
drwxrwsr-x 1 root staff  4096 Apr  3 20:02 ..
-rw-r--r-- 1 root root  57011 Mar 28 14:45 LICENSE
-rw-r--r-- 1 root root   1444 Mar 28 14:45 NOTICE
-rw-r--r-- 1 root root   6741 Mar 28 14:45 RELEASE-NOTES
-rw-r--r-- 1 root root  16195 Mar 28 14:45 RUNNING.txt
drwxr-xr-x 2 root root   4096 Apr  3 20:03 bin
drwxr-xr-x 1 root root   4096 Aug  6 05:10 conf
drwxr-sr-x 3 root staff  4096 Apr  3 20:02 include
drwxr-xr-x 2 root root   4096 Apr  3 20:02 lib
drwxr-xr-x 1 root root   4096 Aug  6 05:10 logs
drwxr-sr-x 3 root staff  4096 Apr  3 20:02 native-jni-lib
drwxr-xr-x 2 root root   4096 Apr  3 20:02 temp
drwxr-xr-x 7 root root   4096 Mar 28 14:44 webapps
drwxr-xr-x 1 root root   4096 Aug  6 05:10 work

root@1bf4ec739fab:/usr/local/tomcat# ls -la conf
total 228
drwxr-xr-x 1 root root    4096 Aug  6 05:10 .
drwxr-sr-x 1 root staff   4096 Apr  3 20:02 ..
drwxr-xr-x 3 root root    4096 Aug  6 05:10 Catalina
-rw------- 1 root root   12767 Mar 28 14:45 catalina.policy
-rw------- 1 root root    7299 Mar 28 14:45 catalina.properties
-rw------- 1 root root    1577 Mar 28 14:45 context.xml
-rw------- 1 root root    3387 Mar 28 14:45 logging.properties
-rw------- 1 root root    6458 Mar 28 14:45 server.xml
-rw------- 1 root root    2164 Mar 28 14:45 tomcat-users.xml
-rw------- 1 root root    2634 Mar 28 14:45 tomcat-users.xsd
-rw------- 1 root root  168378 Mar 28 14:45 web.xml

root@1bf4ec739fab:/usr/local/tomcat# exit

Der Ordner der Tomcat-Konfigurationsdatei im Docker sieht wie folgt aus: `` `/ usr / local / tomcat / conf```. Nachdem wir den Pfad kennen, können wir den Container verlassen.

Extrahieren Sie die Tomcat-Konfigurationsdatei aus dem Docker-Container

Extrahieren Sie den Ordner conf mit dem folgenden Befehl aus tomcat im Docker-Container. Das aktuelle Verzeichnis bei der Ausführung des Befehls ist der Ordner, in dem sich dokcer-compose.yml befindet.

console

$ docker cp qiitadockertomcat8_tomcat_1:/usr/local/tomcat/conf conf

Überprüfen Sie das extrahierte conf-Verzeichnis.

console

$ ls
conf               docker-compose.yml

$ ls -la conf
total 432
drwxr-xr-x  11 cnaos  staff     374  8  6 14:10 .
drwxr-xr-x   4 cnaos  staff     136  8  6 15:03 ..
drwxr-xr-x   3 cnaos  staff     102  8  6 14:10 Catalina
-rw-------   1 cnaos  staff   12767  3 28 23:45 catalina.policy
-rw-------   1 cnaos  staff    7299  3 28 23:45 catalina.properties
-rw-------   1 cnaos  staff    1577  3 28 23:45 context.xml
-rw-------   1 cnaos  staff    3387  3 28 23:45 logging.properties
-rw-------   1 cnaos  staff    6458  3 28 23:45 server.xml
-rw-------   1 cnaos  staff    2164  3 28 23:45 tomcat-users.xml
-rw-------   1 cnaos  staff    2634  3 28 23:45 tomcat-users.xsd
-rw-------   1 cnaos  staff  168378  3 28 23:45 web.xml

Ändern Sie die extrahierte Datei tomcat-users.xml und fügen Sie ein Konto für die Bereitstellung hinzu

Ändern Sie die extrahierte Datei tomcat-users.xml wie folgt.

Sie müssen einen Benutzer erstellen, der "Manager-GUI" und "Manager-Skript" als Rollen hat. Bitte schreiben Sie den Passwortteil selbst neu und legen Sie ihn fest.

tomcat-users.xml

<!--
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <user username="tomcat" password="<must-be-changed>" roles="tomcat"/>
  <user username="both" password="<must-be-changed>" roles="tomcat,role1"/>
  <user username="role1" password="<must-be-changed>" roles="role1"/>
-->
<role rolename="manager-gui"/>
<role rolename="manager-script"/>
<user username="tomcat" password="[Bitte geben Sie ein passendes Passwort ein]" roles="manager-gui,manager-script"/>

</tomcat-users>

Ändern Sie docker-compose.yml und hängen Sie das extrahierte conf-Verzeichnis ein

Ändern Sie docker-compose.yml wie folgt. Volumes werden vor dem Befehl hinzugefügt.

docker-compose.yml

tomcat:
  image: tomcat:8.0-jre8
  ports:
    - "8000:8000"
    - "9090:9090"
  environment:
    VIRTUAL_HOST: tomcat.docker
    VIRTUAL_PORT: 8080
    CATALINA_OPTS: "-Dcom.sun.management.jmxremote
     -Dcom.sun.management.jmxremote.port=9090
     -Dcom.sun.management.jmxremote.rmi.port=9090
     -Dcom.sun.management.jmxremote.ssl=false
     -Dcom.sun.management.jmxremote.local.only=false
     -Dcom.sun.management.jmxremote.authenticate=false
     -Djava.rmi.server.hostname=tomcat.docker"
  volumes:
    - ./conf:/usr/local/tomcat/conf
  command: catalina.sh jpda run

Sobald dies behoben ist und Docker-Compose die Konsole ausführt, geben Sie STRG-C ein, um den Container zu verlassen Starten Sie den Container erneut mit `` `docker-compose up```.

Bestätigen Sie den Benutzer der erstellten Tomca

http://tomcat.docker/manager/html/list

Gehen Sie zu und geben Sie den zuvor festgelegten Benutzer und das Kennwort ein.

Es ist in Ordnung, wenn der folgende Bildschirm angezeigt wird.

Jetzt können Sie War mit dem Webanwendungsmanager von Tomcat bereitstellen.

Erstellen Sie einen Beispielkrieg für die Bereitstellung

Dieses Mal werde ich das Spring-Boot-Beispiel verwenden. Alles, was einen Krieg führen kann, wird funktionieren.

https://spring.io/guides/gs/spring-boot/

Projektaufbau

git klont das Spring-Boot-Projekt in einen anderen Ordner als den, der docker-compose.yml enthält.

console

git clone https://github.com/spring-guides/gs-spring-boot.git

Öffnen Sie den Ordner gs-spring-boot / complete als Projekt in der IDE.

Der Federstiefel wurde geändert, um Krieg zu führen

Im Standardzustand von Spring-Boot wird kein Krieg erstellt. Ändern Sie ihn daher, um Krieg zu erstellen.

Referenz: http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-create-a-deployable-war-file

Anwendungsklasse ändern

Ändern Sie Application.java wie folgt: Bitte schreiben Sie die ursprüngliche Application.java vollständig neu.

Application.java

@SpringBootApplication
public class Application extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }

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

}

Ändern Sie pom.xml

Fügen Sie die folgenden Einstellungen zu pom.xml über dem Build-Tag hinzu

pom.xml

<packaging>war</packaging>

Fügen Sie der Abhängigkeit von pom.xml Folgendes hinzu

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

Referenz: http://qiita.com/ARS_2000/items/3f191aeb6f161101d5f6

Erstelle einen Krieg

Geben Sie im Verzeichnis gs-spring-boot / complete den folgenden Befehl ein, um einen Krieg zu erstellen.

console

$ mvn war:war

Picked up _JAVA_OPTIONS: -Dfile.encoding=UTF-8
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building gs-spring-boot 0.1.0
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-war-plugin:2.6:war (default-cli) @ gs-spring-boot ---
[INFO] Packaging webapp
[INFO] Assembling webapp [gs-spring-boot] in [/Users/cnaos/workbench/gs-spring-boot/complete/target/gs-spring-boot-0.1.0]
[INFO] Processing war project
[INFO] Webapp assembled in [269 msecs]
[INFO] Building war: /Users/cnaos/workbench/gs-spring-boot/complete/target/gs-spring-boot-0.1.0.war
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.288 s
[INFO] Finished at: 2017-08-06T16:25:04+09:00
[INFO] Final Memory: 19M/178M
[INFO] ------------------------------------------------------------------------

Krieg einsetzen

Fügen Sie das Maven-Plugin für die Bereitstellung in Tomcat in pom.xml hinzu

pom.xml

    <build>
         <plugins>
            ...
         
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <server>tomcat-docker</server>
                    <url>http://tomcat.docker/manager/text</url>
                </configuration>
            </plugin>
           
            ...
         </plugins>
    </build>

Der Wert im Server-Tag der Konfiguration wird verwendet, um die Benutzer-ID und das Kennwort für die Bereitstellung abzurufen, die in settings.xml beschrieben werden und später angezeigt werden.

Der Wert im URL-Tag der Konfiguration ist die URL des Webanwendungsmanagers von tomcat. Der Standardwert ist `` `http: // localhost: 8080 / manager / text```, aber ändern Sie ihn, da er für Tomcat auf Docker bereitgestellt wird.

Legen Sie die Anmeldeinformationen fest, die vom Tomcat-Plug-In von maven für die Bereitstellung verwendet werden

Unter dem Ausgangsverzeichnis befindet sich ein verstecktes Verzeichnis ".m2" für maven. Fügen Sie der Datei settings.xml in diesem .m2-Verzeichnis die folgenden Einstellungen hinzu. Wenn keine Datei settings.xml vorhanden ist, erstellen Sie eine Datei settings.xml.

Legen Sie für das Kennwort das in tomcat-users.xml festgelegte Kennwort fest.

xml:~/.m2/settings.xml

<settings>
  <servers>
    <server>
      <id>tomcat-docker</id>
      <username>tomcat</username>
      <password>【tomcat-users.Passwort in XML gesetzt]</password>
    </server>
  </servers>
</settings>

Bereitstellen

console

$ mvn tomcat7:deploy -Dmaven.test.skip=true

Überprüfen Sie den bereitgestellten Krieg mit dem Webanwendungsmanager

http://tomcat.docker/manager/html/list

Wenn Sie darauf zugreifen, wird eine Liste der bereitgestellten Webanwendungen angezeigt. Stellen Sie daher sicher, dass `` `gs-spring-boot``` bereitgestellt wird.

Versuchen Sie, auf den eingesetzten Krieg zuzugreifen

Wie aus der Pfadspalte am linken Ende des Webanwendungsmanagers Nachdem Sie Zugriff auf den Krieg haben, klicken Sie auf den Link `` `/ gs-spring-boot```.

Greetings from Spring Boot!

Sollte angezeigt werden.

Verbinden Sie den Debugger mit der bereitgestellten Webanwendung und beenden Sie den Vorgang

Legen Sie den Port und die Verbindungsadresse für den Debugger in den Tomcat-Starteinstellungen von Docker-Compose fest

8080

 Zur nächsten Zeile von

#### **` 8000`**
```jpda_address

 Hinzufügen.



#### **`docker-compose.yml`**
```xml

tomcat:
  image: tomcat:8.0-jre8
  ports:
    - "8000:8000"
    - "9090:9090"
  environment:
    VIRTUAL_HOST: tomcat.docker
    VIRTUAL_PORT: 8080
    JPDA_ADDRESS: 8000
    CATALINA_OPTS: "-Dcom.sun.management.jmxremote
     -Dcom.sun.management.jmxremote.port=9090
     -Dcom.sun.management.jmxremote.rmi.port=9090
     -Dcom.sun.management.jmxremote.ssl=false
     -Dcom.sun.management.jmxremote.local.only=false
     -Dcom.sun.management.jmxremote.authenticate=false
     -Djava.rmi.server.hostname=tomcat.docker"
  volumes:
    - ./conf:/usr/local/tomcat/conf
  command: catalina.sh jpda run

Starten Sie Docker-Compose nach dem Hinzufügen neu.

Erstellen Sie in der IDE eine Remoteverbindungskonfiguration für den Debugger.

1. Wählen Sie im IntelliJ-Menü Ausführen> Konfigurationen bearbeiten
2. Das Fenster Run / Debug Configurations (Konfigurationen ausführen / debuggen) wird geöffnet. Drücken Sie die Taste +
3. Wählen Sie unter Neue Konfiguration hinzufügen die Option "Remote"
4. Setzen Sie "tomcat.docker" in den Einstellungen auf "Host"
5. Stellen Sie den Port in den Einstellungen auf "8000".

Mit den obigen Einstellungen sieht es so aus.

Stellen Sie eine Remoteverbindung für den Debugger her

Führt die Remoteverbindung des erstellten Debuggers aus.

Wenn auf der Debugger-Konsole Folgendes angezeigt wird, ist die Debugger-Verbindung erfolgreich.

Connected to the target VM, address: 'tomcat.docker:8000', transport: 'socket'

Setzen Sie einen Unterbrechungszeiger und überprüfen Sie

Platzieren Sie einen Unterbrechungszeiger in der Indexmethode von HelloController.java. Aus dem Browser http://tomcat.docker/gs-spring-boot/ Wenn Sie versuchen, auf den Unterbrechungszeiger zuzugreifen und ihn anzuhalten, sind Sie erfolgreich.