Affichage des articles dont le libellé est docker. Afficher tous les articles
Affichage des articles dont le libellé est docker. Afficher tous les articles

7 déc. 2018

[Docker] Installer ELK via Docker

Installer la suite Elasticsearch Logstash Kibana n'est pas une mince affaire surtout si c'est juste pour découvrir et se faire la main. Docker peut être bien pour cela, et en prod aussi (mais ça c'est une autre histoire)

Ma configuration :

  • Machine : VM VirtualBox (5.2.22) https://www.virtualbox.org/wiki/Downloads
  • OS utilisé : Debian 9 (stretch) - Linux elasticsearch 4.9.0-8-amd64 #1 SMP Debian 4.9.130-2 (2018-10-27) x86_64 GNU/Linux
  • Docker version 18.09.0, build 4d60db4
  • curl installé sur la machine (yum install curl -y ou apt-get install curl -y)

Pré-requis (liens utiles)

Installation docker: https://docs.docker.com/install/
Installer Docker Compose : https://docs.docker.com/compose/install/

Nous allons utiliser cette configuration : https://github.com/deviantony/docker-elk

Procédure

Télécharger la dernière version :
$ wget https://github.com/deviantony/docker-elk/archive/master.zip
Décompresser l'archive et entrer dans le répertoire :
$ unzip master.zip
$ cd docker-elk-master/
Lancer la commande docker-compose up :
$ docker-compose up

Tester

maintenant vous pouvez maintenant tester l'accès à elasticsearch :
$ curl localhost:9200 #### ou curl http://:9200 depuis un autre host
{
  "name" : "OMP0ap4",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "TFSNW5vfRQqOVcJXIGR7HA",
  "version" : {
    "number" : "6.4.2",
    "build_flavor" : "oss",
    "build_type" : "tar",
    "build_hash" : "04711c2",
    "build_date" : "2018-09-26T13:34:09.098244Z",
    "build_snapshot" : false,
    "lucene_version" : "7.4.0",
    "minimum_wire_compatibility_version" : "5.6.0",
    "minimum_index_compatibility_version" : "5.0.0"
  },
  "tagline" : "You Know, for Search"
}
Tester kibana :
$ curl localhost:5601 #### ou curl http://:5601 depuis un autre host
$ curl localhost:5601
 

12 juin 2018

[DOCKER] Configurer Docker quand on est derrière un proxy

Dans mon entreprise, en essayant de d'utiliser Docker après avoir installé la version Docker CE sur
une CentOS 7 (sur une VM VirtualBox) je me suis heurté à un message d'erreur.

# docker pull hello-world
Using default tag: latest
Error response from daemon: Get https://registry-1.docker.io/v2/: EOF
Me doutant que c'était probablement un problème réseau et plus particulièrement "proxy", j'ai chercher comment permettre au service Docker d'utiliser les paramètres de mon serveur mandataire.

Je suis tombé là dessus : https://github.com/moby/moby/issues/32270 . Je vous traduit ci-dessous la marche à suivre.

Pour configurer le proxy sur Docker, suivez les instructions suivantes

Créer un répértoire destiné au service docker :
# sudo mkdir /etc/systemd/system/docker.service.d
Créer le fichier pour le HTTP:
# sudo vim /etc/systemd/system/docker.service.d/http-proxy.conf
et mettre les lignes suivantes (à adapter)
[Service]
Environment="HTTP_PROXY=http://:/"
Créer le fichier pour le HTTPS:
# sudo vim /etc/systemd/system/docker.service.d/https-proxy.conf
et mettre les lignes suivantes (à adapter)
[Service]
Environment="HTTPS_PROXY=https://:/"
Recharger systemctl puis redémarrer docker :
# sudo systemctl daemon-reload
# sudo systemctl restart docker
Retester le pull hello-world:
# docker pull hello-world
Using default tag: latest
latest: Pulling from library/hello-world
Digest: sha256:f5233545e43561214ca4891fd1157e1c3cxxxxxxxxxxxxxxxxxxxx
Status: Image is up to date for hello-world:latest
Et voilà !

29 févr. 2016

[DOCKER] Quoi de neuf docker: une websérie à voir

Je suis tombé récemment sur un article de developpez.com qui évoquait la série "Quoi de neuf Docker" qui a pour but d'expliquer ce qu'est Docker et exposer ses fonctionnalités et concepts.

Vidéos:






Vous pouvez aller sur sa chaine Youtube: https://www.youtube.com/channel/UCOAhkxpryr_BKybt9wIw-NQ

27 févr. 2016

[DOCKER] Subuser, une sur-couche à Docker

Subuser est une sur-couche à Docker, il permet de lancer des logiciels dans des
conteneurs, avec un système simple de gestion des permissions, et un accès au serveur X. Subuser transforme les conteneurs Docker en programmes GNU/Linux normaux.

À propos…

Subuser permet de transformer un conteneur Docker en un programme normal, mais sans lui donner tous les privilèges, ainsi par exemple il ne peut accéder qu'au répertoire d'où il est appelé, et non le /home complet de l'utilisateur.

Chaque subuser se voit attribuer un jeu de permissions, de façon similaire à Android, voici un exemple de fichier permissions.json (tiré de la documentation):
{
  "description"                : "A web browser."
  ,"maintainer"                : "Timothy Hobbs "
  ,"executable"                : "/usr/bin/firefox"
  ,"user-dirs"                 : ["Downloads"]
  ,"gui"                       : {"clipboard":true,"cursors":true}
  ,"sound-card"                : true
  ,"allow-network-access"      : true
}
On sort ainsi du schéma « toutes les permissions ou rien » qui est la règle sur Android.

Subuser utilise la même syntaxe que les Dockerfile de Docker, ainsi il n'est pas nécessaire d'en apprendre une nouvelle.

L'accès au serveur X est sécurisé grâce à l'utilisation d'un pont X11 « Xpra », cf. les explications (en anglais).

L'architecture est distribuée, il est facile à n'importe qui d'ajouter son propre dépôt, la commande « subuser pkg » permet de maintenir les dépôts.

Utilisation de Git pour l'historique (le « registre ») : il est possible de facilement revenir en arrière si une mise à jour ne vous plaît pas, ou de bloquer les mises à jour si vous voulez rester sur une version précise. La commande « subuser registry log » permet de savoir ce qui a été installé ou mis à jour.

Philosophie

N.D.R. : j'ai eu l'occasion de rencontrer et discuter avec l'auteur de Subuser, c'est une personne très intéressante et qui a une vraie réflexion éthique et politique autour de son projet

Subuser est construit autour d'une réflexion politique et technique. Pour situer un peu l'auteur, on peut lire ce texte (en anglais) qui décrit ce qu'il appelle les « logiciels égalitaires ».

Dans les réflexions autour de Subuser, outre les aspects sécuritaires évidents, il y a une volonté de pouvoir utiliser un logiciel dans une version précise indéfiniment.
En effet, qui n'a jamais pesté après avoir vu une fonctionnalité disparaître ou une interface changer suite à une mise à jour sur un logiciel auquel il était habitué et qui le satisfaisait parfaitement ? Ou encore, après avoir vu un logiciel ne plus fonctionner à cause d'une mise à jour ou d'un changement du système d'exploitation ?

Subuser en comparaison avec xdg-app

N.D.R. : Subuser peut se comparer à xdg-app, aussi j'ai posé la question à l'auteur pour savoir ce qu'il en pensait, voici sa réponse (traduction en français plus bas):
Xdg-app and subuser are very similar.

Subuser is about 9 months older than xdg-app and Alex Larson knew about
subuser when he wrote xdg-app. When I talked to him about his reason for
not just using subuser, he explained to me that he did not think that
Docker was a good candidate for packaging desktop applications. Xdg-app
has one big advantage in it's current state over subuser/Docker. It uses
OSTree, which allows for seamless data deduplication across images.
That's a really nice feature as it saves a lot of diskspace and makes
downloading images a lot faster.

N.D.R. : cette fonctionnalité est envisagée également dans Subuser, cf. le paragraphe « Futur »

There are other philosophical differences as well. Subuser images are
meant to last forever and be portable, therefore, they are monolithic.
Xdg-app doesn't have the goal of either perfect portabilty or
everlasting images. Instead, xdg-app works more like traditional linux
software distribution. You can create an image for xdg-app and that
image relies on libraries such as the "gnome-runtime" those libraries
can be updated independently of the image. Subuser doesn't allow such a
feature because there is no way of guaranteeing that a new library will
be compatible with an old image.

The next difference is that of portability. Xdg-app is very interested
in making sure that xdg-apps integrate well with gnome. They are
planning features to connect up dbus services which will allow xdg-apps
to, for example, access your gnome contacts list or your gnome
calendar. Subuser values portablilty and security over gnome
integration and so the subuser user experience may suffer as a result.
There is another face to this same issue. Xdg-app is trying to define
new dbus interfaces to allow xdg-apps to communicate with the outside
world. This means, that if you want your xdg-app to access the file
system, it will have to implement a new dbus file access API. Subuser
tries very hard to avoid such new interfaces and preferes to try to
emulate existing POSIX/LINUX protocols and APIs.

Yet another difference is that subuser allows you to have multiple
subusers for a single image. This is usefull for web browsing. For
example, I can have a subuser for internet banking and another subuser
for typical web browsing and a third subuser for using google services
ect. And all of these subusers can share the same firefox/iceweasel
image. This allows for finer grained security policy than is possible
with xdg-app.
traduction:
Xdg-app et Subuser sont très similaires.

Subuser est environ 9 mois plus vieux que Xdg-app et Alex Larson le connaissait quand il a écrit Xdg-app. Quand je lui ai demandé les raisons pour ne pas utiliser Subuser, il m'a expliqué qu'il ne pense pas que Docker soit un bon candidat pour empaqueter des applications de bureau.

Xdg-app a pour le moment un gros avantage par rapport à Subuser/Docker : il utilise OSTree, qui permet une dé-duplication des données homogène à travers les images. C'est une fonctionnalité vraiment chouette : ça économise beaucoup d'espace disque et permet un téléchargement des images beaucoup plus rapide.

N.D.R. : cette fonctionnalité est envisagée également dans Subuser, cf. le paragraphe « Futur »

Il y a d'autres différences philosophiques. Les images Subuser sont pensées pour fonctionner éternellement et être portables, et par conséquence, sont monolithiques.
Xdg-app n'a pour but ni une portabilité parfaite ni des images éternelles. Au contraire, Xdg-app fonctionne plus comme un système de distribution de logiciels Linux traditionnel. Vous pouvez créer une image pour Xdg-app, et cette image va se baser sur des bibliothèques comme le « gnome-runtime », bibliothèques qui peuvent être mises à jour indépendamment de l'image. Subuser ne permet pas ce type de fonctionnalité parce qu'il n'y a aucun moyen de garantir qu'une nouvelle bibliothèque sera compatible avec une ancienne image.

Le point de divergence suivant est la portabilité. Xdg-app cherche vraiment à être sûr que les applications Xdg-app s'intègrent bien avec Gnome. Ils prévoient des fonctionnalités pour connecter un service D-Bus qui va permettre aux applications Xdg-app de, par exemple, accéder à la liste de contacts de Gnome ou à votre calendrier Gnome. Subuser préfère la portabilité et la sécurité à l'intégration à Gnome, aussi l'« expérience utilisateur » des utilisateurs de Subuser peut être moins bonne à cause de cela.
Il y a une autre facette à ce problème : Xdg-app veut définir de nouvelles interfaces D-Bus pour permettre aux applications Xdg-app de communiquer avec le monde extérieur. Ceci signifie, que si vous voulez que votre application Xdg-app accède au système de fichiers, elle devra implémenter une nouvelle API pour accéder aux fichiers via D-Bus. Subuser essaye autant que possible d'éviter ce type de nouvelle interface, et préfère émuler le protocole et les API POSIX/Linux existantes.

Un autre point de divergence est que Subuser permet d'avoir plusieurs « subusers » (N.D.T. : sous-utilisateurs) pour une même image. C'est pratique pour naviguer sur le web. Par exemple, j'ai un subuser pour mes comptes sur Internet, un autre pour la navigation web traditionnelle, et un troisième pour utiliser les services de Google, etc. Et tous ces « subusers » peuvent partager la même image Firefox/Iceweasel (N.D.T. : et bientôt Firefox/Iceweasel). Ceci permet une politique de sécurité plus fine qu'il n'est possible avec Xdg-app.

Il faut bien noter une conséquence majeure de ce que l'auteur explique avec D-Bus : xdg-app demande une modification des logiciels qui doivent appeler des fonctions spécifiques, tandis que Subuser permet d'utiliser un logiciel sans modification.

Futur

Le projet est déjà fonctionnel et tout à fait utilisable. L'auteur aimerait utiliser OSTree ou un mécanisme de dé-duplication similaire dans les prochaines versions.

Il est également envisagé de remplacer Docker par une autre solution, ainsi que l'indique l'auteur suite à une question sur les permissions dynamiques (qui permettraient par exemple l'accès à un répertoire en fonction d'un argument du logiciel et non uniquement au répertoire courant ou spécifié dans la configuration) :
The plan is to move away from Docker and use runC directly. That will fix that problem, and then we will be able to have things like file dialogs which automatically grant permission to access a file…
traduction:
L'idée est de quitter Docker et utiliser runC directement. Cela règlera le problème, et alors il sera possible d'avoir des choses comme une boite de dialogue qui accorde automatiquement des autorisations d'accès à un fichier…
Comment aider ?

L'auteur aimerait beaucoup voir Subuser être empaqueté dans les distributions GNU/Linux, aussi si un développeur Debian, par exemple, lit cette dépêche et souhaite aider le projet, ce serait une contribution précieuse (c'est valable également pour les autres distributions bien entendu).

