Les tutos Docker – Episode 1

PREMIERS PAS DANS LE MONDE DES CONTAINERS ET DE DOCKER

Les tutos Docker est une mini-série d’articles autour de la technologie Docker (Containers, images, docker-compose, Swarm, Kubernetes …).
L’objectif de cette série n’est pas de fournir une documentation exhaustive sur les usages de Docker (la documentation officielle de Docker est déjà très bien faite).
En trois ans seulement, La technologie Docker a su faire sa place et est déjà mondialement connue.
On peut rapidement la définir comme un ensemble d’outils permettant la création d’un environnement qui va recevoir une ou plusieurs applications pour une exécution isolée sur une machine locale ou dans le Cloud.

A PROPOS DE L’AUTEUR

Eric Duquesnoy vous fait découvrir au travers d’une série de vidéos les bénéfice de l’utilisation de Docker.

LA VIDÉO

La vidéo suivante vous présente sous la forme d’un screencast réalisé par Eric les différents sujets abordés dans cet article. Bon visionnage.

MAIS QU’EST CE QUE DOCKER ?

Docker est une plateforme open-source pour les développeurs et les sysadmins (ops) qui permet de construire, livrer et exécuter des applications distribuées.
Docker permet :

d’assembler rapidement des composants en application
d’éliminer les désagréments de passage entre les environnements de développement, de qualité, et de production.

Ainsi, les livraisons sont plus rapides et l’exécution et le comportement de l’application reste inchangé qu’elle soit sur des laptops, des VMs de data center, ou sur n’importe quel cloud.
Cet environnement est très rapide et léger en terme de footprint car le container va utiliser les fonctionnalités du système linux (cgroups, namespaces, …) exécutées par le Host.
Pour rappel, Docker facilite et vulgarise le format de container Linux LXC avec une API qui virtualise les applications de façon isolée.
L’architecture idéale pour Docker est la distribution des applications à travers une ou plusieurs machines en cluster avec une possibilité de gestion des ressources intelligente.

COMMENT FONCTIONNE DOCKER ?

Il s’agit de “containériser” les applications dans un format standard réutilisable. Pour cela Docker est constitué de 2 outils principaux. :

Docker Engine, un outil de packaging et d’exécution portable, qui construit, gère et exécute les containers.
Docker Hub, un service cloud permettant de stocker et de partager simplement les containers.

DOCKER ENGINE

Docker utilise une architecture client-serveur, le client Docker et le daemon Docker. C’est ce dernier qui se charge de la construction, de l’exécution et de la distribution des containers Docker.
Le client et le daemon peuvent être sur le même hôte, mais il est possible d’ avoir un client qui se connecte sur un daemon distant. Le client et le daemon Docker communiquent via sockets ou à travers une API RESTful.

LE DAEMON DOCKER

Le daemon Docker tourne sur une machine hôte. L’utilisateur n’interagit pas directement avec le daemon, il passe par le client Docker.

LE CLIENT DOCKER

Le client Docker se présente sous la forme de l’exécutable docker. Il accepte des commandes de l’utilisateur (docker run, docker build, docker push, …..) et les transmet au daemon Docker.

UN CONTAINER C’EST UNE VM FINALEMENT ?

Il ne faut pas confondre les containers et les machines virtuelles. Dans le premier cas nous n’installons pas un nouvel OS dans sa globalité mais nous utilisons une image (sous forme d’un fichier) qui contient toutes les libraires nécessaires à l’exécution des applications, alors que dans le 2ème cas vous installez un OS en surcouche d’un hyperviseur (donc d’un autre OS avec toute la lourdeur que cela comporte).

Lancer une VM est beaucoup plus long et lourd pour le système mais isole mieux les applications les unes par rapport aux autres.
Etant donné, le partage des ressources entre l’OS de la machine et le container, les linux containers ne tournent que sur un Linux et les windows containers ne fonctionnent qu’avec Windows comme système Hôte.

DOCKER , ÇA SERT À QUOI ?

