Comment construire une image avec le dockerfile

de la création d'applications, de l'installation des dépendances et des services au déploiement automatisé, et plus encore - tout commence par Dockerfile. Prenons la syntaxe de Dockerfile, de la base à la complexité, et quelques meilleures pratiques lors de la construction d'images Docker.

Ce guide écrira un dockerfile docker qui guide docker pour sélectionner un Linux minimisée (image de base) pour les applications que nous fournirons, et est livrée avec notre ensemble d'outils sélectionné et notre configuration spécifique pour créer efficacement notre propre distribution Linux, cette distribution est juste correcte adapté à l'exécution de nos applications.

points clés

Docker permet aux utilisateurs de «créer, livrer et exécuter n'importe quelle application, peu importe où elle est» en emballant l'application avec tous ses binaires, les bibliothèques d'exécution, les outils backend, les ajustements et les services du système d'exploitation. livré immédiatement et déployé automatiquement.
dockerfile est un fichier texte brut contenant des instructions pour la création d'images dans Docker, qui est le point de départ pour la création d'applications, l'installation de dépendances et les services et le déploiement automatisé. La syntaxe de Dockerfile est similaire à celle des fichiers de configuration Apache et est traitée une instruction après l'autre.
DockerFile demande à Docker de sélectionner une image de base (par exemple, Linux minimisé) pour que l'application soit livrée, et est livré avec un ensemble d'outils sélectionnés et de configurations spécifiques, créant efficacement une distribution Linux personnalisée adaptée à l'exécution de l'application.
dockerfile vous permet de sélectionner et d'installer des outils et des bibliothèques spécifiques, définir des variables d'environnement, ajouter des fichiers et des répertoires, gérer les problèmes de cache, etc. pour s'assurer que le conteneur a tout ce dont vous avez besoin.
• La commande docker build est utilisée pour construire des images en fonction des instructions dans le dockerfile, tandis que la commande docker run est utilisée pour démarrer un terminal interactif avec des images créées.
Pourquoi choisir Docker

avec Docker, vous pouvez "construire, livrer et exécuter n'importe quelle application, peu importe où vous êtes." Autrement dit, vous pouvez emballer votre application avec toutes les bibliothèques binaires et d'exécution, les outils backend, le réglage du système d'exploitation et même les services spécifiques requis pour que l'application s'exécute - et permettez-lui d'être livrée et déployée automatiquement.

La technologie de conteneur logiciel implémenté Docker rend cela possible. Bien que je n'entre pas dans les détails derrière cela ici, vous pouvez en savoir plus sur Docker, ce que sont les conteneurs logiciels et comment ils fonctionnent pour comprendre Docker, les conteneurs et la livraison de logiciels plus sûrs.

Installation de Docker

Avant de commencer, vous devez installer Docker, que ce soit sur la machine locale ou sur un serveur distant.

Heureusement, la dernière version de Docker (version 1.12 à ce jour) rend le processus d'installation très fluide, et vous pouvez obtenir un guide simple et facile à comprendre pour Windows, MacOS et Linux.

dockerfile

Pour construire l'image dans Docker, vous devez d'abord définir la directive pour cette version et le contexte dans un fichier texte brut appelé dockerfile (plus à ce sujet plus tard). Ce fichier a une syntaxe similaire au fichier de configuration Apache - une instruction par ligne et ses paramètres correspondants, toutes les instructions sont traitées en séquence. Les commentaires commencent par # des personnages et des espaces. Enfin, une fois que vous aurez le dockerfile, la construction Docker Build créera l'image, que nous couvrirons plus en détail plus tard.

Avant de commencer à écrire le dockerfile, nous installerons l'espace de travail. Nous allons créer un répertoire appelé my_image dans le répertoire domestique, l'utiliser comme notre répertoire de travail et y placer le dockerfile:

mkdir ~/my_build
cd ~/my_build
touch Dockerfile

Maintenant, nous sommes prêts à commencer à construire l'image.

Sélectionner le miroir de base

Lors de la création d'une image, dans la plupart des cas, vous utiliserez un point de départ, c'est-à-dire une autre image. Cela pourrait être l'Ubuntu officiel, MySQL, WordPress ou toute autre image disponible dans Docker Hub. Vous pouvez également utiliser les images que vous avez créées vous-même auparavant.

Remarque : Vous pouvez créer votre propre image de base à l'aide de l'image minimale de Docker (appelé Scratch) qui contient vos propres outils de base et structure de répertoire. Je ne couvrirai pas ce processus ici, mais vous pouvez vous référer au guide sur la création d'images de base sur le site Web de Docker.

