L'administration du système

Comment construire une image docker à l'aide d'un dockerfile

Comment construire une image docker à l'aide d'un dockerfile

Les compétences de Docker sont à forte demande principalement parce que, grâce au Docker Nous pouvons automatiser le déploiement des applications à l'intérieur de soi-disant conteneurs, Création d'environnements sur mesure qui peuvent être facilement reproduits partout Docker La technologie est prise en charge. Dans ce tutoriel, nous verrons comment créer un Image docker à partir de zéro, en utilisant un Dockerfile. Nous apprendrons les instructions les plus importantes que nous pouvons utiliser pour personnaliser notre image, comment construire l'image et comment exécuter des conteneurs en fonction.

Dans ce tutoriel, vous apprendrez:

  • Comment créer une image docker à l'aide d'un dockerfile
  • Certaines des instructions Dockerfile les plus fréquemment utilisées
  • Comment réaliser la persistance des données dans les conteneurs


Exigences et conventions logicielles utilisées

Exigences logicielles et conventions de ligne de commande Linux
Catégorie Exigences, conventions ou version logicielle utilisée
Système Indépendant du SO
Logiciel Docker
Autre
  • Un démon docker en cours d'exécution
  • L'utilitaire de ligne de commande docker
  • Familiarité avec l'interface de ligne de commande Linux
Conventions # - Exige que les commandes Linux soient exécutées avec des privilèges racine soit directement en tant qu'utilisateur racine, soit par l'utilisation de Sudo commande
$ - Exige que les commandes Linux soient exécutées en tant qu'utilisateur non privilégié régulier

Images et conteneurs

Avant de commencer, il peut être utile de définir clairement ce que nous voulons dire lorsque nous parlons de images et conteneurs dans le contexte de Docker. Les images peuvent être considérées comme des éléments constitutifs du monde Docker. Ils représentent les «plans» utilisés pour créer des conteneurs. En effet, lorsqu'un conteneur est créé, il représente une instance concrète des images sur lesquelles il est basé.

De nombreux conteneurs peuvent être créés à partir de la même image. Dans le reste de cet article, nous apprendrons à fournir les instructions nécessaires pour créer une image adaptée à nos besoins à l'intérieur d'un Dockerfile, Comment construire réellement l'image et comment exécuter un conteneur en fonction de celui-ci.

Construisez notre propre image à l'aide d'un dockerfile

Pour construire notre propre image, nous utiliserons un Dockerfile. Un dockerfile contient toutes les instructions nécessaires pour créer et configurer une image. Une fois notre dockerfile prêt, nous utiliserons le docker commande pour créer l'image.

La première chose que nous devrions faire est de créer un nouveau répertoire pour héberger notre projet. Pour le bien de ce didacticiel, nous construireons une image contenant le Apache serveur Web, nous nommerons donc le répertoire racine du projet «dockrized-apache»:

$ mkdir dockerisé-apache

Ce répertoire est ce que nous appelons le construire un contexte. Pendant le processus de construction, tous les fichiers et répertoires contenus, y compris le Dockerfile Nous allons créer, être envoyés au démon docker afin qu'ils puissent être facilement accessibles, à moins qu'ils ne soient répertoriés dans le .dockerignore déposer.

Créons notre Dockerfile. Le fichier doit être appelé Dockerfile et contiendra, comme nous l'avons dit ci-dessus, toutes les instructions nécessaires pour créer une image avec les fonctionnalités souhaitées. Nous lançons notre éditeur de texte préféré et commençons par écrire les instructions suivantes:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "
Copie

La première instruction que nous devons fournir est DEPUIS: avec lui, nous pouvons spécifier une image existante que nous utiliserons comme base (c'est ce qu'on appelle un image de base), pour créer le nôtre. Dans ce cas, notre image de base sera ubuntu. En dehors du nom de l'image, nous avons également utilisé une balise, afin de spécifier la version de l'image que nous voulons utiliser, dans ce cas 18.dix. Si aucune balise n'est spécifiée dernier La balise est utilisée par défaut: cela entraînera l'utilisation de la dernière version disponible de l'image de base. Si l'image n'est pas déjà présente sur notre système, elle sera téléchargée à partir de DockerHub.

