Ce support 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 œuvre dans le déploiement d’applications conçues en services.

Empreint de toute la pédagogie de l’auteur, ce support permet au lecteur de se poser les bonnes questions et d’apprendre à être pleinement autonome pour affronter avec un œil 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 d'intégration de Docker sur une application exemple développée avec les technologies Blazor/ASP.NET Core et utilisant des dépendances externes pour les fonctionnalités communes (Keycloak pour l'IAM, Nuxeo pour la GED, RabbitMQ pour le MOM, MongoDB pour la persistance, etc.). Cette architecture en services permettra d'aborder le maximum de situations différentes d'utilisation de Docker.

Le dernier chapitre est consacré à simuler un déploiement industriel de l'application adaptée à Docker, en utilisant à la fois l’orchestration de conteneurs, avec des exemples sur Swarm et Kubernetes, et une intégration et un déploiement continus avec Azure DevOps.

Téléchargements

• Des fichiers complémentaires (1 Ko)

Principes fondamentaux

1. 1. Positionnement de Docker
   1. 1.1 La problématique racine
   2. 1.2 Approche par augmentation des ressources physiques
   3. 1.3 Approche par parallélisation des traitements
   4. 1.4 L'approche par virtualisation
   5. 1.5 Tentatives de réduction de la consommation de ressources
   6. 1.6 Comment Docker règle radicalement le problème
   7. 1.7 Positionnement de Docker par rapport à la virtualisation
   8. 1.8 Positionnement de Docker par rapport aux clusters
   9. 1.9 Positionnement de Docker par rapport aux approches de bacs-à-sable
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
      4. 3.1.4 chroot
   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 Microservices
      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 Assistant d'installation
      4. 3.3.4 Mises à jour
      5. 3.3.5 Support natif de conteneurs Linux sous Windows avec WSL 2
      6. 3.3.6 Les nouveautés de Docker Desktop
      7. 3.3.7 Désinstallation
   4. 3.4 Docker pour Windows Server
      1. 3.4.1 Prérequis pour Windows Server 2022
      2. 3.4.2 Installation
      3. 3.4.3 Utilisation de machines préinstallées
      4. 3.4.4 Exécution de conteneurs Linux
      5. 3.4.5 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
      4. 2.2.4 Connexion au compte en ligne de commande
      5. 2.2.5 Webhook sur événement de push dans Docker Hub
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 fichier 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 fichier 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 fichier 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 fichiers 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 fichier 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
5. 5. Mise en œuvre d'un registre privé
   1. 5.1 Objectifs
   2. 5.2 Votre registre en complète autonomie
      1. 5.2.1 Image à utiliser
      2. 5.2.2 Lancement du registre
      3. 5.2.3 Utilisation du registre
   3. 5.3 Les limites du mode autonome
      1. 5.3.1 Limites en termes d'utilisation
      2. 5.3.2 Limites en termes de sécurité
      3. 5.3.3 Limites en termes de performance
      4. 5.3.4 Limites en termes de stockage
      5. 5.3.5 Et toutes les autres limitations d'un registre autogéré
   4. 5.4 Utilisation d'un service cloud déjà préparé
      1. 5.4.1 Azure Container Registry
      2. 5.4.2 Notes finales
   5. 5.5 Approches complémentaires
      1. 5.5.1 L'API du registre
      2. 5.5.2 Mise en place d'un miroir
6. 6. Incorporation dans le cycle de développement
   1. 6.1 Positionnement de Docker dans une usine logicielle
      1. 6.1.1 Déploiement
      2. 6.1.2 Compilation
      3. 6.1.3 Infrastructure de l'usine logicielle
      4. 6.1.4 Gestion des tests
      5. 6.1.5 Utilisation pour les machines supports de tests
      6. 6.1.6 Registre pour l'ALM
   2. 6.2 Exemple de mise en œuvre
      1. 6.2.1 Choix des outils
      2. 6.2.2 Création du projet
      3. 6.2.3 Analyse du fichier Dockerfile généré
      4. 6.2.4 Prérequis pour l’intégration continue
   3. 6.3 Docker comme une commodité

Mise en œuvre pratique

