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] mickael-baron.fr mickaelbaron Mise en œuvre avec Docker

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

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 mickael-baron.fr mickaelbaron

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)

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

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/)

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

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

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 noms courts pour les identifier par la suite • Web • Rest • Redis • RabbitMQ • Log • Email • Twitter Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Isoler conteneur Channel = helloworld

mailto:[email protected] ou mailto:[email protected] mickael-baron.fr mickaelbaron Mise en œuvre – Coder avec KumuluzEE

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

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 <dependency> <groupId>com.kumuluz.ee</groupId> <artifactId>kumuluzee-core</artifactId> <version>${kumuluzee.version}</version> </dependency> <dependency> <groupId>com.kumuluz.ee</groupId> <artifactId>kumuluzee-servlet-jetty</artifactId> <version>${kumuluzee.version}</version> </dependency> <dependency> <groupId>com.kumuluz.ee</groupId> <artifactId>kumuluzee-jax-rs</artifactId> <version>${kumuluzee.version}</version> </dependency> 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

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 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://xmlns.jcp.org/xml/ns/javaee" 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"> </beans> Fichier beans.xml à copier dans META-INF <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <version>2.10</version> <executions> <execution> <id>copy-dependencies</id> <phase>package</phase> <goals><goal>copy-dependencies</goal></goals> </execution> </executions> </plugin> Permettra de placer toutes les dépendances dans le répertoire target du projet

Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservice Ces microservices sont des souscripteurs (subscriber) « Fil rouge » : HelloWorld 14 Interface web helloworldwebmicroservice 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) Sept microservices, des noms courts pour les identifier par la suite • Web • Rest • Redis • RabbitMQ • Log • Email • Twitter Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Isoler conteneur Channel = helloworld Service web REST helloworldrestmicroservice

mailto:[email protected] ou mailto:[email protected] mickael-baron.fr mickaelbaron Mise en œuvre – Isoler avec Docker

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)

Docker : un // avec Java 17

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

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

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

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

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

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 Hello Poitiers Thu Jan 7 15:09:02 UTC 2016 # Vérification de l'état d'exécution $ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 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:22 UTC 2016 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 CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 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

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

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

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

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

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

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

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

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

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 <image>:<tag> Dans ce cas il s’agit de la version de Java

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)

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 <command> • 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

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

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 ... # Création d’un conteneur $ docker run –d myimage java –jar /target/myprogram.jar param1 param2 # Vérifie la commande exécutée $ docker ps CONTAINER ID IMAGE COMMAND CREATED ... 50238de77614 myimage “java –jar /target/myprogram.jar param1 param2“ 54 minutes ago ...

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 À l’exécution du conteneur Impossibilité de surcharger la commande lors de l’exécution ENTRYPOINT ["java","-jar", "/target/myprogram.jar"] # 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 ... # Création d’un conteneur $ docker run –d myimage java –jar /target/myprogram.jar param1 param2 # 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 : 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 À l’exécution du conteneur Possibilité de surcharger le contenu de CMD ENTRYPOINT ["java","-jar", "/target/myprogram.jar"] CMD ["param1","param2"] # 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 param1 param2“ 54 minutes ago ... # Création d’un conteneur $ docker run –d myimage param3 # Vérifie la commande exécutée $ docker ps CONTAINER ID IMAGE COMMAND CREATED ... 50238de77614 myimage “java –jar /target/myprogram.jar param3“ 54 minutes ago ...

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

Docker : Dockerfile (démo 5) 40 FROM maven:3.3.3-jdk-8 LABEL maintener="Mickael BARON" ADD pom.xml /work/pom.xml 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 helloworldrestmicroservice Si le pom.xml ne change pas le chargement des dépendances ne se fera pas à chaque modification du code source

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

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

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" ADD pom.xml /work/pom.xml 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 helloworldrestmicroservice Les fichiers de la précédente phase build-java-stage sont identifiés lors de la copie

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

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

Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservice Ces microservices sont des souscripteurs (subscriber) « Fil rouge » : HelloWorld 46 Interface web helloworldwebmicroservice 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) Sept microservices, des noms courts pour les identifier par la suite • Web • Rest • Redis • RabbitMQ • Log • Email • Twitter Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Channel = helloworld Service web REST helloworldrestmicroservice Isoler conteneur

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é

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

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

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

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 CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 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 ...

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

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) # S’attacher au conteneur alpine2 $ docker attach alpine2 # Tester la connexion à partir de alpine2 $ 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) # S’attacher au conteneur alpine3 $ docker attach alpine3 # Tester la connexion à partir de alpine3 $ 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

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

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 CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 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

Docker : rediriger les ports (démo 9) 56 # Sans redirection de port $ docker run --name rest –d --network helloworldnetwork --env REDIS_HOST=tcp://redis:6379 \ 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 $ docker run --name rest –d --network helloworldnetwork --env REDIS_HOST=tcp://redis:6379 \ -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

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

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

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

mailto:[email protected] ou mailto:[email protected] mickael-baron.fr mickaelbaron Mise en œuvre – Composer avec Docker Compose

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

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 # Création de l’ensemble des conteneurs $ 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

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

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

Docker Compose : docker-compose.yml (démo 10 suite) 65 Construction des images puis démarrage des conteneurs # Création de l’ensemble 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

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)

mailto:[email protected] ou mailto:[email protected] mickael-baron.fr mickaelbaron 67 Mise en œuvre – Répartir avec Nginx

Nginx 68

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

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

Architectures Microservices : mise en oeuvre av...

Architectures Microservices : mise en oeuvre avec Java et Docker

More Decks by Mickael BARON

Other Decks in Programming

Featured

Transcript