Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Docker - Concepts fondamentaux et déploiement d'applications conçues en services (2e édition)

Docker Concepts fondamentaux et déploiement d'applications conçues en services (2e édition)

4 avis

Informations

Livraison possible dès le 11 novembre 2024
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
Livres rédigés par des auteurs francophones et imprimés à Nantes

Caractéristiques

  • Livre (broché) - 17 x 21 cm
  • ISBN : 978-2-409-03806-8
  • EAN : 9782409038068
  • Ref. ENI : EI2DOC

Informations

  • Consultable en ligne immédiatement après validation du paiement et pour une durée de 10 ans.
  • Version HTML
Livres rédigés par des auteurs francophones et imprimés à Nantes

Caractéristiques

  • HTML
  • ISBN : 978-2-409-03807-5
  • EAN : 9782409038075
  • Ref. ENI : LNEI2DOC
Ce livre aborde les concepts de base de la technologie Docker, pour les mettre en œuvre dans le déploiement d’applications conçues en services. Il vous propose d'acquérir des bonnes pratiques pour intégrer Docker dans une application Blazor/ASP.NET Core. Le dernier chapitre aborde la simulation d'un déploiement industriel avec l'orchestration de conteneurs Swarm et Kubernetes ainsi que l'intégration et le déploiement continus avec Azure DevOps.
Consulter des extraits du livre en ligne Aperçu du livre papier
  • Niveau Confirmé à Expert
  • Nombre de pages 835 pages
  • Parution décembre 2022
  • Niveau Confirmé à Expert
  • Parution décembre 2022
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 œuvre dans le déploiement d’applications conçues en services.

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 œ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.


Quizinclus dans
la version en ligne !
  • Testez vos connaissances à l'issue de chaque chapitre
  • Validez vos acquis

Téléchargements

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
    6. Index
4,5/5 4 avis
Version papier

Le contenu du livre est très bien. Correspond à ce qu'on peut attendre de ce livre.

Alain A
Version en ligne

C'est bien, mais cela reste très light, pour le prix, c'est dommage.

Dimitri P
Version en ligne

trés bon livre

Jean-Louis C
Version en ligne

bon.

Anonyme
Auteur : Jean-Philippe GOUIGOUX

Jean-Philippe GOUIGOUX

Ingénieur avec un double diplôme en Génie des Systèmes Mécaniques et automatisation de l'Université de Technologie de Compiègne et de Cranfield University, Jean-Philippe GOUIGOUX travaille aujourd'hui pour Salvia Développement en tant que directeur technique d'un groupe de six business units, ce qui lui permet de mettre en œuvre son approche d'industrialisation de l'édition logicielle. Jean-Philippe GOUIGOUX est reconnu Microsoft MVP (Most Valuable Professional) dans diverses spécialités depuis 2011, et certifié TOGAF. 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.
En savoir plus

Découvrir tous ses livres

  • Kubernetes Mise en œuvre d'un cluster et déploiement de microservices (2e édition)
  • Docker et Kubernetes Coffrets de 2 livres :  Maîtrisez le déploiement d'applications conteneurisées
  • C# 10 Coffret de 2 livres - Écrivez du code performant et efficace
  • Ecrire du code .NET performant Profilage, benchmarking et bonnes pratiques (2e édition)
  • Docker - Concepts fondamentaux - Déploiement d'applications distribuées Livre avec complément vidéo : Compilation d'une image Docker
  • Comprendre Docker Prise en main des conteneurs
  • Docker en production Mise en oeuvre en cluster sur des microservices
  • Docker Swarm Mise en oeuvre du cluster et déploiement de conteneurs
  • Docker Mise en oeuvre en environnement Windows
  • Docker Mise en oeuvre sur une architecture microservices
  • Open Data Consommation, traitement, analyse et visualisation de la donnée publique

Nos nouveautés

voir plus