$30 off During Our Annual Pro Sale. View Details »

Architectures Microservices : mise en oeuvre avec Java et Docker

Architectures Microservices : mise en oeuvre avec Java et Docker

Ce support de cours présente la mise en œuvre d'architectures Microservices avec Java et Docker. 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 la bibliothèque KumuluzEE est présentée pour la partie codage de Microservices avec le langage Java et la spécification MicroProfile.

Dans une deuxième partie, Docker est présenté pour montrer comment isoler un Microservice.

Enfin dans une troisième partie, Docker Compose est présenté pour expliquer comment composer des Microservices.

Mickael BARON

May 03, 2022
Tweet

More Decks by Mickael BARON

Other Decks in Programming

Transcript

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

    View Slide

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

    View Slide

  3. Microservices - Docker - 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
    † 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

    View Slide

  4. Microservices - Docker - 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)

    View Slide

  5. Microservices - Docker - 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
    † Utilité des microservices
    † Exemple file rouge tout le long du cours
    † Pré-requis
    † Cours sur JAX-RS
    † Introduction générale sur les Microservices
    † Bases en shell Linux
    † Bases en réseaux
    Ceci est une alerte
    Ceci est une astuce

    View Slide

  6. Microservices - Docker - 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/)

    View Slide

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

    View Slide

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

    View Slide

  9. Microservices - Docker - 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 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

    View Slide

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

    View Slide

  11. Microservices - Docker - 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

    View Slide

  12. Microservices - Docker - 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

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


    com.kumuluz.ee
    kumuluzee-servlet-jetty
    ${kumuluzee.version}


    com.kumuluz.ee
    kumuluzee-jax-rs
    ${kumuluzee.version}

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

    View Slide

  13. Microservices - Docker - 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

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

    Fichier beans.xml à
    copier dans META-INF

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


    copy-dependencies
    package
    copy-dependencies



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

    View Slide

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

    View Slide

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

    View Slide

  16. Microservices - Docker - 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/macOS
    via une VM (DockerDesktop)

    View Slide

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

    View Slide

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

    View Slide

  19. Microservices - Docker - 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

    View Slide

  20. Microservices - Docker - 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

    View Slide

  21. Microservices - Docker - 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

    View Slide

  22. Microservices - Docker - 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

    View Slide

  23. Microservices - Docker - 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

    View Slide

  24. Microservices - Docker - 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

    View Slide

  25. Microservices - Docker - 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

    View Slide

  26. Microservices - Docker - 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

    View Slide

  27. Microservices - Docker - 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

    View Slide

  28. Microservices - Docker - 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

    View Slide

  29. Microservices - Docker - 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

    View Slide

  30. Microservices - Docker - 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

    View Slide

  31. Microservices - Docker - 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

    View Slide

  32. Microservices - Docker - 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
    :
    Dans ce cas il s’agit
    de la version de Java

    View Slide

  33. Microservices - Docker - 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)

    View Slide

  34. Microservices - Docker - 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
    • La commande est exécutée dans
    un shell (/bin/sh -c)
    • À utiliser quand il y a plusieurs
    commandes à appeler à la suite
    dans une même couche
    Forme Exec
    RUN ["command","param1","param2]
    • La commande est directement
    appelée
    • À utiliser quand il n’y a pas
    forcément accès à un shell
    VS

    View Slide

  35. Microservices - Docker - 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

    View Slide

  36. Microservices - Docker - 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 ...

    View Slide

  37. Microservices - Docker - 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 ...

    View Slide

  38. Microservices - Docker - 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 ...

    View Slide

  39. Microservices - Docker - 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

    View Slide

  40. Microservices - Docker - 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

    View Slide

  41. Microservices - Docker - 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

    View Slide

  42. Microservices - Docker - 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 ...

    View Slide

  43. Microservices - Docker - 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

    View Slide

  44. Microservices - Docker - 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

    View Slide

  45. Microservices - Docker - 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

    View Slide

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

    View Slide

  47. Microservices - Docker - 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é

    View Slide

  48. Microservices - Docker - 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

    View Slide

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

    View Slide

  50. Microservices - Docker - 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

    View Slide

  51. Microservices - Docker - 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
    ...

    View Slide

  52. Microservices - Docker - 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

    View Slide

  53. Microservices - Docker - 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

    View Slide

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

    View Slide

  55. Microservices - Docker - 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

    View Slide

  56. Microservices - Docker - 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

    View Slide

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

    View Slide

  58. Microservices - Docker - 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

    View Slide

  59. Microservices - Docker - 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

    View Slide

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

    View Slide

  61. Microservices - Docker - 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

    View Slide

  62. Microservices - Docker - 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

    View Slide

  63. Microservices - Docker - 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

    View Slide

  64. Microservices - Docker - 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

    View Slide

  65. Microservices - Docker - 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

    View Slide

  66. Microservices - Docker - 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)

    View Slide

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

    View Slide

  68. Microservices - Docker - M. Baron - Page
    mickael-baron.fr mickaelbaron
    Nginx
    68

    View Slide

  69. Microservices - Docker - 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

    View Slide

  70. Microservices - Docker - 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)
    † Orchestration avancée avec Kubernetes

    View Slide