Updated sources and readme for TP1 v2025

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

README.md

@@ -0,0 +1,309 @@
+# TP Docker
+
+## Introduction
+
+Ce TP a pour but de vous familiariser avec Docker et Docker Compose.
+Dans un premier temps, nous allons _dockeriser_ une application Java qui utilise OpenCV. Cela consiste à créer un Dockerfile contenant les dépendances nécessaires pour compiler et exécuter l'application.
+Ensuite, nous allons configurer Docker Compose pour déployer plusieurs instances de l'application avec un serveur web en reverse proxy.
+
+## Liens Utiles
+
+<details>
+<summary>Cliquer pour déplier</summary>
+
+- [Documentation Docker](https://docs.docker.com/)
+- [Tutoriel Docker](https://docs.docker.com/get-started/)
+- [Reverse Proxy Nginx Automatisé pour Docker](http://jasonwilder.com/blog/2014/03/25/automated-nginx-reverse-proxy-for-docker/)
+- [Compilation OpenCV sur Ubuntu](https://advancedweb.hu/2016/03/01/opencv_ubuntu/)
+
+</details>
+
+# Modalités de rendu
+
+Tous les rendus TLC se font à travers le gitlab de l'ISTIC : https://gitlab.istic.univ-rennes1.fr/
+
+Si vous ne l'avez pas déjà fait, créez sur Gitlab ISTIC un groupe nommé `TLC_2025_<votre_nom>_<votre_prenom>` 
+
+Pour chaque TP, vous devrez créer un projet dans ce groupe, nommé `TP<numero>_<votre_nom>_<votre_prenom>` et le projet finale nommé `Projet_<votre_nom>_<votre_prenom>`
+
+Pour chaque TP, vous devrez ajouter votre enseignant en tant que membre du projet avec le rôle de "Reporter" pour permettre la correction.
+
+### Étape 0: Prérequis
+Il est fortement conseillé de dérouler ce TP sur une machine Linux (Ubuntu, Fedora, etc.) ou en utilisant une machine virtuelle (VirtualBox, Vagrant, etc.).
+
+1. Installez Docker dans votre environnement de développement.
+2. Clonez ce dépot.
+
+## [PARTIE 1] Dockerisation de l'Application
+
+### Commandes Utiles
+
+<details>
+<summary>pour interagir avec les images</summary>
+
+- `docker build -t <nom_image> .` : Construit une image Docker à partir d'un Dockerfile situé dans le répertoire courant et lui donne un nom.
+- `docker rmi <nom_image>` : Supprime une image.
+- `docker images` : Liste les images.
+- `docker pull <nom_image>` : Télécharge une image depuis le Docker Hub.
+
+</details>
+
+<details>
+<summary>pour interagir avec les conteneurs</summary>
+
+- `docker run [nom_image]` : Démarre un conteneur à partir d'une image.
+- `docker ps` : Liste les conteneurs en cours d'exécution.
+- `docker exec -it [nom_conteneur] /bin/bash` : Exécute la commande `/bin/bash` dans un conteneur avec le mode interactif -] ça donne un shell (si bash est installé).
+- `docker stop [nom_conteneur]` : Arrête un conteneur.
+- `docker rm [nom_conteneur]` : Supprime un conteneur.
+- `docker logs [nom_conteneur]` : Affiche les logs d'un conteneur.
+</details>
+
+D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/docker/).
+
+<details>
+<summary>Étape 1 : version scratch À EFFACER SI NON RETENU</summary>
+
+### Étape 1: Créer une Image Docker à partir de `scratch`
+> Pour la syntaxe du Dockerfile, vous pouvez consulter la documentation officielle de Docker, lien ci-dessous.
+
+1. Création d'un `Dockerfile` à partir d'une image vierge:
+    - Utilisez une image de base `scratch`.
+    - Ajoutez le binaire `hello` en commande de démarrage.
+    - Build, run et vérifiez que tout fonctionne correctement.
+
+2. Ici on va étendre l'image scratch avec l'application Java.
+    - Installez les dépendances nécessaires pour OpenCV.
+    - Ajoutez les fichiers sources et compilez l'application.
+    - Assurez d'avoir la bonne commande de démarrage du conteneur.
+</details>
+
+<details> 
+<summary>Étape 1 : version non scratch À EFFACER SI NON RETENUE</summary>
+
+### Étape 1: Premiers pas avec Docker
+1. Création d'un `Dockerfile` à partir d'une image de base:
+    - Utilisez une image de base de votre choix (debian, ubuntu, etc.).
+    - Ajoutez `echo "Hello World"` en commande de démarrage.
+    - Build, run et vérifiez que tout fonctionne correctement.
+
+2. Ici on va étendre l'image de base avec l'application Java.
+    - Installez les dépendances nécessaires pour OpenCV.
+    - Ajoutez les fichiers sources et compilez l'application.
+    - Assurez d'avoir la bonne commande de démarrage du conteneur.
+</details>
+
+<details>
+<summary>Cliquer pour des liens utiles</summary>
+
+- [Dockerfile Reference](https://docs.docker.com/reference/dockerfile)
+</details>
+
+<details>
+<summary>Cliquer pour des indices</summary>
+    
+- Installez des dépendances comme OpenJDK, Maven, et OpenCV. 
+```shell
+    apt-get update
+    apt-get install -y openjdk-8-jdk
+    apt-get install -y maven
+    apt-get install -f libpng16-16
+    apt-get install -f libjasper1
+    apt-get install -f libdc1394-22
+```
+- Utilisez `mvn package` pour compiler l'application.
+- Utilisez `java -Djava.library.path=lib/ -jar target/fatjar-0.0.1-SNAPSHOT.jar` pour exécuter l'application. (Utilisez lib/ubuntuupperthan18 si vous avez comme image une version d'Ubuntu supérieure à 18.04)
+- L'application est accessible sur le port 8080. Assurez-vous d'exposer ce port ou de le bind à un port de votre choix au démarrage du conteneur. Si tout est correct, http://localhost:8080 devrait être ouvert depuis votre navigateur.
+</details>
+
+### Étape 2: Créer une Version **Light** de l'Image
+
+Maintenant que vous avez une image fonctionnelle, vous allez essayer de la rendre plus légère. 
+
+1. Proposez un nouveau fichier Dockerfile qui permet de créer une image de taille réduite.
+
+<details>
+<summary>Cliquer pour des liens utiles</summary>
+
+- [Build Multi-Stage Docker 1](https://learnk8s.io/blog/smaller-docker-images)
+- [Build Multi-Stage Docker 2](https://docs.docker.com/develop/develop-images/multistage-build/)
+
+</details>
+
+## [PARTIE 2] Configuration d'un reverse proxy sous Docker
+
+
+
+### Étape 1: Configuration Simple avec Nginx
+
+Pour le nginx en reverse proxy, nous allons partir de l'image \[suivante\](https://github.com/jwilder/nginx-proxy).
+
+L'explication du fonctionnement est disponible \[ici\](http://jasonwilder.com/blog/2014/03/25/automated-nginx-reverse-proxy-for-docker/).
+
+> Si vous n'avez pas la tête à lire ça, la version abrégée est que le reverse proxy vous permet tout un tas de choses, y compris de gérer le fait que les containers ont des adresses IP (un peu) trop dynamiques, ce qui fait qu'à chaque changement/lancement de container, il y aurait des problèmes de binding de port. Le reverse proxy va vous permettre de cacher ces aspects-là, puisqu'ils seront gérés par ce composant. Ainsi, les chargements de versions modifiées de votre service n'auront pas besoin d'une gestion fine à la main des connexions, les différents utilisateurs qui voudront envoyer des requêtes simultanées au même service ne seront pas embêtés par des ports qui ne sont pas accessibles, etc.
+
+1. Lancement de nginx en reverse proxy :
+
+```bash
+docker run -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy
+```
+
+⚠️ Pour certaines installations comme sur la dernière édition de Fedora, les règles de sécurité par défaut ont évolué. Pour que le container puisse accéder à la socket Docker, il faut ajouter l'option suivante :
+
+```bash
+docker run --security-opt=label:type:docker_t -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy
+```
+
+2. Si vous êtes sur votre propre portable, modifiez votre fichier `/etc/hosts` pour faire correspondre **m** vers localhost. Ce serait à faire sur votre gestionnaire de nom de domaine en temps normal.
+Vous devez avoir une ligne qui ressemble à cela :
+
+```txt
+127.0.0.1    localhost localhost.localdomain localhost4 localhost4.localdomain m
+```
+
+Pour ceux qui n'ont pas les droits root, exécutez les commandes suivantes :
+
+```bash
+echo 'm localhost' >> ~/.hosts
+export HOSTALIASES=~/.hosts
+curl m:8080
+```
+
+3. Puis créez plusieurs fenêtres dans votre terminal. Ce seront vos différentes machines host émulées. Vous pouvez en créer au moins 3 ou 4. Dans ces terminaux, lancez la commande suivante pour tester votre reverse proxy :
+
+```bash
+docker run -e VIRTUAL_HOST=m -t -i nginx
+```
+
+4.   Testez votre reverse proxy en lançant la commande suivante dans votre terminal originel :
+
+```bash
+curl m:8080
+```
+
+En l'exécutant plusieurs fois et suffisamment rapidement, vous devriez voir tantôt une fenêtre terminator se mettre à jour, tantôt une autre. C'est l'effet du load balancer (un autre service qui est géré par votre nginx).
+
+En tapant la commande suivante, vous pouvez regarder le fichier de configuration nginx qui sera généré à l'adresse suivante `/etc/nginx/conf.d/default.conf`. 
+
+(N'oubliez pas de remplacer `865c1e67a00e` par l'id de votre nginx en reverse proxy (`docker ps`) pour récupérer la liste des containers en cours d'exécution) :
+```bash
+docker exec -it 865c1e67a00e bash
+```
+
+- [source](http://jasonwilder.com/blog/2014/03/25/automated-nginx-reverse-proxy-for-docker/)
+
+Tuez tous les dockers nginx démarrés :
+
+```bash
+docker ps # pour avoir la liste
+docker kill "IDDOCKER" # pour tuer un docker
+```
+
+
+### Étape 2: Configuration Simple avec jwilder/nginx-proxy
+<details>
+<summary>pour interagir avec un deploiement compose</summary>
+
+- `docker-compose up` : Démarre les services.
+- `docker-compose down` : Arrête les services.
+- `docker-compose up -f <fichier>` : Démarre les services à partir d'un fichier spécifique.
+- D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/docker/compose/).
+</details>
+
+1. Créez un fichier docker-compose.yml avec jwilder/nginx-proxy
+
+<details>
+<summary>Cliquer pour un exemple</summary>
+
+```yaml
+    version: '3'
+    services:
+      nginx-proxy:
+        image: jwilder/nginx-proxy
+        ports:
+          - "8080:80"
+        volumes:
+          - /var/run/docker.sock:/tmp/docker.sock
+```
+</details>
+
+2. Ajoutez un service nginx classique qui utiliserait le reverse proxy et donnez lui un nom vhost.
+3. Assurez-vous que votre fichier **/etc/hosts** contient une entrée pour le nom de domaine que vous avez choisi (vhost).
+4. Vérifiez que tout fonctionne correctement en accédant à l'URL du vhost.
+
+
+<details>
+<summary>Cliquer pour des liens utiles</summary>
+
+- [Docker compose services options](https://docs.docker.com/reference/compose-file/services/)
+- [Repo officiel jwilder/nginx-proxy](https://hub.docker.com/r/jwilder/nginx-proxy/)
+</details>
+
+### Étape 3: Docker Compose avec 4 Instances
+1. Maintenant que vous avez familiarisé avec Docker Compose et le reverse proxy, remplacez le service nginx par votre application Java en veillant à bien configurer les fichiers nécessaires.
+2. Vérifiez que l'application fonctionne correctement en accédant à l'URL du vhost.
+3. Créez un fichier `docker-compose-inst.yml` qui permet de deployer 4 instances de l'application.
+
+<details>
+<summary>Cliquer pour des liens utiles</summary>
+
+- [Docker compose services options](https://docs.docker.com/reference/compose-file/services/)
+</details>
+
+
+
+## Rendu TP Docker
+- Un fichier `Dockerfile` pour l'application Java.
+- Un fichier `Dockerfile` pour l'application Java version light.
+- Un fichier `docker-compose.yml` avec le reverse proxy et un service web simple.
+- Un fichier `docker-compose-inst.yml` avec 4 instances de l'application Java.
+
+
+# Annexes
+<details>
+<summary>Annexe 1: Description de l'Application Java</summary>
+
+# How to compile this application
+
+Simple example of using OpenCV in a Web application build using jersey.
+
+This application takes a picture using web browsers camera API (available  in modern browsers) 
+and runs OpenCV face recognition algorithm (using [CascadeClassifier](http://docs.opencv.org/java/org/opencv/objdetect/CascadeClassifier.html) ) for it. If a face is detected a "troll face" is added  on top of it.
+
+![Screenshot](/screenshot.png?raw=true "Screenshot")
+
+This application was inspired by the ingenious ["Trollator" mobile Android application](https://play.google.com/store/apps/details?id=com.fredagapps.android.trollator).
+
+1. OpenCV Installation for local Maven repository
+---
+OpenCV is a native library with Java bindings so you need to install this to your system.
+ - *libopencv_java3410.so* installed in you java.library.path (
+ - *opencv-3410.jar* availble for application
+
+There are good instructions how to build OpenCV with Java bindings for your own platform here: http://docs.opencv.org/doc/tutorials/introduction/desktop_java/java_dev_intro.html
+
+Once you have built the Java library you can install the resulting jar file to your local Maven repository using
+     mvn install:install-file -Dfile=./lib/opencv-3410.jar \
+     -DgroupId=org.opencv  -DartifactId=opencv -Dversion=3.4.10 -Dpackaging=jar
+
+
+2. Building this application
+----
+Once OpenCV jar library is available as a local Maven dependency, you can clone and build this application simply using Git and Maven:
+
+```bash
+     mvn install
+```
+
+And run the application using the embedded Jetty plugin in http://localhost:8080
+
+```bash
+     mvn package
+
+     java -Djava.library.path=lib/ -jar target/fatjar-0.0.1-SNAPSHOT.jar
+	# Do not forget to update the path to your opencv install in Main.java
+	# You can change the image trollface ;)
+```
+
+</details>
+```

Readme.md

@@ -1,307 +0,0 @@
-# Projet Docker
-
-Hello très chers étudiants,
-
-Le but de ce TP est de regarder comment nous pouvons utiliser docker pour faciliter le déploiement d'une application avec la mise en place d'un serveur web en reverse proxy etc...
-
-
-<!--more-->
-
-### Etape -1: Docker
-
-Si vous utilisez une machine perso, installez docker (voir [ici](http://olivier.barais.fr/blog/posts/teaching/istic/m2/french/2018/09/10/Operation_portable_M2_ISTIC.html))
-
-
-
-### Etape 0: Test de votre installation
-
-```bash
-docker run hello-world
-```
-
-Vous devriez avoir le message suivant. 
-
-
-----
-
-Hello from Docker.
-This message shows that your installation appears to be working correctly.
-
-To generate this message, Docker took the following steps:
- 1. The Docker client contacted the Docker daemon.
- 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
- 3. The Docker daemon created a new container from that image which runs the
-    executable that produces the output you are currently reading.
- 4. The Docker daemon streamed that output to the Docker client, which sent it
-    to your terminal.
-
-To try something more ambitious, you can run an Ubuntu container with:
- $ docker run -it ubuntu bash
-
-Share images, automate workflows, and more with a free Docker Hub account:
- https://hub.docker.com
-
-For more examples and ideas, visit:
- https://docs.docker.com/userguide/
-
- 
-----
-
-
-```bash
-docker run -t -i ubuntu /bin/bash
-```
-
-Vous récupérez un shell qui est différent de votre propre distribution. 
-La commande "docker run ubuntu /bin/bash" vous permet de lancer un container à partir d'une image ubuntu.
-Les options -i et -t vous permettent respectivement de passer en mode interaction (donc plutôt que de taper des commandes sur votre shell de votre machine;
-vous allez intéragir avec le container directement), et de spécifier la manière dont vous envoyez les informations de votre machine à votre container (ici avec un "pseudo-TTY" d'après la doc).
-
-Tapez la commande 
-
-```bash
-apt-get update
-apt-get install net-tools
-/sbin/ifconfig
-```
-
-Vous constatez que l'interface réseau n'est pas la même dans le container et dans la machine hote. 
-
-Le container vient avec sa propre interface réseau. 
-
-
-
-### Etape 1 (si vous utilisez docker sur votre machine ou à l'ISTIC): Jouons avec docker: mise en place d'un load balancer et d'un reverse proxy avec docker et nginx
-
-Pour le nginx en resolproxy nous allons partir de l'image [suivante](https://github.com/jwilder/nginx-proxy)
-
-L'explication du fonctionnement est disponible [ici](http://jasonwilder.com/blog/2014/03/25/automated-nginx-reverse-proxy-for-docker/).
-
-Si vous n'avez pas la tête à lire ça, la version abrégée est que le reverse proxy vous permet tout un tas de choses, y compris de gérer le fait que les containers
-ont des adresses IP (un peu) trop dynamique ce qui fait qu'à chaque changement/lancement de container, il y aurait des problèmes de binding de port.
-Le reverse proxy va vous permettre de cacher ces aspects là, puisqu'ils seront gérés par ce composant.
-Ainsi, les chargements de versions modifiées de votre service n'auront pas besoin d'une gestion fine à la main des connexions, les différents utilisateurs qui voudront envoyer
-des requêtes simultanées au même service ne seront pas embêtés par des ports qui ne sont pas accessibles, etc.
-
-
-Lancement de nginx en resolvproxy
-
-```bash
-docker run -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy 
-```
-
-⚠️ Pour certaines installations comme sur la dernière édition de Fedora, les règles de sécurité par défaut ont évolué. Pour que le container puisse accéder, à la socket docker il faut ajouter l'option suivante: 
-
-```bash
-docker run --security-opt=label:type:docker_t  -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy 
-```
-
-
-
-Dans le suite nous allons utiliser terminator pour visualiser les effets du load-balancing (uniquement pour ceux qui sont sur leur propre portable). 
-
-```bash
-apt-get install terminator
-```
-
-Lancez Terminator en root.
-
-```bash
-sudo terminator
-```
-Terminator va simplement vous permettre de simuler le fait que vous ayez plusieurs machines qui hostent des réplicats du même service.
-Vous allez pouvoir voir l'impact d'un reverse proxy (même si on le fait localement).
-
-Si vous êtes sur votre propre portable, modifiez votre fichier /etc/hosts pour faire correspondre **m** vers localhost. Ce serait à faire sur votre gestionnaire de nom de domaine en temps normal.
-
-Vous devez avoir une ligne qui ressemble à cela. 
-
-```txt
-127.0.0.1	localhost localhost.localdomain localhost4 localhost4.localdomain m
-```
-
-
-Pour ceux qui n'ont pas les droits root, exécutez les commandes suivantes
-
-```bash
-echo 'm localhost' >> ~/.hosts
-export HOSTALIASES=~/.hosts
-curl m:8080
-```
-
-
-Puis créer plusieurs fenêtres dans votre navigateur terminator (clic droit puis split horizontal ou vertical). 
-Ce seront vos différentes machines host émulées. Vous pouvez en créer au moins 3 ou 4.
-Dans ces terminales, lancez la commande suivante pour tester votre resolve proxy.
-
-```bash
-docker run -e VIRTUAL_HOST=m -t -i  nginx
-```
-
-Testez votre resolv proxy en lançant la commande suivante dans votre terminal originel. 
-
-```bash
-curl m:8080
-```
-
-En l'exécutant plusieurs fois et suffisament rapidement, vous devriez voir tantôt une fenêtre terminator se mettre à jour,
-tantôt une autre. C'est l'effet du load balancer (un autre service qui est géré par votre nginx).
-
-
-En tapant la commande suivante, vous pouvez regarder le fichier de configuration nginx qui sera généré à l'adresse suivante /etc/nginx/conf.d/default.conf. (N'oubliez pas de remplacer  865c1e67a00e par l'id de votre nginx en resolve proxy ($docker ps) pour récupérer la liste des containers en cours d'exécution.
-
-```bash
-docker exec -it 865c1e67a00e bash
-```
-
-- [source](http://jasonwilder.com/blog/2014/03/25/automated-nginx-reverse-proxy-for-docker/)
-
-
-Tuez tous les dockers nginx démarrer. 
-
-```bash
-docker ps #pour avoir la liste
-docker kill "IDDOCKER" #pour tuer un docker. 
-```
-
-### Etape 2: Utilisation de docker compose
-Maintenant que vous avez fait tout cela à la main, on va essayer d'automatiser ce déployement.
-Utilisez docker compose pour déployer vos 4 services nginx et votre loadbalancer. 
-
-
-### Etape 3: Dockeriser une application existante
-C'était un peu trop simple avec un intérêt limité...
-Maintenant, nous souhaitons partir d'une application Web de détection de visage. 
-
-Src dans ce repository
-
-https://github.com/barais/TPDockerSampleApp (Une documentation pour compiler et lancer cette application est disponible à la fin de ce README.
-
-Construisez le fichier docker file permettant de créer l'image docker pour cette application. 
-
-
-Je vous fournis une version compilé de la librairie openCV (en 64 bit) et du jar d'openCV. 
-Pour faire tourner votre application, il faudra installer le jar d'open CV dans votre repo local maven. (voir ci-après)
-
-#### Prise en main avec l'installation en local
-Testons cette application. Tout d'abord installons les dépendances nécessaire. 
-
-```bash
-apt-get update
-apt-get install -y openjdk-8-jdk
-apt-get install -y maven
-apt-get install -f libpng16-16
-apt-get install -f libjasper1
-apt-get install -f libdc1394-22
-```
-
-Puis clonons le repo, vous pouvez faire un fork avant si vous souhaitez modifier l'application. 
-
-```bash
-git clone https://github.com/barais/TPDockerSampleApp
-cd TPDockerSampleApp
-     mvn install:install-file -Dfile=./lib/opencv-3410.jar \
-     -DgroupId=org.opencv  -DartifactId=opencv -Dversion=3.4.10 -Dpackaging=jar
-```
-
-Lancez cette application.
-
-```bash
-     # Pour compiler
-      mvn package
-     # Pour lancer l'application
-     java -Djava.library.path=lib/ -jar target/fatjar-0.0.1-SNAPSHOT.jar
-     ## Si vous avez une version récente, il se peut qu'il faille utiliser, si aucune des deux versions ne marchent, recompiler opencv ou faites la tourner dans un container avec une image de docker *ubuntu:16.04*
-     java -Djava.library.path=lib/ubuntuupperthan18/ -jar target/fatjar-0.0.1-SNAPSHOT.jar
-```
-
-
-Voici votre application. 
-
-Si vous tournez localement http://localhost:8080
-
-#### Déployement avec Docker
-**TRAVAIL A FAIRE** Construisez un fichier dockerfile qui va créer une image docker permettant de lancer cette application. 
-Vous aurez besoin d'ajoutez le répertoire *lib* et le répertoire *haarcascades* à votre image. 
-
-Nous souhaitons faire en sorte de fournir une image docker finale la plus petite possible. (Un paquet de carambar à la plus petite image fonctionnelle)
-
-
-**Version longue (non obligatoire)**
-
-Si l'on voulait vraiment être reproductible, vous auriez besoin de construire open cv depuis les src (principalement depuis la version 3.4)
-
-https://github.com/opencv/opencv
-
-Vous pourrez utiliser cette documentation pour la compilation d'opencv sur ubuntu.
-
-https://advancedweb.hu/2016/03/01/opencv_ubuntu/
-
-j'ai mis un exemple de dockerfile pour batir opencv dans le repository
-
-N'oubliez pas d'installer ant au sein de votre image docker ainsi que la jvm et maven. 
-
-Nous souhaitons faire en sorte de fournir une image docker finale la plus petite possible. (Un paquet de carambar à la plus petite image fonctionnelle ;). Besoin d'utiliser alpine pour créer opencv pour Java et builder le fatjar de ce projet puis besoin de créer un runtime avec juste le fatjar de l'appli la libopencv et ses dépendances.
-
-Fournissez donc deux fichiers docker file, un premier pour construire l'image qui permet de compiler opencv et compiler votre application. Un deuxième qui permet de construire l'image minimale pour votre application. 
-
-### Etape 4: Dockeriser une application existante
-
-Fournir un docker compose qui permet de mettre en place une application avec 4 instances de votre serveur Web. 
-
-
-
-# How to compile this application
-
-Simple example of using OpenCV in a Web application build using jersey.
-
-This application takes a picture using web browsers camera API (available  in modern browsers) 
-and runs OpenCV face recognition algorithm (using [CascadeClassifier](http://docs.opencv.org/java/org/opencv/objdetect/CascadeClassifier.html) ) for it. If a face is detected a "troll face" is added  on top of it.
-
-![Screenshot](/screenshot.png?raw=true "Screenshot")
-
-This application was inspired by the ingenious ["Trollator" mobile Android application](https://play.google.com/store/apps/details?id=com.fredagapps.android.trollator).
-
-1. OpenCV Installation for local Maven repository
----
-OpenCV is a native library with Java bindings so you need to install this to your system.
- - *libopencv_java3410.so* installed in you java.library.path (
- - *opencv-3410.jar* availble for application
-
-There are good instructions how to build OpenCV with Java bindings for your own platform here: http://docs.opencv.org/doc/tutorials/introduction/desktop_java/java_dev_intro.html
-
-Once you have built the Java library you can install the resulting jar file to your local Maven repository using
-     mvn install:install-file -Dfile=./lib/opencv-3410.jar \
-     -DgroupId=org.opencv  -DartifactId=opencv -Dversion=3.4.10 -Dpackaging=jar
-
-
-2. Building this application
-----
-Once OpenCV jar library is available as a local Maven dependency, you can clone and build this application simply using Git and Maven:
-
-```bash
-     mvn install
-```
-
-And run the application using the embedded Jetty plugin in http://localhost:8080
-
-```bash
-     mvn package
-
-     java -Djava.library.path=lib/ -jar target/fatjar-0.0.1-SNAPSHOT.jar
-	# Do not forget to update the path to your opencv install in Main.java
-	# You can change the image trollface ;)
-```
-
-# Fork this repo
-
-
-If you fork this repo, to be up to date. 
-
-```sh
-git remote add upstream https://github.com/barais/TPDockerSampleApp
-git fetch upstream
-git checkout master
-git merge upstream/master
-```
-

dockeropencv/Dockerfile

@@ -1,45 +0,0 @@
-FROM ubuntu:16.04 AS ubuntu
-
-ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
-
-RUN apt update && \
-# install required tools
-    apt install -y git unzip ant build-essential \
-                   cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev \
-                   python-dev python-numpy libtbb2 libtbb-dev libjpeg-dev libpng-dev libtiff-dev libdc1394-22-dev \
-                   python3 python3-dev python3-numpy \
-                   software-properties-common debconf-utils && \
-# install openjdk-8
-    apt install -y openjdk-8-jdk && \
-# libjasper-dev
-    curl -fs http://security.ubuntu.com/ubuntu/pool/main/j/jasper/libjasper1_1.900.1-debian1-2.4ubuntu1.2_amd64.deb -o /tmp/libjasper1.deb && \
-    curl -fs http://security.ubuntu.com/ubuntu/pool/main/j/jasper/libjasper-dev_1.900.1-debian1-2.4ubuntu1.2_amd64.deb -o /tmp/libjasper-dev.deb && \
-    apt install /tmp/libjasper1.deb /tmp/libjasper-dev.deb && \
-    rm -rf /tmp/* && \
-# download and prepare opencv
-    curl -fsL https://github.com/opencv/opencv/archive/3.4.10.zip -o /tmp/opencv.zip && \
-    cd /tmp && \
-    unzip opencv.zip && \
-    mv opencv-* opencv && \
-    cd opencv && \
-    mkdir build && \
-# build opencv
-    cd /tmp/opencv/build && \
-    cmake \
-    -D CMAKE_BUILD_TYPE=Release \
-    -D CMAKE_INSTALL_PREFIX=/usr/local \
-    -D WITH_FFMPEG=OFF \
-    -D WITH_IPP=OFF \
-    -D WITH_OPENEXR=OFF \
-    -D BUILD_EXAMPLES=OFF \
-    -D BUILD_ANDROID_EXAMPLES=OFF \
-    -D INSTALL_PYTHON_EXAMPLES=OFF \
-    -D BUILD_DOCS=OFF \
-    -D BUILD_opencv_python2=OFF \
-    -D BUILD_opencv_python3=OFF \
-    -D BUILD_SHARED_LIBS=OFF \
-    -D BUILD_TESTS=OFF \
-    -D BUILD_PERF_TESTS=OFF \
-    .. && \
-    make -j8
-#RUN cd /tmp/opencv/build && make install

step1.2/dependency-reduced-pom.xml

@@ -1,73 +1,73 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
+  <modelVersion>4.0.0</modelVersion>
-  <groupId>fr.ensai</groupId>
+  <groupId>fr.ensai</groupId>
-  <artifactId>projetESIR</artifactId>
+  <artifactId>projetESIR</artifactId>
-  <name>projetWE</name>
+  <name>projetWE</name>
-  <version>0.0.1-SNAPSHOT</version>
+  <version>0.0.1-SNAPSHOT</version>
-  <url>http://maven.apache.org</url>
+  <url>http://maven.apache.org</url>
-  <build>
+  <build>
-    <resources>
+    <resources>
-      <resource>
+      <resource>
-        <directory>src/main/</directory>
+        <directory>src/main/</directory>
-      </resource>
+      </resource>
-    </resources>
+    </resources>
-    <finalName>fatjar-${project.version}</finalName>
+    <finalName>fatjar-${project.version}</finalName>
-    <plugins>
+    <plugins>
-      <plugin>
+      <plugin>
-        <groupId>org.eclipse.jetty</groupId>
+        <groupId>org.eclipse.jetty</groupId>
-        <artifactId>jetty-maven-plugin</artifactId>
+        <artifactId>jetty-maven-plugin</artifactId>
-        <version>9.4.15.v20190215</version>
+        <version>9.4.15.v20190215</version>
-      </plugin>
+      </plugin>
-      <plugin>
+      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
+        <artifactId>maven-shade-plugin</artifactId>
-        <version>3.2.1</version>
+        <version>3.2.1</version>
-        <executions>
+        <executions>
-          <execution>
+          <execution>
-            <phase>package</phase>
+            <phase>package</phase>
-            <goals>
+            <goals>
-              <goal>shade</goal>
+              <goal>shade</goal>
-            </goals>
+            </goals>
-            <configuration>
+            <configuration>
-              <transformers>
+              <transformers>
-                <transformer />
+                <transformer />
-                <transformer>
+                <transformer>
-                  <manifestEntries>
+                  <manifestEntries>
-                    <Main-Class>main.Main</Main-Class>
+                    <Main-Class>main.Main</Main-Class>
-                  </manifestEntries>
+                  </manifestEntries>
-                </transformer>
+                </transformer>
-              </transformers>
+              </transformers>
-            </configuration>
+            </configuration>
-          </execution>
+          </execution>
-        </executions>
+        </executions>
-        <configuration>
+        <configuration>
-          <createDependencyReducedPom>true</createDependencyReducedPom>
+          <createDependencyReducedPom>true</createDependencyReducedPom>
-          <filters>
+          <filters>
-            <filter>
+            <filter>
-              <artifact>*:*</artifact>
+              <artifact>*:*</artifact>
-              <excludes>
+              <excludes>
-                <exclude>META-INF/*.SF</exclude>
+                <exclude>META-INF/*.SF</exclude>
-                <exclude>META-INF/*.DSA</exclude>
+                <exclude>META-INF/*.DSA</exclude>
-                <exclude>META-INF/*.RSA</exclude>
+                <exclude>META-INF/*.RSA</exclude>
-              </excludes>
+              </excludes>
-            </filter>
+            </filter>
-          </filters>
+          </filters>
-        </configuration>
+        </configuration>
-      </plugin>
+      </plugin>
-    </plugins>
+    </plugins>
-  </build>
+  </build>
-  <dependencies>
+  <dependencies>
-    <dependency>
+    <dependency>
-      <groupId>junit</groupId>
+      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
+      <artifactId>junit</artifactId>
-      <version>3.8.1</version>
+      <version>3.8.1</version>
-      <scope>test</scope>
+      <scope>test</scope>
-    </dependency>
+    </dependency>
-  </dependencies>
+  </dependencies>
-  <properties>
+  <properties>
-    <maven.compiler.target>1.6</maven.compiler.target>
+    <maven.compiler.target>1.6</maven.compiler.target>
-    <maven.compiler.source>1.6</maven.compiler.source>
+    <maven.compiler.source>1.6</maven.compiler.source>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <version.jetty>9.4.28.v20200408</version.jetty>
+    <version.jetty>9.4.28.v20200408</version.jetty>
-  </properties>
+  </properties>
-</project>
+</project>

step1.2/src/main/webapp/swagger/index.html

@@ -4,9 +4,9 @@
   <head>
     <meta charset="UTF-8">
     <title>Swagger UI</title>
-    <link rel="stylesheet" type="text/css" href="./swagger-ui.css" >
+    <link rel="stylesheet" type="text/css" href="swagger-ui.css" >
-    <link rel="icon" type="image/png" href="./favicon-32x32.png" sizes="32x32" />
+    <link rel="icon" type="image/png" href="favicon-32x32.png" sizes="32x32" />
-    <link rel="icon" type="image/png" href="./favicon-16x16.png" sizes="16x16" />
+    <link rel="icon" type="image/png" href="favicon-16x16.png" sizes="16x16" />
     <style>
       html
       {
@@ -33,8 +33,8 @@
   <body>
     <div id="swagger-ui"></div>
 
-    <script src="./swagger-ui-bundle.js"> </script>
+    <script src="swagger-ui-bundle.js"> </script>
-    <script src="./swagger-ui-standalone-preset.js"> </script>
+    <script src="swagger-ui-standalone-preset.js"> </script>
     <script>
     window.onload = function() {
       // Begin Swagger UI call region