Après le DEPUIS instruction, nous avons utilisé ÉTIQUETER. Cette instruction est facultative, peut être répétée plusieurs fois et est utilisée pour ajouter des métadonnées à notre image. Dans ce cas, nous l'avons utilisé pour spécifier le mainteneur d'image.

L'instruction de course

À ce stade, si nous courons docker, Nous allons simplement produire une image identique à la base, à l'exception des métadonnées que nous avons ajoutées. Ce ne serait d'aucune utilité pour nous. Nous avons dit que nous voulions «docker» le Apache serveur Web, donc la prochaine chose à faire dans notre Dockerfile, est de fournir une instruction pour installer le serveur Web dans le cadre de l'image. L'instruction qui nous a permis d'accomplir cette tâche est COURIR:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Run apt-get update && apt-get -y install apache2
Copie

Le COURIR L'instruction est utilisée pour exécuter des commandes en haut de l'image. Une chose très importante à retenir est que pour chaque COURIR instruction que nous utilisons, un Nouvelle Couche est créé et ajouté à la pile. À cet égard, Docker est très intelligent: les couches déjà construites seront «mises en cache»: cela signifie que si nous construisons une image basée sur notre Dockerfile, Et puis nous décidons, par exemple, pour en ajouter un autre COURIR instruction (et donc une nouvelle couche) à la fin, la construction ne commencera pas de zéro, mais exécutera uniquement les nouvelles instructions.

Pour que cela se produise, bien sûr, les instructions déjà construites sur le Dockerfile ne doit pas être modifié. Est même possible d'éviter complètement ce comportement lors de la construction d'une image, en utilisant simplement le --sans cache option du docker commande.

Dans notre cas, nous avons utilisé le COURIR instruction pour exécuter le apt-get update && apt-get -y install apache2 commandes. Remarquez comment nous avons passé le -y option au Installation de l'apt-get Commande: Cette option fait pour qu'une réponse affirmative soit donnée automatiquement à toutes les confirmations requises par la commande. Ceci est nécessaire car nous installons le package de manière non interactive.

Exposant le port 80

Comme nous le savons, le serveur Web Apache écoute port 80 pour les connexions standard. Nous devons demander à Docker de rendre ce port accessible sur le conteneur. Pour accomplir la tâche, nous utilisons le EXPOSER fonction et fournir le numéro de port. Pour des raisons de sécurité, le port spécifié n'est ouvert que lorsque le conteneur est lancé. Ajoutons cette instruction à notre Dockerfile:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Exécutez la mise à jour apt-get && apt-get -y installer apache2 exposer 80
Copie

Construire l'image

À ce stade, nous pouvons déjà essayer de construire notre image. De l'intérieur du répertoire racine de notre projet, «dockrised-apache», nous exécutons la commande suivante:

$ sudo docker build -t linuxconfig / dockrise-apache .

Examinons la commande. Tout d'abord, nous avons préfixé la commande avec sudo, afin de l'exécuter avec des privilèges administratifs. Il est possible d'éviter cela, en ajoutant un utilisateur à docker groupe, mais cela représente un risque de sécurité. Le -t option que nous avons fournie, abréviation pour --étiqueter, Appliquons un nom de référentiel et éventuellement une balise à notre image si la construction réussit.

Finalement, le . Demande à Docker de chercher le Dockerfile Dans le répertoire actuel. Dès que nous lançons la commande, le processus de construction commencera. Les messages de progression et de construction seront affichés à l'écran:

Envoi du contexte de construction à Docker Daemon 2.048 KB Étape 1/4: De Ubuntu: 18.10 Essayer de tirer le référentiel Docker.IO / Library / Ubuntu… . [… .]]
Copie

