Tutoriel pour apprendre à déployer une application GWT avec Docker

Pour déployer une application GWT monolithe, un serveur d'applications est nécessaire. Nous allons utiliser Jetty à des fins de démonstration. Afin de ne pas réinventer la roue, nous allons utiliser l'image Jetty officielle, disponible sur Docker Hub.

Notre Dockerfile ressemble à ceci :

FROM jetty

VOLUME /c/Users/GWidgets/workspace/test/test-pwa2/

COPY target/test-pwa2-0.1.war /var/lib/jetty/webapps

Explication : nous avons dit à Docker d'attacher le répertoire où réside notre application comme un volume à l'aide de la commande VOLUME, et ensuite copier notre fichier war dans le dossier webapps de Jetty. L'application sera automatiquement déployée au démarrage. Maintenant, nous devons construire notre image et l'exécuter :

docker build -t gwidgets/gwt-jetty .
docker run -ti -p 8080:8080 --rm --name gwt-jetty gwidgets/gwt-jetty

Une application côté client ne contient que des fichiers statiques tels que html, js, css, etc., donc nous pouvons faire sans un serveur d'applications. Nous pouvons utiliser n'importe quel serveur web comme Apache ou Nginx. Nous pouvons également utiliser des modules Node Js comme Express ou http-sever pour écrire notre propre serveur, ou alors le module Python SimpleHTTPServer pour un serveur web encore plus simple. Comme nous n'avons besoin que de fonctionnalités minimales dans cet exemple, nous allons utiliser SimpleHTTPServer pour servir nos fichiers.

Nous allons utiliser l'image officielle docker python. Notre Dockfile ressemble à ceci :

FROM python:2.7

WORKDIR /test/
EXPOSE 8080

CMD python -m SimpleHTTPServer 8080


docker build -t gwidgets/gwt-client-python-server .

docker run --rm -ti -p 8080:8080 -v /c/GWidgets/workspace/test/python-server-docker:/tes
t/ --name gwt-client2 gwidgets/gwt-client-python-server

Explication : nous avons construit notre image à l'aide de la commande build et nous lui avons donné un tag en utilisant l'option -t. Nous avons ensuite utilisé la command run avec l'option -p qui spécifie le port sur la machine hôte qui sert comme interface avec le port du container Docker. De même, l'option -v spécifie quel fichier sur notre système doit être associé au point de montage spécifié par le container, dans notre cas / test /.

Les applications multicouches sont généralement découplées en un côté client et plusieurs services backend où la communication est effectuée en utilisant HTTP. Dans ce cas, nous allons combiner ce que nous avons appris dans les sections précédentes. Pour la partie client, nous pouvons utiliser un container avec un serveur web comme nous l'avons vu dans la deuxième section. Pour les services backend, nous pouvons utiliser un container avec un serveur d'applications ou juste un conteneur avec Java 8 si un serveur intégré est utilisé comme dans le cas de Spring Boot. Puisque nous avons maintenant un ensemble de containers interdépendants, nous avons besoin d'utiliser docker-compose qui est un outil fourni par Docker pour aider à exécuter des applications composées de multiples containers. Docker-compose s'appuie sur un fichier yaml qui décrit les containers qui forment une application. Supposons que notre application GWT soit divisée en un côté client, et deux services backend Restful, notre docker-compose va alors ressembler à ceci :

version: '2'
services:
  client:
    build: gwidgets/gwt-client
    ports:
     - "8080:8080"
    volumes:
     - .:/client
  service1:
    image: gwidgets/service1
    ports:
     - "8081:8081"
  service2:
    image: gwidgets/service2
    ports:
     - "8082:8082"
       depends_on:
     - service1

Après avoir défini notre système de containers interdépendants en utilisant le fichier docker-compose.yml, nous pouvons exécuter notre application à l'aide de la commande docker-compose suivante : docker-compose up.