1. 1. Présentation de l'application exemple
   1. 1.1 Architecture
   2. 1.2 Création d'un fichier des mots de passe
      1. 1.2.1 Principe de sécurité
      2. 1.2.2 Installation de KeePass
      3. 1.2.3 Création du fichier de sécurité
      4. 1.2.4 Remplissage du fichier de mots de passe
   3. 1.3 Mise en place des certificats de sécurité
      1. 1.3.1 Certificat racine
      2. 1.3.2 Certificat client
   4. 1.4 Prérequis
   5. 1.5 Paramétrage
      1. 1.5.1 Paramétrage de l'IAM
      2. 1.5.2 Paramétrage de RecepteurMessages
      3. 1.5.3 Paramétrage du projet API
      4. 1.5.4 Autres projets
      5. 1.5.5 Paramétrage de la solution
   6. 1.6 Première utilisation
      1. 1.6.1 Scénario nominal de test
      2. 1.6.2 Persistance
      3. 1.6.3 Observation des documents
   7. 1.7 Utilité
   8. 1.8 Principes à l'œuvre
      1. 1.8.1 Un mot sur les architectures de services
      2. 1.8.2 Lien avec la programmation SOLID
2. 2. Adaptation à Docker de l'application exemple
   1. 2.1 Préparation de l'environnement
   2. 2.2 Principes de construction
   3. 2.3 Détails du service RecepteurMessages
      1. 2.3.1 Fonctionnement
      2. 2.3.2 Construction du fichier Dockerfile de base
      3. 2.3.3 Classification du support des paramètres
      4. 2.3.4 Cas particulier des paramètres de sécurité
      5. 2.3.5 Modification du projet pour gestion des paramètres
      6. 2.3.6 Évolution du fichier Dockerfile
   4. 2.4 Lancement de RecepteurMessages en mode Docker
      1. 2.4.1 Compilation
      2. 2.4.2 Test de lancement
      3. 2.4.3 Conteneurs en réseau
      4. 2.4.4 Utilisation d'un volume pour pointer sur le certificat
   5. 2.5 Adaptation de Visual Studio
      1. 2.5.1 Paramétrage du projet en mode Docker
      2. 2.5.2 Tests d'intégration
      3. 2.5.3 Publication intégrée
   6. 2.6 Retour sur le problème de secret
      1. 2.6.1 Approche simpliste par variable d'environnement
      2. 2.6.2 Gestion des secrets dans Docker
      3. 2.6.3 Mise en place du fichier pour Docker Compose
      4. 2.6.4 Mise en place de la trace de diagnostic
      5. 2.6.5 Description du problème d'ordonnancement
      6. 2.6.6 Validation du fonctionnement en mode Docker
   7. 2.7 Problème des paramètres liés à XKCD
   8. 2.8 Traitement du projet API
      1. 2.8.1 Passage en mode Docker du projet
      2. 2.8.2 Classification des paramétrages disponibles
      3. 2.8.3 Ajustement du fichier Dockerfile
      4. 2.8.4 Ajout des valeurs pour les paramètres
      5. 2.8.5 Mise à jour du fichier Docker Compose
      6. 2.8.6 Correction paramétrage d'appel du service API
      7. 2.8.7 Test du projet en mode Docker
   9. 2.9 Traitement du projet Server
      1. 2.9.1 Passage en mode Docker du projet
      2. 2.9.2 Classification des paramètres disponibles
      3. 2.9.3 Ajustement du fichier Dockerfile
      4. 2.9.4 Ajout des valeurs pour les paramètres
      5. 2.9.5 Mise à jour du fichier Docker Compose
   10. 2.10 Cas particulier des paramètres du projet Client
   11. 2.11 Test de l'application passée en Docker
       1. 2.11.1 Principe
       2. 2.11.2 Débogage du problème de volume
       3. 2.11.3 Débogage du problème de nom de serveur RabbitMQ
       4. 2.11.4 Débogage du problème d'accès à l'IAM
       5. 2.11.5 Débogage du chargement des personnes
       6. 2.11.6 Débogage de l'authentification serveur
   12. 2.12 État atteint