En quelques minutes, notre image doit être créée avec succès. Pour le vérifier, nous pouvons exécuter le images docker Commande, qui renvoie une liste de toutes les images existant dans notre référentiel Docker local:

$ sudo docker images référentiel étiquette ID d'image créé Taille LinuxConfig / docking-Apache Dernier 7ab7b6873614 il y a 2 minutes 191 Mo
Copie

Comme prévu, l'image apparaît dans la liste. Comme nous pouvons le remarquer, car nous n'avons pas fourni de balise (seulement un nom de référentiel, LinuxConfig / Dockerisé-APACH) le dernier La balise a été automatiquement appliquée à notre image. Un IDENTIFIANT a également été affecté à l'IT, 7AB7B6873614: Nous pouvons l'utiliser pour référencer l'image dans les futures commandes.

Lancement d'un conteneur basé sur l'image

Maintenant que notre image est prête, nous pouvons créer et lancer un récipient en fonction. Pour accomplir la tâche, nous utilisons le run docker commande:

$ sudo docker run --name = linuxconfig-apache -d -p 8080: 80 LinuxConfig / docking-apache apachectl -d premier

Examinons la commande ci-dessus. La première option que nous avons fournie était --nom: Avec lui, nous spécifions un nom pour le conteneur, dans ce cas «LinuxConfig-Apache». Si nous omettons cette option, un nom généré aléatoire aurait été affecté à notre conteneur.

Le -d Option (abréviation pour --détacher) fait fonctionner le conteneur en arrière-plan.

Le -p Option, abréviation pour --publier, est nécessaire pour publier un port de conteneur (ou une gamme de ports) dans le système hôte. La syntaxe de l'option est la suivante:

-P localhost_port: contener_port

Dans ce cas, nous avons publié le port 80 Nous avons précédemment exposé dans le conteneur, à l'hôte Port 8080. Par souci d'exhaustivité, nous devons dire qu'il est également possible d'utiliser le -P Option (abréviation pour --publication) Au lieu de cela, provoquant le mappé de tous les ports exposés dans le conteneur à aléatoire ports de l'hôte.

Les deux dernières choses que nous avons spécifiées dans la commande ci-dessus sont: le image le conteneur doit être basé sur et le commande Pour fonctionner lorsque le conteneur est démarré, ce qui est facultatif. L'image est bien sûr LinuxConfig / Dockerisé-APACH, Celui que nous avons construit avant.

La commande que nous avons spécifiée est apachectl -d premier plan. Avec cette commande le Apache Le serveur Web est lancé dans premier plan Mode: c'est obligatoire pour qu'il fonctionne dans le conteneur. Le run docker La commande exécute la commande spécifiée sur un nouveau récipient:

$ sudo docker run --name = linuxconfig-apache -d -p 8080: 80 linuxconfig / docking-apache apachectl -d premier a51fc9a6dd66b02117f00235a341003a9bf0ffd53f90a040bc1122cbbc453423
Copie

Quel est le numéro imprimé à l'écran? C'est le IDENTIFIANT du conteneur! Une fois le conteneur en cours d'exécution, nous devrions pouvoir accéder à la page desservie par défaut Apache VirtualHost au LocalHost: 8080 adresse (port 8080 sur l'hôte est mappé sur le port 80 sur le conteneur):



Index Apache par défaut.page html

Notre configuration fonctionne correctement. Si nous exécutons le docker ps Commande, qui répertorie tous les conteneurs actifs du système, nous pouvons récupérer des informations sur notre conteneur: ID (version courte, plus facile à référencer la ligne de commande pour un humain), l'image à partir de laquelle il était exécuté, la commande utilisée, sa création Temps et état actuel, cartographie et nom des ports.

$ sudo docker ps id de conteneur ID de commande d'image créé les noms de ports d'état a51fc9a6dd66 LinuxConfig / docking-apache "apachectl -d avant…" Il y a 28 secondes en haut de 28 secondes 0.0.0.0: 8080-> 80 / TCP LinuxConfig-Apache
Copie