Aider les développeurs à coder dans un environnement technique identique à la production.
Aider les ops à déployer les nouvelles applications et les upgrades de version grace à la similitude des environnements .
Découpler l’infrastructure par rapport aux applications.
A masquer la complexité des containers (architecture LXC).

LES DIFFÉRENTS MODÈLES DE LICENCE

Docker est disponible en version Communitiy Edition (CE) et Entreprise Edition (EE).
La version EE est orientée Enterprise avec un ensemble d’options et de fonctionnalités payantes (ex: Image Security Scanning).
Docker est disponible en version on-premise (Linux, Windows et Mac) et dans le cloud (AWS, Azure).
Les versions Linux compatibles avec Docker sont : Centos, Debian, Fedora, Oracle Linux, Red Hat, Suse et Ubuntu.
Pour plus de détails concernant les installations, veuillez vous reférer à cette page : https://docs.docker.com/glossary/?term=install
Pour les utilisateurs de Windows, Docker existe en version Docker-toolbox (exécutable qui installe tout, Virtualbox, une VM (Moby Linux), et les clients) et Docker4Windows (comme docker-toolbox, mais en mieux, utilise Hyper-V au lieu de Virtualbox ,seulement compatible à partir de Windows 10 Pro).

LES CONTAINERS

Un container Docker contient tout ce qui est nécessaire à l’exécution d’une application, on peut le comparer à un répertoire.
Chaque container est créé depuis une image Docker et on peut intéragir avec lui facilement grace à différentes commandes d’exploitation.
Il faut bien comprendre que le container est l’instanciation d’une image dans un mode isolé et sécurisé.
Chaque container est une plateforme isolée est sécurisée. Les containers Docker sont les composants d’exécution de Docker.
Après l’installation (voir le site de l’éditeur) du produit en fonction de votre OS , votre 1ère commande sera le lancement de votre premier container

PS C:\> docker container run hello-world
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world"image from the Docker Hub.
 3. The Docker daemon created a new container from that image whichruns the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, whichsent it
    to your terminal.
To try something moreambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash
Share images, automate workflows, and morewith a freeDocker ID:
 https://cloud.docker.com/
For moreexamples and ideas, visit:
 https://docs.docker.com/engine/userguide/
PS C:\>

Ce container très basique vous permet de vérifier le bon fonctionnement de tous les composants de votre installation.
Continuons avec 2 commandes indispensables pour lister les containers disponibles sur votre système:

# Liste les containers démarrés
$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS              
# Liste tous les containers démarrés ou non
$ docker ps-a
CONTAINER ID        IMAGE                COMMAND                  CREATED             STATUS                     PORTS               NAMES
dfc33aa660bf        hello-world          "/hello"6 minutes ago       Exited (0) 2 minutes ago                       awesome_lalande
6d521fff16cb        debian               "ping google.fr"13 days ago         Exited (137) 13 days ago                       elastic_perlman
6390de37b498        debian               "echo 'bonjour mon..."13 days ago         Exited (0) 13 days ago                         determined_fermat
80903bf165d8        hello-world:latest   "/hello"13 days ago         Exited (0) 13 days ago                         zen_morse
4749c2f7bf88        hello-world          "/hello"13 days ago         Exited (0) 13 days ago                         compassionate_chandrasekhar

Pour complexifier l’exemple, démarrons maintenant le fameux Nginx (serveur HTTP + reverse proxy) en container et exposons le port 80 sur le port 8000 de notre machine.

# pour info le -d permet de lancer le container en mode démon ou détaché et
# le -p permet le mapping des ports entre le port 80 du container et le port 8000 de notre machine
$ docker run -p 8000:80 -d nginx
a4850cdf3a360938f36fa5860aa2060be236f96aade53711dc265a76a5afc60e
# Vérifions si le container est en route.
PS C:\> docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
a4850cdf3a36        nginx               "nginx -g 'daemon ..."35 seconds ago      Up 34 seconds       0.0.0.0:8000->80/tcpsleepy_edison
PS C:\>