Par exemple, si vous souhaitez commencer par une distribution Debian minimisée, vous ajouterez ce qui suit à votre dockerfile:

# 设置基础镜像
FROM debian

de doit être la première instruction que vous utilisez lors de la rédaction d'un dockerfile. Notez que vous pouvez également utiliser une version spécifique de l'image de base en ajoutant: et version_name à la fin du nom de l'image. Par exemple:

# 设置基础镜像
FROM debian:sid

Dans le code ci-dessus, nous utilisons "Sid" Debian (distribution instable). Ceci est également important lorsque vous avez besoin d'une version spécifique de l'interprète Ruby ou Python, de la version MySQL, etc. Lorsque vous utilisez l'image de base officielle de l'un de ces outils. Actuellement, dans ce guide, nous nous en tiendrons à l'image Debian par défaut (stable).

Spécifiez le mainteneur et ajoutez des métadonnées

Vous pouvez choisir de spécifier qui est le mainteneur, remplacez Lucero del Alba par votre nom, votre personne ou votre équipe responsable de la construction:

# 作者
MAINTAINER Lucero del Alba

Ce n'est pas nécessaire, mais nous pouvons également ajouter des métadonnées à l'aide de la directive d'étiquette, qui sera disponible plus tard lors de la vérification de l'image à l'aide de la commande Docker Inspect:

# 额外的元数据
LABEL version="1.0"
LABEL description="First image with Dockerfile."

Pour plus d'informations sur cette fonctionnalité, consultez la balise d'objet Docker.

Créez votre propre distribution

À ce stade, nous sélectionnerons certains outils et bibliothèques à inclure dans le miroir afin que notre conteneur ait tout ce dont nous avons besoin pour effectuer l'action attendue. À la fin de ce tutoriel, nous ferons un travail qui est très proche de la construction d'une distribution Linux.

Certains conteneurs (tels que ceux exécutant des bases de données PostgreSQL) sont conçus pour s'exécuter en arrière-plan. Cependant, nous avons souvent besoin d'une console pour effectuer certaines opérations sur le conteneur, nous pouvons donc avoir besoin d'outils supplémentaires car l'image sous-jacente ne fera que regrouper les outils GNU minimum.

Dépannage des problèmes de cache

Vous aurez presque certainement des problèmes de mise en cache lorsque vous essayez d'installer des packages supplémentaires sur votre image. En effet

Dans une distribution basée sur Debian, vous pouvez ajouter la commande suivante avant d'installer un nouveau package pour gérer ceci:

mkdir ~/my_build
cd ~/my_build
touch Dockerfile

Installation des outils de base

Outils comme l'éditeur de code, les paramètres régionaux, Git ou TMUX - est le moment d'installer tout ce dont vous avez besoin par la suite afin qu'ils soient regroupés dans l'image.

Nous allons en installer un par ligne:

# 设置基础镜像
FROM debian

Nous pouvons installer tout cela en une seule ligne, mais si nous voulons ajouter ou supprimer des packages plus tard, nous devons relancer l'ensemble du processus. La meilleure pratique ici est donc d'installer un package par ligne afin que vous puissiez bénéficier du cache de Docker.

De plus, restez simple. Vous ne voulez pas installer l'outil "au cas où" car cela pourrait augmenter le temps de construction et la taille de l'image.

Installez la bibliothèque d'exécution pour l'application

Nous livrerons également notre application dans cette image. Avez-vous besoin d'une version spécifique de PHP, Ruby ou Python, et quelques modules? Il est maintenant temps de livrer tous les programmes et les temps d'exécution nécessaires pour livrer la demande.

Vous pouvez spécifier comme vous le souhaitez, car ce conteneur est conçu pour exécuter votre application uniquement:

Dans cet exemple, nous installerons Python 3 avec PSYCOPG 2 (pour nous connecter à la base de données PostgreSQL), le module Moustache Python et le module YAML. (Lorsque vous créez votre propre dockerfile, vous installerez naturellement les dépendances spécifiques dont vous avez besoin.)

# 设置基础镜像
FROM debian:sid

Package de compilation et de téléchargement

Votre distribution peut également ne pas avoir de packages pour les modules ou programmes spécifiques dont vous avez besoin. Mais vous n'avez pas besoin de l'installer manuellement dans le conteneur en cours d'exécution! Au lieu de cela, vous pouvez utiliser la directive RUN (une par ligne) pour télécharger, compiler et configurer les bibliothèques dont vous avez besoin pour votre application.

