Architectures Microservices : mise en oeuvre

Architectures Microservices : mise en oeuvre

Ce support de cours présente des outils et bibliothèques pour la mise en œuvre d'architectures Microservices. Tout au long de la présentation une étude de cas sera déroulée pour illustrer les différents usages des outils et bibliothèques présentés.

Ainsi, dans une première partie KumuluzEE sera présenté pour la partie codage de Microservices avec le langage Java et la spécification MicroProfile. Par la suite, Docker sera présenté pour montrer comment isoler un Microservice. Dans une troisième partie RabbitMQ sera présenté pour montrer comment réaliser une communication asynchrone entre des Microservices. Dans une quatrième partie Docker Compose sera présenté pour expliquer comment composer des Microservices. Enfin, dans une cinquième partie, NGINX sera présenté pour expliquer comment répartir la charge et réaliser un proxy inverse.

3c4219fa12e875f02a81d5957876de8e?s=128

Mickael BARON

January 03, 2019
Tweet

Transcript

  1. SOA – Microservices Mickaël BARON – 2016 (Rév. Mai 2020)

    mailto:baron.mickael@gmail.com ou mailto:baron@ensma.fr @mickaelbaron mickael-baron.fr Mise en œuvre
  2. SOA - Microservices - Outils - M. Baron - Page

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

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 † Responsable Rubriques Java de Developpez.com † 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
  4. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page 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)
  5. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Déroulement du cours : Introduction générale 5 † Pédagogie du cours † Des bulles d’aide tout au long du cours † Comprendre une architecture microservices † Pas de technique pour l’instant † 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
  6. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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/)
  7. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  8. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Architecture microservices « fil rouge » : HelloWorld 8 Vous saisissez un message … … il apparaît dans la liste
  9. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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= « ... » Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Isoler conteur Channel = helloworld
  10. SOA – Microservices Mickaël BARON – 2016 (Rév. Mai 2020)

    mailto:baron.mickael@gmail.com ou mailto:baron@ensma.fr @mickaelbaron mickael-baron.fr Mise en œuvre – Coder avec KumuluzEE
  11. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  12. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  13. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  14. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservic e 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 petits noms pour les identifier par la suite • Web • Rest • Redis • RabbitMQ • Log • Email • Twitter Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Channel = helloworld Body= « ... » Isoler conteur Channel = helloworld Service web REST helloworldrestmicroservice
  15. SOA – Microservices Mickaël BARON – 2016 (Rév. Mai 2020)

    mailto:baron.mickael@gmail.com ou mailto:baron@ensma.fr @mickaelbaron mickael-baron.fr Mise en œuvre – Isoler avec Docker
  16. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 et MacOS via une VM (Docker4Mac)
  17. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Docker : un // avec Java 17
  18. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  19. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  20. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  21. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  22. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  23. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  24. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  25. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  26. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  27. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  28. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  29. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  30. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  31. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  32. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  33. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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)
  34. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  35. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  36. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 ...
  37. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 ...
  38. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 ...
  39. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  40. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  41. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  42. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 ...
  43. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  44. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  45. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  46. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservic e 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 petits noms 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 conteur
  47. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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é
  48. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  49. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservic e 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 petits noms 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 conteur Base de données Redis
  50. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  51. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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 ...
  52. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  54. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservic e 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 petits noms 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 conteur Base de données Redis lpush hmset lrange hgetAll Synchrone
  55. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  56. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  57. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Logs helloworldlogmicroservice Email helloworldemailmicroservice Twitter helloworldtwittermicroservic e 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 petits noms 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 conteur Base de données Redis lpush hmset lrange hgetAll Synchrone POST/GET
  58. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  59. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  60. SOA – Microservices Mickaël BARON – 2016 (Rév. Mai 2020)

    mailto:baron.mickael@gmail.com ou mailto:baron@ensma.fr @mickaelbaron mickael-baron.fr Mise en œuvre – Composer avec Docker Compose
  61. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  62. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  63. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  64. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  65. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  66. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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)
  67. SOA – Microservices Mickaël BARON – 2016 (Rév. Mai 2020)

    mailto:baron.mickael@gmail.com ou mailto:baron@ensma.fr @mickaelbaron mickael-baron.fr 67 Mise en œuvre – Répartir avec Nginx
  68. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron Nginx 68
  69. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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
  70. SOA - Microservices - Outils - M. Baron - Page

    SOA - Microservices - Outils - M. Baron - Page mickael-baron.fr @mickaelbaron 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) † Déploiement sur plusieurs machines avec Docker Swarm † Orchestration avancée avec Kubernetes