![Docker - eni - 9782409038068 -](https://www.unitheque.com/Intermediaire3/CouvertureD/O/9782409038068-docker_g.jpg)
Docker
Concepts fondamentaux et déploiement d'applications conçues en services
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 [...]
[lire le résumé du livre]
Auteur : Jean-Philippe GOUIGOUX
Editeur : Eni
Collection : Expert IT
Date parution : 12/2022 2e éditionCB Google/Apple Pay, Chèque, Virement
Quel est le sujet du livre "Docker"
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 !Téléchargements
Ingénieur UTC en Génie des Systèmes Mécaniques, diplômé de l'université de Cranfield en Angleterre et de l'Université Jean Moulin Lyon III, Jean-Philippe GOUIGOUX est aujourd'hui directeur technique d'un groupe de six éditeurs logiciels. Certifié TOGAF, il se spécialise en urbanisation des systèmes d'information et sait le valoriser à la fois dans son environnement professionnel avec la mise en place d'API normalisées permettant des intégrations puissantes et peu coûteuses, ainsi que dans le cadre de la recherche académique sur les architectures de microservices. Jean-Philippe GOUIGOUX est reconnu Microsoft MVP (Most Valuable Professional) dans diverses spécialités depuis 2011. Il intervient régulièrement en université ou lors de conférences sur des sujets informatiques variés tels que la gestion de données, Docker ou la performance en .NET. Passionné par le partage de ses connaissances, il est auteur de plusieurs livres et vidéos parus aux Éditions ENI. Suivez Jean-Philippe GOUIGOUX : https://www.linkedin.com/in/jp-gouigoux/
En suivant ce lien, retrouvez tous les livres dans la spécialité Informatique industrielle - Automatique - Robotique.
Sommaire et contenu du livre "Docker - Concepts fondamentaux et déploiement d'applications conçues en services"
Principes fondamentaux
- 1. Positionnement de Docker
- 1.1 La problématique racine
- 1.2 Approche par augmentation des ressources physiques
- 1.3 Approche par parallélisation des traitements
- 1.4 L'approche par virtualisation
- 1.5 Tentatives de réduction de la consommation de ressources
- 1.6 Comment Docker règle radicalement le problème
- 1.7 Positionnement de Docker par rapport à la virtualisation
- 1.8 Positionnement de Docker par rapport aux clusters
- 1.9 Positionnement de Docker par rapport aux approches de bacs-à-sable
- 2. Principe des conteneurs
- 2.1 Les apports de Docker
- 2.2 Principe des conteneurs industriels
- 2.3 Docker et l'approche normalisée
- 3. Les fondements de Docker
- 3.1 Les technologies Linux clés pour Docker
- 3.1.1 Namespaces
- 3.1.2 Mise en œuvre d'un namespace
- 3.1.3 cgroups
- 3.1.4 chroot
- 3.1 Les technologies Linux clés pour Docker
- 3.2 Autres dépendances du système
- 3.2.1 netfilter et iptables
- 3.2.2 capabilities
- 3.2.3 AppArmor et SELinux
- 3.3 Architecture du moteur Docker
- 3.3.1 LXC
- 3.3.2 libcontainer
- 3.3.3 containerd
- 3.4 Architectures complémentaires
- 3.4.1 rkt
- 3.4.2 Container Runtime Interface
- 3.4.3 Un foisonnement d'alternatives
- 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.1 Au-delà du cloisonnement Linux
- 4.2 L'approche un conteneur = un processus
- 4.3 L’écosystème Docker
- 5.1 Historique des architectures de services
- 5.1.1 Principes
- 5.1.2 Approche EAI
- 5.1.3 Approche SOA
- 5.1.4 Microservices
- 5.1.5 Lien à l'urbanisation des SI
- 5.2.1 Principe
- 5.2.2 Avantages
- 5.2.3 Inconvénients
Installation
- 1. Éditions et canaux
- 1.1 Un standard sous Linux
- 1.2 Les canaux
- 1.3 Les éditions
- 2. Utiliser des machines dans le cloud
- 2.1 Amazon AWS
- 2.1.1 Offre
- 2.1.2 Création de la machine virtuelle
- 2.1.3 Accès à la machine virtuelle
- 2.1.4 Gestion de la consommation
- 2.1.5 Suppression de la machine virtuelle
- 2.1 Amazon AWS
- 2.2 Microsoft Azure
- 2.2.1 Offre
- 2.2.2 Création de la machine virtuelle
- 2.2.3 Accès à la machine virtuelle
- 2.2.4 Suppression de la machine virtuelle
- 2.3 Google Cloud Platform
- 2.3.1 Offre
- 2.3.2 Création de la machine virtuelle
- 2.3.3 Accès à la machine virtuelle
- 2.3.4 Suppression de la machine virtuelle
- 3.1 Installation de Docker sur Linux
- 3.1.1 Prérequis
- 3.1.2 Gestionnaires de paquets
- 3.1.3 Installation par script
- 3.1.4 Cas particulier de l'installation sur Clear Linux
- 3.2.1 Des technologies différentes
- 3.2.2 Docker et Hyper-V
- 3.2.3 L'âge de la maturité
- 3.3.1 Outil d'installation
- 3.3.2 Choix du canal
- 3.3.3 Assistant d'installation
- 3.3.4 Mises à jour
- 3.3.5 Support natif de conteneurs Linux sous Windows avec WSL 2
- 3.3.6 Les nouveautés de Docker Desktop
- 3.3.7 Désinstallation
- 3.4.1 Prérequis pour Windows Server 2022
- 3.4.2 Installation
- 3.4.3 Utilisation de machines préinstallées
- 3.4.4 Exécution de conteneurs Linux
- 3.4.5 Paramétrage système
- 3.5.1 Principe
- 3.5.2 Création d'une machine
- 3.5.3 Provisionnement de Docker
- 3.5.4 Aménagement de l'accès à la machine
- 3.5.5 Connexion à la machine provisionnée
- 3.5.6 Poursuite des opérations Vagrant
Premiers pas avec Docker
- 1. Hello World, Docker
- 1.1 Démarrage d'un conteneur simple
- 1.2 Détails des opérations effectuées
- 1.2.1 Récupération d'une image
- 1.2.2 Identité de l'image
- 1.2.3 Taille des images
- 1.2.4 Anatomie de l'image Linux
- 1.2.5 Anatomie de l'image Windows
- 1.2.6 Lancement du processus
- 1.2.7 Exécution du processus dans un conteneur
- 1.2.8 Opérations suivant l'exécution
- 2.1 Le registre Docker Hub
- 2.1.1 Le principe
- 2.1.2 Recherche et qualification d'images
- 2.1.3 Exemple de recherche
- 2.1.4 Cas des images communautaires
- 2.1.5 Compléments sur les images officielles
- 2.1.6 Recherche par la ligne de commande
- 2.1.7 Précautions sur une image non officielle
- 2.2.1 Création d'un compte
- 2.2.2 Caractéristiques du compte
- 2.2.3 Automated build
- 2.2.4 Connexion au compte en ligne de commande
- 2.2.5 Webhook sur événement de push dans Docker Hub
- 3.1 Récupération de l'image
- 3.2 Explication des tags
- 3.3 Premier lancement
- 3.4 Lancement en mode interactif
- 3.5 Persistance des modifications sous forme d'une image
- 3.6 Prise en main du client Docker
- 3.6.1 Ménage dans les conteneurs
- 3.6.2 Ménage dans les images
- 3.6.3 Le grand ménage
- 3.6.4 Suppression automatique à la sortie
- 3.6.5 Affectation d'un nom de conteneur
- 3.6.6 Modification du point d'entrée par défaut
- 3.6.7 Envoi de variables d'environnement
- 3.6.8 Modification du hostname
- 3.7.1 Lancement en mode bloquant
- 3.7.2 Lancement en arrière-plan
- 3.7.3 Gestion correcte du cycle de vie des conteneurs
- 3.7.4 Exposition de fichiers
- 3.7.5 Supervision des conteneurs
Création et gestion d’images Docker
- 1. Création manuelle d'une nouvelle image
- 1.1 Objectif
- 1.2 Approche
- 1.3 Difficultés
- 1.4 Conclusion
- 2. Utilisation d’un fichier Dockerfile
- 2.1 Intérêt des fichiers Dockerfile
- 2.2 Utilisation d'un fichier Dockerfile
- 2.3 Anatomie d'un fichier Dockerfile
- 2.3.1 FROM
- 2.3.2 RUN
- 2.3.3 ENV
- 2.3.4 VOLUME
- 2.3.5 COPY
- 2.3.6 ENTRYPOINT
- 2.3.7 EXPOSE
- 2.3.8 CMD
- 2.4 Notre premier fichier Dockerfile
- 2.4.1 Fonctionnalité souhaitée
- 2.4.2 Création et test du script
- 2.4.3 Création du Dockerfile
- 2.4.4 Génération de l'image
- 2.4.5 Lancement du conteneur
- 2.4.6 Arrêt et relance du conteneur
- 2.4.7 Une méthode moins brutale
- 2.4.8 Gestion des paramètres
- 2.4.9 Reconstruction de l'image et cache
- 2.5 Commandes additionnelles
- 2.5.1 Gestion des fichiers
- 2.5.2 Notion de contexte
- 2.5.3 Retours sur l'affectation du processus à démarrer
- 2.5.4 Remarque sur le format ligne de commande ou exécution
- 2.5.5 Commandes diverses
- 3.1 Envoi sur votre compte Docker Hub
- 3.2 Export et import sous forme de fichiers
- 4.1 Principe du cache local d'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 fichier 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.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 fichier Dockerfile
- 4.6.1 La bonne image de base
- 4.6.2 Votre propre image de base
- 4.6.3 Adapter l'image de base avec les compilations multi-stage
- 4.7.1 Avantage d'une arborescence type
- 4.7.2 Intégration des fichiers
- 4.7.3 Limitation du contexte
- 4.8.1 Principe général
- 4.8.2 Exception au principe général avec Supervisor
- 4.8.3 Critique
- 4.8.4 Approche intermédiaire
- 5.1 Objectifs
- 5.2 Votre registre en complète autonomie
- 5.2.1 Image à utiliser
- 5.2.2 Lancement du registre
- 5.2.3 Utilisation du registre
- 5.3.1 Limites en termes d'utilisation
- 5.3.2 Limites en termes de sécurité
- 5.3.3 Limites en termes de performance
- 5.3.4 Limites en termes de stockage
- 5.3.5 Et toutes les autres limitations d'un registre autogéré
- 5.4.1 Azure Container Registry
- 5.4.2 Notes finales
- 5.5.1 L'API du registre
- 5.5.2 Mise en place d'un miroir
- 6.1 Positionnement de Docker dans une usine logicielle
- 6.1.1 Déploiement
- 6.1.2 Compilation
- 6.1.3 Infrastructure de l'usine logicielle
- 6.1.4 Gestion des tests
- 6.1.5 Utilisation pour les machines supports de tests
- 6.1.6 Registre pour l'ALM
- 6.2.1 Choix des outils
- 6.2.2 Création du projet
- 6.2.3 Analyse du fichier Dockerfile généré
- 6.2.4 Prérequis pour l’intégration continue
Mise en œuvre pratique
- 1. Présentation de l'application exemple
- 1.1 Architecture
- 1.2 Création d'un fichier des mots de passe
- 1.2.1 Principe de sécurité
- 1.2.2 Installation de KeePass
- 1.2.3 Création du fichier de sécurité
- 1.2.4 Remplissage du fichier de mots de passe
- 1.3 Mise en place des certificats de sécurité
- 1.3.1 Certificat racine
- 1.3.2 Certificat client
- 1.4 Prérequis
- 1.5 Paramétrage
- 1.5.1 Paramétrage de l'IAM
- 1.5.2 Paramétrage de RecepteurMessages
- 1.5.3 Paramétrage du projet API
- 1.5.4 Autres projets
- 1.5.5 Paramétrage de la solution
- 1.6 Première utilisation
- 1.6.1 Scénario nominal de test
- 1.6.2 Persistance
- 1.6.3 Observation des documents
- 1.7 Utilité
- 1.8 Principes à l'œuvre
- 1.8.1 Un mot sur les architectures de services
- 1.8.2 Lien avec la programmation SOLID
- 2.1 Préparation de l'environnement
- 2.2 Principes de construction
- 2.3 Détails du service RecepteurMessages
- 2.3.1 Fonctionnement
- 2.3.2 Construction du fichier Dockerfile de base
- 2.3.3 Classification du support des paramètres
- 2.3.4 Cas particulier des paramètres de sécurité
- 2.3.5 Modification du projet pour gestion des paramètres
- 2.3.6 Évolution du fichier Dockerfile
- 2.4.1 Compilation
- 2.4.2 Test de lancement
- 2.4.3 Conteneurs en réseau
- 2.4.4 Utilisation d'un volume pour pointer sur le certificat
- 2.5.1 Paramétrage du projet en mode Docker
- 2.5.2 Tests d'intégration
- 2.5.3 Publication intégrée
- 2.6.1 Approche simpliste par variable d'environnement
- 2.6.2 Gestion des secrets dans Docker
- 2.6.3 Mise en place du fichier pour Docker Compose
- 2.6.4 Mise en place de la trace de diagnostic
- 2.6.5 Description du problème d'ordonnancement
- 2.6.6 Validation du fonctionnement en mode Docker
- 2.8.1 Passage en mode Docker du projet
- 2.8.2 Classification des paramétrages disponibles
- 2.8.3 Ajustement du fichier Dockerfile
- 2.8.4 Ajout des valeurs pour les paramètres
- 2.8.5 Mise à jour du fichier Docker Compose
- 2.8.6 Correction paramétrage d'appel du service API
- 2.8.7 Test du projet en mode Docker
- 2.9.1 Passage en mode Docker du projet
- 2.9.2 Classification des paramètres disponibles
- 2.9.3 Ajustement du fichier Dockerfile
- 2.9.4 Ajout des valeurs pour les paramètres
- 2.9.5 Mise à jour du fichier Docker Compose
- 2.11.1 Principe
- 2.11.2 Débogage du problème de volume
- 2.11.3 Débogage du problème de nom de serveur RabbitMQ
- 2.11.4 Débogage du problème d'accès à l'IAM
- 2.11.5 Débogage du chargement des personnes
- 2.11.6 Débogage de l'authentification serveur
Orchestration par Docker Compose
- 1. Redéployer automatiquement avec Docker Compose
- 1.1 Principe de Docker Compose
- 1.2 Écriture du fichier docker-compose.yml
- 1.2.1 Remarques préliminaires
- 1.2.2 Préparation du squelette du fichier
- 1.2.3 Mise en place des dépendances externes
- 1.2.4 Ajout de la détection de statut des services
- 1.2.5 Inclusion du projet RecepteurMessages
- 1.2.6 Ajout du projet API
- 1.2.7 Finalisation avec le projet Server
- 1.3 Mise en œuvre
- 1.3.1 Exclusion du mode HTTPS
- 1.3.2 Premier lancement
- 1.3.3 Retour sur le problème d'authentification
- 1.3.4 Tentative de résolution par le réseau hôte
- 1.3.5 Stratégie d'externalisation de l'IAM
- 1.4 Mise en œuvre avec IAM externalisée
- 1.4.1 Préparation d'une machine dans le cloud
- 1.4.2 Ajout de Docker dans Clear Linux
- 1.4.3 Préparation de l'application Keycloak complète
- 1.4.4 Passage de Keycloak en HTTPS
- 1.4.5 Ajout de la persistance pour la configuration Keycloak
- 1.4.6 Gestion de la robustesse par un service Linux
- 1.4.7 Ajustement de l'application exemple
- 1.4.8 Test final
- 1.5 Débogages complémentaires du mode Docker Compose
- 1.5.1 Astuce préliminaire
- 1.5.2 Gestion de la génération de PDF en mode Linux
- 1.5.3 Intégration des polices pour la génération de PDF
- 1.5.4 Exposition différenciée des ports de la GED
- 1.5.5 Exposition en HTTPS du projet API
- 1.5.6 Passage de l'appel d'API en HTTPS
- 1.5.7 Ménage dans les paramètres
- 2.1 Retour sur la gestion des conteneurs
- 2.2 Parallélisation des traitements
- 2.3 Autre avantage de l'approche par conteneurs
- 2.4 Limites de l'application exemple
- 2.5 Intégration dans Visual Studio
- 2.5.1 Argumentaire
- 2.5.2 Mise en œuvre
- 2.5.3 Gestion des profils de lancement
- 3.1 Le réseau dans Docker
- 3.1.1 Mode de fonctionnement standard (bridge)
- 3.1.2 Modes de fonctionnement alternatifs
- 3.1.3 Support des liens entre conteneurs
- 3.1.4 Gestion des réseaux overlay
- 3.1.5 Alias préinstallés
- 3.2.1 Le problème de la persistance
- 3.2.2 Les volumes comme solution simple
- 3.2.3 Lien direct sur un répertoire local
- 3.2.4 Partage de volumes
- 3.2.5 Gestion des volumes orphelins
- 3.2.6 Sophistication de l'approche
- 3.2.7 Application à la gestion des logs
- 3.2.8 Volumes déclarés
- 3.2.9 Plugins pour la gestion avancée des volumes
- 4.1 Java
- 4.1.1 Image Java
- 4.1.2 Image openjdk
- 4.1.3 Image Maven
- 4.2.1 Mode ligne de commande
- 4.2.2 Mode serveur web
Déploiement en cluster par une usine logicielle
- 1. Le besoin d'orchestration
- 1.1 Objectif
- 1.2 Approche théorique
- 1.2.1 La problématique de montée en charge
- 1.2.2 La solution découplée
- 1.2.3 Conséquences sur l'approche initiale
- 1.3 Lien aux microservices
- 1.3.1 Orchestration des services
- 1.3.2 Elasticité
- 1.3.3 Robustesse
- 1.4 Fonctionnement pratique
- 1.4.1 Notion de réseau
- 1.4.2 Les différents types de nœuds
- 1.4.3 Fonctionnalités du cluster
- 2.1 Gestion du cluster Swarm
- 2.1.1 Prérequis
- 2.1.2 Alternative aux prérequis
- 2.1.3 Initialisation
- 2.1.4 Liaison des agents
- 2.1.5 Ajout d'un manager
- 2.1.6 Les limites à l'ajout de managers
- 2.1.7 Promotion d'un nœud
- 2.1.8 Suppression d'un nœud
- 2.3.1 Application exemple
- 2.3.2 Préparation des images
- 2.3.3 Lancement des services
- 2.3.4 Premier test
- 2.3.5 Mise en place d'un réseau overlay dédié
- 2.3.6 Validation du fonctionnement
- 2.3.7 Passage à l'échelle
- 2.3.8 Suppression des ressources déployées
- 2.4.1 Récupérer l'application exemple
- 2.4.2 Le retour partiel de Docker Compose
- 2.4.3 Détail du vocabulaire
- 2.4.4 Compilation éventuelle des images
- 2.4.5 Lancement par Docker Compose
- 2.4.6 Déploiement d'une stack
- 2.4.7 Autres avertissements possibles
- 2.4.8 Diagnostic et validation du fonctionnement
- 2.4.9 Mise au point du déploiement
- 2.4.10 Utilisation de l'ingress
- 2.4.11 Déploiement de l'IAM sur Docker Swarm
- 2.4.12 Ajustement de la stack applicative
- 2.4.13 Débogage du service de traitement des messages
- 2.5.1 Provenance des images
- 2.5.2 Passage à l'échelle
- 2.5.3 Mise à jour des images
- 2.5.4 Gestion des contraintes
- 2.5.5 Arrêt de la stack
- 3.1 Traefik
- 3.1.1 Utilité
- 3.1.2 Lancement
- 3.1.3 Mise en œuvre sur l'application exemple
- 3.1.4 Vérification du fonctionnement
- 3.2.1 Présentation
- 3.2.2 Réunification des stacks
- 3.2.3 Remplacement de Traefik par Caddy
- 3.2.4 Exposition simpliste pour test
- 3.2.5 Ajout d'un fichier de configuration
- 3.2.6 Modifications complémentaires
- 3.2.7 Conclusion sur Caddy
- 4.1 Positionnement
- 4.2 Comparaison avec Docker Swarm
- 4.3 Concepts
- 4.3.1 Pods
- 4.3.2 Namespaces
- 4.3.3 Services
- 4.3.4 IngressController
- 4.3.5 Volumes
- 4.3.6 ConfigMap
- 4.3.7 Deployment
- 4.4.1 Choix de la méthode
- 4.4.2 Création d'un cluster AKS
- 4.4.3 Paramétrage de l'accès au cluster
- 4.4.4 Accès au cluster
- 4.5.1 Contexte
- 4.5.2 Création du déploiement
- 4.5.3 Vérification du déploiement
- 4.5.4 Présence d'un pod
- 4.5.5 Exposition par un service
- 4.5.6 Test de l’application
- 4.5.7 Nettoyage
- 5.1 Approche
- 5.2 Intégration continue de l'application exemple
- 5.2.1 Création du projet Azure DevOps
- 5.2.2 Création d'un pipeline de compilation pour le projet Server
- 5.2.3 Correction du problème de compilation
- 5.2.4 Remarques sur l'intégration des plateformes
- 5.3.1 Objectifs
- 5.3.2 Création du namespace
- 5.3.3 Notion de fichier descriptif
- 5.3.4 Mise en place de l'ingress
- 5.3.5 Application au service Server
- 5.3.6 Gestion des paramètres
- 5.3.7 Déploiement du service GED
- 5.3.8 Gestion des secrets sous forme de fichiers
- 5.3.9 Digression sur la gestion des images
- 5.3.10 Retour sur la gestion des secrets
- 5.3.11 Gestion des secrets sous forme de chaînes
- 5.3.12 Gestion du healthcheck
- 5.3.13 Débogage des démarrages suspendus
- 5.3.14 Retour sur le ConfigMap
- 5.3.15 Gestion d'une application en mode console
- 5.3.16 Démarrage à l'échelle
- 5.3.17 Ajustement du DNS du service
- 5.3.18 Cas particulier de l'IAM
- 5.3.19 Gestion des consommations de ressources
- 5.3.20 Remarques sur les labels
- 5.3.21 Gestion des volumes
- 5.3.22 Lancement d'un seul coup
- 5.3.23 Arrêt de l'application
- 5.4.1 Objectif
- 5.4.2 Mécanisme utilisé
- 5.4.3 Paramétrage dans Azure DevOps
- 5.4.4 Ménage
- 5.5.1 Scan des images
- 5.5.2 Software Bill Of Material
- 5.5.3 Pour aller plus loin avec Kubernetes
- 6.1 Principe
- 6.2 Préparation d'une image
- 6.3 Lancement du conteneur
- 6.4 Correction de l'erreur et relance
- 6.5 Coût et effort
- Index