1. Livres et vidéos
  2. Docker - Prise en main et mise en pratique sur une architecture micro-services (2e édition)

Docker Prise en main et mise en pratique sur une architecture micro-services (2e édition)

  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Ce livre sur Docker s'adresse à tout développeur, architecte, administrateur souhaitant aboutir à une connaissance structurée de Docker en s'appuyant sur la mise en pratique d'un exemple concret de déploiement d'une application en conteneurs. Une connaissance même minimale de Linux et des réseaux TCP/IP est un prérequis indispensable pour tirer le meilleur profit de ce livre qui est organisé en deux parties.

La première partie détaille les mécanismes constituant les fondements de Docker avec des exemples de manipulations sur des exercices pratiques. Docker faisant partie d'un écosystème foisonnant et extrêmement mouvant, l'auteur s'attache à fournir au lecteur des bases solides sur son fonctionnement et sur ses concepts les plus importants pour que son utilisation soit efficace et pour maîtriser les besoins élémentaires des utilisateurs professionnels (création d'images simples et solides, connaissance des bonnes pratiques, sécurité...).

Dans une seconde partie, l'auteur met en œuvre une infrastructure complète autour d'une application exemple, en architecture micro services. Le point de vue adopté par l'auteur est celui d'un éditeur de logiciels dont le besoin est de mettre en œuvre des services logiciels sur une architecture souple et évolutive. Cette mise en pratique sur une application réaliste permet de décrire les astuces de déploiement de conteneurs pour Java, Core .NET, Python et Node.js/AngularJS. L'application ainsi créée est ensuite déployée dans un cluster de machines géré par Docker Swarm.

Des éléments sont en téléchargement sur le site www.editions-eni.fr et sur le compte GitHub des Editions ENI. Ainsi, le lecteur est en mesure de mettre en œuvre la totalité de l'exemple traité dans le livre.


Les chapitres du livre :
Avant-propos – Introduction à Docker – Premiers pas – Création de vos propres images – Installation d'un registre privé – Mise en œuvre d'une architecture logicielle – Déploiement dans un cluster – Encore plus loin avec Docker

