Créer un environnement de développement d'applications Web Java avec Docker pour Mac Part2

introduction

Dans part1, j'ai même déplacé tomcat avec docker. Cette fois, je voudrais procéder au déploiement et au débogage de l'application Web (war).

Cette fois, nous ferons les quatre choses suivantes. Utilisez maven pour construire et déployer la guerre. Utilisez IntelliJ IDEA pour le débogage.

1. [Activez le gestionnaire d'applications Web de tomcat pour le déploiement. ](#Activer le gestionnaire d'applications Web de tomcat pour le déploiement)
2. [Créez un exemple de guerre pour le déploiement. ](#Créer un exemple de guerre pour le déploiement)
3. [Déployez la guerre. ](Déployer #war)
4. [Connectez le débogueur à l'application Web déployée et arrêtez l'opération. ](# Connectez le débogueur à l'application Web déployée et arrêtez l'opération)

Activer le gestionnaire d'applications Web de tomcat pour le déploiement

Vous devez activer le gestionnaire d'applications Web de tomcat pour déployer la guerre, Pour ce faire, vous devez modifier le fichier de configuration de tomcat "tomcat-users.xml" pour définir les utilisateurs et les mots de passe.

Lors de l'utilisation de docker, il semble bon de monter le fichier de paramètres modifié sur le conteneur et de le lire sans changer l'image lors de la modification du fichier de paramètres, etc., donc je le fais.

Extraire le fichier de configuration tomcat

Découvrez le nom du conteneur de tomcat fonctionnant sur docker

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

Dans ce cas, qiitadockertomcat8_tomcat_1``` est le nom du conteneur dans lequel tomcat est en cours d'exécution.

Entrez dans le conteneur et vérifiez le chemin du fichier de configuration tomcat

Maintenant que nous connaissons le nom du conteneur, allons dans le conteneur et jetons un œil au contenu pour savoir à partir de quel chemin copier.

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

Le dossier du fichier de configuration de tomcat dans le menu fixe ressemble à `` / usr / local / tomcat / conf ''. Maintenant que nous connaissons le chemin, nous pouvons quitter le conteneur.

Extraire le fichier de configuration tomcat du conteneur docker

Extrayez le dossier conf de tomcat dans le conteneur docker avec la commande suivante. Le répertoire courant lors de l'exécution de la commande est le dossier où se trouve dokcer-compose.yml.

console

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

Vérifiez le répertoire conf extrait.

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

Modifiez le fichier tomcat-users.xml extrait et ajoutez un compte pour le déploiement

Modifiez le fichier tomcat-users.xml extrait comme suit.

Vous devez créer un utilisateur avec comme rôles manager-gui '' et manager-script '' Veuillez réécrire la partie du mot de passe par vous-même et la définir.

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="[Veuillez définir un mot de passe approprié]" roles="manager-gui,manager-script"/>

</tomcat-users>

Modifiez docker-compose.yml et montez le répertoire conf extrait

Modifiez docker-compose.yml comme suit. Les volumes sont ajoutés avant la commande.

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

Après avoir résolu le problème, une fois que vous avez tapé CTRL-C sur la console exécutant docker-compose, fermez le conteneur, Redémarrez le conteneur avec docker-compose up```.

Confirmer l'utilisateur de la tomca créée

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

Accédez à et entrez l'utilisateur et le mot de passe que vous avez définis précédemment.

C'est OK lorsque l'écran suivant s'affiche.

Vous pouvez maintenant déployer war à l'aide du gestionnaire d'applications Web de tomcat.

Créer un exemple de guerre pour le déploiement

Cette fois, j'utiliserai l'exemple de démarrage à ressort. Tout ce qui peut faire une guerre fera l'affaire.

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

Configuration du projet

git clonez le projet spring-boot dans un dossier différent de celui contenant docker-compose.yml.

console

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

Ouvrez le dossier gs-spring-boot / complete en tant que projet dans l'EDI.

Changement de démarrage à ressort pour créer la guerre

Dans l'état par défaut de spring-boot, la guerre n'est pas créée, changez-la pour créer la guerre.

Référence: http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-create-a-deployable-war-file

Modifier la classe d'application

Modifiez Application.java comme suit: Veuillez réécrire entièrement le fichier Application.java d'origine.

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);
    }

}

