Aller au contenu

Construire un Dockerfile

Ce tuto sert à créer une image personnalisée Docker à l’aide d’un Dockerfile, puis de s’y connecter.
dockerfile

I. Construction de l’image

1. Créer un fichier Dockerfile
nano Dockerfile 
2. Choisir une image de base par exemple :
  • alpine
  • ubuntu
  • debian
  • kali
3. Créer le fichier suivant cette logique :
  • Commencer par FROM suivi de l’image de base
  • Avant chaque commande ou instruction, mettre RUN
  • Si on installe un programme, il ne faut pas oublier de mettre -y
  • Si on ajoute des lignes dans un fichier qui comprends des caractères spéciaux, ajouter un \ après le “
  • A la fin du fichier, ajouter CMD [« /bin/bash »]
Légende :
FROM ubuntu ; debian ; kali etc...

LABEL maintainer="[email protected]" description "jesuisunedescription"

RUN permet de lancer une commande, mais aura aussi pour effet de créer une image intermédiaire.

ADD permet de copier un fichier depuis la machine hôte ou depuis une URL

EXPOSE permet d'exposer un port du container vers l'extérieur

CMD détermine la commande qui sera exécutée lorsque le container démarrera

ENTRYPOINT permet d'ajouter une commande qui sera exécutée par défaut, et ce, même si on choisit d'exécuter une commande différente de la commande standard

WORKDIR permet de définir le dossier de travail pour toutes les autres commandes (par exemple RUN, CMD, ENTRYPOINT et ADD)

ENV permet de définir des variables d'environnements qui pourront ensuite être modifiées grâce au paramètre de la commande run --env <key>=<value>.

VOLUMES permet de créer un point de montage qui permettra de persister les données. On pourra alors choisir de monter ce volume dans un dossier spécifique en utilisant la commande `run -v <chemin hôte>:
4. Par exemple :
FROM debian

RUN apt update
RUN apt install -y nano
RUN apt install -y htop

CMD ["/bin/bash"]
5. Lancer la compilation de l’image avec la commande suivante :
docker build -t nomimage:1.0 .
docker build -t test-debian:1.0 .

[+] Building 0.0s (9/9) FINISHED
 => [internal] load build definition from Dockerfile                                                                                                                                                   0.0s
 => => transferring dockerfile: 162B                                                                                                                                                                   0.0s
 => [internal] load .dockerignore                                                                                                                                                                      0.0s
 => => transferring context: 2B                                                                                                                                                                        0.0s
 => [internal] load metadata for docker.io/library/debian:latest                                                                                                                                       0.0s
 => [1/5] FROM docker.io/library/debian                                                                                                                                                                0.0s
 => CACHED [2/5] RUN apt update                                                                                                                                                                        0.0s
 => CACHED [3/5] RUN apt install -y nano                                                                                                                                                               0.0s
 => CACHED [4/5] RUN apt install -y htop                                                                                                                                                               0.0s
 => CACHED [5/5] RUN apt install -y net-tools                                                                                                                                                          0.0s
 => exporting to image                                                                                                                                                                                 0.0s
 => => exporting layers                                                                                                                                                                                0.0s
 => => writing image sha256:16e96b8dac5bee4dbc4aa1638fee612133646330d42b30b46c1821544cac134f                                                                                                           0.0s
 => => naming to docker.io/library/test-debian:1.0                                                                                                                                                     0.0s
6. Lancer l’image avec docker run
docker run -ti -d --name test-debian test-debian:1.0
root@5fdffaefabb2:/#
docker rm idduconteneur 
Puis relancer le docker run.

II. Connexion au conteneur

On peut utiliser plusieurs arguments avec docker run par exemple :
docker run -i rends le conteneur intéractif 
docker run -d lancer le conteneur en arrière plan (il ne s'éteint pas tout seul)
docker run -it lance le conteneur et se connecter directement à son shell 
On peut se connecter au conteneur via docker exec et le nom du conteneur ou son identifiant :
docker ps
CONTAINER ID   IMAGE                      COMMAND                  CREATED             STATUS                  PORTS            NAMES
c85df91fa7ec   test-debian:1.4            "/bin/bash"              About an hour ago   Up About an hour                         test-debian
Par exemple :
docker exec -ti c85df91fa7ec bash
OU
docker exec -ti test-syslog bash

III. Gestion des images

Lister les images
docker image ls 
Supprimer une image
docker image rm iddelimage -f
OU
docker rmi iddelimage -f
Dupliquer une image / changer son tag
docker image tag image:1.0 image:1.1
Lister ses conteneurs
docker container ls 

Plus d’infos sur Docker → https://ldugrain.xyz/docker