Orchestration par Docker Compose

1. 1. Redéployer automatiquement avec Docker Compose
   1. 1.1 Principe de Docker Compose
   2. 1.2 Écriture du fichier docker-compose.yml
      1. 1.2.1 Remarques préliminaires
      2. 1.2.2 Préparation du squelette du fichier
      3. 1.2.3 Mise en place des dépendances externes
      4. 1.2.4 Ajout de la détection de statut des services
      5. 1.2.5 Inclusion du projet RecepteurMessages
      6. 1.2.6 Ajout du projet API
      7. 1.2.7 Finalisation avec le projet Server
   3. 1.3 Mise en œuvre
      1. 1.3.1 Exclusion du mode HTTPS
      2. 1.3.2 Premier lancement
      3. 1.3.3 Retour sur le problème d'authentification
      4. 1.3.4 Tentative de résolution par le réseau hôte
      5. 1.3.5 Stratégie d'externalisation de l'IAM
   4. 1.4 Mise en œuvre avec IAM externalisée
      1. 1.4.1 Préparation d'une machine dans le cloud
      2. 1.4.2 Ajout de Docker dans Clear Linux
      3. 1.4.3 Préparation de l'application Keycloak complète
      4. 1.4.4 Passage de Keycloak en HTTPS
      5. 1.4.5 Ajout de la persistance pour la configuration Keycloak
      6. 1.4.6 Gestion de la robustesse par un service Linux
      7. 1.4.7 Ajustement de l'application exemple
      8. 1.4.8 Test final
   5. 1.5 Débogages complémentaires du mode Docker Compose
      1. 1.5.1 Astuce préliminaire
      2. 1.5.2 Gestion de la génération de PDF en mode Linux
      3. 1.5.3 Intégration des polices pour la génération de PDF
      4. 1.5.4 Exposition différenciée des ports de la GED
      5. 1.5.5 Exposition en HTTPS du projet API
      6. 1.5.6 Passage de l'appel d'API en HTTPS
      7. 1.5.7 Ménage dans les paramètres
2. 2. Fonctionnalités supplémentaires de Docker Compose
   1. 2.1 Retour sur la gestion des conteneurs
   2. 2.2 Parallélisation des traitements
   3. 2.3 Autre avantage de l'approche par conteneurs
   4. 2.4 Limites de l'application exemple
   5. 2.5 Intégration dans Visual Studio
      1. 2.5.1 Argumentaire
      2. 2.5.2 Mise en œuvre
      3. 2.5.3 Gestion des profils de lancement
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 Support des liens entre conteneurs
      4. 3.1.4 Gestion des réseaux overlay
      5. 3.1.5 Alias préinstallés
   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 Volumes déclarés
      9. 3.2.9 Plugins pour la gestion avancée des volumes
4. 4. Exemples de fichier Dockerfile pour d'autres plateformes
   1. 4.1 Java
      1. 4.1.1 Image Java
      2. 4.1.2 Image openjdk
      3. 4.1.3 Image Maven
   2. 4.2 PHP
      1. 4.2.1 Mode ligne de commande
      2. 4.2.2 Mode serveur web
   3. 4.3 Node.js
   4. 4.4 Go
   5. 4.5 Python
   6. 4.6 Un mot sur les DevContainers

Déploiement en cluster par une usine logicielle

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 Elasticité
      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 Alternative aux prérequis
      3. 2.1.3 Initialisation
      4. 2.1.4 Liaison des agents
      5. 2.1.5 Ajout d'un manager
      6. 2.1.6 Les limites à l'ajout de managers
      7. 2.1.7 Promotion d'un nœud
      8. 2.1.8 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 partiel 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 Autres avertissements possibles
      8. 2.4.8 Diagnostic et validation du fonctionnement
      9. 2.4.9 Mise au point du déploiement
      10. 2.4.10 Utilisation de l'ingress
      11. 2.4.11 Déploiement de l'IAM sur Docker Swarm
      12. 2.4.12 Ajustement de la stack applicative
      13. 2.4.13 Débogage du service de traitement des messages
   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
