Ce livre de la collection vBook se compose d'un livre de référence sur Docker qui présente les concepts fondamentaux de la technologie Docker et d’un approfondissement sous forme de vidéo sur la compilation et les fonctionnalités de production d’une image Docker.

Livre Docker - Concepts fondamentaux - Déploiement d'applications distribuées

Ce livre s’adresse aux développeurs, architectes et administrateurs système, ainsi qu’à toute personne désireuse de comprendre les concepts fondamentaux de la technologie Docker, sans entrer dans toutes ses subtilités ni tous ses cas d’usage, pour les mettre en oeuvre dans le déploiement d’applications distribuées.

Empreint de toute la pédagogie de l’auteur, ce livre permet au lecteur de se poser les bonnes questions et d’apprendre à être pleinement autonome pour affronter avec un oeil critique la masse de conseils disponibles sur Internet afin de trouver la bonne information.

Après plusieurs chapitres dédiés à la prise en main de Docker, l’auteur transmet les bonnes pratiques de création d’images avant de montrer en quoi Docker permet de mettre en oeuvre des applications découpées en modules, voire en microservices, en prenant l’exemple d’une application développée en .NET Core.

Un chapitre est dédié à l’orchestration de conteneurs, que ce soit à l’aide de Kubernetes ou de Swarm, qui peut se révéler être une alternative intéressante du fait de sa simplicité d’utilisation. Les spécificités de Docker sous Windows sont également mises en avant.

Pour finir, le lecteur appréhende la mise en oeuvre en conditions industrielles de Docker, avec des recommandations de bonnes pratiques pour les environnements de production.

Vidéo Docker – Compilation et fonctionnalités de production d’une image

Docker est une brique fondamentale des approches DevOps et de la capacité à déployer en continu des produits logiciels complexes.

L’objectif de cette vidéo est de vous donner les clés pour comprendre les principes de Docker et la philosophie sous-jacente des approches par conteneurs pour vous amener à faire les bons choix d’implémentation de la technologie dans un écosystème de plus en plus complexe. Pour bien la suivre, quelques prérequis sur Linux et les commandes de base sur ce système d’exploitation sont utiles.

Après une présentation de l’architecture de Docker et de la compilation d’une image Docker très simple, vous étudierez ensuite des fichiers Dockerfile un peu plus complexes et manipulerez un registre d’images pour expliquer comment ces dernières peuvent être versionnées et diffusées. La gestion du réseau et des volumes pour la persistance sera également détaillée.

Téléchargements

• Des fichiers complémentaires (407 Ko)

Principes fondamentaux

1. 1. Docker comme alternative légère à la virtualisation
   1. 1.1 L'approche par virtualisation
   2. 1.2 Tentatives de réduction de la consommation de ressources
   3. 1.3 Comment Docker règle radicalement le problème
   4. 1.4 Positionnement de Docker par rapport à la virtualisation
2. 2. Principe des conteneurs
   1. 2.1 Les apports de Docker
   2. 2.2 Principe des conteneurs industriels
   3. 2.3 Docker et l'approche normalisée
3. 3. Les fondements de Docker
   1. 3.1 Les technologies Linux clés pour Docker
      1. 3.1.1 Namespaces
      2. 3.1.2 Mise en œuvre d'un namespace
      3. 3.1.3 cgroups
   2. 3.2 Autres dépendances du système
      1. 3.2.1 netfilter et iptables
      2. 3.2.2 capabilities
      3. 3.2.3 AppArmor et SELinux
   3. 3.3 Architecture du moteur Docker
      1. 3.3.1 LXC
      2. 3.3.2 libcontainer
      3. 3.3.3 containerd
   4. 3.4 Architectures complémentaires
      1. 3.4.1 rkt
      2. 3.4.2 Container Runtime Interface
      3. 3.4.3 Un foisonnement d'alternatives
   5. 3.5 Système de fichiers en couches
      1. 3.5.1 Principe d'isolation des fichiers
      2. 3.5.2 Approche par virtualisation
      3. 3.5.3 Utilité des systèmes de fichiers en couches
      4. 3.5.4 Gestion des modifications de fichiers
      5. 3.5.5 Dernière couche en écriture
      6. 3.5.6 Technologies utilisées
