5 règles à suivre pour créer des images Docker de haute qualité | de Joel Belton | décembre 2022

Posté Par: Windows2022tutosur: décembre 14, 2022Dans: Node JsPas De Commentaires

2. Choisissez judicieusement votre image de base

Docker est devenu un incontournable dans le monde du développement logiciel. Tout le monde et leur mère profitent de la flexibilité des microservices. Mais même après sa montée en popularité rapide, je vois toujours des développeurs l’utiliser de manière inefficace ; tant de gens ont compris les bases mais manquent de cet avantage expert pour aller jusqu’au bout.

Vous pourriez penser que l’écriture d’un Dockerfile devrait être un processus simple, mais en réalité, il peut y avoir beaucoup de choses à faire pour créer une image prête pour la production.

Des DockerFiles non optimisés conduiront généralement à une image globale plus grande. Cela crée un vecteur d’attaque plus important pour les menaces et peut augmenter la probabilité de vulnérabilités de sécurité. Tout cela est une mauvaise nouvelle pour votre application.

Aujourd’hui, nous allons nous concentrer sur quelques bonnes pratiques pour créer des fichiers Docker afin de créer des images efficaces et de haute qualité.

En 2017, Docker 17.06 CE est sorti, et avec lui est venu le outil de construction en plusieurs étapes. C’était la tentative de Docker d’implémenter un Modèle de constructeur fonctionnalité à l’outil, et il doit s’agir de l’une des fonctionnalités les plus sous-utilisées de Docker.

La construction en plusieurs étapes tire parti de l’utilisation de plusieurs FROM commandes dans un Dockerfile . Chacune de ces instructions s’appuiera sur les étapes précédentes et en créera de nouvelles. En construisant progressivement comme ceci, nous pouvons séparer toutes les étapes dont nous n’aurons pas besoin dans l’application finale et les éliminer, économisant ainsi de l’espace.

Par exemple, nous pouvons créer une étape de construction où nous installons certaines dépendances, téléchargeons notre code, exécutons des tests, etc. Mais comme la plupart de ces éléments ne sont pas nécessaires dans l’image finale, nous pouvons les supprimer avant qu’ils n’atteignent notre version finale. . Nous compilons notre application au stade de la construction et ne copions notre code compilé que dans l’image finale allégée pour l’exécution.

Prenons un exemple :

# First, specify a base image that has the dependencies and tools needed to build your application
FROM golang:1.14 as builder# Copy your application code into the image
COPY . /app
# Use the RUN command to build your application
RUN cd /app && go build -o myapp
# Now, create a new stage using a lightweight base image
# that only has the dependencies needed to run your application
FROM alpine:3.12
# Copy the compiled binary from the previous stage into this stage
COPY --from=builder /app/myapp /usr/local/bin/myapp
# Set the default command to run when a container is started from this image
CMD ["myapp"]

L’utilisation de cette technique de construction en plusieurs étapes dans Docker présente plusieurs avantages :

Efficacité et performances améliorées : en créant plusieurs étapes dans votre Dockerfile, vous pouvez isoler les différentes étapes de votre processus de construction et n’inclure que les fichiers et dépendances nécessaires à chaque étape. Cela peut vous aider à créer des images Docker plus efficaces et plus légères, plus faciles à gérer et à entretenir.
Taille d’image réduite : en utilisant une image de base légère à l’étape finale de votre build, vous pouvez réduire la taille de vos images Docker et faciliter leur distribution et leur déploiement. Cela peut être particulièrement utile si vous déployez vos conteneurs dans un environnement à ressources limitées, tel qu’une plate-forme de conteneurs basée sur le cloud.
Sécurité améliorée : en utilisant une construction en plusieurs étapes, vous pouvez éviter d’inclure des informations sensibles ou confidentielles dans vos images Docker finales. Cela peut aider à protéger votre application et vos utilisateurs, et cela peut également vous aider à vous conformer aux réglementations en matière de sécurité et de confidentialité.

Dans l’ensemble, la technique de construction en plusieurs étapes est impérative pour créer des images de haute qualité qui sont à la fois plus efficaces et plus faciles à entretenir.

Vous pouvez écrire le meilleur Dockerfile que le monde ait jamais vu, mais si vous utilisez la mauvaise image de base, c’est du gâchis. Chaque fois que vous utilisez le From commande, vous prenez tout le code de l’image précédente et de chaque image dont elle hérite. Assurez-vous donc de démarrer le Dockerfile avec une image de base contenant tout ce dont votre application a besoin pour s’exécuter, comme une version spécifique d’un système d’exploitation. Cela rendra votre Dockerfile plus efficace et réduira la taille de l’image finale.

Vous devriez viser à considérer les éléments suivants :

Compatibilité avec votre application : l’image de base doit inclure le système d’exploitation et les dépendances dont votre application a besoin pour s’exécuter. Cela peut inclure des versions spécifiques des runtimes de langage, des bibliothèques ou des outils dont dépend votre application.
Taille et Efficacité: L’image de base doit être aussi petite et efficace que possible pour réduire la taille de votre image Docker finale et améliorer les performances.
Sécurité: L’image de base doit être sécurisée et bien entretenue, avec des mises à jour et des correctifs de sécurité réguliers. Cela aidera à protéger votre application et vos utilisateurs contre les vulnérabilités et autres risques de sécurité.
Réputation et fiabilité: L’image de base doit provenir d’une source fiable, et elle doit être largement utilisée et bien testée dans la communauté Docker.
Souplesse et personnalisation: L’image de base doit être suffisamment flexible pour vous permettre de la personnaliser et d’ajouter vos propres dépendances et configuration. Cela vous donnera plus de contrôle sur l’image Docker finale et vous permettra d’adapter l’image de base à vos besoins spécifiques.

Une autre bonne pratique consiste à utiliser ENV pour définir vos variables d’environnement. Cela rendra vos conteneurs plus portables et vous évitera de modifier quoi que ce soit concernant le système d’exploitation Linux dans le conteneur sans modifier le système d’exploitation du système hôte.

# Start with a base image that has the dependencies and tools needed to run your application
FROM python:3.8# Use the ENV command to define your environment variables
ENV APP_NAME="My Application"
ENV APP_PORT=5000
# Use the COPY or ADD command to add your application code to the image
COPY . /app
# Use the RUN command to install any additional dependencies and perform other setup tasks
RUN pip install -r /app/requirements.txt
# Use the EXPOSE command to specify the ports that your application listens on
EXPOSE 5000
# Use the CMD command to specify the default command that should be run when a container is started from your image
CMD ["python", "/app/main.py"]

Par exemple, vous pouvez utiliser le APP_NAME variable dans votre code d’application pour afficher le nom de votre application, et vous pouvez utiliser la APP_PORT variable pour spécifier le port sur lequel votre application écoute.

La ENV La commande peut être utilisée pour définir n’importe quel nombre de variables d’environnement, et vous pouvez utiliser la commande ENV commande plusieurs fois dans votre Dockerfile si nécessaire. Cela peut faciliter la gestion et la configuration de votre application lorsqu’elle s’exécute dans un conteneur Docker.

Faites également attention aux ports qui sont exposés. Par défaut, Docker exposera tous vos conteneurs à une gamme de ports internes aléatoires. Cela peut constituer un risque pour la sécurité, donc si vous utilisez un service qui doit être exposé à l’Internet public, assurez-vous de créer une entrée dans votre Dockerfile.

Télécharger ici