Introduction et Utilisation Basique de Docker

Gestion des Versions de Docker

Docker propose deux éditions principales : l'Édition Entreprise (EE) et l'Édition Communautaire (CE). Chaque trimestre, une version stable est publiée pour les deux éditions. Les versions CE bénéficient de 4 mois de support, tandis que les versions EE sont supportées pendant 12 mois. De plus, une version mensuelle "Edge" est disponible pour la CE chaque mois. Depuis le premier trimestre 2017, la nomenclature des versions suit le format AA.MM-xx, par exemple, 18.06.0-ce pour la première publication communautaire de juin 2018.

Installation de Docker

Configuration du transfert réseau sur l'hôte

Si ce n'est pas déjà configuré, exécutez les commandes suivantes pour activer le transfert IP et la redirection des paquets pour iptables/ip6tables dans le noyau :


cat <<eof>  /etc/sysctl.d/docker.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward=1
EOF
sysctl -p /etc/sysctl.d/docker.conf
 </eof>

Configuration et Installation via Yum

Pour installer Docker sur un système CentOS 7, suivez ces étapes :


## Télécharger les fichiers de dépôt
curl -o /etc/yum.repos.d/Centos-7.repo http://mirrors.aliyun.com/repo/Centos-7.repo
curl -o /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

## Actualiser le cache des paquets
yum clean all && yum makecache

## Installer une version spécifique de Docker CE
yum install docker-ce-20.10.6 -y

## Lister les versions disponibles (trier par ordre décroissant)
yum list docker-ce --showduplicates | sort -r

## Pour installer une ancienne version, décommentez et adaptez :
## yum install -y docker-ce-18.09.9

## Configurer un miroir pour accélérer le téléchargement des images
## Rendez-vous sur https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors pour obtenir un miroir
mkdir -p /etc/docker
cat <<eof> /etc/docker/daemon.json
{
 "registry-mirrors": [
   "https://VOTRE_IDENTIFIANT_MIROIR.mirror.aliyuncs.com"
 ]
}
EOF

## Activer le démarrage automatique de Docker
systemctl enable docker
systemctl daemon-reload

## Démarrer le service Docker
systemctl start docker

## Vérifier l'état de Docker
systemctl status docker

## Vérifier les informations de Docker
docker info

## Localiser l'exécutable du client Docker
which docker

## Vérifier le processus du démon Docker
ps aux | grep docker

## Vérifier le processus containerd
ps aux | grep containerd
 </eof>

Utilisation de Docker

Visualisation des Images

Pour afficher la liste des images Docker locales :


docker images

Acquisition d'Images

  1. Téléchargement depuis un registre distant : ```bash

    docker pull nginx:alpine docker images

  2. Application d'un tag : Utile pour renommer une image ou lui associer une adresse de registre. ```bash

    docker tag nginx:alpine votre_registre.com/nginx:alpine docker images

  3. Construction à partir d'un Dockerfile : ```bash

    docker build . -t mon-nginx:ubuntu -f Dockerfile

Lancement de Conteneurs

Pour démarrer un conteneur à partir d'une image :


docker run --name mon-nginx-alpine -d nginx:alpine

-d lance le contenuer en mode détaché (arrière-plan).

Inspection du Contenu d'un Conteneur

Pour accéder à l'environnement d'un conteneur et voir les processus en cours :


# Entrer dans le conteneur avec un terminal interactif
docker exec -ti mon-nginx-alpine /bin/sh
# Lister les processus
ps aux

Construction d'Images Docker

Création d'un Dockerfile

Un Dockerfile contient les instructions pour construire une image.


# Utiliser une image de base
FROM ubuntu:latest

# Mettre à jour la liste des paquets et installer Nginx
RUN apt-get update && apt-get install -y nginx

# Commande à exécuter au démarrage du conteneur
CMD ["/usr/sbin/nginx", "-g", "daemon off;"]

Construction de l'Image Locale


docker build . -t mon-nginx:ubuntu -f Dockerfile

Accès aux Services d'un Conteneur

Pour accéder à un service s'exécutant à l'intérieur d'un conteneur depuis ce même conteneur :


# Entrer dans le conteneur
docker exec -ti mon-nginx-alpine /bin/sh
# Vérifier le processus Nginx et tester l'accès local
ps aux | grep nginx
curl localhost:80

Accès aux Services d'un Conteneur depuis l'Hôte

Pour rendre un service accessible depuis l'hôte, mappez un port :