Source : http://linuxfr.org/news/subuser-une-sur-couche-a-docker

5 févr. 2016

[DOCKER] trouver et utiliser whalesay (ETAPE 3)

Traduction depuis le site https://docs.docker.com/linux/step_three/
 
Des gens tout autour du monde créés des images Docker. Vous pouvez trouver ces images en parcourant le site internet "Docker Hub". Dans cette section, c'est exactement ce que vous allez faire, c'est-à-dire, trouver l'image et l'utiliser.

Etape 1: Localiser l'image nommée "whalesay"
 

1 - Ouvrir votre navigateur et aller sur le site Docker Hub


Le site Docker Hub contient des images dont l'origine provient d'individus comme vous et moi et d'organisation telles que RedHat, IBM, Google, etc.

2 - Rechercher le mot clé "whalesay" dans le moteur de recherche


3 - Cliquer sur "docker/whalesay" dans les résultats de recherche, cela va afficher le repository pour whalesay

Chaque repository d'image contient des informations la concernant telle que le type de logiciel que contient cette image et comment l'utiliser.
Vous pouvez notez que l'image whalesay est basée sur la distribution Linux UBUNTU. La prochaine étape consiste à lancer whalesay depuis votre machine de test.

Étape 2: Lancer whalesay

1 - Retourner sur votre shell
Taper:
$ docker run docker/whalesay cowsay boo
Unable to find image 'docker/whalesay:latest' locally
latest: Pulling from docker/whalesay
2880a3395ede: Pull complete
515565c29c94: Pull complete
98b15185dba7: Pull complete
2ce633e3e9c9: Pull complete
35217eff2e30: Pull complete
326bddfde6c0: Pull complete
3a2e7fe79da7: Pull complete
517de05c9075: Verifying Checksum
8f17e9411cf6: Download complete
ded5e192a685: Download complete
Pulling repository docker.io/docker/whalesay
fb434121fc77: Download complete
e9e06b06e14c: Download complete
a82efea989f9: Download complete
37bea4ee0c81: Download complete
07f8e8c5e660: Download complete
676c4a1897e6: Download complete
5b74edbcaa5b: Download complete
1722f41ddcb5: Download complete
99da72cfe067: Download complete
5d5bd9951e26: Download complete
Status: Downloaded newer image for docker/whalesay:latest
docker.io/docker/whalesay: this image was pulled from a legacy registry.  Important: This registry version will not be supported in future versions of docker.
 _____