4. 4. Les plus de Docker
   1. 4.1 Au-delà du cloisonnement Linux
   2. 4.2 L'approche un conteneur = un processus
   3. 4.3 L’écosystème Docker
5. 5. Architectures de services
   1. 5.1 Historique des architectures de services
      1. 5.1.1 Principes
      2. 5.1.2 Approche EAI
      3. 5.1.3 Approche SOA
      4. 5.1.4 Micro-services
      5. 5.1.5 Lien à l'urbanisation des SI
   2. 5.2 Architecture de microservices
      1. 5.2.1 Principe
      2. 5.2.2 Avantages
      3. 5.2.3 Inconvénients
   3. 5.3 Apport de Docker
   4. 5.4 Fil conducteur

Installation

1. 1. Éditions et canaux
   1. 1.1 Un standard sous Linux
   2. 1.2 Les canaux
   3. 1.3 Les éditions
2. 2. Utiliser des machines dans le cloud
   1. 2.1 Amazon AWS
      1. 2.1.1 Offre
      2. 2.1.2 Création de la machine virtuelle
      3. 2.1.3 Accès à la machine virtuelle
      4. 2.1.4 Gestion de la consommation
      5. 2.1.5 Suppression de la machine virtuelle
   2. 2.2 Microsoft Azure
      1. 2.2.1 Offre
      2. 2.2.2 Création de la machine virtuelle
      3. 2.2.3 Accès à la machine virtuelle
      4. 2.2.4 Suppression de la machine virtuelle
   3. 2.3 Google Cloud Platform
      1. 2.3.1 Offre
      2. 2.3.2 Création de la machine virtuelle
      3. 2.3.3 Accès à la machine virtuelle
      4. 2.3.4 Suppression de la machine virtuelle
3. 3. Installation de Docker
   1. 3.1 Installation de Docker sur Linux
      1. 3.1.1 Prérequis
      2. 3.1.2 Gestionnaires de paquets
      3. 3.1.3 Installation par script
      4. 3.1.4 Cas particulier de l'installation sur Clear Linux
   2. 3.2 Le paradoxe Docker sous Windows
      1. 3.2.1 Des technologies différentes
      2. 3.2.2 Docker et Hyper-V
      3. 3.2.3 L'âge de la maturité
   3. 3.3 L'outil Docker pour Windows
      1. 3.3.1 Outil d'installation
      2. 3.3.2 Choix du canal
      3. 3.3.3 Mises à jour
      4. 3.3.4 Assistant d'installation
      5. 3.3.5 Enfin du natif avec WSL 2
      6. 3.3.6 Désinstallation
   4. 3.4 Docker pour Windows Server
      1. 3.4.1 Installation
      2. 3.4.2 Utilisation de machines préinstallées
      3. 3.4.3 Exécution de conteneurs Linux
      4. 3.4.4 Paramétrage système
   5. 3.5 Utilisation de Docker avec Vagrant
      1. 3.5.1 Principe
      2. 3.5.2 Création d'une machine
      3. 3.5.3 Provisionnement de Docker
      4. 3.5.4 Aménagement de l'accès à la machine
      5. 3.5.5 Connexion à la machine provisionnée
      6. 3.5.6 Poursuite des opérations Vagrant

Premiers pas avec Docker

1. 1. Hello World, Docker
   1. 1.1 Démarrage d'un conteneur simple
   2. 1.2 Détails des opérations effectuées
      1. 1.2.1 Récupération d'une image
      2. 1.2.2 Identité de l'image
      3. 1.2.3 Taille des images
      4. 1.2.4 Anatomie de l'image Linux
      5. 1.2.5 Anatomie de l'image Windows
      6. 1.2.6 Lancement du processus
      7. 1.2.7 Exécution du processus dans un conteneur
      8. 1.2.8 Opérations suivant l'exécution
2. 2. Utiliser des images Docker préexistantes
   1. 2.1 Le registre Docker Hub
      1. 2.1.1 Le principe
      2. 2.1.2 Recherche et qualification d'images
      3. 2.1.3 Exemple de recherche
      4. 2.1.4 Cas des images communautaires
      5. 2.1.5 Compléments sur les images officielles
      6. 2.1.6 Recherche par la ligne de commande
      7. 2.1.7 Précautions sur une image non officielle
   2. 2.2 Gestion du compte Docker Hub et dépôts privés
      1. 2.2.1 Création d'un compte
      2. 2.2.2 Caractéristiques du compte
      3. 2.2.3 Automated build et compte GitHub
      4. 2.2.4 Connexion au compte en ligne de commande
      5. 2.2.5 Webhook sur événement de push dans Docker Hub
      6. 2.2.6 Déconnexion des comptes Docker Hub et GitHub