# Supprimer l'ancien conteneur s'il existe
docker rm -f mon-nginx-alpine
# Lancer un nouveau conteneur en mappant le port 8080 de l'hôte au port 80 du conteneur
docker run --name mon-nginx-alpine -d -p 8080:80 nginx:alpine
# Tester l'accès via l'adresse IP de l'hôte et le port mappé
curl <ip_hote>:8080
 </ip_hote>

Communication Client-Démon Docker

Le client Docker communique avec le démon via un socket Unix (par défaut /var/run/docker.sock). Vous pouvez monter ce socket dans un conteneur pour lui permettre de contrôler Docker.


docker run --name portainer -d -p 9001:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer

Exportation d'une Image vers un Fichier


docker save -o nginx-alpine.tar nginx:alpine

Chargement d'une Image depuis un Fichier


docker load -i nginx-alpine.tar

Suppression d'Images


docker rmi nginx:alpine

Visualisation des Conteneurs

  • Afficher uniquement les conteneurs en cours d'exécution : ```bash

    docker ps

  • Afficher tous les conteneurs (en cours d'exécution et arrêtés) : ```bash

    docker ps -a

Gestion du Démarrage des Conteneurs

  • Démarrage en arrière-plan : ```bash

    docker run --name mon-app -d mon-image:tag

  • Mappage de ports (hôte:conteneur) : ```bash

    docker run --name mon-app -d -p 8080:80 mon-image:tag

  • Limitation des ressources (mémoire) : ```bash

    docker run --memory=500m mon-image:tag

Persistance des Données des Conteneurs

Utilisez les volumes pour monter des répertoires de l'hôte dans le conteneur.

  • Montage d'un répertoire hôte : ```bash

    docker run --name mon-app -d -v /chemin/sur/hote:/chemin/dans/conteneur mon-image:tag

  • Exemple avec MySQL, en montant le répertoire de données : ```bash

    docker run --name mysql-db -e MYSQL_ROOT_PASSWORD=monMotDePasse -d -v /opt/mysql/data:/var/lib/mysql mysql:5.7

Exécution de Commandes dans un Conteneur

Accédez à un shell interactif ou exécutez une commande spécifique.


# Shell interactif
docker exec -ti <id_ou_nom_conteneur> /bin/sh

# Exécuter une commande spécifique (ex: changer le nom d'hôte)
docker exec <id_ou_nom_conteneur> hostname
 </id_ou_nom_conteneur></id_ou_nom_conteneur>

Copie de Données entre l'Hôte et le Conteneur

  • Copier de l'hôte vers le conteneur : ```bash

    echo 'Contenu du fichier' > /tmp/monfichier.txt docker cp /tmp/monfichier.txt mon-app:/tmp/ docker exec mon-app cat /tmp/monfichier.txt

  • Copier du conteneur vers l'hôte : ```bash

    docker cp mon-app:/chemin/dans/conteneur/fichier.txt ./destination/locale/

Consultation des Logs de Conteneur

  • Afficher tous les logs : ```bash

    docker logs mon-app

  • Afficher les logs en temps réel : ```bash

    docker logs -f mon-app

  • Afficher les 100 dernières lignes en temps réel : ```bash

    docker logs --tail=100 -f mon-app

Arrêt et Suppression de Conteneurs

  • Arrêter un conteneur en cours : ```bash

    docker stop mon-app

  • Démarrer un conteneur arrêté : ```bash

    docker start mon-app

  • Supprimer un conteneur arrêté : ```bash

    docker rm mon-app

  • Supprimer un conteneur en cours (force) : ```bash

    docker rm -f mon-app

Inspection Détaillée des Conteneurs et Images

  • Informations détaillées sur un conteneur (y compris son adresse IP) : ```bash

    docker inspect mon-app

  • Informations détaillées sur une image : ```bash

    docker inspect mon-image:tag

Déploiement d'un Registre Docker Privé

Lancement d'un Service de Registre

Pour héberger vos propres images Docker, vous pouvez déployer un registre privé.


## Lancer le conteneur du registre avec persistance des données
docker run -d -p 5000:5000 --restart always -v /opt/registry:/var/lib/registry --name registry registry:2

Par défaut, ce registre n'utilise pas d'authentification. Pour en configurer une, consultez la documentation officielle de Docker Registry.

Pousser une Image Locale vers le Registre

  1. Appliquez un tag à votre image avec l'adresse de votre registre : ```bash

    docker tag mon-image:tag ip_serveur_registre:5000/mon-image:tag

  2. Poussez l'image : ```bash

    docker push ip_serveur_registre:5000/mon-image:tag

Note sur les Registres HTTP : Docker refuse par défaut de pousser vers des registres non sécurisés (HTTP). Pour contourner cela lors de tests locaux ou sur des réseaux privés de confiance, vous devez configurer le démon Docker de l'hôte pour inclure l'adresse de votre registre dans la liste insecure-registries.


# Modifier le fichier de configuration du démon Docker
cat <<eof> /etc/docker/daemon.json
{
   "registry-mirrors": [
       "https://votre_miroir.aliyuncs.com"
   ],
   "insecure-registries": [
       "ip_serveur_registre:5000"
   ]
}
EOF

# Redémarrer le démon Docker
systemctl restart docker

# Retenter la commande push
docker push ip_serveur_registre:5000/mon-image:tag
 </eof>

Pour vérifier le contenu du catalogue du registre :


curl -X GET http://ip_serveur_registre:5000/v2/_catalog
curl -X GET http://ip_serveur_registre:5000/v2/mon-image/tags/list

Montage de Données Existantes pour un Registre

Si vous avez des données de registre préexistantes, vous pouvez les monter dans le conteneur lors de son lancement.


## Décompresser les données de l'image hors ligne dans un répertoire
tar zxf registry.tar.gz -C /opt

## Supprimer le conteneur de registre existant s'il y en a un
docker rm -f registry

## Lancer un nouveau conteneur en montant le répertoire des données
docker run -d -p 5000:5000 --restart always -v /opt/registry:/var/lib/registry --name registry registry:2

Structure d'un Dockerfile

Un Dockerfile est un script contenant une série d'instructions pour assembler une image Docker.


docker build . -t NomImage:TagImage -f Dockerfile

  • FROM : Définit l'image de base. C'est la première instruction obligatoire. ```

    FROM ubuntu:latest

  • MAINTAINER : Endique le mainteneur de l'image. ```

    MAINTAINER Nom email@exemple.com

  • COPY / ADD : Copie des fichiers ou répertoires du contexte de build vers le système de fichiers de l'image. ```

    COPY . /app ADD https://example.com/file.tar.gz /usr/local/

  • WORKDIR : Définit le répertoire de travail pour les instructions suivantes (RUN, CMD, ENTRYPOINT, etc.). ```

    WORKDIR /app

  • RUN : Exécute des commandes lors de la construction de l'image. Chaque instruction RUN crée une nouvelle couche dans l'image. ```

    RUN apt-get update && apt-get install -y --no-install-recommends nginx RUN pip install --no-cache-dir -r requirements.txt

  • CMD : Spécifie la commande par défaut à exécuter lorsque le conteneur démarre. Elle peut être surchargée lors de l'exécution de docker run. Il ne peut y avoir qu'une seule instruction CMD effective. ```

    CMD ["python", "app.py"] CMD service nginx start

  • ENTRYPOINT : Configure un conteneur pour qu'il s'exécute comme un exécutable. Les arguments passés à docker run sont ajoutés à l'ENTRYPOINT. Il ne peut y avoir qu'une seule instruction ENTRYPOINT effective. ```

    ENTRYPOINT ["python", "app.py"] ENTRYPOINT ["/usr/sbin/nginx", "-g", "daemon off;"]

  • ENV : Définit des variables d'environnement dans l'image. ```

    ENV APP_PORT=8080 ENV DB_HOST=db.local

  • EXPOSE : Informe Docker que le conteneur écoute sur les ports réseau spécifiés au moment de l'exécution. Cela n'a pas d'effet sur la publication des ports ; elle doit être faite avec l'option -p ou -P lors du docker run. ```

    EXPOSE 80 443

Réseaux Docker

Docker fournit une isolation réseau pour les conteneurs. Les questions clés sont : comment les conteneurs communiquent-ils entre eux ? Comment communiquent-ils avec l'hôte ? Comment le mappage de ports fonctionne-t-il ?

Modes Réseau

L'option --net (ou --network) lors de docker run permet de spécifier le mode réseau du conteneur :

  • bridge (par défaut) : Le conteneur obtient sa propre pile réseau isolée sur un pont réseau virtuel géré par Docker.
  • host : Le conteneur partage directement la pile réseau de l'hôte. Aucune isolation réseau n'est effectuée.
  • container:NAME_or_ID : Le conteneur partage l'espace de noms réseau d'un autre conteneur spécifié.
  • none : Le conteneur dispose d'un espace de noms réseau isolé mais sans aucune configuration réseau (pas de carte réseau, d'adresse IP ou de route).

Étiquettes: Docker conteneurisation gestion d'images Dockerfile réseau docker

Publié le 24 juillet à 06h23

Étiquettes Populaires

©2026 L'Atelier Monstre