Introduction aux Architectures Microservices : mise en oeuvre

transcript

SOA – Microservices

Mickaël BARON – 2016 (Rév. Janvier 2017)mailto:baron.mickael@gmail.com ou mailto:baron@ensma.fr

@mickaelbaron

Mise en œuvre

SOA - Microservices - Outils - M. Baron - PageSOA - Microservices - Outils - M. Baron - Page

onLicence

Creative CommonsContrat Paternité

Partage des Conditions Initiales à l'Identique

2.0 France

http://creativecommons.org/licenses/by-sa/2.0/fr

onA propos de l’auteur …

� Mickaël BARON

� Ingénieur de Recherche au LIAS

� http://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

� http://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

onPlan du cours

� Architecture microservices « fil rouge »

� Coder avec KumuluzEE

� Isoler avec Docker

� Communiquer avec RabbitMQ

� Composer avec Docker Compose

� Répartir la charge avec Nginx

onDéroulement du cours : Introduction générale

� 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

onRessources : Liens sur le Web

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

onRessources : Bibliothèque

� 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

onArchitecture microservices « fil rouge » : HelloWorld

Vous saisissez un message …

… il apparaît dans la liste

onArchitecture microservices « fil rouge » : HelloWorld

Service web RESThelloworldrestmicroservice

Interface webhelloworldwebmicroservice

Logshelloworldlogmicroservice

Emailhelloworldemailmicroservice

Twitterhelloworldtwittermicroservic

Base de donnéesRedis

Bus d’événements

RabbitMQ

Synchrone

Asynchrone

POST/GET

lpushhmset

lrangehgetAll

Body= « ... »

Ce microservice est unpublieur (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 = helloworldBody= « ... »

Isoler conteur

Channel = helloworld

@mickaelbaron 10

Mise en œuvre – Coder avec KumuluzEE

onJava et les microservices : KumuluzEE

� Site web : https://ee.kumuluz.com

� Très jeune projet, a gagné le Duke’s Choice Award 2015

� KumuluzEE s’appuie sur les standards Java EE pour les

briques logicielles (JAX-RS, JPA…)

� Aucune nouvelle API proposée en dehors de Java EE et tout

ce que vous avez appris en Java EE s’applique

� Seule la manière de déployer change

onKumuluzEE : mode d’emploi

1) Créer un projet Maven simple2) Ajouter les dépendances KumuluzEE à votre pom.xml

1) Développer votre application Java 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 {

...@GETpublic Response getHelloWorlds() {

return Response.ok(currentDAO.getHelloWorlds()).build();

@POSTpublic 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

onKumuluzEE : mode d’emploi

5) Ajouter le plugin maven-dependency-plugin au pom.xml

6) Ajouter le fichier beans.xml et créer un répertoire webapp

7) Compiler : $ mvn package