et vérifions sa bonne exécution dans un browser :

Great ça fonctionne ! nginx utilise maintenant le port 8000 en local.

# Stoppons le container
PS C:\> docker stop a4850cdf3a36
a4850cdf3a36
# Vraiment arreté ? Indeed !
PS C:\> docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
# Redemmarage avec le nom du container auto-généré
PS C:\> docker start sleepy_edison
sleepy_edison
PS C:\> docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
a4850cdf3a36        nginx               "nginx -g 'daemon ..."15 minutes ago      Up 23 seconds       0.0.0.0:8000->80/tcpsleepy_edison
# Connectons-nous dans le container avec exec -it et l'id du container et vérifions que
# nginx tourne sous debian.
$ docker exec-it a4850cdf3a36 /bin/bash
root@a4850cdf3a36:/etc# ls -l *rel*
lrwxrwxrwx 1 root root 21 Oct  7 12:17 os-release -> ../usr/lib/os-release
root@a4850cdf3a36:/etc# cat os-release
PRETTY_NAME="Debian GNU/Linux 9 (stretch)"
NAME="Debian GNU/Linux"
VERSION_ID="9"
VERSION="9 (stretch)"
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

La meilleure pratique pour lancer un container est en mode détaché (ou mode daemon).
Mais pour intéragir avec lui ou pour débugger, l’exécution d’un container en mode “exec” ou “attach” est une très bonne solution.
Voici comment “s’attacher” à ce container :

# La commande Attach permet de se fixer à un container :
Docker container attach --sig_proxy=falsenom ducontainer
# option très utile, le --sig_proxy à false permet d'éviter le stop du container  lors
# de l'exécution de la commande ctrl-C pour sortir du container.
our éviter ledown de container après un attach - Ctrl-C

Tips : Nous pouvons vérifier la présence des containers dans notre système en listant ce répertoire : “/var/lib/docker/containers” (Notez les containers ID)
Lorsque vous créez un container , vous avez plusieurs options à votre disposition :

-w => permet de se positionner dans un répertoire particulier
–privileged => permet de lancer le container avec plus de droits sur la machine hôte.
-rm => supprime le container lors de son arrêt
–log-driver=> permet de personnaliser et modifier la sortie des logs des containers (usage avancé)

Comment nommer un container au moment de sa création ?

# avec l'option --name
$ docker run -p 8000:80 --name mon_nginx -d nginx
$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
683262a175dd        nginx               "nginx -g 'daemon ..."7 seconds ago       Up 6 seconds        0.0.0.0:8000->80/tcpmon_nginx
# c'est beaucoup plus simple !
$ docker start mon_nginx

LE DOCKERFILE ET LES IMAGES

Ok, nous avons vu comment manipuler les containers mais maintenant interessons-nous à la “source” des containers c’est à dire les images !
Une image Docker est un template en lecture seule. Elle contient tout ce qui est nécessaire à l’exécution de l’application.
Docker fournit une façon simple de créer de nouvelles images ou de modifier les existantes. iÎl est aussi possible de télécharger des images existantes depuis le Docker Hub.
Il faut savoir que la plupart des éditeurs travaillent depuis plusieurs années par une version dockerisée de leurs productions.
L’utilsation des images fournies par ces sociétés sont extrèmement facile à utiliser , il n’y a pas de phase d’installation à proprement dit.
L’avantage par rapport à l’installation complexe d’une application est évident.
Les images Docker sont le composant de construction de Docker. Une image est constituée de couches (layers) qui vont permettre de produire un artéfact cohérent et optimisé pour l’instanciation du container.

Commandes Docker