< boo >
 -----
    \
     \
      \
                    ##        .
              ## ## ##       ==
           ## ## ## ##      ===
       /""""""""""""""""___/ ===
  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
       \______ o          __/
        \    \        __/
          \____\______/

La première fois que vous lancer une image, la commande docker devrait ressembler à ça. Si l'image n'est pas présente, docker s'occupera de la télécharger depuis Docker Hub.

2 - La commande suivante permet de lister les images sur votre système en local. vous devrez voir docker/whalesay dans la liste
Entrer
$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
hello-world         latest              0a6ba66e537a        3 months ago        960 B
docker/whalesay     latest              fb434121fc77        8 months ago        247 MB
                            3a2e7fe79da7        8 months ago        247 MB
Quand vous lancer une image dans un container, Docker télécharge l'image sur votre ordinateur. Cette copie en locale vous fait gagner du temps. Docker re-télécharge seulement l'image seulement si la source a changé sur Docker Hub. Vous pouvez bien évidement supprimer l'image par vous-même. Vous l'apprendrez plus tard, pour le moment nous pouvons laisser l'image sur la machine car nous aurons à l'utiliser plus tard.

3 - Prenons un moment pour s'amuser avec le container whalesay.

Essayez de lancer whalesay encore en remplaçant "boo" par autre chose:
Entrer:
$ docker run docker/whalesay cowsay Salut-on-s-amuse-bien-avec-Docker!
 ____________________________________
< Salut-on-s-amuse-bien-avec-Docker! >
 ------------------------------------
    \
     \
      \
                    ##        .
              ## ## ##       ==
           ## ## ## ##      ===
       /""""""""""""""""___/ ===
  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
       \______ o          __/
        \    \        __/
          \____\______/