Vous pouvez même scripter ce fichier sur un fichier séparé, ajouter ce fichier à la build et l'exécuter, que nous verrons dans la livraison de votre propre section d'application.

nettoyage

Pour rendre votre miroir soigné et aussi petit que possible, il est préférable de nettoyer à la fin de la séquence d'installation

:

Aussi, veuillez noter que nous utilisons APT-GET parce que nous avons choisi Debian, mais veuillez utiliser la commande correspondante pour la distribution de l'image de base.

# 作者
MAINTAINER Lucero del Alba

livrer votre propre application

Le but de la construction de cet environnement est de vous permettre de livrer en douceur votre application et de vous préparer à fonctionner. Pour ajouter le contenu des fichiers, des répertoires et même des URL distants à l'image, nous utiliserons la directive ADD.

Cependant, avant d'ajouter des fichiers, nous devons les mettre dans le contexte

approprié. Pour simplifier les opérations, nous mettons tout dans le répertoire My_Build susmentionné, ainsi que le Dockerfile lui-même.

En supposant l'utilisation de l'application et tout ce que nous voulons mettre dans l'image, nous avons les fichiers suivants dans ~ / my_build (où app.py et lib.py sont dans le sous-répertoire app /):

mkdir ~/my_build
cd ~/my_build
touch Dockerfile

Nous ajoutons les scripts .bashrc et .profile au répertoire / racine dans le conteneur afin qu'ils exécutent lorsque nous démarrons le shell sur le conteneur et copiez le contenu de l'application / vers le répertoire / app / dans le conteneur.

Nous ajoutons la commande suivante:

# 设置基础镜像
FROM debian

Définissez votre environnement

Enfin, nous définirons certaines variables d'environnement nécessaires au niveau du système et de l'application.

Beaucoup d'entre vous utilisent le jeu de personnages Debian par défaut pour le faire, mais comme nous ciblons un public international, voyons comment avoir un terminal UTF-8. Nous avons déjà installé le package des localités, donc maintenant tout ce que nous avons à faire est de générer le jeu de caractères et de configurer l'environnement Linux approprié:

# 设置基础镜像
FROM debian:sid

Vous devrez peut-être également définir certaines variables d'environnement pour que l'application échange des mots de passe et des chemins. Dockerfile fournit des instructions Env pour le faire avec précision:

# 作者
MAINTAINER Lucero del Alba

Notez que vous pouvez également transmettre des variables d'environnement à partir de la ligne de commande lors du démarrage du conteneur, ce qui peut être pratique pour partager certaines informations sensibles (telles que les mots de passe).

docker de docker complet

Bien sûr, vous devez ajuster le dockerfile comme vous le souhaitez, mais j'espère que vous comprenez ses possibilités.

C'est le fichier complet:

# 额外的元数据
LABEL version="1.0"
LABEL description="First image with Dockerfile."

construire un miroir

De l'intérieur du répertoire my_build, nous utiliserons la commande docker build, passant l'indicateur -t pour "tag" la nouvelle image avec le nom, dans ce cas my_image. .

# 更新源列表
RUN apt-get clean
RUN apt-get update

Cela générera une longue sortie où chaque "étape" est une directive dans notre dockerfile. Voici une sortie tronquée:

# 每行安装一个基本应用程序，以获得更好的缓存
RUN apt-get install -qy git
RUN apt-get install -qy locales
RUN apt-get install -qy nano
RUN apt-get install -qy tmux
RUN apt-get install -qy wget

Énumérez le miroir

Nous pouvons utiliser la commande docker images pour répertorier nos images:

# 安装应用程序运行时和模块
RUN apt-get install -qy python3
RUN apt-get install -qy python3-psycopg2
RUN apt-get install -qy python3-pystache
RUN apt-get install -qy python3-yaml

Cela sortira notre My_image et d'autres images de base nouvellement créées que nous avons téléchargées:

# 清理
RUN apt-get -qy autoremove

… c'est tout, notre miroir est prêt à être livré et courir!

Démarrez le conteneur

Enfin, afin de démarrer notre terminal interactif nouvellement créé, nous utiliserons la commande docker run:

<code>.bashrc
.profile
app/app.py
app/lib.py
Dockerfile</code>

Étapes suivantes

Je n'ai pas présenté toutes les possibilités de Dockerfile. En particulier, je n'ai pas examiné comment exposer les ports afin que vous puissiez exécuter des services et même lier des conteneurs entre eux; et d'autres fonctionnalités utiles.