Table des matières

  • Introduction à Docker
    • 1. Docker comme alternative légère à la virtualisation
      • 1.1 L'approche par virtualisation
      • 1.2 Docker pour optimiser l'usage des ressources
      • 1.3 Positionnement de Docker par rapport à la virtualisation
    • 2. Principe des conteneurs
      • 2.1 Principe des conteneurs industriels
      • 2.2 Docker et l'approche normalisée
    • 3. Les fondements de Docker
      • 3.1 Namespaces
      • 3.2 Cgroups
      • 3.3 LXC
      • 3.4 Libcontainer
      • 3.5 Système de fichiers en couches
        • 3.5.1 Principe d'isolation des fichiers
        • 3.5.2 Approche par virtualisation
        • 3.5.3 Utilité des systèmes de fichiers en couches
        • 3.5.4 Gestion des modifications de fichiers
        • 3.5.5 Dernière couche en écriture
        • 3.5.6 Technologies utilisées
    • 4. Les plus de Docker
    • 5. L’écosystème Docker
    • 6. Architectures de services
      • 6.1 Historique des architectures de services
        • 6.1.1 Principes
        • 6.1.2 Approche EAI
        • 6.1.3 Approche SOA
        • 6.1.4 Microservices
        • 6.1.5 Lien à l'urbanisation des SI
      • 6.2 Architecture de microservices
        • 6.2.1 Principe
        • 6.2.2 Avantages
        • 6.2.3 Inconvénients
      • 6.3 Apport de Docker
      • 6.4 Fil conducteur
  • Premiers pas
    • 1. Installation de Docker
      • 1.1 Utiliser des machines préconfigurées
      • 1.2 Installation de Docker sur Linux
        • 1.2.1 Prérequis système
        • 1.2.2 Installation par gestionnaire de paquets
        • 1.2.3 Installation par script
      • 1.3 Installation de Docker sous Windows
        • 1.3.1 Un paradoxe résolu
        • 1.3.2 Installation sur Windows 10
        • 1.3.3 Installation sur Windows Server 2016
        • 1.3.4 Machine virtuelle
    • 2. Hello World, Docker
      • 2.1 Démarrage d'un conteneur simple
      • 2.2 Que s'est-il passé ?
        • 2.2.1 Récupération de l'image
        • 2.2.2 Anatomie de l'image obtenue
        • 2.2.3 Lancement du processus
        • 2.2.4 Arrêt du conteneur
    • 3. Utiliser des images Docker préexistantes
      • 3.1 Le Docker Store
        • 3.1.1 Le principe
        • 3.1.2 Recherche et qualification d'images
        • 3.1.3 Exemple de recherche
        • 3.1.4 Cas des images communautaires
        • 3.1.5 Compléments sur les images officielles
        • 3.1.6 Lien avec le registre Docker Hub
        • 3.1.7 Recherche par la ligne de commande
        • 3.1.8 Précautions sur une image non officielle
      • 3.2 Gestion du compte DockerHub et dépôts privés
        • 3.2.1 Création d'un compte
        • 3.2.2 Caractéristiques du compte
        • 3.2.3 Automated build et compte GitHub
        • 3.2.4 Connexion au compte en ligne de commande
        • 3.2.5 Webhook sur évènement de push dans Docker Hub
        • 3.2.6 Déconnexion des comptes Docker Hub et Github
    • 4. Un second conteneur
      • 4.1 Récupération de l'image
      • 4.2 Explication des tags
      • 4.3 Premier lancement
      • 4.4 Lancement en mode interactif
      • 4.5 Persistance des modifications sous forme d'une image
      • 4.6 Prise en main du client Docker
        • 4.6.1 Ménage dans les conteneurs
        • 4.6.2 Ménage dans les images
        • 4.6.3 Le grand ménage
        • 4.6.4 Suppression automatique à la sortie
        • 4.6.5 Affectation d'un nom de conteneur
        • 4.6.6 Modification du point d'entrée par défaut
        • 4.6.7 Envoi de variables d'environnement
        • 4.6.8 Modification du hostname
      • 4.7 Manipulation des conteneurs
        • 4.7.1 Lancement en mode bloquant
        • 4.7.2 Lancement en arrière-plan
        • 4.7.3 Gestion correcte du cycle de vie des conteneurs
        • 4.7.4 Exposition de fichiers
        • 4.7.5 Supervision des conteneurs
    • 5. Retours sur les premiers pas
  • Création de vos propres images
    • 1. Création manuelle d'une nouvelle image
      • 1.1 Installation d'un logiciel dans un conteneur
      • 1.2 Persistance de l'image pour une utilisation future
      • 1.3 Utilisation de l'image créée
      • 1.4 Connexion depuis la machine hôte
      • 1.5 Suite des opérations
    • 2. Utilisation d’un Dockerfile
      • 2.1 Intérêt des fichiers Dockerfile
      • 2.2 Utilisation d'un fichier Dockerfile
      • 2.3 Résultats de l'utilisation d'un Dockerfile complet
      • 2.4 Anatomie d'un fichier Dockerfile
        • 2.4.1 FROM
        • 2.4.2 RUN
        • 2.4.3 ENV
        • 2.4.4 VOLUME
        • 2.4.5 COPY
        • 2.4.6 ENTRYPOINT
        • 2.4.7 EXPOSE
        • 2.4.8 CMD
      • 2.5 Notre premier Dockerfile
        • 2.5.1 Création et test du script
        • 2.5.2 Création du Dockerfile
        • 2.5.3 Génération de l'image
        • 2.5.4 Lancement du conteneur
        • 2.5.5 Arrêt et relance du conteneur
        • 2.5.6 Gestion des paramètres
        • 2.5.7 Reconstruction de l'image et cache
      • 2.6 Commandes additionnelles
        • 2.6.1 Gestion des fichiers
        • 2.6.2 Notion de contexte
        • 2.6.3 Retours sur l'affectation du processus à démarrer
        • 2.6.4 Remarque sur le format ligne de commande ou exécution
        • 2.6.5 Commandes diverses
    • 3. Partage et réutilisation simple des images
      • 3.1 Envoi sur votre compte Docker Hub
      • 3.2 Export et import sous forme de fichiers
    • 4. Bonnes pratiques
      • 4.1 Principe du cache sur les images
      • 4.2 Principe du cache à la compilation
        • 4.2.1 Retour sur les images intermédiaires
        • 4.2.2 Anatomie d'une compilation d'image
        • 4.2.3 Analyse d'une modification du Dockerfile
        • 4.2.4 Gestion correcte des étiquettes
        • 4.2.5 Invalidation du cache par modification de l'image de base
        • 4.2.6 Invalidation du cache par modification du contexte
      • 4.3 Conséquences sur l'écriture des Dockerfile
        • 4.3.1 Le problème sur les opérations non idempotentes
        • 4.3.2 Contournement du problème de cache
        • 4.3.3 Effets bénéfiques sur le nombre et la taille des images
        • 4.3.4 Ordonnancement des commandes dans le Dockerfile
      • 4.4 Conséquences sur le choix des images de base
        • 4.4.1 La bonne image de base
        • 4.4.2 Votre propre image de base
      • 4.5 Arborescence recommandée
        • 4.5.1 Avantages d'une arborescence type
        • 4.5.2 Intégration des fichiers
        • 4.5.3 Limitation du contexte
      • 4.6 La question du processus unique
        • 4.6.1 Principe général
        • 4.6.2 Exception au principe général avec Supervisor
        • 4.6.3 Critique
        • 4.6.4 Approche intermédiaire
    • 5. Pour aller plus loin
  • Installation d’un registre privé
    • 1. Premiers pas pour un registre privé
      • 1.1 Remarque préliminaire importante
      • 1.2 Avertissement sur l'ancien registre
      • 1.3 Image Docker en local
      • 1.4 Pointer sur un registre donné
      • 1.5 Registre sur un réseau public
        • 1.5.1 Scénario et préparation des machines
        • 1.5.2 Démarrage du registre
        • 1.5.3 Dépôt de l'image depuis une autre machine
        • 1.5.4 Utilisation de l'image depuis une troisième machine
        • 1.5.5 Suppression de l'image sur la machine source
    • 2. Un registre plus professionnel
      • 2.1 Gestion de la persistance
        • 2.1.1 Gestion locale par volume
        • 2.1.2 Remarque sur SELinux
        • 2.1.3 Un stockage plus sécurisé
      • 2.2 Sécurisation du registre
        • 2.2.1 Préparation des clés pour le canal crypté
        • 2.2.2 Mise en place du frontal Nginx
        • 2.2.3 Accès par le client Docker
        • 2.2.4 Outils additionnels de diagnostic
        • 2.2.5 Génération du fichier des utilisateurs autorisés
        • 2.2.6 Ajout de l'authentification dans Nginx
        • 2.2.7 Correction sur les headers
        • 2.2.8 Gestion de la connexion
      • 2.3 Un vrai registre en production
    • 3. Utilisation d'un service de registre dans le cloud
      • 3.1 Principe
      • 3.2 Offre payante de Docker Hub
      • 3.3 Azure Container Registry
        • 3.3.1 Préparation
        • 3.3.2 Création du registre
        • 3.3.3 Paramétrage
    • 4. Approches complémentaires
      • 4.1 L'API du registre
      • 4.2 Mise en place d'un miroir
      • 4.3 Mise en place d'un cache pour les paquetages
        • 4.3.1 Contournement possible
        • 4.3.2 Mise en œuvre d'un cache de paquetages
  • Mise en œuvre d’une architecture logicielle
    • 1. Présentation de l'application exemple
      • 1.1 Architecture
      • 1.2 Installation
      • 1.3 Utilisation
      • 1.4 Utilité
      • 1.5 Principes à l'œuvre
        • 1.5.1 Un mot sur les architectures de microservices
        • 1.5.2 Lien avec la programmation SOLID
    • 2. Création de l'architecture exemple
      • 2.1 Principes de construction
      • 2.2 Détails du service optimizer
        • 2.2.1 Fonctionnement
        • 2.2.2 Intégration dans Docker
        • 2.2.3 Tests
        • 2.2.4 Remarques
      • 2.3 Détails du service calculator
        • 2.3.1 Fonctionnement
        • 2.3.2 Intégration dans Docker
        • 2.3.3 Tests
      • 2.4 Mise en place de liens entre conteneurs
      • 2.5 Détails du service reporting
        • 2.5.1 Fonctionnement
        • 2.5.2 Dockerisation
        • 2.5.3 Tests
      • 2.6 Détails du service notifier
        • 2.6.1 Fonctionnement
        • 2.6.2 Dockerisation
        • 2.6.3 Tests
      • 2.7 Détails du service de persistance
      • 2.8 Mise en œuvre éventuelle d’une image de base
      • 2.9 Détails du service portal
        • 2.9.1 Fonctionnement
        • 2.9.2 Dockerisation
        • 2.9.3 Tests
      • 2.10 État atteint
    • 3. Redéployer automatiquement avec Docker Compose
      • 3.1 Principe de Docker Compose
      • 3.2 Écriture du fichier docker-compose.yml
      • 3.3 Mise en œuvre
        • 3.3.1 Préparation
        • 3.3.2 Lancement des conteneurs
        • 3.3.3 Gestion des conteneurs
      • 3.4 Parallélisation des traitements
      • 3.5 Limites
    • 4. Exploitation d'une infrastructure Docker
      • 4.1 Le réseau dans Docker
        • 4.1.1 Mode de fonctionnement standard (bridge)
        • 4.1.2 Modes de fonctionnement alternatifs
        • 4.1.3 Support des liens entre conteneurs
        • 4.1.4 Autres options
        • 4.1.5 Limites de la couche réseau existante
      • 4.2 Les volumes Docker
        • 4.2.1 Le problème de la persistance
        • 4.2.2 Les volumes comme solution simple
        • 4.2.3 Lien direct sur un répertoire local
        • 4.2.4 Partage de volumes
        • 4.2.5 Gestion des volumes orphelins
        • 4.2.6 Sophistication de l'approche
        • 4.2.7 Application à la gestion des logs
        • 4.2.8 Plus loin avec les volumes
  • Déploiement dans un cluster
    • 1. Description globale de l'approche
      • 1.1 Objectif
      • 1.2 État des lieux
      • 1.3 Déroulement de l'exemple
      • 1.4 Avertissement
    • 2. Montage d'un cluster Swarm
      • 2.1 Fonctionnement résumé de Swarm
      • 2.2 Description des machines utilisées
      • 2.3 Initialisation du cluster
      • 2.4 Attachement des autres machines
      • 2.5 Prise en main à distance
    • 3. Déploiement sur le cluster Swarm
      • 3.1 Principes des services
      • 3.2 Envoi des images sur le registre
      • 3.3 Lancement d'une stack
      • 3.4 Passage à l'échelle
    • 4. Quelques informations supplémentaires sur Swarm
      • 4.1 Ce qui s'est passé sous le capot
        • 4.1.1 Commandes de diagnostic
        • 4.1.2 Gestion du réseau overlay et des ports
      • 4.2 Pour aller plus loin
        • 4.2.1 Arrêt de la plateforme
        • 4.2.2 Branchement sur un registre privé
        • 4.2.3 Gestion des contraintes
        • 4.2.4 Déploiement incrémental (rolling update)
  • Encore plus loin avec Docker
    • 1. Docker dans votre usine logicielle
      • 1.1 Docker à tous les étages
      • 1.2 Produire des images en sortie de build
        • 1.2.1 Positionnement
        • 1.2.2 Utilité
        • 1.2.3 Conseils de mise en place
      • 1.3 Utiliser des conteneurs pour l’usine logicielle
        • 1.3.1 Positionnement
        • 1.3.2 Utilité
        • 1.3.3 Conseils de mise en place
      • 1.4 Utiliser des conteneurs pour les tests
        • 1.4.1 Positionnement
        • 1.4.2 Utilité
        • 1.4.3 Conseils de mise en place
        • 1.4.4 Variante associée
      • 1.5 Retour sur le registre
    • 2. Avant de partir en production avec Docker
      • 2.1 Sécurité
      • 2.2 Restriction sur les ressources
    • 3. Docker et Windows
    • 4. Conclusion
    • Index

Auteur

Jean-Philippe GOUIGOUXEn savoir plus

Ingénieur en Génie des Systèmes Mécaniques (Université de Technologie de Compiègne), diplômé de l'université de Cranfield en Angleterre (Master of science, spécialité Advanced Automation and Design), Jean-Philippe GOUIGOUX est aujourd'hui directeur technique de la société MGDIS, éditeur de logiciels spécialisés dans les architectures microservices et l'urbanisation des systèmes d'information. Jean-Philippe GOUIGOUX est reconnu Microsoft MVP (Most Valuable Professional) dans diverses spécialités depuis 2011. Il intervient régulièrement en conférences sur des sujets informatiques variés allant de la gestion de données à Docker, en passant par la performance en .NET. Passionné par le partage de ses connaissances, il est auteur de plusieurs livres et vidéos parus aux Éditions ENI.

Caractéristiques

  • Niveau Expert
  • Nombre de pages 468 pages
  • Parution février 2018
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-01237-2
    • EAN : 9782409012372
    • Ref. ENI : EP2DOC
  • Niveau Expert
  • Parution février 2018
    • HTML
    • ISBN : 978-2-409-01254-9
    • EAN : 9782409012549
    • Ref. ENI : LNEP2DOC

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (19,9 Ko)