3. 3. Un second conteneur
   1. 3.1 Récupération de l'image
   2. 3.2 Explication des tags
   3. 3.3 Premier lancement
   4. 3.4 Lancement en mode interactif
   5. 3.5 Persistance des modifications sous forme d'une image
   6. 3.6 Prise en main du client Docker
      1. 3.6.1 Ménage dans les conteneurs
      2. 3.6.2 Ménage dans les images
      3. 3.6.3 Le grand ménage
      4. 3.6.4 Suppression automatique à la sortie
      5. 3.6.5 Affectation d'un nom de conteneur
      6. 3.6.6 Modification du point d'entrée par défaut
      7. 3.6.7 Envoi de variables d'environnement
      8. 3.6.8 Modification du hostname
   7. 3.7 Manipulation des conteneurs
      1. 3.7.1 Lancement en mode bloquant
      2. 3.7.2 Lancement en arrière-plan
      3. 3.7.3 Gestion correcte du cycle de vie des conteneurs
      4. 3.7.4 Exposition de fichiers
      5. 3.7.5 Supervision des conteneurs
4. 4. Retours sur les premiers pas

Création et gestion d’images Docker

1. 1. Création manuelle d'une nouvelle image
   1. 1.1 Objectif
   2. 1.2 Approche
   3. 1.3 Difficultés
   4. 1.4 Conclusion
2. 2. Utilisation d’un Dockerfile
   1. 2.1 Intérêt des fichiers Dockerfile
   2. 2.2 Utilisation d'un fichier Dockerfile
   3. 2.3 Anatomie d'un fichier Dockerfile
      1. 2.3.1 FROM
      2. 2.3.2 RUN
      3. 2.3.3 ENV
      4. 2.3.4 VOLUME
      5. 2.3.5 COPY
      6. 2.3.6 ENTRYPOINT
      7. 2.3.7 EXPOSE
      8. 2.3.8 CMD
   4. 2.4 Notre premier Dockerfile
      1. 2.4.1 Fonctionnalité souhaitée
      2. 2.4.2 Création et test du script
      3. 2.4.3 Création du Dockerfile
      4. 2.4.4 Génération de l'image
      5. 2.4.5 Lancement du conteneur
      6. 2.4.6 Arrêt et relance du conteneur
      7. 2.4.7 Une méthode moins brutale
      8. 2.4.8 Gestion des paramètres
      9. 2.4.9 Reconstruction de l'image et cache
   5. 2.5 Commandes additionnelles
      1. 2.5.1 Gestion des fichiers
      2. 2.5.2 Notion de contexte
      3. 2.5.3 Retours sur l'affectation du processus à démarrer
      4. 2.5.4 Remarque sur le format ligne de commande ou exécution
      5. 2.5.5 Commandes diverses
3. 3. Partage et réutilisation simple des images
   1. 3.1 Envoi sur votre compte Docker Hub
   2. 3.2 Export et import sous forme de fichiers
4. 4. Bonnes pratiques
   1. 4.1 Principe du cache local d'images
   2. 4.2 Principe du cache à la compilation
      1. 4.2.1 Retour sur les images intermédiaires
      2. 4.2.2 Anatomie d'une compilation d'image
      3. 4.2.3 Analyse d'une modification du Dockerfile
      4. 4.2.4 Gestion correcte des étiquettes
      5. 4.2.5 Invalidation du cache par modification de l'image de base
      6. 4.2.6 Invalidation du cache par modification du contexte
   3. 4.3 Conséquences sur l'écriture des Dockerfile
      1. 4.3.1 Le problème sur les opérations non idempotentes
      2. 4.3.2 Contournement du problème de cache
      3. 4.3.3 Effets bénéfiques sur le nombre et la taille des images
      4. 4.3.4 Ordonnancement des commandes dans le Dockerfile
   4. 4.4 Ajout d'une image de cache intermédiaire
   5. 4.5 Mise en œuvre d'un cache de paquetages
   6. 4.6 Conséquences sur le choix des images de base
      1. 4.6.1 La bonne image de base
      2. 4.6.2 Votre propre image de base
      3. 4.6.3 Adapter l'image de base avec les compilations multi-stage
   7. 4.7 Arborescence recommandée
      1. 4.7.1 Avantage d'une arborescence type
      2. 4.7.2 Intégration des fichiers
      3. 4.7.3 Limitation du contexte
   8. 4.8 La question du processus unique
      1. 4.8.1 Principe général
      2. 4.8.2 Exception au principe général avec Supervisor
      3. 4.8.3 Critique
      4. 4.8.4 Approche intermédiaire

