Optimisation des images Docker
Les développeurs aiment travailler avec Docker pour sa flexibilité et sa facilité d'utilisation. Lors de la création d'applications, il vaut la peine d'investir le temps supplémentaire d'optimiser les images Docker et Dockerfiles. L'optimisation aidera les équipes à partager des images plus petites, à améliorer les performances et à faciliter le débogage des problèmes. Vous trouverez ci-dessous quelques recommandations pour créer de meilleures images et dockerfiles.
Optimisation des images Docker
De grandes images Docker peuvent rendre difficile le partage. De plus, de grandes images ralentissent l'exécution. Ainsi, l'optimisation des images peut aider avec le développement global et le processus de production.
Sélectionnez les images de base appropriées
Les images disponibles sur Docker Hub sont déjà optimisées. Au lieu de construire le vôtre, c'est une bonne idée d'utiliser les images optimisées disponibles. Par exemple, si vous avez besoin d'une image redis, vous avez la possibilité de la construire sur une image Ubuntu ou de télécharger directement le redis. L'utilisation de l'image Redis déjà construite est une meilleure option car les développeurs ont déjà pris soin de tous les packages redondants.
Utiliser des versions multi-étages
La nouvelle option en plusieurs étapes dans Docker (depuis la version 17.05) peut vous aider à créer des moyens intelligents d'optimiser vos images. Vous pouvez créer une application, puis la transférer dans un nouvel environnement propre pour déployer. Il garantira que seules les bibliothèques et dépendances d'exécution nécessaires font partie de l'image finale.
Réduire le nombre de couches
Lors de la construction d'une image, faites attention aux couches créées par Dockerfiles. Chaque commande d'exécution crée un nouveau calque. Ainsi, la combinaison des couches peut réduire la taille de l'image. Un exemple simple est l'apt-get. Généralement, les utilisateurs exécutent la commande comme ceci:
Exécutez la mise à jour de l'apt-get -y |
Exécuter apt-get install -y python |
Il créera deux couches. Mais la combinaison des commandes créera une seule couche dans l'image finale:
Exécutez apt-get -y mise à jour et installation apt-get -y python |
Ainsi, des combinaisons intelligentes de commandes peuvent conduire à des images plus petites.
Créer des images de base personnalisées
Docker cache des images. Si vous avez besoin de plusieurs instances des mêmes couches, c'est une bonne idée de chercher à optimiser les couches et à créer une image de base personnalisée. Il accélérera les temps de chargement et facilitera le suivi.
Construire sur les images de production
Les images de test nécessitent plus d'outils et de bibliothèques pour tester les fonctionnalités. C'est une bonne idée d'utiliser l'image de production comme base et de créer des images de test par-dessus. Les fichiers de test inutiles seront en dehors de la base. Les images de production resteront donc petites et propres pour le déploiement.
Évitez de stocker les données d'application
Le stockage des données d'application dans le conteneur fera monter vos images. Pour les environnements de production, utilisez toujours la fonction de volume pour garder le conteneur séparé des données.
Meilleures pratiques pour écrire des dockerfiles
Dockerfiles permet aux développeurs de codifier les processus. Donc, c'est un excellent outil pour améliorer le processus de création d'images Docker. Voici quelques pratiques qui vous aideront à améliorer votre développement.
Concevoir des conteneurs éphémères
Essayez de concevoir des contenants faciles à créer et à détruire. Si les conteneurs dépendent trop des environnements et des configurations périphériques, ils sont plus difficiles à maintenir. La conception de conteneurs sans état peut donc aider à simplifier le système.
Utiliser .dockerignore pour optimiser les images
Si vous avez une version compliquée qui passe par plusieurs répertoires récursivement, tous les fichiers et répertoires sont envoyés au démon docker. Cela peut entraîner des images plus grandes et des temps de construction plus lents. Vous pouvez utiliser le .dockergnore pour exclure les fichiers et dossiers inutiles qui compliquent le processus de construction.
Utiliser des versions multi-étages
Les versions à plusieurs étages sont une nouvelle fonctionnalité Docker depuis la version 17.05. Il permet aux développeurs de créer plusieurs images dans le même dockerfile et de déplacer des artefacts d'un conteneur à un autre dans le docker lui-même. Vous pouvez donc avoir des artefacts plus petits et optimisés dans votre image finale sans utiliser de scripts compliqués pour obtenir les mêmes résultats.
Installez les packages requis uniquement
Dockerfile ne doit installer que les packages minimums nus nécessaires pour exécuter les services. Chaque paquet a besoin d'espace dans l'image. Ainsi, certaines applications comme Ping ou Text Editor peuvent être inutiles dans le contexte du service qui s'exécutera sur le conteneur. Comprendre les exigences d'un service particulier peut vous aider à écrire de meilleurs dockerfiles qui peuvent créer des images optimisées.
Pensez aux microservices
La conception de DockerFiles avec l'architecture des microservices peut être utile. Il n'est pas toujours possible de déployer un processus par conteneur. Mais les développeurs peuvent penser comment distribuer leurs processus de manière plus proactive et prendre des décisions qui aideront à déploier les services de manière découplée. Les conteneurs sont un ajustement naturel pour la conception modulaire. Ainsi, vos dockerfiles devraient profiter des opportunités que Docker offre.
Considérez l'effet des instructions sur les couches
Exécuter, copier et ajouter dans dockerfiles Créez de nouvelles couches depuis la version 1.dix. D'autres instructions n'ont pas d'impact direct sur la taille des images finales. Vous devez donc être vigilant lorsqu'ils utilisent ces commandes. En outre, la combinaison de plusieurs commandes peut diminuer le nombre de couches. Moins de couches signifient des tailles plus petites.
Trier les arguments multi-lignes
Chaque fois que vous avez un argument multi-lignes, triez les arguments de manière alphanumérique pour améliorer la maintenance du code. Les arguments aléatoires peuvent entraîner des duplications. Ils sont également plus difficiles à mettre à jour. Un bon exemple:
Exécutez la mise à jour apt-get && apt-get install -y \ |
apache2 \ |
git \ |
iPutils-ping \ |
Python \ |
Éviter d'utiliser: dernier
Si vous utilisez depuis [ImageName]: Dernière, vous pouvez rencontrer des problèmes chaque fois que l'image change. Cela peut devenir un problème difficile à tracer. L'utilisation de balises spécifiques peut vous assurer que vous connaissez l'image exacte utilisée à partir du registre Docker.
Ajouter uniquement les fichiers requis du répertoire
Les commandes DockerFile sont exécutées consécutivement pour construire des images et ne construit que des couches qui ne sont pas déjà présentes. Supposons que vous ayez un colis.JSON pour le NPM et les exigences.txt pour pip. Vous pouvez écrire le package DockerFile suivant.JSON et exigences.txt est dans le dossier mycode:
COPIE ./ mycode / / home / programme / |
Exécuter l'installation de NPM |
Exécuter les exigences de l'installation PIP -R |
Cependant, chaque fois qu'il y a un changement dans l'un des fichiers de MyCode, les deux commandes d'exécution doivent être reconstruites. Au lieu de cela, si le code est écrit de la manière suivante:
COPIE ./ mycode / package.JSON / Home / Program / Package.json |
Workdir / Home / Program |
Exécuter l'installation de NPM |
COPIE ./ mycode / exigences.TXT / Home / Program / Exigences.SMS |
Workdir / Home / Program |
Exécuter les exigences de l'installation PIP -R |
Ensuite, les commandes d'exécution seront indépendantes les unes des autres et le changement dans un seul fichier dans le dossier MyCode n'affectera pas les commandes NPM et PIP RUN. Regarder des dépendances comme celle-ci peut vous aider à écrire de meilleurs dockerfiles.
Une étude plus approfondie
Les techniques et les meilleures pratiques ci-dessus devraient vous aider à créer des images Docker plus petites et à écrire de meilleurs dockerfiles. Voici des liens pour vous aider à trouver plus d'informations sur différents sujets:
- Meilleures pratiques de développement docker
- Builds docker en plusieurs étapes
- Référence du fichier docker
Les références:
- https: // docs.docker.com / développer / dev-best-pratiques /
- https: // docs.docker.com / moteur / userguide / eng-image / dockerfile_best-practices /
- https: // docs.docker.com / moteur / userguide / eng-image / buasemages /
- https: // docs.docker.com / moteur / userguide / eng-image / multi-build /
- https: // blog.codes.com / réduction-docker-image-size /
- https: // hackernoon.com / TIPS-To-Reduce-Docker-Image-Size-876095DA3B34
- https: // docs.docker.com / moteur / référence / constructeur / # dockergnore-file
- https: // runnable.com / blog / 9-commodi-dockerfile-mistakes
https: // linuxhint.com / installer-and-use-docker-on-ubuntu /