Architectures Microservices : mise en oeuvre avec Java et Docker

SOA – Microservices
Mickaël BARON – 2016 (Rév. Mai 2022)
mailto:[email protected] ou mailto:[email protected]
@mickaelbaron mickael-baron.fr
Mise en œuvre avec Docker

View Slide

Microservices - Docker - M. Baron - Page
mickael-baron.fr @mickaelbaron
Licence
2
Creative Commons
Contrat Paternité
Partage des Conditions Initiales à l'Identique
2.0 France
creativecommons.org/licenses/by-sa/2.0/fr

View Slide

A propos de l’auteur …
3
Mickaël BARON
Ingénieur de Recherche au LIAS
https://www.lias-lab.fr
Equipe : Ingénierie des Données et des Modèles
Responsable des plateformes logicielles, « coach » technique
Ancien responsable Java de Developpez.com (2011-2021)
Communauté Francophone dédiée au développement informatique
https://java.developpez.com
4 millions de visiteurs uniques et 12 millions de pages vues par mois
750 00 membres, 2000 forums et jusqu'à 5000 messages par jour
@mickaelbaron
mickael-baron.fr

View Slide

Plan du cours
4
Architecture microservices « fil rouge »
Coder avec KumuluzEE
Isoler avec Docker
Composer avec Docker Compose
Répartir la charge avec Nginx
Communiquer avec Push ou Publish-Subscribe
(voir cours précédents : REST + Streaming HTTP)

View Slide

Déroulement du cours : Introduction générale
5
Pédagogie du cours
Des bulles d’aide tout au long du cours
Utilité des microservices
Exemple file rouge tout le long du cours
Pré-requis
Cours sur JAX-RS
Introduction générale sur les Microservices
Bases en shell Linux
Bases en réseaux
Ceci est une alerte
Ceci est une astuce

View Slide

Ressources : Liens sur le Web
6
Billets issus de Blog
tuhrig.de/layering-of-docker-images
labs.ctl.io/optimizing-docker-images
Github
github.com/jpetazzo/orchestration-workshop
github.com/wsargent/docker-cheat-sheet
github.com/chanezon/docker-tips
github.com/javaee-samples/docker-java/tree/master/slides
Articles
www.programering.com/a/MDMzAjMwATk.html
Présentations
xebia.github.io/docker-introduction/slides
Images (crédits)
Site Docker (https://www.docker.com/)
Blog de Laurelt, dessinatrice pour Docker (http://bloglaurel.com/)

View Slide

Ressources : Bibliothèque
7
Docker: Up & Running
Auteur : Karl Matthias, Sean P. Kane
Éditeur : O’Reilly
Edition : June. 2015 - 224 pages - ISBN : 9781491917572
RabbitMQ in Action
Auteur : Alvaro Videla, Jason J. W. Williams
Éditeur : Manning Publications
Edition : May 2012 - 312 pages - ISBN : 9781935182979
Docker Cookbook
Auteur : Sébastien Goasguen
Éditeur : O’Reilly
Edition : Dec. 2015 - 366 pages - ISBN : 9781491919712

View Slide

Architecture microservices « fil rouge » : HelloWorld
8
Vous saisissez
un message …
… il apparaît
dans la liste

View Slide

Architecture microservices « fil rouge » : HelloWorld
9
Service web REST
helloworldrestmicroservice
Interface web
helloworldwebmicroservice
Logs
helloworldlogmicroservice
Email
helloworldemailmicroservice
Twitter
helloworldtwittermicroservice
Base de données
Redis
Bus d’événements
RabbitMQ
Synchrone
Asynchrone
POST/GET
lpush
hmset
lrange
hgetAll
HTML/JS
Body= « ... »
Ce microservice est un
publieur (publisher)
Ces microservices sont des
souscripteurs (subscriber)
Sept microservices, des petits noms
pour les identifier par la suite
• Web
• Rest
• Redis
• RabbitMQ
• Log
• Email
• Twitter
Channel = helloworld
Body= « ... »
Body= « ... »
Body= « ... »
Isoler conteur

View Slide

Mise en œuvre – Coder avec KumuluzEE

View Slide

Java et les microservices : KumuluzEE
11
Site web : https://ee.kumuluz.com
Version actuelle : 3.9.0
Très jeune projet, a gagné le Duke’s Choice Award 2015
KumuluzEE s’appuie sur la spécification MicroProfile 3.3
basée sur des briques logicielles de Jakarta EE (JAX-RS, CDI…)
Pas de nouvel apprentissage de technologie majeure, tout ce
que nous avons vu s’applique (JAX-RS)
Seule la manière de déployer change

View Slide

KumuluzEE : mode d’emploi
12
1) Créer un projet Maven simple
2) Ajouter les dépendances KumuluzEE à votre pom.xml
3) Développer votre application Jakarta EE

com.kumuluz.ee
kumuluzee-core
${kumuluzee.version}

com.kumuluz.ee
kumuluzee-servlet-jetty

com.kumuluz.ee
kumuluzee-jax-rs

Dépendances minimales pour
faire du service REST
Possibilité de choisir le serveur
web souhaité (à venir)
@Path("/helloworld")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class HelloWorldResource {
...
@GET
public Response getHelloWorlds() {
return Response.ok(currentDAO.getHelloWorlds()).build();
}
@POST
public Response addHelloWorld(HelloWorld newHelloWorld) {
if (newHelloWorld != null) {
newHelloWorld.setStartDate(new Date().toString());
}
currentDAO.addHelloWorld(newHelloWorld);
return Response.status(Status.CREATED).build();
}
}
Rien de nouveau.
C’est du JAX-RS comme vu dans
les précédents cours