Docker et les microservices

1. 1. Présentation de l'application exemple
   1. 1.1 Principes à l'œuvre
      1. 1.1.1 Utilité
      2. 1.1.2 Architecture de microservices
   2. 1.2 Description de l'application
      1. 1.2.1 Présentation des fonctionnalités
      2. 1.2.2 Limites logicielles
      3. 1.2.3 Où trouver l'application exemple
      4. 1.2.4 Utilisation des API
      5. 1.2.5 Scénarios d'utilisation
   3. 1.3 Mode de développement
      1. 1.3.1 Code source et paramétrage
      2. 1.3.2 Intégration continue
2. 2. Déployer automatiquement avec Docker Compose
   1. 2.1 Docker Compose
      1. 2.1.1 Principe
      2. 2.1.2 Installation
   2. 2.2 Écriture du fichier docker-compose.yml
      1. 2.2.1 Premier service
      2. 2.2.2 Un service sans interface graphique
      3. 2.2.3 Mise en place de Traefik
      4. 2.2.4 Complément du fichier descriptif
   3. 2.3 Vérification du déploiement
   4. 2.4 Paramétrage de l'application
      1. 2.4.1 Avec Postman
      2. 2.4.2 Avec curl
   5. 2.5 Test de l’application
   6. 2.6 Vérification en base de données
      1. 2.6.1 Objectif
      2. 2.6.2 Mise en place du tunnel SSH
      3. 2.6.3 Lecture par un client MongoDB
3. 3. Exploitation d'une infrastructure Docker
   1. 3.1 Le réseau dans Docker
      1. 3.1.1 Mode de fonctionnement standard (bridge)
      2. 3.1.2 Modes de fonctionnement alternatifs
      3. 3.1.3 Création dynamique de réseaux dédiés
      4. 3.1.4 Support des liens entre conteneurs
      5. 3.1.5 Extension à l'état de santé des conteneurs
      6. 3.1.6 Approche complètement découplée
      7. 3.1.7 Autres options
      8. 3.1.8 Limites de la couche réseau existante
   2. 3.2 Les volumes Docker
      1. 3.2.1 Le problème de la persistance
      2. 3.2.2 Les volumes comme solution simple
      3. 3.2.3 Lien direct sur un répertoire local
      4. 3.2.4 Partage de volumes
      5. 3.2.5 Gestion des volumes orphelins
      6. 3.2.6 Sophistication de l'approche
      7. 3.2.7 Application à la gestion des logs
      8. 3.2.8 L'état de l'art
4. 4. Exemples de Dockerfile pour d'autres langages
   1. 4.1 Python
   2. 4.2 Java
   3. 4.3 Node.js
   4. 4.4 Go
5. 5. Pour aller plus loin en architecture microservices
   1. 5.1 Bonnes pratiques
   2. 5.2 Lien à l'urbanisation des SI
   3. 5.3 Persistance
   4. 5.4 Orchestration fonctionnelle

Orchestration des conteneurs

1. 1. Le besoin d'orchestration
   1. 1.1 Objectif
   2. 1.2 Approche théorique
      1. 1.2.1 La problématique de montée en charge
      2. 1.2.2 La solution découplée
      3. 1.2.3 Conséquences sur l'approche initiale
   3. 1.3 Lien aux microservices
      1. 1.3.1 Orchestration des services
      2. 1.3.2 Élasticité
      3. 1.3.3 Robustesse
   4. 1.4 Fonctionnement pratique
      1. 1.4.1 Notion de réseau
      2. 1.4.2 Les différents types de nœuds
      3. 1.4.3 Fonctionnalités du cluster