8) Exécuter : $ java -cp target/classes:target/dependency/*

com.kumuluz.ee.EeApplication

9) 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/javaeehttp://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

« Fil rouge » : HelloWorld

RabbitMQ

Synchrone

Asynchrone

POST/GET

lpushhmset

lrangehgetAll

Body= « ... »

Isoler conteur

@mickaelbaron 15

Mise en œuvre – Isoler avec Docker

onDocker : généralités

� 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� AUFS : https://en.wikipedia.org/wiki/Aufs

� Outils sont principalement en ligne de commande� Fonctionne sous Linux nativement et sous Windows et MacOS

via une VM (Docker Toolbox)

onDocker : un // avec Java

onDocker : images

� 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’UnionMountdont l’implémentation est aufs)

Identique à la plupart des distributions Linux

Spécifique à chaque distribution

onDocker : images

� 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 baseSans image pas de conteneur

… patience le concept de conteneur est expliqué

Une image ne peut être modifiée

puisqu’elle est en lecture seule

onDocker : images

� 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

onDocker : conteneur

� 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

onDocker : conteneur interactif (démo 1)

# Télécharge l'image 'busybox' depuis DockerHub$ docker pull busyboxUsing default tag: latestlatest: Pulling from library/busybox

c00ef186408b: Pull completeac6a7980c6c2: Pull completeDigest: sha256:e4f93f6ed15a0cdd342f5aae387886fba0ab98af0a102da6276eaf24d6e6ade0Status: 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$ lsbin 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 –aCONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMESd2bc3ccd2ee1 busybox "/bin/sh" 26 minutes ago Exited (0) 23 minutes ago goofy_bhabha

� Commandes : run, ps

onDocker : conteneur détaché (démo 2)

# 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 2016Hello Poitiers Thu Jan 7 15:09:02 UTC 2016

# Vérification de l'état d'exécution$ docker psCONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES01d4dacd55e2 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 2016Hello Poitiers Thu Jan 7 15:17:23 UTC 2016 # Pour terminer un CTRL-C

# Vérification de l'état d'exécution$ docker ps -aCONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES01d4dacd55e2 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

onDocker : conteneur sans état (démo 3)

# 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 /tmp074426074526

# Changement sur le système de fichier – C = Changement, A = Ajout, D = Delete$ docker diff $JOBC /tmpA /tmp/094126A /tmp/094226

# Suppression du conteneur$ docker rm -f $JOB01dbf7a101abc13a80a95fae41c78a3997de90fa9636c26a4c6498738c631c26

# 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

onDocker : cinq types de commandes

1. Exécution d’un conteneur

2. Informations sur un conteneur

3. Système de fichiers d’un conteneur

4. Gestion des images

5. Gestion du repository DockerHub

onDocker : commandes pour l’exécution

� 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� network : gère le réseau sur Docker (sous commandes)� 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

onDocker : commandes pour des informations

� 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

onDocker : commandes pour le système de fichiers

� 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

� volume : gère les volumes (sous commandes)

onDocker : commandes pour la gestion des images

� 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

onDocker : créer une image

� A 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

onDocker : créer une image « manuellement » (démo 4)

# 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 demo4A /tmp/094840A /tmp/094940

# Création d’une image appelée mickaelbaron/demo4$ docker commit demo4 mickaelbaron/demo4C40410395aedf8cfb8f55469a974a519ee764dd3a765e3c78df8df60316870ad # => Id de l’image

# Suppression du conteneur actuel$ docker rm -f demo4demo4

# Affiche la liste des images en cachedocker imagesREPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZEmickaelbaron/demo4 latest c40410395aed About a minute ago 1.113 MBbusybox 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 /tmp094840 # Anciens fichiers094940095317 # Nouveau fichier

� Commandes : run, exec, diff, commit, images

onDocker : créer une image depuis Dockerfile

� 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

onDocker : Dockerfile FROM et MAINTENER

� 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 MAINTAINER permet d’indiquer l’auteur

� Exemple

� MAINTAINER Mickael BARON

FROM java:8

Permet de spécifier <image>:<tag>

Dans ce cas il s’agit de la version de Java

onDocker : Dockerfile RUN

� 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� Regrouper toutes les installations de package si possible� Ne pas faire update et ensuite un install dans un RUN

RUN ["mvn","package"]

RUN apt-get update && apt-get install -y \maven \git

: Mise à jour et installations (form)

onDocker : Dockerfile deux formes pour les instructions

� Deux formes pour écrire des instructions dans un Dockerfile

� Pas forcément limitées à l’instruction RUN (voir plus tard)

Forme Shell RUNRUN <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 ExecRUN ["command","param1","param2]

• La commande est directement appelée

• A utiliser quand il n’y a pas forcément accès à un shell

• Si possible utiliser cette forme d’écriture

onDocker : Dockerfile ADD

� 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

onDocker : Dockerfile CMD

� 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 psCONTAINER 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 psCONTAINER ID IMAGE COMMAND CREATED ...50238de77614 myimage “java –jar /target/myprogram.jar param1 param2“ 54 minutes ago ...

onDocker : Dockerfile ENTRYPOINT

� L’instruction ENTRYPOINT fait comme CMD sauf qu’elle ne peut être surchargée lors de l’exécution du conteneur

� Elle ne peut être exécutée qu’une seule fois� Exemple

� Impossibilité de surcharger la commande lors de l’exécution

ENTRYPOINT ["java","-jar", "/target/myprogram.jar"]

# Création d’un conteneur$ docker run –d myimage java –jar /target/myprogram.jar param1 param2

onDocker : Dockerfile CMD et ENTRYPOINT

� Possibilité de combiner l’instruction ENTRYPOINT et CMD� L’intérêt est pouvoir fixer un début de commande via

ENTRYPOINT et compléter la commande via CMD (défaut)� Exemple

� Possibilité de surcharger le contenu de CMD

ENTRYPOINT ["java","-jar", "/target/myprogram.jar"]

CMD ["param1","param2"]

# Vérifie la commande exécutée$ docker psCONTAINER 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 psCONTAINER ID IMAGE COMMAND CREATED ...50238de77614 myimage “java –jar /target/myprogram.jar param3“ 54 minutes ago ...

onDocker : Dockerfile EXPOSE

� 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 souhaiter n’exposer que Tomcat

� Exemple

� EXPOSE 8080

onDocker : Dockerfile (démo 5)

FROM maven:3.3.3-jdk-8MAINTAINER Mickael BARON

ADD pom.xml /work/pom.xmlWORKDIR /workRUN ["mvn", "dependency:go-offline"]

ADD ["src", "/work/src"]RUN ["mvn", "package"]

EXPOSE 8080ENTRYPOINT ["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

onDocker : Dockerfile (démo 5) - suite

� Construction de l’image et création du conteneur de rest# Création d’une image à partir du précédent Dockerfile conteneur $ docker build -t mickaelbaron/helloworldrestmicroservice .Sending build context to Docker daemon 12.95 MBStep 1 : FROM maven:3.3.3-jdk-83.3.3-jdk-8: Pulling from library/maven523ef1d23f22: Pull complete...Digest: sha256:62995ea43d8554c7b581c2576fb53d8097039dae19fc68a11f485406a13380dfStatus: Downloaded newer image for maven:3.3.3-jdk-8---> 319dadddb414Step 2 : MAINTAINER Mickael BARON---> Running in 840480e4ec74---> f298b9092c72Removing intermediate container 840480e4ec74Step 3 : ADD pom.xml /work/pom.xml---> f9a9360b890cRemoving intermediate container 1ee48de07452Step 4 : WORKDIR /work---> Running in ee125209a9b9---> 7cfef739d3f7Removing intermediate container ee125209a9b9...Step 9 : ENTRYPOINT java -cp target/classes:target/dependency/* com.kumuluz.ee.EeApplication---> Running in 098f76f8eac9---> ac952da4967cRemoving intermediate container 098f76f8eac9Successfully built ac952da4967c

A chaque étape du Dockerfile une couche intermédiaire sera créée

RabbitMQ

Synchrone

Asynchrone

POST/GET

lpushhmset

lrangehgetAll

Body= « ... »

Isoler conteur

onDocker : persister les données avec les volumes

� 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é

onDocker : persister les données avec les volumes

� 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 psCONTAINER 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 -ltotal 0-rw-r--r-- 1 999 docker 0 Jan 20 21:14 appendonly.aof # Fichier créé par redis du conteneur.

-v hostdirectory:/containerdirectory

RabbitMQ

Synchrone

Asynchrone

POST/GET

lpushhmset

lrangehgetAll

Body= « ... »

Isoler conteur

onDocker : lier les conteneurs avec les links

� Les links est une première solution permettant de lier plusieurs conteneurs entre eux

� Dans notre exemple, le conteneur redis doit être lié au conteneur associé au microservice Rest

� Syntaxe (-l ou --link)�

� Comment ça fonctionne ?� À la création du conteneur où le link est défini, Docker va modifier le

fichier /etc/hosts en en associant l’IP du conteneur lié à valeurAlias

� Pour la composition de conteneurs il est d’usage d’utiliser Docker Compose (voir partie suivante)

--link nomDuConteneur:/valeurAlias

Parler des variables créées lors du link

� Utilisation des links pour relier les conteneurs redis et rest# Création du conteneur redis$ docker run --name redis -v /var/redis:/data -d redis redis-server --appendonly yes

# Création du conteneur rest# --link création du lien avec le conteneur redis# --env création d’une variable d’environnement REDIS_HOST avec redisalias comme valeur$ docker run --name rest –d --link redis:redisalias --env REDIS_HOST=redisalias \

mickaelbaron/helloworldrestmicroservice

# Vérification que les conteneurs sont démarrés$ docker psCONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES8ea3292c609a hellorest... "java -cp target/clas" 3 seconds ago Up 2 seconds 8080/tcp rest0b2d2671f0d6 redis "/entrypoint.sh redis" 21 hours ago Up 3 hours 6379/tcp redis

# Afficher le fichier /etc/hosts pour voir la liaison de rest avec redis$ docker exec -it rest /bin/sh -c 'cat /etc/hosts’172.17.0.3 8ea3292c609a127.0.0.1 localhost::1 localhost ip6-localhost ip6-loopbackfe00::0 ip6-localnetff00::0 ip6-mcastprefixff02::1 ip6-allnodesff02::2 ip6-allrouters172.17.0.2 redisalias 0b2d2671f0d6 redis

# Depuis rest le dialogue vers redis se fait via redisalias, pour preuve ...$ docker exec -it rest /bin/sh -c 'ping redisalias'PING redisalias (172.17.0.2): 56 data bytes64 bytes from 172.17.0.2: icmp_seq=0 ttl=64 time=0.005 ms...

RabbitMQ

Asynchrone

POST/GET Body= « ... »

Isoler conteur

lpushhmset

lrangehgetAll

Synchrone

onDocker : rediriger les ports

� 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 va permettre 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 psCONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES8ea3292c609a hellorest... "java -cp target/clas" 3 seconds ago Up 2 seconds 8080/tcp rest0b2d2671f0d6 redis "/entrypoint.sh redis" 21 hours ago Up 3 hours 6379/tcp redis

-p portHôte:portConteneur

onDocker : rediriger les ports

# Sans redirection de port$ docker run --name rest --link redis:redisalias --env REDIS_HOST=redisalias \

-d mickaelbaron/helloworldrestmicroservice

# Recherche l’IP du conteneur$ $IP_REST = $(docker inspect rest | jq -r '.[0] | .NetworkSettings.IPAddress’)

# Appel le service web REST$ curl -H "Content-type: application/json" -X POST -d '{"message":"coucou"}' $IP_REST:8080/helloworld$ curl $IP_REST:8080/helloworld[{"rid":1,"message":"coucou","startDate":"Thu Jan 21 20:56:12 UTC 2016"}]

# Suppression du conteneur rest$ docker rm –f rest

# Avec redirection de port$ docker run --name rest -p 8080:8080 –d --link redis:redisalias --env REDIS_HOST=redisalias \

mickaelbaron/helloworldrestmicroservice

# Vérification que les ports ont été redirigés$ docker psCONTAINER ID IMAGE COMMAND STATUS PORTS NAMESca04734156cb hellorest... "java -cp target/clas" Up 3 seconds 0.0.0.0:8080->8080/tcp rest0b2d2671f0d6 redis "/entrypoint.sh redis" Up 6 hours 6379/tcp redis

# Appel le service web REST du conteneur rest via la redirection de port$ curl http://localhost:8080/helloworld[{"rid":1,"message":"coucou","startDate":"Thu Jan 21 20:56:12 UTC 2016"}]

� Redirection de ports avec run

RabbitMQ

Asynchrone

Body= « ... »

Isoler conteur

lpushhmset

lrangehgetAll

Synchrone

POST/GET

onDocker : aller plus loin

� Présentation rapide de Docker et de ses commandes

� A 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

onDocker : tips

� 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 (nécessite l’installation de jq)�

� 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 mycont | jq -r '.[0] | .NetworkSettings.IPAddress'

@mickaelbaron 56

Mise en œuvre – Communiquer avec RabbitMQ

onRabbitMQ

@mickaelbaron 58

Mise en œuvre – Composer avec Docker Compose

onDocker Compose : généralités

� Docker Compose adresse le constat suivant# Création de l’ensemble des conteneurs$ docker run --name redis -v /var/redis:/data -d redis redis-server --appendonly yes$ docker run --name rabbitmq -d -p 5672:5672 -p 15672:15672 --hostname my-rabbit rabbitmq:management$ docker run --name log –d --link rabbitmq:rabbitmqalias mickaelbaron/helloworldlogmicroservice rabbitmqalias$ docker run --name rest -p 8080:8080 -d --link redis:redisalias --link rabbitmq:rabbitmqalias

--env REDIS_HOST=redisalias --env RABBIT_MQ_HOST=rabbitmqalias mickaelbaron/helloworldrestmicroservice$ docker run --name web -d -p 80:8080 mickaelbaron/helloworldwebmicroservice

� Docker Compose est à utiliser quand vous avez plus d’un conteneur à exécuter pour déployer une application

� A 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

onDocker Compose : fichier docker-compose.yml

� Composition 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)

rabbitmq:image: rabbitmq:managementhostname: my-rabbitports:

- 5672:5672- 15672:15672

log:build: helloworldlogmicroservice/links:

- rabbitmq:rabbitmqaliascommand: rabbitmqalias

# Création de l’ensemble des conteneurs$ docker run --name rabbitmq -d -p 5672:5672 -p 15672:15672 --hostname my-rabbit rabbitmq:management$ docker run --name log –d --link rabbitmq:rabbitmqalias mickaelbaron/helloworldlogmicroservice rabbitmqalias

Fichier docker-compose.yml

Utilisation d’une image

L’image sera construite

automatiquement

onDocker Compose : docker-compose.yml (démo 6)

� Description de la composition des cinq conteneurs

redis:image: redisvolumes:

- /var/redis:/datacommand: redis-server --appendonly yes

rabbitmq:image: rabbitmq:managementhostname: my-rabbitports:

- 5672:5672- 15672:15672

log:build: helloworldlogmicroservice/links:

- rabbitmq:rabbitmqaliascommand: rabbitmqalias

rest:build: helloworldrestmicroservice/links:

- rabbitmq:rabbitmqalias- redis:redisalias

ports:- 8080:8080

environment:REDIS_HOST: redisaliasRABBIT_MQ_HOST: rabbitmqalias

web:build: helloworldwebmicroserviceports:

- 80:8080

Fichier docker-compose.yml

onDocker Compose : sous commandes

� 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

onDocker Compose : docker-compose.yml (démo 6 suite)

� Construction des images puis démarrage des conteneurs# Création de l’ensemble des conteneurs$ docker-compose up –dCreating microservices_web_1Creating microservices_redis_1Creating microservices_rabbitmq_1Creating microservices_log_1Creating microservices_rest_1

# Affiche la liste des conteneurs$ docker-compose psName Command State Ports

--------------------------------------------------------------------------------------------------------microservices_log_1 java -cp target/classes:ta ... Exit 1microservices_rabbitmq_1 /docker-entrypoint.sh rabb ... Up 15671/tcp, 0.0.0.0:15672->15672/...microservices_redis_1 /entrypoint.sh redis-serve ... Up 6379/tcpmicroservices_rest_1 java -cp target/classes:ta ... Up 0.0.0.0:8080->8080/tcpmicroservices_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 webAttaching to microservices_web_1web_1 | Starting up http-server, serving /workdir/siteweb_1 | Available on:web_1 | http:127.0.0.1:8080web_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_1Starting up http-server, serving /workdir/siteAvailable on:

http:127.0.0.1:8080Hit CTRL-C to stop the server

onDocker Compose : les avantages et les inconvénients

� 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

� Inconvénients

� Faire attention à l’enchainement : l’ordre

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

@mickaelbaron 65

Mise en œuvre – Répartir avec Nginx

onNginx

onConclusion – Bilan – On a vu …

� Comment déployer une application Java EE dans uneapproche « container-less »

� Comment isoler une application Java 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

onProchainement dans une nouvelle version

� Utilisation du framework self-contained Spring Boot

� 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 avec

� Partie sur le test de charge (outil AB par exemple)

� Déploiement sur plusieurs machines avec Docker Swarm

Introduction aux Architectures Microservices : mise en oeuvre

Technology