m3204 dockerfile195.83.128.21/~pgommery/img/pdf/s3-tp06-dockerfile.pdfdockerfile - m3204 1 m3204...

DOCKERFILE - M3204 1

M3204 Dockerfile Patrice Gommery – Mai 2020

PRE-REQUIS

Pour réaliser ce TP vous devez avoir en votre possession : - L'adresse IP de votre serveur VPS hébergé chez PulseHeberg - Votre identifiant MMI (mmiXXxxx) - Le mot de votre identifiant MMI créé lors de l'initialisation de votre VPS. En cas de problème : - Un accès à votre compte PulseHeberg pour lancer la console VNC - Le mot de passe du compte root de votre VPS (premier mail de PulseHeberg)

Consignes Générales pour le TP Pendant tout le TP, remplacez VPS l'adresse IP de votre VPS PulseHeberg remplacez MMI par votre identifiant MMI (mmiXXxxx)


Préambule :

Après avoir vu les principes de bases de Docker et notamment la création et la gestion des containers, cette seconde partie sur Docker s'intéressera aux images et à la construction.

Image Docker :

Nous avons donc vu dans le TP précédent qu'un container est instancié à partir d'un image. On peut donc considérer cette image comme une classe ou un template permettant de définir ce que contiendront finalement les containers créés à partir de celle-ci. Mais que contient une image ? Une image est construite par un ajout successif de couches (layers) . Comme vous pouvez le voir dans schéma ci-dessus , chacune des couches contient les différents éléments nécessaires au fonctionnement d'un container. Une couche peut-elle même être composée d'autres couches en fonction des besoins. Et nous le verrons plus tard, une image peut donc être construite à partir d'autres images. Une image est donc principalement un assemblage de couches qui une fois assemblées viendront constituer le filesystem des containers instanciés. Par exemple :


L'image ci-dessus pourrait représenter les différentes couches nécessaires pour l'implémentation d'un container avec Wordpress et donc tous les services (apache, Mysql) et langages nécessaires à son fonctionnement (php), mais aussi un OS (Debian) pour fournir à l'ensemble les bibliothèques systèmes nécessaires pour interagir avec la machine hôte. L'image wordpress que vous avez utilisée dans l'exercice final du tp précédent est à peu près similaire à l'exception de mysql qui n'était pas implémenté dans notre container. et que nous avons dû installer manuellement pour finaliser notre installation. Pourquoi les créateurs de l'image n'ont pas implémenté une couche mysql dans celle-ci ? Tout simplement pour une bonne pratique qui consiste à séparer les services dans différents containers soit pour créer des stacks (piles) de containers. Nous aborderons cet aspect dans un prochain TP avec docker compose.

Partie 1 : LAYER CONTAINER Pour bien comprendre ce principe de couches, revenons sur ce qui passe lorsque l'on créait un container à partir d'une image. Lors de la création du container, Docker va donc récupérer toutes les couches constituant l'image et en faire une copie qui constituera le filesystem du container. Ce filesystem initial est créé en lecture/seule et ne peut donc pas être modifiée. Comment peut-on alors écrire des données dans le container si toutes les couches le constituant sont en lecture seules ? Pour cela, lors de la création du container, Docker créait une couche qui est dédiée au container et à lui seul. Cette couche qui bien sûr est accessible en lecture/écriture stockera toutes les données gérées par les applications, mais aussi une copie des fichiers initiaux de l'image qui auraient été modifiés. C'est ce que Docker appelle le mécanisme de Copy-On-Write. Ce qu'il faut bien comprendre dans ce principe c'est que toutes les modifications faites sur un container sont écrites dans cette couche spécifique et pas dans une couche de l'image initiale. Donc si vous faites une mise à jour, ou comme nous l'avons fait dans le tp précédent ajoutez un service à votre container, celui-ci ne sera valable que pour lui. Si vous créez un nouveau container en repartant de l'image initial vous ne retrouverez pas vos modifications.

DEMONSTRATION : Créez un container avec un terminal interactif en utilisant l'image de base debian. docker container run -ti debian

A l'invite de commandes du container, installez le paquet figlet. (figlet est une application qui prend un texte en entrée et le formate en ascii art) apt update

apt install figlet

figlet demo

Ensuite quitter le container

exit


Maintenant, créez un nouveau container avec la même image debian et essayez de lancer la commande : figlet demo