Pour l'arrêter le conteneur, tout ce que nous devons faire est de le référencer par son identifiant ou son nom, et exécuter le Docker Stop commande. Par exemple:

$ sudo docker stop linuxconfig-apache

Pour recommencer:

$ sudo docker start linuxconfig-apache

Exécuter la commande directement via le dockerfile

Depuis ici, nous avons construit une image de base et à l'exécution, en utilisant le run docker Commande, nous avons spécifié la commande à lancer lorsque le conteneur est démarré. Parfois, nous voulons spécifier ce dernier directement à l'intérieur du dockerfile. Nous pouvons le faire de deux manières: utiliser CMD ou POINT D'ACCÈS.

Les deux instructions peuvent être utilisées dans le même but, mais elles se comportent différemment lorsqu'une commande est également spécifiée à partir de la ligne de commande. Voyons comment.

L'instruction CMD

Le CMD L'instruction peut essentiellement être utilisée sous deux formes. Le premier est le exécutif former:

Cmd ["/ usr / sbin / apachectl", "-d", "premier plan"]

L'autre est le coquille former:

CMD / USR / SBIN / APachectl -D

Le exécutif de est généralement préféré. Il convient de noter que lors de l'utilisation du formulaire Exec, un shell n'est pas invoqué, donc les extensions variables ne se produiront pas. Si une expansion variable est nécessaire, nous pouvons utiliser le coquille forme ou nous pouvons invoquer une coquille directement dans le exécutif Mode, comme:

Cmd ["sh", "-c", "echo", "$ home"]

Le CMD L'instruction ne peut être spécifiée qu'une seule fois dans le Dockerfile. Si multiple CMD Des options sont fournies, seuls le dernier prendra effet. Le but de l'instruction est de fournir un défaut commande à lancer lorsque le conteneur démarre:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Run apt-get update && apt-get -y installer apache2 expose 80 cmd [" / usr / sbin / apachectl "," -d "," foreground "]
Copie

La commande spécifiée avec CMD à l'intérieur de Dockerfile, Fonctionne par défaut et sera remplacé si une autre commande est spécifiée à partir de la ligne de commande lors de l'exécution run docker.

L'instruction de point d'entrée

Le POINT D'ACCÈS L'instruction peut également être utilisée pour configurer une commande à utiliser lorsque le conteneur est démarré, et comme CMD, les deux exécutif et coquille le formulaire peut être utilisé avec lui. La grande différence entre les deux est qu'une commande passée de la ligne de commande ne remplacera pas celle spécifiée par POINT D'ACCÈS: Au lieu de cela, ce sera annexé pour lui.

En utilisant cette instruction, nous pouvons spécifier une commande de base et la modifier avec les options que nous fournissons lors de l'exécution du docker commande, faisant se comporter notre conteneur comme un exécutable. Voyons un exemple avec notre Dockerfile:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Run apt-get update && apt-get -y installer apache2 exposer 80 entrée [" / usr / sbin / apachectl "]
Copie

Dans ce cas, nous avons substitué le CMD instruction avec POINT D'ACCÈS et a également supprimé le -D2 Option du format Exec. Supposons que nous reconstruisons maintenant l'image et recréons le conteneur à l'aide de la commande suivante:

$ sudo docker run --name = linuxconfig-apache -d -p 8080: 80 LinuxConfig / dockrized-apache -d premier

Lorsque le récipient commence, le -D2 Les arguments sont ajoutés à la commande fournie dans le Dockerfile avec le POINT D'ACCÈS instruction, mais seulement si vous utilisez le exécutif former. Cela peut être vérifié en exécutant le docker ps Commande (Ici, nous avons ajouté quelques options à la commande, pour mieux afficher et formater sa sortie, en sélectionnant uniquement les informations dont nous avons besoin):

$ sudo docker ps --no-trunc - format ".Noms \ t .Commande "LinuxConfig-apache" / usr / sbin / apachectl -d premier plan "
Copie

