Docker pas à pas sur une application Symfony2 – Partie 1 – Présentation

A l’ère du cloud, du big data et de la virtualisation, une technologie sort son épingle du jeu et prend de plus en plus d’ampleur dans le monde de l’opensource.

Jusqu’à aujourd’hui, nous trouvions des applications prêtes à l’emploi sous forme d’images (ISO, VMDK, OVF…) embarquant toute la couche d’applications et le système d’exploitation compatible grâce à plusieurs technologies telles que VMWARE, CITRIX XEN, QEMU ou encore VirtualBox.

Docker est une petite révolution dans le monde de la virtualisation qui change aujourd’hui les règles.
C’est cette nouvelle technologie que je vais vous présenter dans cet article.

Introduction

Pourquoi un article sur docker ? Il y a en a tellement me direz-vous !
Au commencement de ma phase d’intégration de docker au sein de Webnet, j’ai dû faire un travail de R&D important.
Je n’ai cependant pas trouvé un seul article complet intégrant toutes les briques à utiliser et un tutorial clé en main pour monter une application fonctionnelle.
Cet article aura aussi pour but de faire un retour d’expérience sur l‘intégration de docker dans une infrastructure déjà rodée et fonctionnelle.

Présentation

Un peu de théorie et d’explications sont nécessaires avant de passer à la pratique 😉

Docker est un logiciel open source (licence apache 2.0) développé avec le langage Go.

Docker est à mi-chemin entre la virtualisation et l’automatisation qui permet d’isoler des applications et ses dépendances sans système d’exploitation dans des containers indépendants de la plateforme système sur laquelle elle se lance. Ces derniers pourront être exécutés sur n’importe quel serveur Linux en quelques secondes.

Il permet donc d’améliorer les performances, d’étendre la portabilité et la flexibilité que ce soit sur une machine physique, un cloud privé/public ou encore une machine virtuelle.

Docker n’est pas limité à la virtualisation d’applications mais peut aussi être utilisé pour embarquer un OS complet.

La solution n’embarque pas de système d’exploitation mais uniquement le strict nécessaire, c’est ce qui fait sa force et sa légèreté comparé à une machine virtuelle classique qui embarque systématiquement un système d’exploitation et ses dépendances. Il utilise le noyau (kernel) de l’hôte sur lequel il est lancé.

Docker n’a pas de limite, nous pouvons déployer 1000 containers sur un seul serveur physique en quelques secondes.

Un peu d’histoire

Docker a été développé par Solomon Hykes pour un projet interne de dotCloud, une société proposant une plate-forme en tant que service (PAAS), avec les contributions d’Andrea Luzzardi et Francois-Xavier Bourlet, également employés de dotCloud. docker est une évolution basée sur les technologies propriétaires de dotCloud, elles-mêmes construites sur des projets open source.

docker a été distribué en tant que projet open source à partir de mars 2013.

Au 18 novembre 2013, le projet a été mis en favoris plus de 7 300 fois sur GitHub (14e projet le plus populaire), avec plus de 900 forks et 200 contributeurs6.

Au 9 mai 2014, le projet a été mis en favoris plus de 11 000 fois sur GitHub, avec plus de 1 900 forks et 420 contributeurs6.

En février 2015, le projet a été mis en favoris plus de 35 000 fois sur GitHub, avec plus de 7 500 forks et 1 400 contributeurs.

Les principaux composants de Docker

La technologie Docker repose sur 3 composants fondamentaux :

• LXC : Linux containers
• Cgroups pour la gestion des ressources
• Le kernel Linux

LXC

Les containers linux LXC permettent de faire de la virtualisation libre pour des ordinateurs basés sous Linux/GNU.
Cela permet à un noyau hôte de faire fonctionner plusieurs unités de façon isolée et virtuelle.

Similaire aux chroots de linux, ces unités sont sécurisées et se partagent les ressources de façon optimale puisqu’elles s’exécutent sur le même noyau et une plus ou moins grande partie du système hôte.

CGROUPS

Cgroups (control groups) est inclus dans le noyau linux sous forme de fonctionnalité.
Cgroups permet de limiter, isoler et monitorer les ressources hardware (cpu, ram, espace disque…)

Kernel

Le noyau linux est un noyau de système d’exploitation de type UNIX.

Le noyau linux (kernel) est un logiciel libre développé essentiellement en langage C par des contributeurs bénévoles.

Le kernel s’occupe de fournir une interface aux logiciels afin d’utiliser le matériel.

Comparaison avec une VM classique

La virtualisation classique avec des hyperviseurs comme Citrix XenServer ou VMWare doivent créer une copie complète du système d’exploitation. L’hyperviseur est alors responsable de tous les échanges de données au sein des machines virtuelles.

Sur un même hyperviseur l’exécution simultanée de plusieurs machines virtuelles demande beaucoup de ressources pour assumer un fonctionnement correct.

Les avantages des containers par rapport aux machines virtuelles sont :