3. 3. Outils avancés d'exposition
   1. 3.1 Traefik
      1. 3.1.1 Utilité
      2. 3.1.2 Lancement
      3. 3.1.3 Mise en œuvre sur l'application exemple
      4. 3.1.4 Vérification du fonctionnement
   2. 3.2 Caddy
      1. 3.2.1 Présentation
      2. 3.2.2 Réunification des stacks
      3. 3.2.3 Remplacement de Traefik par Caddy
      4. 3.2.4 Exposition simpliste pour test
      5. 3.2.5 Ajout d'un fichier de configuration
      6. 3.2.6 Modifications complémentaires
      7. 3.2.7 Conclusion sur Caddy
4. 4. Introduction à Kubernetes
   1. 4.1 Positionnement
   2. 4.2 Comparaison avec Docker Swarm
   3. 4.3 Concepts
      1. 4.3.1 Pods
      2. 4.3.2 Namespaces
      3. 4.3.3 Services
      4. 4.3.4 IngressController
      5. 4.3.5 Volumes
      6. 4.3.6 ConfigMap
      7. 4.3.7 Deployment
   4. 4.4 Installation
      1. 4.4.1 Choix de la méthode
      2. 4.4.2 Création d'un cluster AKS
      3. 4.4.3 Paramétrage de l'accès au cluster
      4. 4.4.4 Accès au cluster
   5. 4.5 Premier déploiement par ligne de commande
      1. 4.5.1 Contexte
      2. 4.5.2 Création du déploiement
      3. 4.5.3 Vérification du déploiement
      4. 4.5.4 Présence d'un pod
      5. 4.5.5 Exposition par un service
      6. 4.5.6 Test de l’application
      7. 4.5.7 Nettoyage
5. 5. Intégration et déploiement continus
   1. 5.1 Approche
   2. 5.2 Intégration continue de l'application exemple
      1. 5.2.1 Création du projet Azure DevOps
      2. 5.2.2 Création d'un pipeline de compilation pour le projet Server
      3. 5.2.3 Correction du problème de compilation
      4. 5.2.4 Remarques sur l'intégration des plateformes
   3. 5.3 Déploiement de l'application microservices
      1. 5.3.1 Objectifs
      2. 5.3.2 Création du namespace
      3. 5.3.3 Notion de fichier descriptif
      4. 5.3.4 Mise en place de l'ingress
      5. 5.3.5 Application au service Server
      6. 5.3.6 Gestion des paramètres
      7. 5.3.7 Déploiement du service GED
      8. 5.3.8 Gestion des secrets sous forme de fichiers
      9. 5.3.9 Digression sur la gestion des images
      10. 5.3.10 Retour sur la gestion des secrets
      11. 5.3.11 Gestion des secrets sous forme de chaînes
      12. 5.3.12 Gestion du healthcheck
      13. 5.3.13 Débogage des démarrages suspendus
      14. 5.3.14 Retour sur le ConfigMap
      15. 5.3.15 Gestion d'une application en mode console
      16. 5.3.16 Démarrage à l'échelle
      17. 5.3.17 Ajustement du DNS du service
      18. 5.3.18 Cas particulier de l'IAM
      19. 5.3.19 Gestion des consommations de ressources
      20. 5.3.20 Remarques sur les labels
      21. 5.3.21 Gestion des volumes
      22. 5.3.22 Lancement d'un seul coup
      23. 5.3.23 Arrêt de l'application
   4. 5.4 Déploiement continu avec Azure DevOps
      1. 5.4.1 Objectif
      2. 5.4.2 Mécanisme utilisé
      3. 5.4.3 Paramétrage dans Azure DevOps
      4. 5.4.4 Ménage
   5. 5.5 Fonctionnalités supplémentaires d'usine logicielle
      1. 5.5.1 Scan des images
      2. 5.5.2 Software Bill Of Material
      3. 5.5.3 Pour aller plus loin avec Kubernetes
6. 6. Azure Container Instances
   1. 6.1 Principe
   2. 6.2 Préparation d'une image
   3. 6.3 Lancement du conteneur
   4. 6.4 Correction de l'erreur et relance
   5. 6.5 Coût et effort
   11. Index