View Slide

KumuluzEE : mode d’emploi
13
4) Ajouter le plugin maven-dependency-plugin au pom.xml
5) Ajouter le fichier beans.xml et créer un répertoire webapp
6) Compiler : $ mvn package
7) Exécuter : $ java -cp target/classes:target/dependency/*
com.kumuluz.ee.EeApplication
8) Tester : localhost:8080/helloworld

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/beans_1_2.xsd"
bean-discovery-mode="all">

Fichier beans.xml à
copier dans META-INF

org.apache.maven.plugins
maven-dependency-plugin
2.10

copy-dependencies
package
copy-dependencies

Permettra de placer toutes les
dépendances dans le répertoire
target du projet

View Slide

Logs
Email
Twitter
helloworldtwittermicroservic
e
« Fil rouge » : HelloWorld
14
Interface web
Base de données
Redis
RabbitMQ
Synchrone
Asynchrone
POST/GET
lpush
hmset
lrange
hgetAll
HTML/JS
Body= « ... »
• Web
• Rest
• Redis
• RabbitMQ
• Log
• Email
• Twitter
Body= « ... »
Body= « ... »
Body= « ... »
Isoler conteur
Service web REST

View Slide

Mise en œuvre – Isoler avec Docker

View Slide

Docker : généralités
16
Docker Inc. est une jeune entreprise mars 2013
Sites web de référence
https://www.docker.com
Documentation : https://docs.docker.com/
Installation : https://docs.docker.com/engine/installation/
Propose une suite d’outils du même nom que la société
Basés principalement sur
LinuX Containers (LXC) : https://en.wikipedia.org/wiki/LXC
Union Mounting : https://en.wikipedia.org/wiki/Union_mount
Outils sont principalement en ligne de commande
Fonctionne sous Linux nativement et sous Windows/macOS
via une VM (DockerDesktop)

View Slide

Docker : un // avec Java
17

View Slide

Docker : images
18
Dans un système Linux classique, deux systèmes de fichiers
bootfs : contient le « boot loader » et le noyau (kernel)
rootfs : contient la structure des répertoires (/usr, /lib, /bin…)
Dans un système Linux
classique le rootfs est
en lecture / écriture
Sous Docker le rootfs est en lecture
unique (utilisation d’UnionMount
dont l’implémentation est aufs)
Identique à la plupart
des distributions Linux
Spécifique à chaque
distribution

View Slide

Docker : images
19
Plusieurs rootfs ?
Sous un système Linux classique un seul rootfs
Sous Docker possibilité de plusieurs rootfs
Le rootfs constitue l’image de base d’un conteneur Docker
Image de base
Sans image pas de conteneur
… patience le concept de
conteneur est expliqué
Une image ne peut
être modifiée
puisqu’elle est en
lecture seule

View Slide

Docker : images
20
Une image est décomposée d’un ensemble de couches
appelée layer qui composent l’image finale
Chaque couche est liée à la couche inférieure dite parent
Exemple
Image finale = Apache + Emacs + Debian
Image de base = Debian
Emacs est une couche de l’image finale
Emacs est la couche parente de celle d’Apache
Facilite la réutilisation des images
Où trouver des images ?
https://hub.docker.com

View Slide

Docker : conteneur
21
Un conteneur est une couche modifiable qui est liée à la
couche inférieure
Comparaison avec le monde « Java »
bootfs = JVM
image de base = classe Object
image = classe
relation parent = héritage
conteneur = instance d’une classe
Seul le conteneur est en lecture et écriture

View Slide

Docker : conteneur interactif (démo 1)
22
# Télécharge l'image 'busybox' depuis DockerHub
$ docker pull busybox
Using default tag: latest
latest: Pulling from library/busybox
c00ef186408b: Pull complete
ac6a7980c6c2: Pull complete
Digest: sha256:e4f93f6ed15a0cdd342f5aae387886fba0ab98af0a102da6276eaf24d6e6ade0
Status: Downloaded newer image for busybox:latest
# Création d'un conteneur
$ docker run -it busybox /bin/sh # -i = interactif –t dans la console en cours
/ #
# Liste le contenu du 'rootfs' du conteneur
$ ls
bin dev etc home proc root sys tmp usr var
# Liste les processus du conteneur
/ # ps -ef
# Fermeture du conteneur (le conteneur se termine)
/ # exit
# Affichage des conteneurs (en cours, arrêtés, stoppés...)
$ docker ps –a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d2bc3ccd2ee1 busybox "/bin/sh" 26 minutes ago Exited (0) 23 minutes ago goofy_bhabha
Commandes : run, ps

View Slide

Docker : conteneur détaché (démo 2)
23
# Démarre un processus très long
$ JOB=$(docker run -d busybox /bin/sh -c 'while true; do echo Hello Poitiers $(date); sleep 1; done')
# Affichage des informations
$ docker logs $JOB
...
Hello Poitiers Thu Jan 7 15:09:01 UTC 2016
# Vérification de l'état d'exécution
$ docker ps
01d4dacd55e2 busybox "/bin/sh -c 'while" 1 minutes ago Up 25 seconds reverent_franklin
# Attacher un conteneur
$ docker attach $JOB
...
Hello Poitiers Thu Jan 7 15:17:23 UTC 2016 # Pour terminer un CTRL-C
# Vérification de l'état d'exécution
$ docker ps -a
01d4dacd55e2 busybox "/bin/sh -c 'while" 9 minutes ago Exited (0) 44 s reverent_franklin
# Suppression d'un conteneur
$ docker rm $JOB # Un conteneur doit être arrêté pour le supprimer ou forcer par l’option -f
Commandes : run, logs, ps, attach

View Slide

Docker : conteneur sans état (démo 3)
24
# Création de fichiers dans le répertoire /tmp
$ JOB=$(docker run -d busybox
/bin/sh -c 'while true ; do /bin/touch /tmp/$(date +%H%M%S); sleep 60; done')
# Liste le contenu du répertoire /tmp
$ docker exec $JOB /bin/ls /tmp
074426
074526
# Changement sur le système de fichier – C = Changement, A = Ajout, D = Delete
$ docker diff $JOB
C /tmp
A /tmp/094126
A /tmp/094226
# Suppression du conteneur
$ docker rm -f $JOB
01dbf7a101abc13a80a95fae41c78a3997de90fa9636c26a4c6498738c631c26
# Si nouveau conteneur les anciens fichiers ne sont plus là
$ docker run -it busybox /bin/ls /tmp
# N'avez-vous jamais voulu faire cela ? ‘rm –rf /usr’
$ docker run -it busybox /bin/sh -c '/bin/rm -rf /usr;/bin/ls /'
Commandes : run, exec, diff, rm

View Slide

Docker : plusieurs familles de commandes
25
Des familles de commandes pour gérer des
conteneurs (container)
images (image)
réseaux (network)
dossiers et fichiers partagés (volume)
système (system)
d’autres qui concernent Docker Swarm
Pour appeler une commande d’une famille de commande
Exemple
Utilisation de la version simplifiée
$ docker COMMAND_FAMILLY COMMAND …
$ docker container run -it busybox /bin/sh
$ docker run -it busybox /bin/sh

View Slide

Docker et conteneur : commandes pour l’exécution
26
attach : s’attacher à un conteneur
create : crée un conteneur sans le démarrer
exec : exécute une commande dans un conteneur
kill : tue un conteneur via un SIGKILL
ps : affiche tous les conteneurs
rm : supprime un conteneur
run : exécute une commande dans un nouveau conteneur
start, stop : démarre ou arrête un conteneur
wait : bloque jusqu’à l’arrêt du conteneur et affiche le temps
pause, unpause : met en pause tous les processus
rename : change le nom d’un conteneur

View Slide

Docker et conteneur : commandes pour les informations
27
events : donne des informations temps-réel des conteneurs
info : informations sur le daemon Docker
inspect : méta-données sur un conteneur
logs : affiche les logs (sortie console) d’un conteneur
port : liste les ports redirigés d’un conteneur
stats : statistique temps-réel des conteneurs
top : affiche comme top sur un conteneur
version : affiche la version du daemon Docker

View Slide

Docker et conteneur : commandes pour les fichiers
28
cp : copie un fichier/répertoire vers un conteneur
diff : changements sur le système de fichier d’un conteneur
export : exporte le contenu d’un conteneur (pas une image)
import : importe le contenu d’une archive tar

View Slide

Docker : créer une image
29
À chaque création d’un conteneur, le système de fichiers
correspond à celui de l’image « parente »
Lors de l’arrêt du conteneur les modifications apportées sont
perdues
Questions ? J’aimerais pouvoir conserver ce qui suit
Installations de programmes
Organisation de répertoires
Configuration (réseaux, programmes…)
Solutions => créer une nouvelle image
Pour créer une nouvelle image
Manuellement via la commande commit
Via l’utilisation d’un fichier Dockerfile

View Slide

Docker : créer une image « manuellement » (démo 4)
30
# Création de fichiers dans le répertoire /tmp
$ docker run --name demo4 -d busybox
/bin/sh -c 'while true ; do /bin/touch /tmp/$(date +%H%M%S); sleep 60; done’
# Changement sur le système de fichier – C = Changement, A = Ajout, D = Delete
$ docker diff demo4
A /tmp/094840
A /tmp/094940
# Création d’une image appelée mickaelbaron/demo4
$ docker commit demo4 mickaelbaron/demo4
C40410395aedf8cfb8f55469a974a519ee764dd3a765e3c78df8df60316870ad # => Id de l’image
# Suppression du conteneur actuel
$ docker rm -f demo4
demo4
# Affiche la liste des images en cache
docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
mickaelbaron/demo4 latest c40410395aed About a minute ago 1.113 MB
busybox latest ac6a7980c6c2 5 weeks ago 1.113 MB
# Création d’un conteneur à partir de la nouvelle image (re-exécute la précédente commande while…)
$ docker run --name demo4 -d mickaelbaron/demo4
# Affichage du contenu
$ docker exec demo4 /bin/ls /tmp
094840 # Anciens fichiers
094940
095317 # Nouveau fichier
Commandes : run, exec, diff, commit, images

View Slide

Docker : créer une image depuis Dockerfile
31
Un fichier Dockerfile pour créer automatiquement des images
Provisionner (installer des applications, copier des fichiers…)
Configuration (ouverture de port, commande en tâche de fond...)
Command build pour construire une image
Dockerfile composé d’instructions (détaillées dans la suite)
Format du fichier
# pour les commentaires
INSTRUCTION arguments
Chaque instruction est exécutée indépendament et
suivie par un commit => image à chaque instruction
$ docker build –t imagename .
-t pour donner un
nom à l’image

View Slide

Docker : Dockerfile FROM et MAINTENER
32
L’instruction FROM permet d’indiquer l’image de base à partir
de laquelle l’image à construire s’appuiera (l’image parente)
Doit être la première instruction du fichier Dockerfile
Peut apparaître plusieurs fois pour des images multiples
Exemple

L’instruction LABEL maintener permet d’indiquer l’auteur
Exemple
LABEL maintener="Mickael BARON"
FROM java:8
Permet de spécifier
:
Dans ce cas il s’agit
de la version de Java

View Slide

Docker : Dockerfile RUN
33
L’instruction RUN permet d’exécuter des commandes Linux
dans une nouvelle couche pour être commitée dans l’image
L’instruction RUN peut être utilisée plusieurs fois
Des exemples avec deux formes possibles (détails après)
: lancer le goal package de Maven (exec)

Bonnes pratiques (https://docs.docker.com/develop/develop-images/dockerfile_best-practices
)
Minimiser le nombre de couches
Regrouper toutes les installations de package si possible
RUN ["mvn","package"]
RUN apt-get update &&
apt-get install –y maven git : Mise à jour et
installations (form)

View Slide

Docker : Dockerfile deux formes pour les instructions
34
Deux formes pour écrire des instructions dans un Dockerfile
Pas forcément limitées à l’instruction RUN (voir plus tard)
Forme Shell RUN
RUN
• La commande est exécutée dans
un shell (/bin/sh -c)
• À utiliser quand il y a plusieurs
commandes à appeler à la suite
dans une même couche
Forme Exec
RUN ["command","param1","param2]
• La commande est directement
appelée
• À utiliser quand il n’y a pas
forcément accès à un shell
VS

View Slide

Docker : Dockerfile ADD
35
L’instruction ADD permet de copier des ressources d’une
source vers le système de fichiers du conteneur
Les ressources peuvent être des fichiers, des répertoires ou
des fichiers distants
Si la ressource est un fichier archive dont le format est connu
il sera automatiquement décompressé
Exemple (ajoute un répertoire du hôte vers /work du conteneur)

L’instruction COPY fait la même chose mais ne gère pas les
archives et les fichiers distants
ADD pom.xml /work/pom.xml

View Slide

Docker : Dockerfile CMD
36
L’instruction CMD permet de fournir la commande par défaut
lors de l’exécution d’un conteneur
Elle ne peut être exécutée qu’une seule fois
Exemple

À l’exécution du conteneur
Possibilité de surcharger la commande lors de l’exécution
CMD ["java","-jar", "/target/myprogram.jar"]
Pour l’instruction
CMD privilégier la
forme d’écriture de
type exec
# Création d’un conteneur
$ docker run –d myimage
# Vérifie la commande exécutée
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED ...
50238de77614 myimage “java –jar /target/myprogram.jar“ 54 minutes ago ...
$ docker run –d myimage java –jar /target/myprogram.jar param1 param2
$ docker ps
50238de77614 myimage “java –jar /target/myprogram.jar param1 param2“ 54 minutes ago ...

View Slide

Docker : Dockerfile ENTRYPOINT
37
L’instruction ENTRYPOINT fait comme CMD sauf qu’elle ne
peut être surchargée lors de l’exécution du conteneur
Elle ne peut être exécutée qu’une seule fois
Exemple

Impossibilité de surcharger la commande lors de l’exécution
ENTRYPOINT ["java","-jar", "/target/myprogram.jar"]
$ docker ps
$ docker run –d myimage java –jar /target/myprogram.jar param1 param2
$ docker ps

View Slide

Docker : Dockerfile CMD et ENTRYPOINT
38
Possibilité de combiner l’instruction ENTRYPOINT et CMD
L’intérêt est pouvoir fixer un début de commande via
ENTRYPOINT et compléter la commande via CMD (défaut)
Exemple

Possibilité de surcharger le contenu de CMD
ENTRYPOINT ["java","-jar", "/target/myprogram.jar"]
CMD ["param1","param2"]
$ docker ps
50238de77614 myimage “java –jar /target/myprogram.jar param1 param2“ 54 minutes ago ...
$ docker run –d myimage param3
$ docker ps
50238de77614 myimage “java –jar /target/myprogram.jar param3“ 54 minutes ago ...

View Slide

Docker : Dockerfile EXPOSE
39
L’instruction EXPOSE permet de définir quels sont les ports
réseaux du conteneur à exposer
Ne peut être utilisé qu’une seule fois mais en précisant
plusieurs ports à exposer
Pratique si vous avez un serveur web Tomcat en 8080 et que
vous souhaitez n’exposer que Tomcat
Exemple
EXPOSE 8080

View Slide

Docker : Dockerfile (démo 5)
40
FROM maven:3.3.3-jdk-8
LABEL maintener="Mickael BARON"
WORKDIR /work
RUN ["mvn", "dependency:go-offline"]
ADD ["src", "/work/src"]
RUN ["mvn", "package"]
EXPOSE 8080
ENTRYPOINT ["java", "-cp", "target/classes:target/dependency/*",
"com.kumuluz.ee.EeApplication"]
Préparation à la construction de l’image du microservice Rest
Fichier Dockerfile du projet
Si le pom.xml ne change pas le
chargement des dépendances
ne se fera pas à chaque
modification du code source

View Slide

Docker : Dockerfile (démo 5) - suite
41
Construction de l’image et création du conteneur de rest
# Création d’une image à partir du précédent Dockerfile
$ docker build -t mickaelbaron/helloworldrestmicroservice .
Sending build context to Docker daemon 12.95 MB
Step 1 : FROM maven:3.3.3-jdk-8
3.3.3-jdk-8: Pulling from library/maven
523ef1d23f22: Pull complete
...
Digest: sha256:62995ea43d8554c7b581c2576fb53d8097039dae19fc68a11f485406a13380df
Status: Downloaded newer image for maven:3.3.3-jdk-8
---> 319dadddb414
Step 2 : MAINTAINER Mickael BARON
---> Running in 840480e4ec74
---> f298b9092c72
Removing intermediate container 840480e4ec74
Step 3 : ADD pom.xml /work/pom.xml
---> f9a9360b890c
Removing intermediate container 1ee48de07452
Step 4 : WORKDIR /work
---> Running in ee125209a9b9
---> 7cfef739d3f7
Removing intermediate container ee125209a9b9
...
Step 9 : ENTRYPOINT java -cp target/classes:target/dependency/* com.kumuluz.ee.EeApplication
---> Running in 098f76f8eac9
---> ac952da4967c
Removing intermediate container 098f76f8eac9
Successfully built ac952da4967c
À chaque étape du Dockerfile une
couche intermédiaire sera créée

View Slide

Docker : Dockerfile et Multi-Stage Build
42
Constat sur le Dockerfile précédent
Les phases de compilation et d’exécution sont dans la même image
Des outils de compilation ne sont pas utiles à l’exécution (Maven)
Des données ne sont pas utiles à l’exécution (dépendances Maven)
L’image fournie est relativement volumineuse ~ 706 Mo
Solution envisagée : utiliser le Multi-Stage Build
Une phase de compilation
Une phase d’exécution qui copie des données de l’étape précédente
Phase Compilation
Phase Exécution
$ mvn clean package
$ java –cp ...

View Slide

Docker : Dockerfile et Multi-Stage Build (démo 6)
43
Préparation à la construction de l’image du microservice Rest
via le Multi-Stage Build
# Build env
FROM maven:3-jdk-8 AS build-java-stage
LABEL maintainer="Mickael BARON"
WORKDIR /work
RUN ["mvn", "dependency:go-offline"]
ADD ["src", "/work/src"]
RUN ["mvn", "package"]
# Run env
FROM openjdk:8-jre-slim
COPY --from=build-java-stage /work/target/classes /classes/
COPY --from=build-java-stage /work/target/dependency/*.jar /dependency/
EXPOSE 8080
ENTRYPOINT ["java", "-cp", "classes:dependency/*", "com.kumuluz.ee.EeApplication"]
Fichier DockerfileMSB du projet
Les fichiers de la précédente
phase build-java-stage sont
identifiés lors de la copie

View Slide

Docker : Dockerfile et Multi-Stage Build (démo 6) - suite
44
Construction de l’image et création du conteneur de rest via
le Multi-Stage Build
# Création d’une image à partir du précédent DockerfileMSB
$ docker build -f DockerfileMSB -t mickaelbaron/helloworldrestmicroservice .
Sending build context to Docker daemon 110.6kB
Step 1/12 : FROM maven:3-jdk-8 AS build-java-stage
...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 7.207 s
[INFO] Finished at: 2020-05-04T17:20:30Z
[INFO] ------------------------------------------------------------------------
Removing intermediate container 8907e60eb09f
---> 77d18dc14f6b
Step 8/12 : FROM openjdk:8-jre-slim
...
Step 12/12 : ENTRYPOINT ["java", "-cp", "classes:dependency/*", "com.kumuluz.ee.EeApplication"]
---> Using cache
---> 4f6445d0688f
Successfully built 4f6445d0688f
Successfully tagged mickaelbaron/helloworldrestmicroservice
$ docker images
REPOSITORY TAG IMAGE ID CREATED
SIZE
mickaelbaron/restmicroservice msb 4f6445d0688f 17 minutes ago 184MB
mickaelbaron/restmicroservice latest 938e12997834 About an hour ago 706MB
L’image en utilisant le Multi-Stage Build
est réduite de 706 Mo à 184 Mo

View Slide

Docker et images : commandes pour la gestion
45
build : construit une image à partir d’un Dockerfile
commit : construit une image à partir du conteneur
history : montre l’historique de l’image
images : liste les images disponibles
load : charge une image depuis une archive tar
rmi : supprime une image depuis la liste
save : sauvegarder une image vers une archive tar

View Slide

Logs
Email
Twitter
e
46
Interface web
Base de données
Redis
RabbitMQ
Synchrone
Asynchrone
POST/GET
lpush
hmset
lrange
hgetAll
HTML/JS
Body= « ... »
• Web
• Rest
• Redis
• RabbitMQ
• Log
• Email
• Twitter
Body= « ... »
Body= « ... »
Body= « ... »
Service web REST
Isoler conteur

View Slide

Docker : persister les données avec les volumes
47
Pour rappel un conteneur est volatile toutes les données
produites sont perdues lors de la destruction du conteneur
Logs
Données d’une base de données
Fichiers intermédiaires…
Comment s’assurer que si je recrée mon conteneur Redis je
retrouverai mes données ? => utilisation des Volumes
Il s’agit d’un dossier qui se trouve à la fois sur le hôte et
sur le conteneur (un peu comme un dossier partagé)
Les données restent sur le hôte même si le conteneur a été
supprimé

View Slide

Docker : persister les données avec les volumes
48
Pour créer un volume, utilisation du paramètre -v lors de la
création d’un conteneur
Syntaxe

Créer un volume pour le conteneur redis
# Récupération de l’image de Redis
$ docker pull redis
# Création du conteneur à partir de l’image Redis
# -v /var/redis:/data : associe /var/redis du hôte au répertoire /data du conteneur
$ docker run --name redis -v /var/redis:/data -d redis redis-server --appendonly yes
# Vérification que le conteneur a été créé
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS
0b2d2671f0d6 redis "/entrypoint.sh redis" 2 minutes ago Up 2 minutes
# Vérification que le volume est opérationnel
$ ls /var/redis -l
total 0
-rw-r--r-- 1 999 docker 0 Jan 20 21:14 appendonly.aof # Fichier créé par redis du conteneur.
-v hostdirectory:/containerdirectory

View Slide

Logs
Email
Twitter
e
49
Interface web
RabbitMQ
Synchrone
Asynchrone
POST/GET
lpush
hmset
lrange
hgetAll
HTML/JS
Body= « ... »
• Web
• Rest
• Redis
• RabbitMQ
• Log
• Email
• Twitter
Body= « ... »
Body= « ... »
Body= « ... »
Service web REST
Isoler conteur
Base de données
Redis

View Slide

Docker : lier des conteneurs
50
Pourquoi lier des conteneurs ?
Faire communiquer des conteneurs sans forcément les rendre
accessibles à « tout le monde »
Exemple : le conteneur rest doit pouvoir voir le conteneur redis
Solution : utiliser des réseaux Docker via la famille network
Comment cela fonctionne ?
Créer un ou plusieurs réseaux (create)
Connecter un conteneur à un réseau (connect)
Docker associe au conteneur une IP pour chaque réseau
Docker associe au conteneur des alias correspondant à ces « noms »
Pour la composition de conteneurs il est d’usage d’utiliser
Docker Compose (voir partie suivante)
$ docker network COMMAND …
Un conteneur peut
être connecté à
plusieurs réseaux

View Slide

Docker : lier des conteneurs (démo 7)
51
Utilisation des réseaux pour relier les conteneurs redis et rest
# Création du réseau helloworldnetwork
$ docker network create helloworldnetwork
# Création du conteneur redis
$ docker run --name redis -v /var/redis:/data -d redis redis-server --appendonly yes
# Connecter le conteneur redis au réseau helloworldnetwork
$ docker network connect helloworldnetwork redis
# Création du conteneur rest et connexion au réseau helloworldnetwork (--network)
$ docker run --name rest –d --network helloworldnetwork --env REDIS_HOST=tcp://redis:6379 \
mickaelbaron/helloworldrestmicroservice
# Vérification que les conteneurs sont démarrés
$ docker ps
8ea3292c609a hellorest... "java -cp target/clas" 3 seconds ago Up 2 seconds 8080/tcp rest
0b2d2671f0d6 redis "/entrypoint.sh redis" 21 hours ago Up 3 hours 6379/tcp redis
# Vérifier que les conteneurs rest et redis sont présents dans le réseau helloworldnetwork
$ docker network inspect helloworldnetwork
...
"Containers": {
"5c5989fcd60b94604dc4994134bcfd4...": { "Name": "redis", "IPv4Address": "172.21.0.2/16", ... },
"dfa6b7baf018f42e6d494a259a815fc...": { "Name": "rest", "IPv4Address": "172.21.0.3/16", ... }
}
# Depuis rest le dialogue vers redis se fait via redis, pour preuve ...
$ docker exec -it rest /bin/sh -c 'ping redis'
PING redis (172.21.0.3): 56 data bytes
64 bytes from 172.21.0.3: icmp_seq=0 ttl=64 time=0.005 ms
...

View Slide

Docker : lier des conteneurs (réseau bridge)
52
Il existe un réseau par défaut appelé bridge
Si aucun réseau n’est spécifié à la construction d’un conteneur
(--network) le conteneur se connectera sur le réseau par
défaut bridge
Les conteneurs connectés sur le réseau par défaut bridge se
voient tous mais sont UNIQUEMENT accessibles en utilisant
les IPs (pas les noms)
Le réseau par défaut bridge n’est pas RECOMMANDÉ pour la
mise en production

View Slide

53
Docker : lier des conteneurs (réseau bridge) – (démo 8)
Comprendre le réseau par défaut bridge
# Création du réseau testnetwork
$ docker network create testnetwork
# Création de trois conteneurs
$ docker run -dit --name alpine1 --network testnetwork alpine # Alpine1 dans testnetwork et bridge
$ docker network connect testnetwork alpine1
$ docker run -dit --name alpine2 --network testnetwork alpine # Alpine2 dans testnetwork
$ docker run -dit --name alpine3 alpine # Alpine3 dans bridge
# Récupérer les IPs des conteneurs
$ docker network inspect testnetwork (172.22.X.Y)
// alpine1 => 172.22.0.2 ; alpine2 => 172.22.0.3
$ docker network inspect bridge (172.17.X.Y)
// alpine1 => 172.17.0.5 ; alpine3 => 172.17.0.6
# S’attacher au conteneur alpine1
$ docker attach alpine1
# Tester la connexion à partir de alpine1
$ ping 172.22.0.3 ou ping alpine2 => OK
$ ping 172.17.0.6 => OK ping alpine3 => NON OK (car pas testnetwork)
$ ping 172.22.0.2 ou ping alpine1 => OK
$ ping 172.17.0.5 ou ping 172.17.0.6 ou ping alpine3 => NON OK (car pas bridge)
$ ping 172.22.0.2 ou ping 172.22.0.3 ou ping alpine1 ou ping alpine2 => NON OK (car pas testnetwork)
$ ping 172.17.0.5 ou ping 172.17.0.6 => OK

View Slide

Logs
Email
Twitter
e
54
Interface web
RabbitMQ
Asynchrone
POST/GET
HTML/JS
Body= « ... »
• Web
• Rest
• Redis
• RabbitMQ
• Log
• Email
• Twitter
Body= « ... »
Body= « ... »
Body= « ... »
Service web REST
Isoler conteur
Base de données
Redis
lpush
hmset
lrange
hgetAll
Synchrone

View Slide

Docker : rediriger les ports
55
Actuellement nous avons deux conteneurs qui s’exécutent
Pour communiquer avec le conteneur rest adresser une
requête via son IP:8080
La redirection de port permet d’accéder au conteneur en
utilisant l’accès réseau du système hôte
Syntaxe
: mappe portHôte avec portConteneur
: mappe tous les ports du conteneur avec l’hôte
# Vérification que les conteneurs sont démarrés
$ docker ps
8ea3292c609a hellorest... "java -cp target/clas" 3 seconds ago Up 2 seconds 8080/tcp rest
0b2d2671f0d6 redis "/entrypoint.sh redis" 21 hours ago Up 3 hours 6379/tcp redis
-p portHôte:portConteneur
-P

View Slide

Docker : rediriger les ports (démo 9)
56
# Sans redirection de port
mickaelbaron/helloworldrestmicroservice
# Recherche l’IP du conteneur
$ $IP_REST = $(docker inspect -f '{{ .NetworkSettings.Networks.helloworldnetwork.IPAddress }}' rest)
# Tentative d’appel le service web REST
$ curl -H "Content-type: application/json" -X POST -d '{"message":"coucou"}' $IP_REST:8080/helloworld
=> $IP_REST n‘est pas joignable depuis le hôte car le sous-réseau n‘est pas disponible depuis le hôte
# Suppression du conteneur rest
$ docker rm –f rest
# Avec redirection de port
-p 8080:8080 mickaelbaron/helloworldrestmicroservice
# Vérification que les ports ont été redirigés
$ docker ps
CONTAINER ID IMAGE COMMAND STATUS PORTS NAMES
ca04734156cb hellorest... "java -cp target/clas" Up 3 seconds 0.0.0.0:8080->8080/tcp rest
0b2d2671f0d6 redis "/entrypoint.sh redis" Up 6 hours 6379/tcp redis
# Appel le service web REST du conteneur rest via la redirection de port
$ curl -H "Content-type: application/json" -X POST -d '{"message":"coucou"}’ localhost:8080/helloworld
$ curl http://localhost:8080/helloworld
[{"rid":1,"message":"coucou","startDate":"Thu Jan 21 20:56:12 UTC 2018"}]
Redirection de ports avec run

View Slide

Logs
Email
Twitter
e
57
Interface web
RabbitMQ
Asynchrone
HTML/JS
Body= « ... »
• Web
• Rest
• Redis
• RabbitMQ
• Log
• Email
• Twitter
Body= « ... »
Body= « ... »
Body= « ... »
Service web REST
Isoler conteur
Base de données
Redis
lpush
hmset
lrange
hgetAll
Synchrone
POST/GET

View Slide

Docker : aller plus loin
58
Présentation rapide de Docker et de ses commandes
À approfondir
Gestion de la mémoire
Gestion avancée du réseau
Variables d’environnement
Docker fournit Kitematic un outil graphique pour gérer
facilement la création de conteneurs => http://kitematic.com
ImageLayers est un outil pour examiner l’historique d’une
image => https://imagelayers.io

View Slide

Docker : tips
59
Pour supprimer tous les conteneurs arrêtés

Pour supprimer les images qui n’ont pas de nom

Connaître l’IP d’un conteneur

S’attacher à un conteneur en cours d’exécution

Pour se détache CTRL+p CTRL+q
Dans Dockerfile, pour run utiliser un « exec form ["..",".."] »
car toutes les images n’ont pas forcément de shell
Liens
https://www.ctl.io/developers/blog/post/15-quick-docker-tips
docker rm $(docker ps -a -q)
docker rmi $(docker images -f "dangling=true" -q)
docker inspect –f '{{.NetworkSettings.IPAddress }}' mycont
docker attach mycont <=> docker exec –it mycont /bin/bash

View Slide

Mise en œuvre – Composer avec Docker Compose

View Slide

Docker Compose : généralités
61
Docker Compose adresse le constat suivant
# Création de l’ensemble des conteneurs
$ docker run --name redis -v /var/redis:/data --network helloworldnetwork -d redis redis-server --appendonly yes
$ docker run --name rabbitmq -d --network helloworldnetwork -p 5672:5672 -p 15672:15672 --hostname my-rabbit
rabbitmq:management
$ docker run --name log –d --network helloworldnetwork mickaelbaron/helloworldlogmicroservice rabbitmq
$ docker run --name rest -p 8080:8080 -d --network helloworldnetwork --env REDIS_HOST=tcp://redis:6379
--env RABBITMQ_HOST=rabbitmq mickaelbaron/helloworldrestmicroservice
$ docker run --name web -d --network helloworldnetwork -p 80:8080 mickaelbaron/helloworldwebmicroservice
Docker Compose est à utiliser quand vous avez plus d’un
conteneur à exécuter pour déployer une application
À partir d’une commande docker-compose s’occupe de
construire et de démarrer les conteneurs
La description de la composition est réalisée à partir d’un
fichier de configuration docker-compose.yml
L’outil docker-compose doit être installé en plus de Docker
engine

View Slide

Docker Compose : fichier docker-compose.yml
62
Description d’un fichier docker-compose.yml
Chaque paramètre de la ligne de commande se retrouve
dans le fichier docker-compose.yml (pas de nouveau concept)
version: ’3’
services:
log:
build: helloworldlogmicroservice/
depends_on:
- rabbitmq
networks:
- helloworld-net
command: rabbitmq
networks:
helloworld-net:
external:
name: helloworldnetwork
$ docker run --name log –d --network helloworldnetwork mickaelbaron/helloworldlogmicroservice rabbitmq
Fichier docker-compose.yml
L’image sera construite
automatiquement
Le conteneur log sera démarré
après le conteneur rabbitmq
Le conteneur log sera
connecté au réseau
helloworldnetwork
helloworld-net est
associé à un réseau
externe

View Slide

Docker Compose : docker-compose.yml (démo 10)
63
Description de la composition des cinq conteneurs
version: '3’
services:
redis:
image: redis
command: redis-server --appendonly yes
volumes:
- /var/redis:/data
networks:
- helloworld-net
rabbitmq:
image: rabbitmq:management
hostname: my-rabbit
ports:
- 5672:5672
- 15672:15672
networks:
- helloworld-net
log:
build: helloworldlogmicroservice/
image: mbaron/helloworldlogmicroservice
depends_on:
- rabbitmq
command: rabbitmq
networks:
- helloworld-net
rest:
build: helloworldrestmicroservice/
image: mbaron/helloworldrestmicroservice
depends_on:
- rabbitmq
- redis
ports:
- 8080:8080
environment:
REDIS_HOST: tcp://redis:6379
RABBITMQ_HOST: rabbitmq
networks:
- helloworld-net
web:
build: helloworldwebmicroservice
image: mbaron/helloworldwebmicroservice
ports:
- 80:8080
networks:
- helloworld-net
networks:
helloworld-net:
external:
name: helloworldnetwork
Fichier docker-compose.yml

View Slide

Docker Compose : sous commandes
64
L’exécution d’un fichier docker-compose.yml passe par la
commande docker-composer et des sous commandes
Si le nom du service (i.e. redis) n’est pas donné en paramètre
les sous commandes s’appliquent sur tous les conteneurs
• build : construit les images
• kill : kill -9 sur les conteneurs
• logs : affiche la sortie
• pause : met en pause
• ps : liste les conteneurs
• pull : importe les images
• restart : arrête et démarre
• rm : supprimer les conteneurs
• run : démarre les conteneurs
• scale : augmente le nombre
• start : démarre les conteneurs
• stop : arrête les conteneurs
• unpause : sort de pause
• up : build, créer et démarre

View Slide

Docker Compose : docker-compose.yml (démo 10 suite)
65
Construction des images puis démarrage des conteneurs
$ docker-compose up –d
Creating microservices_web_1
Creating microservices_redis_1
Creating microservices_rabbitmq_1
Creating microservices_log_1
Creating microservices_rest_1
# Affiche la liste des conteneurs
$ docker-compose ps
Name Command State Ports
--------------------------------------------------------------------------------------------------------
microservices_log_1 java -cp target/classes:ta ... Exit 1
microservices_rabbitmq_1 /docker-entrypoint.sh rabb ... Up 15671/tcp, 0.0.0.0:15672->15672/...
microservices_redis_1 /entrypoint.sh redis-serve ... Up 6379/tcp
microservices_rest_1 java -cp target/classes:ta ... Up 0.0.0.0:8080->8080/tcp
microservices_web_1 http-server /workdir/site ... Up 0.0.0.0:80->8080/tcp
# Affiche les logs du conteneur associé au service ‘web’
$ docker-compose logs web
Attaching to microservices_web_1
web_1 | Starting up http-server, serving /workdir/site
web_1 | Available on:
web_1 | http:127.0.0.1:8080
web_1 | Hit CTRL-C to stop the server
# La même chose en utilisant Docker engine mais en passant par le nom du conteneur ‘microservices_web_1’
$ docker logs microservices_web_1
Starting up http-server, serving /workdir/site
Available on:
http:127.0.0.1:8080
Hit CTRL-C to stop the server

View Slide

Docker Compose : les avantages et les inconvénients
66
Avantages
Traiter par lots l’arrêt et la suppression des conteneurs
L’automatisation des commandes (plus facile pour la reprise)
docker-compose logs => affichera toutes les sorties des consoles
L’ordre est géré par la balise depends_on (ne gère pas la disponibilité)
Inconvénients
Faire attention à la disponibilité des conteneurs dépendants : une
base de données peut prendre un certains temps => prévoir un
système de reconnexion automatique (Healthcheck)

View Slide

67
Mise en œuvre – Répartir avec Nginx

View Slide

Nginx
68

View Slide

Conclusion – Bilan – On a vu …
69
Comment déployer une application Jakarta EE dans une
approche « container-less »
Comment isoler une application Jakarta EE avec un
conteneur Docker
Comment écrire un Dockerfile et construire une image
Comment communiquer entre deux conteneurs
Comment faire des communications synchrones et
asynchrones entre des services
Comment composer des conteneurs

View Slide

Prochainement dans une nouvelle version
70
Utilisation d’API spécifique à MicroProfile (ex : Metrics…)
Partie sur le bus d’événements avec RabbitMQ
Partie sur la montée en charge docker-compose scale
Partie sur le reverse-proxy et la répartition de charges
Partie sur le test de charge (outil AB par exemple)
Orchestration avancée avec Kubernetes

View Slide

Architectures Microservices : mise en oeuvre avec Java et Docker

Architectures Microservices : mise en oeuvre avec Java et Docker

Mickael BARON

More Decks by Mickael BARON

Other Decks in Programming

Featured

Transcript