[DOCKER] Images et Containers ? (ETAPE 2)

Cet article concerne la partie 2 du tutoriel Docker pour Linux: https://docs.docker.com/linux/step_two/


En apprendre plus sur Images et Containers

Le moteur Docker (Docker Engine) fourni la technologie core Docker qui permet d'activer les images et containers.
Lors de la première partie de l'installation, la commande hello-world (docker run hello-world) a utiliser une tâche "core" via le moteur Docker.
Cette commande comporte 3 parties

  • docker: commande docker installée sur votre système d'exploitation (ici GNU/Linux)
  • run: option de la commande docker qui permet de créer et lancer un container
  • hello-world: indique à docker quelle image doit être chargée dans le container
Qu'est-ce qu'un Container ?

Un container est une version minimal de Linux.

Qu'est-ce qu'une Image ?

Une image est un logiciel que l'on charge dans le container.

Quand on lance la commande docker, le moteur logiciel (Engine software):
  • Vérifier si l'image hello-world est présente
  • Télécharge l'image depuis Docker Hub (plus à ce sujet dans le chaptire suivant)
  • Charge l'image dans le container et la lance
Dépendant du comment elle est construite, une image pourrait lancer une simple et unique commande et ensuite se finir. C'est ce que "Hello-world" fait.

Une image Docker, est néanmoins capable de beaucoup plus que ça. Une image peut démarrer un programme aussi complexe qu'une base de donnée, attendre que vous (ou un tier) ajoute des donnée, stoque les données pour les utiliser plus tard et attendre un autre utilisateur.