Juste comme CMD, le POINT D'ACCÈS L'instruction ne peut être fournie qu'une seule fois. S'il apparaît plusieurs fois dans le dockerfile, seule la dernière occurrence sera considérée. Il est possible de remplacer la valeur par défaut POINT D'ACCÈS de l'image de la ligne de commande, en utilisant le --point d'accès option du run docker commande.

Combinaison CMD et point d'entrée

Maintenant que nous connaissons la particularité du CMD et POINT D'ACCÈS instructions que nous pouvons également les combiner. Que pouvons-nous obtenir en faisant cela? On peut utiliser POINT D'ACCÈS Pour spécifier une commande de base valide, et le CMD instruction pour spécifier les paramètres par défaut.

La commande s'exécutera avec ces paramètres par défaut par défaut, à moins que nous ne les remployions à partir de la ligne de commande lors de l'exécution run docker. S'en tenir à notre Dockerfile, Nous pourrions écrire:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Run apt-get update && apt-get -y install apache2 expose 80 entrypoint [" / usr / sbin / apachectl "] cmd [" -d "," foreground "]
Copie

Si nous reconstruisons l'image de ce Dockerfile, Supprimer le conteneur précédent que nous avons créé et relancer le run docker commande sans spécifier aucun argument supplémentaire, le / usr / bin / apachectl -d premier plan La commande sera exécutée. Si nous fournissons plutôt certains arguments, ils l'emporteront sur ceux spécifiés dans le Dockerfile avec le CMD instruction. Par exemple, si nous courons:

$ sudo docker run --name = linuxconfig-apache -d -p 8080: 80 LinuxConfig / dockrized-apache -x

La commande qui sera exécutée lors du démarrage du conteneur sera / usr / bin / apachectl -x. Vérifions-le:

$ sudo docker ps --no-trunc - format ".Noms \ t .Commande "LinuxConfig-apache" / usr / sbin / apachectl -x "
Copie

La commande lancée était comme prévu: le -X L'option, soit dit en passant, se fait pour que le démon httpd soit lancé dans Mode débogage.

Copie de fichiers dans le conteneur

Notre serveur Apache «docking» fonctionne. Comme nous l'avons vu, si nous naviguons vers LocalHost: 8080, Nous visualisons la page de bienvenue Apache par défaut. Maintenant, disons que nous avons un site Web prêt à être expédié avec le conteneur, comment pouvons-nous le «charger» pour qu'Apache le serve à la place?

Eh bien, pour le bien de ce tutoriel, nous allons simplement remplacer l'index par défaut.fichier html. Pour accomplir la tâche, nous pouvons utiliser le COPIE instruction. Supposons que nous ayons un indice alternatif.Fichier HTML à l'intérieur de la racine de notre projet (notre contexte de construction) avec ce contenu:

  
Bonjour!
 
Ce fichier a été copié dans le conteneur avec l'instruction de copie!
Copie

Nous voulons le charger et le copier sur le / var / www / html répertoire à l'intérieur du conteneur, donc à l'intérieur de notre Dockerfile Nous ajoutons le COPIE instruction:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Run apt-get update && apt-get -y installer apache2 exposer 80 entrée [" / usr / sbin / apachectl "] cmd [" -d "," Foreground "] copier l'index.html / var / www / html / index.html
Copie

Nous reconstruisons l'image et le conteneur. Si je navigue maintenant vers LocalHost: 8080, Nous verrons le nouveau message:

# nouveau message

Le COPIE L'instruction peut être utilisée pour copier les fichiers et les répertoires. Lorsque le chemin de destination n'existe pas, il est créé à l'intérieur du conteneur. Tous les nouveaux fichiers et répertoires sont créés avec un Uid et Gid de 0.

Une autre solution possible pour copier des fichiers dans le conteneur consiste à utiliser le AJOUTER instruction, qui est plus puissante que COPIE. Avec cette instruction, nous pouvons copier des fichiers, des répertoires mais aussi URL. De plus, si nous copie un local archive de goudron Avec un format comprimé reconnu, il sera automatiquement non compressé et copié comme répertoire à l'intérieur du conteneur.