Nous les présenterons dans les futurs articles. Actuellement, vous pouvez consulter les ressources suivantes.

sur le site Web de Docker:

référence dockerfile
Best Practice pour écrire Dockerfile

de SitePoint:

• Comprendre le docker, les conteneurs et la livraison de logiciels plus sûrs
• Sous-canal docker
• Tous les articles liés à Docker

FAQ sur la façon de construire des images à l'aide de dockerfile

Quelle est l'importance de construire des images Docker à l'aide de Dockerfile?

dockerfile est un document texte contenant toutes les commandes que l'utilisateur peut appeler sur la ligne de commande pour assembler l'image. L'utilisation de DockerFile simplifie le processus de construction d'images dans Docker. Il vous permet d'automatiser le processus, le rendant plus efficace et moins sujet aux erreurs. Dockerfile fournit également une documentation claire et de versioning sur la façon de créer des images, ce qui facilite la compréhension de votre travail et de l'utilisation ou de l'utilisation.

Comment optimiser le processus de construction à l'aide de dockerfile?

dockerfile fournit une variété de façons d'optimiser le processus de construction. L'un des moyens les plus efficaces consiste à utiliser des versions en plusieurs étapes. Cela vous permet d'utiliser plusieurs instructions dans votre dockerfile. Chacun de l'instruction peut utiliser une fondation différente, et chaque instruction commence une nouvelle étape de construction. Vous pouvez éventuellement copier des artefacts d'une étape à l'autre, laissant tout ce que vous ne voulez pas apparaître dans l'image finale.

Quelles sont les meilleures pratiques pour écrire Dockerfiles?

Il existe plusieurs meilleures pratiques pour écrire des dockerfiles. Tout d'abord, vous devez éviter d'installer des packages inutiles pour garder la taille du miroir petite. Deuxièmement, utilisez des versions multi-étages pour optimiser le processus de construction. Troisièmement, chaque dockerfile doit représenter une seule application. Si vous avez plusieurs applications, vous devez utiliser plusieurs dockerfiles docker. Enfin, vous devez utiliser le fichier .dockaignore pour exclure les fichiers et répertoires qui ne doivent pas être inclus dans l'image.

Comment déboguer Dockerfile?

dockerfile peut être débogué en construisant l'image et en l'exécutant avec la commande shell. Si la version échoue, Docker renvoie un message d'erreur qui peut vous aider à identifier le problème. Vous pouvez également utiliser la commande RUN pour exécuter des commandes qui vous aideront à déboguer votre dockerfile.

Puis-je utiliser des variables d'environnement dans dockerfile?

Oui, vous pouvez utiliser des variables d'environnement dans votre dockerfile. La directive Env définit la variable d'environnement sur cette valeur. Cette valeur sera dans l'environnement de toutes les instructions ultérieures de la phase de construction et peut également être remplacée en ligne dans de nombreuses instructions.

Comment copier des fichiers de l'hôte vers l'image docker?

Vous pouvez utiliser la directive Copie pour copier de nouveaux fichiers de l'hôte vers l'image Docker. Copiez des fichiers à partir de la source de l'hôte vers la destination dans l'image Docker.

Comment exposer un port dans une image Docker?

Vous pouvez utiliser la directive Expose pour informer le conteneur Docker pour écouter un port réseau spécifié lors de l'exécution. Cependant, cela ne publie pas réellement le port. Pour publier un port, vous devez utiliser l'indicateur -p sur la commande docker run.

Comment configurer un répertoire fonctionnel dans une image Docker?

Vous pouvez utiliser la directive WorkDIR pour définir le répertoire de travail pour toute exécution, CMD, Pointpoint d'entrée, copie et ajouter des directives dans le DockerFile.

Comment exécuter les commandes dans l'image docker?

Vous pouvez utiliser la directive RUN pour exécuter les commandes dans une image Docker. Cela exécutera n'importe quelle commande sur le nouveau calque au-dessus de l'image actuelle et soumettra le résultat.

Comment spécifier les commandes par défaut pour les images Docker?

Vous pouvez utiliser la directive CMD pour fournir des valeurs par défaut pour le conteneur exécutif. Ceux-ci peuvent inclure des fichiers exécutables, ou des fichiers exécutables peuvent être omis, auquel cas vous devez spécifier la directive d'entrée.

Cette sortie révisée maintient le formatage d'image d'origine et évite des modifications importantes de la signification de l'article tout en reformulant les phrases et les paragraphes pour l'originalité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!