Qui a créer l'image "hello-world" ?

Ici, c'est Docker qui l'a développé, mais tout un chacun peut créer des images. Le moteur Docker (Docker Engine) laisse les personnes ou les entreprises créer et partager des logiciels à travers les images Docker. Concernant l'utilisation du moteur, vous n'avez pas à vous soucier à propos des capacités de votre ordinateur à lancer les images - un container peut toujours le faire.

4 févr. 2016

[DOCKER] Commencer avec Docker sous Linux (ETAPE 1)

J'ai testé le tutoriel "Get Started with Docker for Linux" (source : https://docs.docker.com/linux/)

Ce tuto est destiné à toute personne intéressée pour en apprendre plus de Docker (ce qui est mon cas!)
Il sera a moitié en Anglais et mes commentaires en Français "rouge italique citation"

Commençons ...

This getting started is for non-technical users who are interested in learning about Docker. By following this getting started, you’ll learn fundamental Docker features by performing some simple tasks. 

  You’ll learn how to:
  • install Docker
  • run a software image in a container
  • browse for an image on Docker Hub
  • create your own image and run it in a container
  • create a Docker Hub account and an image repository
  • create an image of your own
  • push your image to Docker Hub for others to use
The getting started was user tested to reduce the chance of users having problems. For the best chance of success, follow the steps as written the first time before exploring on your own. It takes approximately 45 minutes to complete.
Make sure you understand…

This getting started uses Docker commands with a terminal window. You don’t need to be experienced using a command line, but you should be familiar with how to open one and type commands.
Il faut suivre scrupuleusement les étapes pour espérer que ça fonctionne, cela devrait durer 45 minutes. Pas besoin d'être un pro de la ligne de commande mais ça peut servir...
Installer Docker
Dans mon cas, je dispose d'une machine virtuelle 1Go de RAM, le système d'exploitation est Ubuntu 14.04.3 LTS
This installation procedure is written for users who are unfamiliar with package managers. If you are comfortable with package managers, prefer not to use wget, or have problems installing and want to troubleshoot, please use our apt and yum repositories instead for your installation.

1 - Log into your Ubuntu installation as a user with sudo privileges.
2 - Verify that you have wget installed.