2. 2. L'approche Docker Swarm
   1. 2.1 Gestion du cluster Swarm
      1. 2.1.1 Prérequis
      2. 2.1.2 Initialisation
      3. 2.1.3 Liaison des agents
      4. 2.1.4 Ajout d'un manager
      5. 2.1.5 Les limites à l'ajout de managers
      6. 2.1.6 Promotion d'un nœud
      7. 2.1.7 Suppression d'un nœud
   2. 2.2 Test du cluster avec un cas simple
   3. 2.3 Déploiement manuel sur le cluster Swarm
      1. 2.3.1 Application exemple
      2. 2.3.2 Préparation des images
      3. 2.3.3 Lancement des services
      4. 2.3.4 Premier test
      5. 2.3.5 Mise en place d'un réseau overlay dédié
      6. 2.3.6 Validation du fonctionnement
      7. 2.3.7 Passage à l'échelle
      8. 2.3.8 Suppression des ressources déployées
   4. 2.4 Déploiement de l'application microservices
      1. 2.4.1 Récupérer l'application exemple
      2. 2.4.2 Le retour de Docker Compose
      3. 2.4.3 Détail du vocabulaire
      4. 2.4.4 Compilation éventuelle des images
      5. 2.4.5 Lancement par Docker Compose
      6. 2.4.6 Déploiement d'une stack
      7. 2.4.7 Diagnostic et validation du fonctionnement
      8. 2.4.8 Utilisation du DNS
   5. 2.5 Considérations additionnelles
      1. 2.5.1 Provenance des images
      2. 2.5.2 Passage à l'échelle
      3. 2.5.3 Mise à jour des images
      4. 2.5.4 Gestion des contraintes
      5. 2.5.5 Arrêt de la stack
   6. 2.6 Mélanger déploiement Swarm et Traefik
      1. 2.6.1 Fusion des grammaires précédentes
      2. 2.6.2 Passer Traefik en mode Swarm
      3. 2.6.3 Correction du placement de Traefik
      4. 2.6.4 Correction de la grammaire sur les labels
      5. 2.6.5 Note sur Traefik V2
3. 3. Kubernetes
   1. 3.1 Positionnement
   2. 3.2 Concepts
      1. 3.2.1 Pods
      2. 3.2.2 Namespaces
      3. 3.2.3 Services
      4. 3.2.4 IngressController
      5. 3.2.5 Volumes
      6. 3.2.6 ConfigMap
      7. 3.2.7 Deployment
   3. 3.3 Installation
      1. 3.3.1 Choix de la méthode
      2. 3.3.2 Création d'un cluster AKS
      3. 3.3.3 Paramétrage de l'accès au cluster
      4. 3.3.4 Accès au cluster
   4. 3.4 Premier déploiement par ligne de commande
      1. 3.4.1 Contexte
      2. 3.4.2 Création du déploiement
      3. 3.4.3 Vérification du déploiement
      4. 3.4.4 Présence d'un pod
      5. 3.4.5 Exposition par un service
      6. 3.4.6 Test de l’application
      7. 3.4.7 Nettoyage
   5. 3.5 Déploiement de l'application microservices
      1. 3.5.1 Structure du projet de déploiement
      2. 3.5.2 Namespace
      3. 3.5.3 Fichier de paramétrage
      4. 3.5.4 Fichiers liés aux bases de données
      5. 3.5.5 Fichiers liés aux services
      6. 3.5.6 Définition de l'ingress
      7. 3.5.7 Lancement d'un seul coup
      8. 3.5.8 Consommation de l'application
      9. 3.5.9 Déploiement continu
      10. 3.5.10 Arrêt de la stack
   6. 3.6 Pour aller plus loin avec Kubernetes
4. 4. Azure Container Instances
   1. 4.1 Principe
   2. 4.2 Préparation d'une image
   3. 4.3 Lancement du conteneur
   4. 4.4 Correction de l'erreur et relance
   5. 4.5 Coût et effort

Docker et Windows