• Vitesse : rapidité et facilité de déploiement des applications, exécution du container en une commande et démarrage de celui-ci en quelques secondes
• Légèreté : un container non optimisé fait globalement en moyenne quelques centaines de Mo contre quelques Go pour une VM (Virtual Machine)
• Portabilité : un container peut être exécuté sur n’importe quel hôte Linux
• Performance : un container n’embarque pas d’OS contrairement à la virtualisation. Il y a donc moins d’utilisation de ressources mémoire. Des comparatifs officiels prouvent que docker fait jeu égal avec Linux natif, il est par contre quasiment deux fois plus performant sur des opérations de calcul d’une machine virtuelle classique sous KVM.
• Résilience : possibilité de relancer directement des containers et de former des clusters automatiquement
• Orientation micro-services : cette tendance répond à plusieurs objectifs comme :
  • Amélioration de l’élasticité d’une application
  • Augmentation des performances de l’application. Celle-ci est divisée en briques qui ont un usage précis et sont optimisées, on peut imaginer ajouter des centaines de containers sur la partie e-commerce d’un site lors de soldes pour assurer la charge sans pour autant intervenir sur la partie blog
  • Fonctionnement modulaire
• Autonomie dans les phases de développement : docker permet aussi d’augmenter la productivité des équipes de développement. Couplé avec docker compose, il suffit de préparer un répertoire de projet et une seule commande (docker-compose up) suffit à monter un environnement complet. Le développeur possède dès lors un environnement entièrement fonctionnel.
• Flexibilité : docker permet d’isoler une application en plusieurs containers, en prenant l’exemple d’une application Symfony LAMP, l’application est découpée en 3 containers (Apache/PHP, MySQL et un contenant le code Symfony). Nous verrons par la suite que cette flexibilité se révèle très intéressante dans le cas de montée en version PHP car il suffira simplement d’inter-changer le container Apache/PHP.

Ce schéma permet de comprendre un peu mieux la différence entre un container et une VM classique :

Pourquoi Docker ?

L’adoption de docker au sein de Webnet est due à un besoin précis.
Le but était d’améliorer la productivité des équipes de développement au départ d’un projet.
Nous lui avons trouvé par la suite d’autres atouts à exploiter.

Actuellement, pour le démarrage d’un projet « X » reposant sur une architecture LAMP (Apache MySQL PHP) le processus d’initialisation était le suivant :

1. Création d’une machine virtuelle de développement par l’architecte technique
2. Configuration de la machine virtuelle
   1. Installation des composants LAMP
   2. Configuration des composants LAMP
   3. Configuration de l’application

A ce stade, la VM est prête et l’environnement de développement est prêt.
La VM fait alors en moyenne 5Go à 10Go selon les projets.

Nous arrivons maintenant au moment où l’architecte technique doit mettre à disposition des équipes la VM de développement, cette opération se révèle lourde

• Exportation de la VM
• Transfert de la VM sur un espace partagé
  •  Temps de transfert conséquent
• Importation de la VM sur le poste du développeur
  • Temps de récupération conséquent

Dans le cas d’une personne travaillant sur plusieurs projets, ces opérations peuvent être lourdes et faire perdre beaucoup de temps pour chaque machine virtuelle à importer.

Au niveau des ressources utilisées, nous avons là aussi un point faible si on utilise un nombre conséquent de VMs sur la machine du développeur.

La démarche d’utiliser Docker dans cette phase d’initialisation de projet est de mettre à disposition un environnement de développement au développeur rapidement.

On peut trouver à Docker plusieurs autres objectifs :

• Avoir des composants homogènes (version et configuration) entre postes de DEV
• Simuler la topologie du réseau, les containers communiquent entre eux via des DNS/IP via le réseau, cela évite les problèmes lors d’un passage dans une architecture cible distribuée
• Simuler des architectures complexes, comme la répartition de charge par exemple (LoadBalancing) où il faut un minimum de 3 serveurs sans pour autant avoir à les installer et à les configurer un à un
• Améliorer le cycle d’intégration continue lors des passages en recette jusqu’à la production : Nous pouvons imaginer utiliser les mêmes containers en développement, en recette puis en production.

Architecture

Allez encore un peu de théorie avant de passer à la pratique 😉

Voici un schéma simplifié de l’architecture que nous allons mettre en place pour une application Symfony.
Ce schéma vous sera utile afin de mieux comprendre la suite de l’article :

L’application Symfony reposera sur 3 containers :

• Un container Apache 2.4 et PHP 5.6
• Un container MySQL 5.6
• Un container de fichiers qui contiendra le code

L’application Symfony sera accessible sur Internet via le DNS « dev.app1.webnet.fr » sur le port 80
La base de données MySQL sera exposée sur son port (3306) afin de pouvoir s’y connecter directement via un client (utile pendant la phase de développement par exemple).
L’adresse IP de notre machine hôte sera : 192.168.51.128
Je reviendrai plus tard sur la gestion du réseau avec Docker.

Suite de l’article : Docker pas à pas sur une application Symfony2 – Partie 2 – Installation du socle technique