Taper:
root@docker:~# which wget
/usr/bin/wget
If wget isn’t installed, install it after updating your manager:
Taper:
$ sudo apt-get update
$ sudo apt-get install wget
3 - Get the latest Docker package.
Taper:
$ wget -qO- https://get.docker.com/ | sh
The system prompts you for your sudo password. Then, it downloads and installs Docker and its dependencies.

Note: If your company is behind a filtering proxy, you may find that the apt-key command fails for the Docker repo during installation. To work around this, add the key directly using the following:


Penser à faire un export https_proxy="http://proxy:8080/" si vous êtes derrière un proxy ...
$ wget -qO- https://get.docker.com/gpg | sudo apt-key add -
4 - Verify docker is installed correctly.
Taper:
$ sudo docker run hello-world
sudo: unable to resolve host docker
Unable to find image 'hello-world:latest' locally
Pulling repository docker.io/library/hello-world
Error while pulling image: Get https://index.docker.io/v1/repositories/library/hello-
world/images: dial tcp: lookup index.docker.io: no such host
Dans mon cas ça ne s'est pas passer comme prévu car j'utilise un Proxy, pour résoudre ce problème. Suivre les instructions suivantes:
Editer /etc/default/docker
Taper:
$ sudo vim /etc/default/docker
ajouter les lignes suivantes:
export http_proxy="http://10.250.0.5:8080/"
export https_proxy="http://10.250.0.5:8080/"
export HTTP_PROXY="http://10.250.0.5:8080/"
export HTTPS_PROXY="http://10.250.0.5:8080/"

(10.250.0.5 à remplacer par votre proxy...)
Redémarrer le service docker
# service docker restart
docker stop/waiting
docker start/running, process 5072
Relancer la commande docker

root@docker:~# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
b901d36b6f2f: Pull complete
0a6ba66e537a: Pull complete
Digest: sha256:8be990ef2aeb16dbcb9271ddfe2610fa6658d13f6dfb8bc72074cc1ca36966a7
Status: Downloaded newer image for hello-world:latest

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 which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker Hub account:
 https://hub.docker.com

For more examples and ideas, visit:
 https://docs.docker.com/userguide/

SOURCE: https://docs.docker.com/linux/step_one/




2 févr. 2016

[DOCKER] C’est quoi et à quoi ça sert ?

Présentation de Docker

Docker a révolutionné le monde du logiciel open-source et du cloud. Inventé par Solomon Hykes et Sébastien Barbier, cet outil innovant permet de pallier à tous les problèmes actuels du cloud computing tels que le déploiement d’applications et le packaging. Quelques points bons à savoir sur l’utilité et les avantages de ce logiciel open-source.

Docker : à quoi ça sert ?

Docker permet d’automatiser le déploiement d’applications dans des conteneurs logiciels grâce à une API simple. Avec cet outil, il sera possible d’ajouter plusieurs applications ainsi que ses dépendances dans un container virtuel qui pourra par la suite être lancé sur tous types de serveurs comme Linux. Son principal objectif est de rendre faciles la gestion des conteneurs et les déploiements des applications. Grâce à un hub collaboratif, Docker offre à tout le monde l’opportunité de mettre rapidement en place un système de conteneur et de faire un partage d’images. Ces dernières pourront après être servies pour réaliser la base de construction des conteneurs. À signaler qu’il sera possible de basculer une application entre les clouds de Google, de Microsoft et d’Amazon en utilisant Docker.

Docker : en quoi est-ce avantageux ?

Praticité, portabilité, facilité des déploiements et de gestion, nombreuses sont les raisons d’opter pour cet outil disponible en juin 2014. Contrairement à la virtualisation, Docker est beaucoup plus léger parce qu’elle ne nécessite pas l’utilisation d’un OS supplémentaire grâce au container. En plus, l’exécution des applications se fait automatiquement, sans avoir besoin de passer par la lourde procédure d’installation. D’où la rapidité du lancement qui facilitera les tâches des développeurs et des testeurs. La ligne de commande est capable en elle-même de charger le container et de l’exécuter. Ce n’est pas tout, c’est facile de lancer et d’arrêter les containers en fonction des besoins.

Différences majeures entre Red Hat 6, 7, 8 et 9

Quelles sont les différences majeures entre RHEL 6, 7, 8 et 9 ? Système de fichiers RHEL 6: Par défaut : ext4. Autres : ext2, ext3 supportés...