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

Zakaria Amine

Ce tutoriel montre comment utiliser Docker pour le déploiement d'une application GWT.

Pour réagir au contenu de ce tutoriel, un espace de dialogue vous est proposé sur le forum Commentez . ♪

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

- Auteur : Zakaria Amine

- Parution : 6 mars 2017

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2017 Zakaria Amine. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Construire et tester une application GWT dans Docker

- III. Déploiement d'une application GWT dans Docker

- III-A. Application monolithe

- III-B. Application côté client

- III-C. Application multicouche

- IV. Conclusion

- V. Remerciements

I - Introduction

Docker est l'un des outils les plus populaires, si ce n'est le plus populaire, pour l'infrastructure virtuelle. Il fournit une structure spéciale appelée container, qui peut être utilisée pour le packaging, le build et le déploiement d'une application. Parmi les principaux avantages de Docker, l'efficacité en matière de ressources (comparé à une machine virtuelle), et la portabilité : tant que Docker est là, le container fonctionnera de la même manière même sur des environnements différents (Deploy Once Work Everywhere). En raison de ces avantages, Docker est devenu un must pour le cycle de développement. Il est temps pour les développeurs GWT d'ajouter Docker dans leur routine de développement. Dans ce post, nous allons voir comment utiliser Docker pour le build et le déploiement d'une application GWT. Avant de décoller, certaines connaissances de base sur le fonctionnement de Docker sont nécessaires. Le didacticiel « Docker for Java Developpers » par Zero Turnaround est un bon point de départ.

II - Construire et tester une application GWT dans Docker

Docker peut également être utilisé pour créer un environnement sandbox (isolé) pour le build d'une application. Dans GWT, notre environnement doit avoir des bibliothèques GWT, Java, et peut-être un système de build comme Maven. Comme exemple, nous allons utiliser Docker comme environnement de build pour l'application gwt-polymer-starter-kit. Pour notre build, nous allons avoir besoin d'une image Docker avec Maven, et Java 8 :

1. FROM java:8

3. RUN  \

4. export DEBIAN_FRONTEND=noninteractive && \

5. sed -i 's/# \(.*multiverse$\)/\1/g' /etc/apt/sources.list && \

6. apt-get update && \

7. apt-get -y upgrade && \

8. apt-get install -y wget curl maven

10. VOLUME /gwt-build

12. RUN mkdir gwt-polymer-starter-kit

13. COPY src gwt-polymer-starter-kit/

14. COPY pom.xml gwt-polymer-starter-kit/

16. WORKDIR /gwt-polymer-starter-kit

19. CMD ["mvn", "package"]

Dans cette image, nous avons fait usage d'une image Java 8 déjà existante, et rajouté Maven. Nous avons dit à Docker d'appliquer la commande mvn package après le démarrage ; une fois que la commande va terminer le container, Docker s'arrêtera. Nous avons besoin maintenant de construire et d'exécuter notre image en utilisant les commandes suivantes :

1. docker build -t gwidgets/gwt-polymer-starter-build .

3. docker run -it --rm -v /c/gwidgets/gwt-polymer-starter-kit

En utilisant Docker, nous nous assurons que notre build est propre, et qu'aucun autre paramètre provenant d'autres projets ou du système d'exploitation n'interfère avec.

III - Déploiement d'une application GWT dans Docker

Une application GWT peut avoir plusieurs formes ou architectures. Certaines formes communes sont : l'application monolithe (fichier war contenant la partie front et le back), une application côté client ou une application multicouche. Dans cette section, nous allons voir comment appliquer Docker dans chacun de ces cas.

III-A - Application monolithe

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 :

1. FROM jetty

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

5. 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 :

1. docker build -t gwidgets/gwt-jetty .

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

III-B - Application côté client

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 :

1. FROM python:2.7

3. WORKDIR /test/

4. EXPOSE 8080

6. CMD python -m SimpleHTTPServer 8080

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

11. docker run --rm -ti -p 8080:8080 -v /c/GWidgets/workspace/test/python-server-docker:/tes

12. 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 /.

III-C - Application multicouche

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 :

1. version: '2'

2. services:

3. client:

4. build: gwidgets/gwt-client

5. ports:

6. - "8080:8080"

7. volumes:

8. - .:/client

9. service1:

10. image: gwidgets/service1

11. ports:

12. - "8081:8081"

13. service2:

14. image: gwidgets/service2

15. ports:

16. - "8082:8082"

17. depends_on:

18. - 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.

IV - Conclusion

Docker peut donner une meilleure expérience au développement d'applications GWT, surtout quand cela concerne des applications large-scale avec des environnements complexes et un temps de compilation long. Docker peut aider à fournir un meilleur environnement de test et de build, et à allouer les ressources plus efficacement.

V - Remerciements

Cet article a été publié avec l'aimable autorisation de Zakaria Amine. L'article original est disponible à cette adresse : Dockerizing a GWT app.

Nous tenons à remercier KartSeven pour la relecture orthographique attentive de cet article et Mickael Baron pour la mise au gabarit.