1. 1. Spécificités sous Windows
   1. 1.1 Images de base
      1. 1.1.1 Nécessité
      2. 1.1.2 Windows Server Core
      3. 1.1.3 Nano Server
      4. 1.1.4 Compatibilité et disponibilité
      5. 1.1.5 Autres versions
      6. 1.1.6 Cas particulier de .NET
   2. 1.2 Différences avec Linux
      1. 1.2.1 Généralités
      2. 1.2.2 Dockerfile
      3. 1.2.3 Gestion du réseau
   3. 1.3 Mise en œuvre
2. 2. L'outil Docker for Windows
   1. 2.1 Configuration standard
   2. 2.2 Les deux modes de conteneurs disponibles
   3. 2.3 Mode conteneurs Linux (hors mode WSL)
   4. 2.4 Gestion des images
   5. 2.5 Cas particulier des lecteurs de disque
   6. 2.6 Gestion Kubernetes

Industrialisation

1. 1. Bonnes pratiques de production
   1. 1.1 Supervision
      1. 1.1.1 Approche "bétail plutôt qu’animal domestique"
      2. 1.1.2 Outillage possible
      3. 1.1.3 Outillage des logs
   2. 1.2 Bonnes pratiques logicielles
      1. 1.2.1 Importance de la normalisation des logs
      2. 1.2.2 API de statut
      3. 1.2.3 Retry policies et circuit breakers
      4. 1.2.4 Répartition de la charge
      5. 1.2.5 Inversion de consommation
      6. 1.2.6 Gestion du multitenant au moyen des conteneurs
   3. 1.3 Gestion de la performance
      1. 1.3.1 Passage à l'échelle automatique
      2. 1.3.2 Cas particulier du cache
      3. 1.3.3 Alignement sur le CPU et les threads
      4. 1.3.4 Approche "production only"
   4. 1.4 Sécurité
      1. 1.4.1 Mangue ou noix de coco ?
      2. 1.4.2 Évolution de la gestion de la sécurité par Docker
      3. 1.4.3 Pratique de sécurisation des ports
      4. 1.4.4 Sécurité sur l'utilisation des images
      5. 1.4.5 Restriction sur les ressources
2. 2. Mise en œuvre d'un registre privé
   1. 2.1 Objectifs
   2. 2.2 Votre registre en complète autonomie
      1. 2.2.1 Image à utiliser
      2. 2.2.2 Lancement du registre
      3. 2.2.3 Utilisation du registre
   3. 2.3 Les limites du mode autonome
      1. 2.3.1 Limites en termes d'utilisation
      2. 2.3.2 Limites en termes de sécurité
      3. 2.3.3 Limites en termes de performance
      4. 2.3.4 Limites en termes de stockage
      5. 2.3.5 Et toutes les autres limitations d'un registre autogéré
   4. 2.4 Utilisation d'un service cloud déjà préparé
      1. 2.4.1 Azure Container Registry
      2. 2.4.2 Notes finales
   5. 2.5 Approches complémentaires
      1. 2.5.1 L'API du registre
      2. 2.5.2 Mise en place d'un miroir
3. 3. Plateformes de déploiement de conteneurs
   1. 3.1 Amazon Web Services
      1. 3.1.1 Description des services
      2. 3.1.2 Amazon ECR
      3. 3.1.3 Amazon ECS
      4. 3.1.4 Amazon Elastic Beanstalk
   2. 3.2 Microsoft Azure
      1. 3.2.1 Description des services
      2. 3.2.2 Azure Kubernetes Service
      3. 3.2.3 Azure Cluster Service Fabric
      4. 3.2.4 Azure Container Instances
   3. 3.3 Google Cloud Platform
      1. 3.3.1 Description des services
      2. 3.3.2 Google Kubernetes Engine
      3. 3.3.3 Google Compute Engine
      4. 3.3.4 Google Container Registry
      5. 3.3.5 Google Cloud Run
4. 4. Remarques sur les usages industriels de Docker
   1. 4.1 Supervision mixte
   2. 4.2 Intégration de bases de données
   3. 4.3 Cluster hybride
   4. 4.4 Docker en usine logicielle
      1. 4.4.1 Déploiement
      2. 4.4.2 Compilation
      3. 4.4.3 Infrastructure de l'usine logicielle
      4. 4.4.4 Gestion des tests
      5. 4.4.5 Utilisation pour les machines supports de tests
      6. 4.4.6 Registre pour l'ALM
   5. 4.5 Docker comme une commodité
   9. Index