Logiquement, le système vous retourne une erreur, figlet n'est pas installé sur ce container.

bash: figlet: command not found

Pour finir, quitter le container exit

On voit donc bien ici que toute modification apportée à un container est faite sur celui-ci et pas dans la couche OS initiale de l'image. La modification a juste été faites dans la couche spécifique du container. Si vous supprimez ce container, cette modification sera donc perdue. Tant que le container existe , cette couche persistante sera maintenue. Essayons de redémarrer notre container. Comme nous ne l'avons pas nommé, il nous retrouver son ID . N'oubliez pas de préciser -a, souvenez-vous qu'une fois le dernier processus terminé, le container est automatiquement stoppé. docker container ls -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

3a3327c75007 debian "bash" 42 seconds ago Exited (130) 1 second ago infallible_jones

34cc67ae43d0 debian "bash" 15 minutes ago Exited (0) 8 minutes ago eager_greider

Notre premier container basé sur debian est le plus ancien des deux . Copiez son ID (ici 34cc67ae43d0 ) et utilisez la commande start pour le relancer. (vous pouvez aussi utiliser son nom). Puis exécuter un shell bash dans un terminal interactif pour obtenir son invite de commandes

docker container start 34cc67ae43d0

docker container exec -ti 34cc67ae43d0 bash

Exécutez de nouveau la commande figlet figlet hello

Logiquement (si vous avez redémarré le bon container), celle-ci devrait fonctionner . Pour terminer , quitter et arrêter le container.

Partie 2 : IMAGES Maintenant que nous avons bien compris le lien entre les images et les containers voyons comment nous pouvons les manipuler. Vous en avez déjà eu un aperçu dans le TP précédent, la syntaxe est assez similaire à celle utilisée pour les containers et ressemble donc à ceci : docker image COMMAND [OPTIONS] Quelques-unes des COMMAND les plus utilisées :

ls Liste des images

rm Suppression d'un container

pull Téléchargement d'une image

inspect Détail d'une image

history Historique de la construction de l'image

save Sauvegarde une image dans un fichier tar

load Restaure une image dans un fichier tar


Commençons par le plus simple, lister (ls) les images présentes sur votre VPS :

docker image ls

REPOSITORY TAG IMAGE ID CREATED SIZE

wordpress 5.4.1-php7.4-apache 7219fcfe43f8 6 days ago 544MB

alpine latest f70734b6a266 2 weeks ago 5.61MB

debian latest 3de0e2c97e5c 2 weeks ago 114MB

hello-world latest bf756fb1ae65 4 months ago 13.3kB

On retrouve ici , le nom de l'image (REPOSITORY) ainsi que sa version (TAG) . On voit ici que pour wordpress, nous disposons de wordpress:5.4.1-php7.4-apache, une version bien précise de l'image wordpress. Alors que pour les autres images, nous avons la dernière version publiée (latest) au moment de son téléchargement . Nous voyons aussi son ID et sa date de création par son concepteur. Nous avons vu que ces images ont été ajoutées lors de la création de nos containers et que Docker les a téléchargées automatiquement. On peut aussi télécharger une image sans pour autant créer un container en utilisant la commande pull . Par exemple, retéléchargeons une image de php que nous avions supprimée à la fin du dernier tp. docker image pull php:7.4

7.4: Pulling from library/php

54fec2fa59d0: Already exists

cc4504446071: Already exists

f8d55b89827d: Already exists

6bf7f8bea876: Already exists

408b24f0cbbd: Pull complete

d76755163b41: Pull complete

b5ec10034b1f: Pull complete

b81d62ef030e: Pull complete

61a5d74c992c: Pull complete

Digest: sha256:3e6d31cfef1b37595ed11877f274a3105ab54f51bdb3b5c41cd089cda9b3d0d6

Status: Downloaded newer image for php:7.4

docker.io/library/php:7.4

Vous remarquez que certains éléments sont marqués comme déjà existant (Already exits). C'est tout à fait normal, car chacun des éléments correspond à une couche de l'image et dans notre cas nous possédons déjà certaines couche de php7.4, puisqu'elles sont dans l'image de wordpress. Vérifions que notre image est bien présente (en précisant juste son nom, pour filtrer)

docker image ls php


php 7.4 bae68dcbe13d 7 days ago 405MB