#listons les images sur notre poste
$ docker images
PS C:\Users> docker images
REPOSITORY                                                                        TAG                 IMAGE ID            CREATED             SIZE
osixia/openldaplatest              37f5729b73ed        8 days ago          185MB
nginx                                                                             latest              40960efd7b8f        12 days ago         108MB
ivankrizsan/elastalertlatest              0c27c09a8209        2 weeks ago         237MB
sebp/elklatest              c354f49c0856        4 weeks ago         1.03GB
khezen/elastalertlatest              1bb06fab0927        4 weeks ago         507MB
cassandra                                                                         2.2.11              d7903aea3314        5 weeks ago         366MB
648292630089.dkr.ecr.eu-west-1.amazonaws.com/secretos/centos7latest              e7c00fa8e296        5 weeks ago         316MB
portainer/portainerlatest              a64783906447        7 weeks ago         11MB
centos                                                                            latest              196e0ce0c9fb        2 months ago        197MB
hello-world                                                                       latest              05a3bd381fc2        2 months ago        1.84kB
khezen/kibana4                   408a0643ce12        2 months ago        327MB
docker.elastic.co/elasticsearch/elasticsearch5.4.0               865382d9b822        5 months ago        511MB
docker.elastic.co/kibana/kibana5.4.0               e4fe4d5612a2        6 months ago        639MB
khezen/elasticsearch2                   8c8c370e17b5        6 months ago        347MB
d4w/nsenterlatest              9e4f13a0901e        14 months ago       83.8kB
# TAG => version
# IMAGE ID => identifiant unique
# Vous pouvez consulter la liste des images "intermediaires" ou temporaires qui construisent l'image finale avec l'option -a
PS C:\Users> docker images -a
REPOSITORY                                                                        TAG                 IMAGE ID
  CREATED             SIZE
osixia/openldaplatest              37f5729b73ed
  8 days ago          185MB
nginx                                                                             latest              40960efd7b8f
  12 days ago         108MB
ivankrizsan/elastalertlatest              0c27c09a8209
  2 weeks ago         3.14GB
<none>                                                                            <none>              10023ef2ed61
  2 weeks ago         2.19GB
<none>                                                                            <none>              aba88d1d7b38
  2 weeks ago         2.19GB
<none>                                                                            <none>              8c0c898f2bbf
  2 weeks ago         1.41GB
648292630089.dkr.ecr.eu-west-1.amazonaws.com/secret-integration/axway-apimanager<none>              7d0b99f555df
  3 weeks ago         2.35GB
<none>                                                                            <none>              5c45869de21c
  3 weeks ago         1.41GB
<none>                                                                            <none>              e626068be5dc
  3 weeks ago         1.41GB
648292630089.dkr.ecr.eu-west-1.amazonaws.com/secret-integration/axway-cassandra1.0.0-SNAPSHOT      77f8debc0c02
  3 weeks ago         2.68GB
<none>                                                                            <none>              b2f3597cb974
  3 weeks ago         2.68GB
<none>                                                                            <none>              a736c6d3a56d
# Pas de nom (juste un ID) et pas de tag pour les images intermediaires mais une taille non négligeable !
# Commande alternative pour lister les images :
$ docker image ls
REPOSITORY                                                                        TAG                 IMAGE ID            CREATED             SIZE
osixia/openldaplatest              37f5729b73ed        8 days ago          185MB
nginx                                                                             latest              40960efd7b8f        12 days ago         108MB
...

Suppression des images :

# suppression par le nom
$ docker rmi nginx
# suppression de TOUTES les images par une petite astuce
$ docker rm-f $(docker ps-a -q)

COMMENT CONSTRUIRE UNE IMAGE ?

La construction d’une image est assez simple avec la commande “docker build” et un fichier déclaratif, le fameux Dockerfile !
En effet, le principal avantage d’utilisé des dockerfile est son aspect déclaratif, vous allez “coder” l’architecture de votre image.
A travers un fichier Yaml, sans utiliser un langage particulier de type Groovy vous aller déclarer et décrire tout ce que vous souhaitez installer dans votre image. Ce fichier pourra être la garant des images produites et stocker dans le registry.
La commande “docker build” va produire l’image en quelques minutes en respectant à la lettre les commande du Dockerfile.
Voici quelques options liées à la commande build :