La stratégie idéale serait d'utiliser COPIE Sauf si les fonctionnalités supplémentaires fournies par AJOUTER sont vraiment nécessaires.

Créer un volume

Dans l'exemple précédent, pour démontrer comment le COPIE L'instruction fonctionne, nous avons remplacé l'index par défaut.Fichier HTML de l'Apache VirtualHost par défaut à l'intérieur du conteneur.

Si nous nous arrêtons et commençons le conteneur, nous trouverons toujours la modification que nous avons apportée, mais si le conteneur pour une raison quelconque est supprimé, toutes les données contenues sur sa couche écrivative seront perdues avec. Comment résoudre ce problème? Une approche consiste à utiliser le VOLUME instruction:

De Ubuntu: 18.10 étiquettes se maintient = "egidio.docile @ linuxconfig.org "Run apt-get update && apt-get -y installer apache2 exposer 80 entrée [" / usr / sbin / apachectl "] cmd [" -d "," Foreground "] copier l'index.html / var / www / html / index.Volume HTML / var / www / html
Copie

Le VOLUME L'instruction prend un ou plusieurs répertoires (dans ce cas / var / www / html) et fait qu'ils soient utilisés comme points de montage pour les volumes externes et nommés au hasard générés lorsque le conteneur est créé.

De cette façon, les données que nous mettons dans les répertoires utilisées comme points de montage seront persistées à l'intérieur des volumes montés et existeront toujours même si le conteneur est détruit. Si un ensemble de répertoires à utiliser comme point de montage contient déjà des données au moment de l'initialisation, ces données sont copiées à l'intérieur du volume qui est monté dessus.

Reconstruisons l'image et le conteneur. Nous pouvons maintenant vérifier que le volume a été créé et qu'il est utilisé en inspectant le conteneur:

$ sudo docker inspecter linuxconfig-apache [… .] "Mounts": [  "Type": "volume", "Name": "8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61", "Source": "/var/lib/docker/volumes/8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61/_data", "Destination": "/var/ www / html "," pilote ":" local "," mode ":" "," rw ": true," propagation ":" "], [… .]]
Copie

Comme déjà dit, le volume survivra même après que le conteneur est détruit afin que nos données ne soient pas perdues.

Le VOLUME instruction à l'intérieur du Dockefile, Comme nous pouvons le voir sur la sortie de la commande docker inspecter ci-dessus, fait un volume nommé au hasard. Pour définir un volume nommé, ou pour monter un volume déjà existant dans un conteneur, nous devons le spécifier au moment de l'exécution, lors de l'exécution du run docker commande, en utilisant le -V Option (abréviation pour --volume). Voyons un exemple:

$ sudo docker run --name = linuxconfig-apache -d -p 8080: 80 -v myvolume: / var / www / html linuxconfig / dockrized-apache