Comme pour les containers, nous pouvons inspecter les détails de l'image avec la commande inspect. Le résultat renvoyé est aussi au format json. On peut voir par exemple les identifiants des couches "layers) qui constituent l'image (Remarquez qu'il faut préciser le nom et le tag de l'image) docker image inspect php:7.4


"RootFS": {

"Type": "layers",

"Layers": [

"sha256:c2adabaecedbda0af72b153c6499a0555f3a769d52370469d8f6bd6328af9b13",

"sha256:cd93d8f35636a50673bdc383a3d81f265aea5a9238f60eb7ae2957c6dbb38d88",

"sha256:92ae4025fb201623e7341f8351134f15dc6ea13d8426a7da22ad4e17fc21b731",

"sha256:a8621e64f5a07769e52d782a16a2d49bcc44ffc15f8206cecc7e676b7ea25721",

"sha256:050d27e37b55036ceba803e2eab2171237a51e77e317cf1117e09316ac0cd308",

"sha256:fb6059c83652a2244f65d9ca2625e5f0cef123fe86aa63b1fdf8eeab87d7e673",

"sha256:c7e87b919c844bdd08c1ba6f87db6169926926b4f234b4dc4b41f26780b65b9e",

"sha256:d9880664cffc5964cc54a67afdbe256ba8f923c8e5caf2a1056bc47ca1027102",

"sha256:d2c1a3a556310279f7969046c1463dd395205ec4e89f9c36b02ad101a71bb536"

Par exemple pour l'image php:7.4 on voit ici qu'elle est constituée de 9 couches. Ce qui correspond bien aux nombres de couches vues pendant son téléchargement. Une autre commande, très utile pour comprendre comment est construite une image. La commande history qui va lister toutes les étapes de la construction de l'image. docker image history php:7.4

IMAGE CREATED CREATED BY SIZE COMMENT

bae68dcbe13d 7 days ago /bin/sh -c #(nop) CMD ["php" "-a"] 0B

<missing> 7 days ago /bin/sh -c #(nop) ENTRYPOINT ["docker-php-e… 0B

<missing> 7 days ago /bin/sh -c docker-php-ext-enable sodium 20B

<missing> 7 days ago /bin/sh -c #(nop) COPY multi:0b7e4a1b9cd5748… 6.53kB

<missing> 7 days ago /bin/sh -c set -eux; savedAptMark="$(apt-m… 97.1MB

<missing> 7 days ago /bin/sh -c #(nop) COPY file:ce57c04b70896f77… 587B

<missing> 7 days ago /bin/sh -c set -eux; savedAptMark="$(apt-m… 11.5MB

<missing> 7 days ago /bin/sh -c #(nop) ENV PHP_SHA256=d059fd7f55… 0B

<missing> 7 days ago /bin/sh -c #(nop) ENV PHP_URL=https://www.p… 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ENV PHP_VERSION=7.4.5 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ENV GPG_KEYS=42670A7FE4D0… 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ENV PHP_LDFLAGS=-Wl,-O1 -… 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ENV PHP_CPPFLAGS=-fstack-… 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ENV PHP_CFLAGS=-fstack-pr… 0B

<missing> 2 weeks ago /bin/sh -c set -eux; mkdir -p "$PHP_INI_DIR… 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ENV PHP_INI_DIR=/usr/loca… 0B

<missing> 2 weeks ago /bin/sh -c set -eux; apt-get update; apt-g… 227MB

<missing> 2 weeks ago /bin/sh -c #(nop) ENV PHPIZE_DEPS=autoconf … 0B

<missing> 2 weeks ago /bin/sh -c set -eux; { echo 'Package: php… 46B

<missing> 2 weeks ago /bin/sh -c #(nop) CMD ["bash"] 0B

<missing> 2 weeks ago /bin/sh -c #(nop) ADD file:9b8be2b52ee0fa31d… 69.2MB

On voit ici toutes les commandes qui ont servi à créer l'image finale, en partant d'un premier fichier (ADD d'une image de base) en bas puis les ajouts de paquets et les création de fichiers qui ont permis de créer les différentes couches. Vous reconnaissez surement certaines des commandes utilisées comme apt update ou mkdir par exemple. Nous verrons un peu plus loin dans ce TP comment sont exécutées ses commandes pour arriver à la création de l'image. Pour finir sur cette partie et avant de voir comment nous pouvons créer nos propres images, deux commandes à connaitre : save et load qui permettent respectivement de sauvegarder (save) une image dans un fichier tar et de la restaurer (load)

DEMONSTRATION : Créez un container basé sur l'image alpine et supprimé le aussitôt (juste pour être sûr que l'image sera présente pour la démonstration)

docker container run --name demo alpine

docker container rm demo


Vérifions que l'image est bien présente sur notre machine docker image ls alpine

Sauvegardons l'image alpine dans un fichier /mmitrans/alpine.tar sudo docker image save -o /mmitrans/alpine.tar alpine

Précédez la commande de sudo si vous n'êtes pas dans une session root Supprimez l'image alpine avec la commande rm -f (pour forcer la suppression) docker image rm -f alpine

Vérifiez que l'image a bien été supprimée docker image ls

Plus d'image alpine. Pas de souci nous pouvons la restaurer à partir du fichier tar

sudo docker image load -i /mmitrans/alpine.tar

Vérifiez que l'image a bien été restaurée docker image ls alpine


alpine latest f70734b6a266 2 weeks ago 5.61MB

Pour valider votre TP, créez un fichier TP06.txt dans votre dossier /mmitrans et répondez aux différentes questions en utilisant comme d'habitude le format QX:REPONSE (Une ligne par question) Q1: Quels sont les noms des containers que vous avez créés à partir de l'image debian ? Q2: Quel est l'ID de l'image debian que vous avez téléchargée ? Q3: Quel est l'ID de l'image php que vous avez téléchargée ? Q4: De combien de couches est constituée l'image php:7.4 ?

Partie 3 : Dockerfile Attaquons-nous maintenant à la partie surement la plus intéressante de ce TP : La création d'image. Comment sont créées les images Docker ? A l'aide de la commande build et surtout d'un fichier nommé Dockerfile qui va décrire toutes les instructions (comme vu avec history) de la construction d'une image. Voici quelques-unes des instructions principales du Dockerfile :

FROM Image de base

ARG / ENV Définir des variables d'environnement

RUN Exécute des commandes pour construire le FileSystem de l'image

COPY / ADD Copie des ressources depuis l'hôte vers le FileSystem de l'image

EXPOSE Expose un port applicatif

WORKDIR Définit le répertoire de travail

ENTRYPOINT avec CMD , Définit la commande exécutée au lancement du container


Pour commencer simplement, essayons de construite une image simple basée sur debian et apache. Un container basée sur cette image devra simplement afficher une page index.html qui affiche votre nom et votre prénom, ainsi que votre identifiant MMI. Si nous raisonnons en couches, cela devrait ressembler à ça :

index.html et style.css

apache

debian

Donc 3 couches : - Une pour l'OS : Debian - Une pour les services : Apache - Une pour notre application : Notre page web et sa feuille de style Si nous devions installer cela sur un serveur (comme une VM dans la salle réseau) . Comment aurions-nous procédé ? L'OS serait déjà installé, mais il faudrait quand même installer Apache et recopier notre page et notre feuille de style dans le dossier /var/www/html . Pour créer notre image il suffit de faire la même chose et c'est ce que nous allons décrire dans notre fichier Dockerfile. Avant de continuer créer un dossier app sur votre machine (dans le dossier courant) et créez dans ce dossier une page index.html et un feuille de style style.css. La page devra simplement affichée votre identifiant MMI, votre prénom et votre nom. Créons maintenant notre fichier Dockerfile. ATTENTION celui-ci ne doit pas se trouver dans le dossier app, il doit être au même niveau que le dossier. L'arborescence doit ressembler à cela

Dockerfile

app

|- index.html

|- style.css

Qu'allons-nous mettre dans notre fichier ? Commençons par la base. Première couche à créer : l'OS. La partie la plus simple nous allons partir d'une image existante : debian:buster-slim Dans notre fichier cela donne : FROM debian:buster-slim

(cela constituera la première couche de notre image) Ensuite nous devons installer apache. Si nous étions sur un serveur nous taperions les commandes apt update et apt install apache2 . Ici nous allons faire la même chose à l'aide de la commande RUN (Cette commande créera la seconde couche de notre image) Ajoutons ceci dans notre fichier :

RUN apt update -y && apt install -q -y apache2

Il ne nous reste plus qu'à copier nos fichiers dans le dossier /var/www/html d'apache pour créer la troisième et dernière couche de notre image. Utilisons pour cela la commande COPY :


COPY app /var/www/html

Nos trois couches sont créées, il ne nous reste plus qu'à configurer le lancement de notre container lance bien apache au démarrage et expose son port 80 pour que nous puissions le rediriger vers un autre de notre choix Pour exposer le port : EXPOSE 80

Pour définir le dossier /var/www/html comme répertoire de travail WORKDIR /var/www/html

Pour lancer apache au démarrage:

ENTRYPOINT ["apachectl"]

CMD ["-D","FOREGROUND"]

Pour terminer , enregistrez votre fichier Dockerfile (qui doit donc contenir les commandes vues ci-dessus). Il ne nous reste plus qu'à exécuter la commande build pour construire notre image :

docker image build -t sitemmi:1.0 .

ATTENTION : le . (point) à la fin de la commande est important, il désigne l'emplacement du fichier Dockerfile. C'est à dire le répertoire en cours. Au lancement de la commande vous devriez voir passer les 7 étapes de la construction de notre image, ce qui correspond aux commandes que nous avons saisie dans le Dockerfile. Sending build context to Docker daemon 433.3MB

Step 1/7 : FROM debian:buster-slim

buster-slim: Pulling from library/debian

5b54d594fba7: Pull complete

Digest: sha256:73be3c825cb4d8766f811007bb11ac228519a103638492312990fdd6f19a0167

Status: Downloaded newer image for debian:buster-slim

---> 02dcc8aeaee7

Step 2/7 : RUN apt update -y && apt install -q -y apache2

---> Running in 30ec4a244afb

.... ici toute l'installation d'apache - ne tenez pas compte des quelques erreurs.

Removing intermediate container 30ec4a244afb

---> 1b719d21907c

Step 3/7 : COPY app /var/www/html

---> 55b25fcb78ee

Step 4/7 : EXPOSE 80

---> Running in be466c1f06c3

Removing intermediate container be466c1f06c3

---> 91473f1d04dd

Step 5/7 : WORKDIR /var/www/html

---> Running in ef708c29b0d1

Removing intermediate container ef708c29b0d1

---> 0e34452d9c2f

Step 6/7 : ENTRYPOINT ["apachectl"]

---> Running in 8db45893cdd6

Removing intermediate container 8db45893cdd6

---> f68582ae0196

Step 7/7 : CMD ["-D","FOREGROUND"]

---> Running in 12fef230cf84

Removing intermediate container 12fef230cf84

---> 959390e00f99

Successfully built 959390e00f99

Successfully tagged sitemmi:1.0

Nous pouvons vérifier que notre image est bien là : docker image ls



sitemmi 1.0 959390e00f99 5 minutes ago 194MB

Nous pouvons aussi faire un inspect docker image inspect sitemmi:1.0

"RootFS": {

"Type": "layers",

"Layers": [

"sha256:15458c1ab3242f51e5c0d34275cca5e7ee13e6aa29802b632534dc70b297eba7",

"sha256:a8b6460eb9dc5608f4ec6713c94dd35c37d197ddc8e1cfe9188d713eaf9d7c80",

"sha256:9edf63b83111efde364c5ca5ee5adf3e883cf8587ff16a2d5bc951a4debadb3f"

Nous voyons bien en fin d'affichage, les 3 couches construites par les commandes FROM, RUN et COPY et un history docker image history sitemmi:1.0

IMAGE CREATED CREATED BY SIZE COMMENT

959390e00f99 8 minutes ago /bin/sh -c #(nop) CMD ["-D" "FOREGROUND"] 0B

f68582ae0196 8 minutes ago /bin/sh -c #(nop) ENTRYPOINT ["apachectl"] 0B

0e34452d9c2f 8 minutes ago /bin/sh -c #(nop) WORKDIR /var/www/html 0B

91473f1d04dd 8 minutes ago /bin/sh -c #(nop) EXPOSE 80 0B

55b25fcb78ee 8 minutes ago /bin/sh -c #(nop) COPY dir:d3a709d0472124852… 225B

1b719d21907c 8 minutes ago /bin/sh -c apt update -y && apt install -q -… 125MB

02dcc8aeaee7 2 hours ago /bin/sh -c #(nop) CMD ["bash"] 0B

<missing> 2 hours ago /bin/sh -c #(nop) ADD file:ca8f84daab6688a5d… 69.2MB

On retrouve bien ici toutes les étapes de notre construction. Il ne reste plus qu'à tester notre image, en créant un container. N'oublions de rediriger le port 80 du container vers un de nos ports libres sur notre VPS, par exemple : 8888 docker container run -d --name sitemmi -p 8888:80 sitemmi:1.0

docker container ls

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

9308ca21a921 sitemmi:1.0 "apachectl -D FOREGR…" 16 seconds ago Up 14 seconds 0.0.0.0:8888->80/tcp sitemmi

Et ouvrons notre navigateur pour vérifier que notre page web à bien été copiée dans le bon dossier. Ouvrez votre navigateur avec l'URL : MMI.h205.online:8888 Vous devriez voir votre page web s'afficher. Félicitations, vous venez de construire votre première image Docker.

Avant de continuer, répondez aux questions suivantes : Q5: Quelles sont les commandes de notre Dockerfile qui ont permis de créer les 3 couches ? Q6: Quelle version d'apache est installée dans votre container ? (apache2 -v)

Résumons notre fichier Dockerfile :


FROM debian:buster-slim

RUN apt update -y && apt install -q -y apache2

COPY app /var/www/html

EXPOSE 80

WORKDIR /var/www/html



VARIABLES D'ENVIRONNEMENT Essayons de l'améliorer en ajoutant quelques options. Premièrement, ajoutons des variables d'environnement. le Dockerfile en possède deux type : ARG : Pour stocker des variables temporaires qui ne servent que pendant la création de l'image. ENV : Des variables persistantes qui sont exploitées par le Dockerfile, mais aussi dans les containers Dans notre exemple, nous pourrions utiliser ARG pour définir le répertoire de travail d'Apache .

ARG DOCUMENROOT="/var/www/html"

et ensuite , exploiter cette variable dans la COPY et la déclaration du WORKDIR

COPY app ${DOCUMENTROOT}

WORKDIR ${DOCUMENTROOT}

Une autre pratique assez courante, est le passage d'options récurrentes, comme par exemple le '-q -y' de la commande apt install . ARG APT_FLAGS="-q -y"

Ce qui permettrait de faire nos faire nos "apt install"comme ceci :

RUN apt update -y && apt install ${ APT_FLAGS } apache2

Notre fichier final, va donc ressembler à ceci : FROM debian:buster-slim

ARG DOCUMENTROOT="/var/www/html"

ARG APT_FLAGS="-y -q"

RUN apt update -y && apt install ${APT_FLAGS} apache2

COPY app ${DOCUMENTROOT}

EXPOSE 80

WORKDIR ${DOCUMENTROOT}



Nous pouvons donc , maintenant générer une nouvelle image sitemmi:1.1 par exemple

docker image build -t sitemmi:1.1 .

et créer un nouveau container pour la tester. docker container run -d --name sitemmi2 -p 8889:80 sitemmi:1.1

docker container ls

ATTENTION à bien changer le nom du container créé, ainsi que le port et la version de l'image. Ouvrez votre navigateur avec l'URL : MMI.h205.online:8889 et vérifier que votre page d'affiche bien

Avant de continuer faites une copie de votre fichier Dockerfile dans le dossier /mmitrans


Partie 4 : Exercice Pour finir cette rapide introduction aux images Docker , je vous propose l'exercice suivant: Sur le même modèle que l'image précédente, créez un Dockerfile qui permettra d'implémenter des containers avec debian,apache et php. Objectif : Si l'on instancie un container à partir de votre image en utilisant la commande suivante :

docker container run -d --name mmiphp -p 8989:80 mmiphp:1.0

Je dois pouvoir afficher une page info.php avec l'URL suivante : MMI.h205.online:8989/info.php Vous pouvez repartir de votre Dockerfile existant. La version de php n'a pas d'importance. La page info.php doit être copiée dans l'image (on n'utilise pas de -v pour créer le container)

Pour ceux qui voudrait faire un peu plus fort. Version php7.4 obligatoire Et la page doit s'afficher directement avec l'URL MMI.h205.online:8989 donc sans préciser son nom.

m3204 dockerfile195.83.128.21/~pgommery/img/pdf/s3-tp06-dockerfile.pdfdockerfile - m3204 1 m3204...

Documents