-t => permet de faire un tag (version) sur l’image produite
-f => permet de spéficier un Dockerfile ( qui n’est pas dans le répertoire courant
-rm => force l’effacement des images intermédiaires (voir la commande “docker images -a”)0

Et maintenant au travail !
Entrons en détails dans le fichier Dockerfile pour personnaliser notre image nginx.
Dans cet exemple nous allons prendre la version 1.7 de Nginx

# La commande FROM permet de charger une image de base téléchargeable dans le Hub Docker ou dans un répertoire privé.
$ cat/opt/docker/catDockerfile
FROM nginx:1.7
# Il est possible de créer une image à partir d'une feuille blanche , voici un exemple :
$ "FROM scratch"
#  Attention : Un fichier Dockerfile doit contenir 1 seule instruction FROM

La commande COPY :
Nous allons personnaliser la page index.html de Nginx en copiant un fichier modifié stocké sur notre machine.

# La commande COPY permet de copier les fichier de notre Host vers l'image nginx.
$ cat/opt/docker/catDockerfile
FROM nginx:1.7
COPY index.html /usr/share/nginx/html/index.html
# Voyons le résultat maintenant

Parfait ! nous savons maintenant comment intéragir avec nos containers.
L’instruction ENV (environnement) :
Cette commande permet de créer des variables d’environnement (on l’aurait deviné facilement). Leur utilisation est surtout importante au moment de l’exécution du container.
Imaginons que vous exécutiez un container PostgreSQL ou MySQL, il va falloir définir un user / password en tant qu’administrateur de votre database.
Ce genre d’information indispensable et confidentiel peut être transmis par l’utilisation des instruction ENV (soit dans le dockerfile ou pendant le lancement du container).

# ENV name=value
# il est possible de le faire au moment du run
docker run --rm--envNGINX_VERSION "1.13.7"--name my_nginx nginx:1.13
# Mais aussi dans le Dockerfile
ENV PATH /usr/local/nginx/bin:$PATH
# Comment lister les variables d'environnement d'une image
docker inspect --format='{{json .Config.Env}}'mon_nginx

LES MODES D’EXÉCUTIONS

Dans les Dockerfiles, il y a deux types d’exécution : soit en mode EXEC ou soit en mode SHELL.

voici le Mode SHELL => /bin/bash “ping www.google.fr”
Nous pouvons voir dans cette commande 2 processes : le bash et la commande ping. Le process Bash aura le PID1 et la commande ping un autre numéro de PID (aléatoire)
Lors de l’arret du container, un arret du PID1 va être envoyé au container mais pas aux autres processes (ex la commande ping dans notre exemple), ce qui peut être problématique si nous souhaitons arreter “proprement” les processus fils (plus d’info ici.).
Tandis que le mode exécutable => CMD [“ping”,”www.google.fr“] permettra à la commande ping d’avoir le PID 1 et donc d’avoir un arret “propre” lors de l’arret du container.
Il est donc préférable d’utiliser le mode EXEC en dernière instruction de notre Dockerfile.
Les commande RUN, ENTRYPOINT et CMD utilisent ces 2 modes .

Exemple avec RUN

RUN mkdir/opt/test.txt  (mode Shell) ou  RUN ["/bin/sh", "-c", "mkdir /opt/test.txt"]  (mode Execution)
#Installation d'un package avec yum :
RUN yum update -y && yum install-y wget
#Tips : il faut s'assurer que tout est à jour "yum update" avant le déploiement de nouveaux packages
# Un autre exemple pour notre image nginx
# Donner uniquement les droits sur un certificats à Root
RUN chmod600 /etc/nginx/server.key

Exemple avec CMD et ENTRYPOINT

# Voici un exemple pour mixer les commandes ENTRYPOINT et CMD
ENTRYPOINT ["nginx"]
CMD ["-g", "daemon off;"]
# Le résultat sera le lancement de nginx en dernière opération avec un PID 1
# et des options associés à cette commande grace à l'ajout de CMD.
# CMD peut être surchargée au moment de l'appel, pas l'entrypoint.
# donc possibilité de changer les options de nginx

Tagger une image :
Le “Tag” d’image veut simplement dire versionner notre image et donc pouvoir l’identifier dans une chaine d’intégration continue et de stockage à travers le registry.
Il est indispensable pour tout developpeurs de tagger son code et de gerer le versionning à travers cette commande.

# Comment versionner ou tagger une image une image
$ docker image  build --file/etc/Docker/Dockerfile_monnginx--tag smartwave/nginx_secured:2.5 .
# Si le tag est omis, le status "LATEST" sera inséré dans le répertoire.

L’historique d’une image (ses différentes layers) est possible avec la commande docker history :

$ C:\> docker image historynginx
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
40960efd7b8f        2 weeks ago         /bin/sh-c #(nop)  CMD ["nginx" "-g" "daem...   0B
<missing>           2 weeks ago         /bin/sh-c #(nop)  STOPSIGNAL [SIGTERM]         0B
<missing>           2 weeks ago         /bin/sh-c #(nop)  EXPOSE 80/tcp                0B
<missing>           2 weeks ago         /bin/sh-c ln-sf /dev/stdout/var/log/ngi...   22B
<missing>           2 weeks ago         /bin/sh-c set-x  && apt-get update  && a...   53.1MB
<missing>           2 weeks ago         /bin/sh-c #(nop)  ENV NJS_VERSION=1.13.6....   0B
<missing>           2 weeks ago         /bin/sh-c #(nop)  ENV NGINX_VERSION=1.13....   0B
<missing>           2 weeks ago         /bin/sh-c #(nop)  LABEL maintainer=NGINX ...   0B
<missing>           2 weeks ago         /bin/sh-c #(nop)  CMD ["bash"]                 0B
<missing>           2 weeks ago         /bin/sh-c #(nop) ADD file:45233d6b5c9b91e...   55.3MB

Les differentes commandes de copie utilisables dans un Dockerfile:
Nous utiliserons la plupart du temps l’instruction COPY en place de ADD pour éviter la décompression des fichiers TAR ou ZIP que nous souhaitons copier dans l’image.

# Command ADD : ajoute des fichiers (local ou en remote) dans l'image 
# Attention, il décompresse automatiquement les fichiers compressés
ADD SOURCE DESTINATION_DS_IMAGE
ADD http://example.com/big.tar.xz /usr/src/things/
# Command COPY : plus de fonctionnalité que ADD (exemple *.*)
# ne fait pas de décompression automatique.
COPY SOURCE DESTINATION_DS_IMAGE
COPY nginx.conf /etc/nginx/nginx.conf

La commande LABEL
C’est une instruction très utile pour ajouter des métadata à son image. En effet, rien de plus rageant d’utiliser une image sans avoir des informations
supplémentaires et pertinentes sur son créateur, la date de création, la version commerciale, le descriptif ….
En bref, plus votre image sera “labelisée” plus son contenu sera identifié dans votre registry.

$ La commande LABEL est utilisée pour ajouter des metadata dans l'image
LABEL KEY=VALUE
LABEL version="1.0"
LABEL description="voir un texte sur  \
plusieurs lignes."
# Comment vérifier les labels d'une image
$ docker image inspect -f {{.Config.Labels}} image_id

La commande WORKDIR

# L'instruction WORKDIR permet de se déplacer dans l'arboresence de l'image.
# Exemple, nous nous plaçons dans le répertoire de /etc/nginx avant de poursuivre les commandes du Dockerfile
$ WORKDIR /etc/nginx
# Attention, WORKDIR doit toujours contenir un chemin absolu.

RECAPITULATIF :

Une image Docker se crée en se basant sur des images Docker OS de référence :

soit en exécutant un container de l’image Docker OS de référence, puis en l’enrichissant avec les applications à installer et enfin en l’enregistrant en tant qu’image
soit en créant un Dockerfile utilisant l’image Docker OS de référence et décrivant les applications à installer, puis en laissant construire l’image par Docker avec ce Dockerfile.

DOCKERISATION D’UN MIDDLEWARE

Une recherche rapide sur GitHub, nous permet d’obtenir un Dockerfile et ces dépendances permettant la création d’une image Docker contenant Weblogic 12c :
Attention ce Dockerfile est beaucoup plus complexe mais il vous montre toutes les possibilités d’un tel fichier.

# Telechargement image de base sous linux
# ---------------
FROM oraclelinux:7.0
# Maintainer
# ----------
MAINTAINER Mohamed Bouchenafa <mbouchenafa@smartwavesa.com>
# Install wget
# -------------
RUN yum -y installwget
# Download WebLogic 12.1.3
# -------------------------
RUN wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http://www.oracle.com/; oraclelicense=accept-securebackup-cookie""http://download.oracle.com/otn-pub/java/jdk/8u25-b17/jdk-8u25-linux-x64.rpm"
# Environment variables required for this build (do NOT change)
# --------------------------------------------------------------
ENV WLS_PKG  fmw_12.1.3.0.0_wls.jar
ENV JAVA_RPM jdk-8u25-linux-x64.rpm
ENV MW_HOME  /u01/oracle/weblogic
# WLS Admin Password (you may change)
# This password is used for:
#  (a) 'oracle' Linux user in this image
# -----------------------------------
ENV ADMIN_PASSWORD welcome1
# Install and configure Oracle JDK 8u25
# -------------------------------------
RUN rpm -i $JAVA_RPM && \
    rm$JAVA_RPM
ENV JAVA_HOME /usr/java/default
ENV CONFIG_JVM_ARGS -Djava.security.egd=file:/dev/./urandom
 
# Configuration utilisateur et packages
# ------------------------------------------------------------
RUN mkdir/u01&& \
    chmoda xr /u01&& \
    useradd-b /u01-m -s /bin/bashoracle && \
    echooracle:$ADMIN_PASSWORD | chpasswd
# Add files required to build this image
# ------------------------------------------
COPY $WLS_PKG /u01/
COPY setup/* /u01/
# Change the open file limits in /etc/security/limits.conf
# ---------------------------------------------------------
RUN sed-i '/.*EOF/d'/etc/security/limits.conf && \
    echo"* soft nofile 16384">> /etc/security/limits.conf && \
    echo"* hard nofile 16384">> /etc/security/limits.conf && \
    echo"# EOF">> /etc/security/limits.conf
# Modification du kernet
-----------------------------------------------------
RUN echo"net.core.rmem_max=4192608"> /u01/oracle/.sysctl.conf && \
    echo"net.core.wmem_max=4192608">> /u01/oracle/.sysctl.conf && \
    sysctl -e -p /u01/oracle/.sysctl.conf
# Ajustement des permissions du FS /u01 comme user 'oracle' pour effectuer la WLS installation
RUN chownoracle:oracle -R /u01
WORKDIR /u01
USER oracle
# Installation of WebLogic
# -------------------------
RUN mkdir/u01/oracle/.inventory
RUN java -jar $WLS_PKG -silent -responseFile /u01/install.file-invPtrLoc /u01/oraInst.loc -jreLoc $JAVA_HOME
RUN rm$WLS_PKG /u01/oraInst.loc /u01/install.file
WORKDIR /u01/oracle/weblogic
USER oracle
# Lancement de bash comme etape finale
# --------------------------------------
CMD ["/bin/bash"]

GESTION DES IMAGES

Commiter les modifications effectuées dans une image:
Parfois certaines modifications ne se font pas au sein d’un Dockerfile mais directement dans le shell du container. ll est tout de même possible d’enregistrer toutes ces modifications dans l’image d’origine.
Attention , cette pratique est déconseillée et est utilisable que pour des cas particuliers (Troubleshooting, ..)

# Commiter les modifications dans l'image
# la syntaxe est "docker container commit container_name repository:tag"
$ docker commit mon_nginx  smartwave/nginx_secured:3

Comment sauvegarder une image dans un fichier TAR.

$ docker image save -o file.tarsmartwave/nginx_secured:3

LE REGISTRY DOCKER

Un registry (officiel ou non) est une plateforme qui vous permet de stocker vos images Docker et de les distribuer par la suite.
Un système de versionning des image Docker est intégré dans la plateforme.
C’est un élément important dans votre eco-système Docker car il permet de garantir la sécurité des images utilisées.
Vous pour trouver une très bonne explication du Docker Hub officiel ici : (docker-hub)
Comment renommer une image et stocker une nouvelle image dans un registry privé

# Faire un pull d'une image qui se trouve dans le registry officiel Docker
$ docker image pull alpine
# Renommer le Tag de l'image (localhost:8000 est notre repo. privé)
$ docker image tag alpine localhost:8000/nouveau_nom
# Pousser l'image renommée dans notre repo
$ docker image push localhost:8000/nouveau_nom
# On fait la même chose sur Amazon AWS
# Buid d'une image beta
$ docker image build -t image_beta .
# Renommage de l'image
$ docker image tag image_beta:latest 687019238689.dkr.ecr.eu-west-1.amazonaws.com/image_beta:latest
# Push de l'image dans Amazon ECR
$ docker image push 687012238689.dkr.ecr.eu-west-1.amazonaws.com/image_beta:latest

Nous venons de voir qu’il est possible de gérer le push/pull d’une image dans le registry de Docker mais aussi en privé et finalement dans le cloud.

LE MONITORING ET L’ADMINISTRATION DE DOCKER

Qui parle d’architecture, parle de monitoring et d’exploitation car la production de toutes ces images necessitent une certaine organisation.
Heureusement Docker nous fournit un ensemble d’outils essentiels pour assurer cette partie.
Comment suivre les logs d’un container ?

# Commande qui nous produit les 5 dernieres lignes de logs du container Cassandra
$ docker container logs --tail5 mon_nginx
# les logs depuis une date précise
$ docker container logs --since 2017-11-24T11:00 mon_nginx

Comment surveiller les ressources de mon container ?

# Commande TOP (comme sur Linux)
docker container topcassandra

Comment surveiller les ressources consommées par mes containers sur mon Hôte ?

# Commande pour surveiller un container en particuler
docker container stats cassandra
# pour surveiller tous les containers
docker container stats  --all

Comment limiter les ressources d’un container ?

# limiter les ressources CPU (à 50%) et mémoire au lancement
$ docker container run -d --name nginx --cpu-shares 512 --memory 256M -p 8082:80 nginx
# limiter les ressources d'un container en cours d'execution
$ docker container update --cpu-shares 512 --memory 128M --memory-swap 256M nginx_limited

Comment retarder le stop d’un container ?
Bien que bizarre, cette commande est utilise lorsque l’application dockerisée à un processus d’arret assez long (plus que 10s).
Elle évite un kill “tranchant” sur notre application et lui laisse le temps de finir sa procédure de fermeture.
Les bases de données sont souvent visées par ce comportement.

# Retarder le stop de Cassandra de 60s
$ docker container stop -t 60 cassandra

Comment supprimer tous les containers déja stoppés ?

C:\Users> docker container prune
WARNING! This will remove all stopped containers.
Are you sure you want to continue? [y/N]
# Comment supprimer un container précis
$ docker container stop nginx3 && docker container rmnginx3
# Ajouter -f pour forcer un arret de container et éviter une double commande

Comment lister la redirection des ports d’un container ?

# commande simple
$ docker container port cassandra
 
# commande plus complexe
$ docker inspect --format='{{range $p, $conf := .Config.ExposedPorts}} {{$p}} {{end}}'containerid
80/tcp-> 8000

Comment exécuter une commande shell dans un container en cours d’exécution ?

# La commande exec permet les exécutions unitaires dans le container
$ docker execcontainer1 /bin/sh-c 'echo"ajout de data"> /tmp/temp.txt