Dans la commande ci-dessus, nous avons utilisé le -V option spécifiant le nom de volume (très important: notez que ce n'est pas un chemin, mais un nom simple) et le point de montage À l'intérieur du conteneur à l'aide de la syntaxe suivante:

:

Lorsque nous effectuons une telle commande, le volume nommé «MyVolume» sera monté sur le chemin spécifique à l'intérieur du conteneur (le volume sera créé s'il n'existe pas déjà). Comme nous l'avons dit précédemment, si le volume est vide, les données déjà existantes sur le point de montage à l'intérieur du conteneur seront copiées à l'intérieur. En utilisant le volume docker ls Commande, nous pouvons confirmer un volume avec le nom que nous avons spécifié a été créé:

$ sudo docker volume ls volume de pilote nom local myvolume
Copie

Pour supprimer un volume, nous utilisons le Docker Volume RM commander et fournir le nom du volume à supprimer. Docker, cependant, ne nous permettra pas de supprimer un volume utilisé par un conteneur actif:

$ sudo docker volume rm MyVolume Error Response from Daemon: Impossible de supprimer le volume, volume toujours utilisé: supprimer myVolume: le volume est utilisé - [95381b7b6003f6165dfe2e1912d2f827f7167ac26e22cf26c1bcab704a2d7e02]
Copie

Une autre approche pour la persistance des données, particulièrement utile pendant le développement, consiste à montage un répertoire d'hôte à l'intérieur du conteneur. Cette approche a l'avantage de nous laisser travailler sur notre code localement avec nos outils préférés et de voir l'effet des modifications immédiatement réfléchies à l'intérieur du conteneur, mais a un gros inconvénient: le conteneur devient dépendant de la structure du répertoire hôte.

Pour cette raison, car la portabilité est l'une des principales cibles de Docker, n'est pas possible de définir un montage à l'intérieur d'un dockerfile, mais seulement à l'exécution. Pour accomplir cette tâche, nous utilisons le -V option run docker commander à nouveau, mais cette fois, nous fournissons le chemin d'un répertoire à l'intérieur du système de fichiers hôte au lieu d'un nom de volume:

$ sudo docker run --name = linuxconfig-apache -d -p 8080: 80 -v / path / on / host: / var / www / html linuxconfig / dockrized-apache

Lors du lancement de la commande ci-dessus, le répertoire hôte / path / on / hôte sera monté sur / var / www / html à l'intérieur du conteneur. Si le répertoire sur l'hôte n'existe pas, il est créé automatiquement. Dans ce cas, les données du répertoire MountPoint à l'intérieur du conteneur (/ var / www / html dans notre exemple) pas copié dans le répertoire hôte qui est monté dessus, comme cela se produit à la place pour les volumes.

Conclusion

Dans ce tutoriel, nous avons appris les concepts de base nécessaires pour créer et créer une image Docker à l'aide d'un Dockerfile et comment exécuter un conteneur en fonction. Nous avons construit une image très simple qui nous a permis d'exécuter une version «dockerisée» du serveur Web Apache. Dans le processus, nous avons vu comment utiliser le DEPUIS instruction, qui est obligatoire pour spécifier une image de base sur laquelle travailler, le ÉTIQUETER instruction pour ajouter des métadonnées à notre image, la EXPOSER instruction pour déclarer les ports à exposer dans le conteneur. Nous avons également appris à cartographier lesdits port (s) au port du système hôte.

Nous avons appris à utiliser le
COURIR instruction pour exécuter les commandes sur l'image, et nous avons appris à spécifier une commande à exécuter lorsque le conteneur est démarré à la fois à partir de la ligne de commande et à l'intérieur du Dockerfile. Nous avons vu comment accomplir cela en utilisant le CMD et POINT D'ACCÈS instructions, et quelles sont les différences entre les deux. Enfin, nous avons vu comment COPIE Données à l'intérieur du conteneur et comment réaliser la persistance des données à l'aide de volumes. Dans nos exemples, nous avons discuté uniquement d'un petit sous-ensemble des instructions qui peuvent être utilisées dans un Dockerfile.

Pour une liste complète et détaillée, veuillez consulter la documentation officielle Docker. En attendant, si vous voulez savoir comment construire un tout LAMPE Stack à l'aide de Docker et de l'outil Docker-Compose, vous pouvez jeter un œil à notre article sur la façon de créer une pile de lampe basée sur Docker à l'aide de Docker-Compose sur Ubuntu 18.04 Bionic Beaver Linux.

Tutoriels Linux connexes:

  • Une introduction à l'automatisation Linux, des outils et des techniques
  • Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
  • Choses à installer sur Ubuntu 20.04
  • Comment monter l'image ISO sur Linux
  • Comment créer des sauvegardes système incrémentielles avec Timeshift sur…
  • Kubernetes vs docker, quelle est la différence?
  • Comment redimensionner une image de disque QCOW2 sur Linux
  • Comment créer une pile de lampe basée sur Docker à l'aide de Docker sur…
  • Masterring Bash Script Loops
  • Choses à faire après l'installation d'Ubuntu 22.04 Jammy Jellyfish…