Modifier pom.xml

Ajoutez les paramètres suivants à pom.xml au-dessus de la balise de construction

pom.xml

<packaging>war</packaging>

Ajoutez ce qui suit à la dépendance de pom.xml

pom.xml

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

référence: http://qiita.com/ARS_2000/items/3f191aeb6f161101d5f6

Créer une guerre

Dans le répertoire gs-spring-boot / complete, entrez la commande suivante pour créer une guerre.

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] ------------------------------------------------------------------------

Déployer la guerre

Ajouter le plugin maven pour le déploiement sur tomcat dans pom.xml

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>

La valeur à l'intérieur de la balise serveur de configuration est utilisée pour récupérer l'ID utilisateur et le mot de passe pour le déploiement décrit dans settings.xml qui apparaîtra plus tard.

La valeur à l'intérieur de la balise url de configuration est l'URL du gestionnaire d'applications Web de tomcat. La valeur par défaut est `` http: // localhost: 8080 / manager / text '', mais modifiez-la car elle sera déployée sur tomcat sur docker.

Définissez les informations d'identification utilisées par le plug-in tomcat de maven pour le déploiement

Il y a un répertoire caché ".m2" pour maven sous le répertoire personnel. Ajoutez les paramètres suivants à settings.xml situé dans ce répertoire .m2. S'il n'y a pas de fichier settings.xml, créez un fichier settings.xml.

Pour le mot de passe, définissez le mot de passe défini dans tomcat-users.xml.

xml:~/.m2/settings.xml

<settings>
  <servers>
    <server>
      <id>tomcat-docker</id>
      <username>tomcat</username>
      <password>【tomcat-users.Mot de passe défini en xml]</password>
    </server>
  </servers>
</settings>

Déployer

console

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

Vérifiez la guerre déployée avec le gestionnaire d'applications Web

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

Lorsque vous y accédez, vous verrez une liste des applications Web déployées, alors assurez-vous que `` gs-spring-boot '' est déployé.

Essayez d'accéder à la guerre déployée

Tel qu'il est dans la colonne du chemin à l'extrémité gauche du gestionnaire d'applications Web Maintenant que vous avez accès à la guerre, cliquez sur le lien `` / gs-spring-boot ''.

Greetings from Spring Boot!

Doit être affiché.

Connectez le débogueur à l'application Web déployée et arrêtez l'opération

Définissez le port et l'adresse de connexion du débogueur dans les paramètres de démarrage de tomcat de docker-compose

8080

 À la ligne suivante de

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

 Ajouter.



#### **`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

Une fois ajouté, redémarrez docker-compose.

Dans l'EDI, créez un paramètre de connexion à distance pour le débogueur.

1. Sélectionnez Exécuter> Modifier les configurations .. dans le menu IntelliJ
2. Le panneau Configurations Exécuter / Déboguer s'ouvre, appuyez sur le bouton +
3. Sélectionnez "Remote" dans Add New Configuration
4. Définissez "tomcat.docker" sur Hôte dans les paramètres
5. Définissez Port dans Paramètres sur "8000"

Avec les paramètres ci-dessus, cela ressemblera à ceci.

Établir une connexion à distance pour le débogueur

Exécute la connexion à distance du débogueur créé.

Si ce qui suit s'affiche sur la console du débogueur, la connexion du débogueur est réussie.

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

Définissez un pointeur de rupture et vérifiez

Placez un pointeur d'arrêt dans la méthode d'index de HelloController.java. Depuis le navigateur http://tomcat.docker/gs-spring-boot/ Si vous essayez d'accéder et de vous arrêter au pointeur d'arrêt, vous réussissez.