Ecrire un Dockerfile. Meilleures pratiques

Nous publions une nouvelle traduction et espérons que les recommandations de l'auteur vous aideront à optimiser votre image Docker.

Depuis sa création, Docker a révolutionné la façon dont nous utilisons les conteneurs. Cela est principalement dû à la simplicité fournie par Docker. Il peut être utilisé sans même comprendre les sujets complexes des conteneurs.







Si vous êtes nouveau dans Docker, vous pouvez choisir un modèle (image de base) et définir vos instructions (commandes Dockerfile) pour placer votre code à l'intérieur de l'image et l'exécuter.



La simplicité de Docker vous guidera dès le début de son utilisation, et la compétence pour l'optimiser vient avec l'expérience et prend généralement du temps.



Je travaille avec Docker depuis longtemps, j'ai donc décidé de partager mon expérience sur la façon de mieux créer des conteneurs, même si vous êtes débutant.

1. Définissez les unités mises en cache ➱

Saviez-vous que chaque commande RUN incluse dans le Dockerfile affecte le niveau de mise en cache?



L'utilisation de plusieurs commandes RUN pour installer des packages affectera les performances et l'efficacité du processus de génération. L'utilisation d'une commande RUN pour installer tous les packages et dépendances vous aidera à créer une unité mise en cache au lieu de plusieurs.

RUN apt-get update && apt-get install -y \
    aufs-tools \
    automake \
    build-essential \
    curl \
    dpkg-sig \
    libcap-dev \
    libsqlite3-dev \
    mercurial \
    reprepro \
    ruby1.9.1 \
    ruby1.9.1-dev \
    s3cmd=1.1.*

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

2. Réduisez la taille de l'image

La taille de l'image joue un rôle important dans la création d'un bon Dockerfile. L'utilisation d'images plus petites facilite un déploiement plus rapide et réduit le potentiel d'attaques.



Supprimer les dépendances inutiles



Évitez d'installer des outils inutiles, tels que des outils de débogage, dans l'image.



Si le gestionnaire de packages utilise automatiquement les packages recommandés pour l'installation, utilisez les indicateurs du gestionnaire de packages et évitez d'installer des dépendances inutiles.

RUN apt-get update && apt-get -y install --no-install-recommends
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Astuce: partagez des composants réutilisables entre des projets à l'aide de Bit ( Github ).



Bit facilite la documentation, le partage et la réutilisation de composants indépendants entre les projets. Utilisez-le pour réutiliser le code, maintenir la cohérence de la conception, la collaboration en équipe, accélérer la livraison et créer des applications évolutives.



Bit prend en charge Node, TypeScript, React, Vue, Angular et plus encore.





Découvrez les composants publiés sur Bit.dev

3. Prise en charge de l'image

Le choix de la bonne image de base pour votre application est très important.



Utilisez l'image Docker officielle L'



utilisation de l'image Docker officielle réduit sa taille en réduisant les dépendances inutiles qui agrandissent l'image. Il y a 3 principaux avantages à utiliser l'image officielle:

• nous permet d'utiliser une image basée sur les meilleures pratiques,
• assure la fiabilité de l'image et sa sécurité,
• améliore la confiance et la sécurité.

#    
FROM node:13.12.0-alpine

#   
WORKDIR /app

#  `/app/node_modules/.bin`  $PATH
ENV PATH /app/node_modules/.bin:$PATH
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Utiliser des balises spécifiques



Lors du choix d'une image de base, il est recommandé d'utiliser une balise spécifique. N'utilisez pas la dernière balise pour l'image . La dernière balise peut subir des modifications radicales au fil du temps.

#    
FROM node:13.12.0-alpine
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Utilisez une version de construction minimale Une version



minimale réduit la taille de l'image finale. Cela vous permet de déployer des applications plus rapidement et de manière plus sécurisée.







Comme vous pouvez le voir dans l'exemple ci-dessus, lorsque vous utilisez la version minimale, la taille de l'image est plus petite. La plupart des images utilisent l'assemblage alpin. Alpine est une image très légère avec une taille standard de 2 Mo.



En utilisant une image alpine, nous pouvons réduire considérablement la taille de l'image résultante.

4. Reproductibilité

Construction à partir des sources dans un environnement cohérent



Si vous utilisez Docker, il est préférable de créer votre application dans un environnement géré pour assurer l'isolation.



Nous devons éviter de créer des applications localement et de les ajouter au registre.



Sinon, les packages que vous avez installés dans votre environnement local peuvent affecter la cohérence de l'image. Personne ne veut probablement être dans cette situation, car cela compromet l'un des principaux avantages de Docker - une exécution cohérente dans différents environnements.



Utilisation d'assemblys en plusieurs étapes pour supprimer les dépendances



Il est recommandé d'utiliser une méthode de déploiement d'application en plusieurs étapes.



Cela élimine l'utilisation de dépendances d'assembly dans un conteneur en cours d'exécution.



Nous pouvons créer l'application en utilisant une image de construction unique qui a des dépendances de développement et déplacer les binaires compilés dans une image de conteneur distincte pour l'exécuter.

# Stage 0, "build-stage", based on Node.js, to build and compile the frontend
FROM node:13.12.0 as build-stage
WORKDIR /app
COPY package*.json /app/
RUN npm install
COPY ./ /app/
RUN npm run build
# Stage 1, based on Nginx, to have only the compiled app, ready for production with Nginx
FROM nginx:1.15
COPY --from=build-stage /app/build/ /usr/share/nginx/html
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Il y a deux étapes distinctes dans le Dockerfile ci-dessus. L'étape 0 est utilisée pour créer une application de nœud à partir de l'image de nœud d'origine et l'étape 1 est utilisée pour copier les fichiers assemblés de l'image de construction vers l'image du serveur Web (Nginx) qui sert finalement l'application.

Conclusion

C'est tout ce que je voulais te dire. Si vous êtes nouveau dans Docker, je vous recommande d'essayer les pratiques décrites lors de la création de votre première image. Cela vous aidera à mieux comprendre le sujet et vous permettra d'utiliser efficacement Docker dès le premier jour.



Si vous connaissez d'autres pratiques intéressantes, partagez-les dans les commentaires. Merci d'avoir lu!