Lancer un conteneur à partir de votre image personnalisée

Introduction : récolter les fruits de votre build

Après avoir méticuleusement défini les étapes dans votre Dockerfile et utilisé la commande `docker build` pour assembler votre image, le moment est venu de concrétiser vos efforts. L'objectif ultime de la création d'une image personnalisée est de pouvoir l'exécuter sous forme de conteneur, afin de déployer votre application ou votre environnement spécifique de manière isolée et reproductible. C'est l'étape où la recette prend vie.

Lancer un conteneur à partir de votre propre image est la validation finale du processus de build. Cela confirme que les instructions de votre Dockerfile ont correctement configuré l'environnement, que vos fichiers ont été copiés au bon endroit et que la commande de démarrage par défaut (`CMD` ou `ENTRYPOINT`) est prête à lancer votre application. Heureusement, le processus est très similaire à celui utilisé pour lancer des conteneurs à partir d'images publiques téléchargées depuis Docker Hub.

Ce chapitre vous montrera exactement comment utiliser la commande `docker run` avec le nom et le tag de l'image que vous venez de créer. Nous rappellerons les options essentielles comme le mapping de ports et le nommage, appliquées cette fois à votre propre création, pour que vous puissiez interagir avec votre application conteneurisée.

Utiliser `docker run` avec votre image locale

La bonne nouvelle est que la commande `docker run` fonctionne de manière identique, que l'image provienne de Docker Hub ou qu'elle ait été construite localement par vos soins. La seule différence réside dans le nom de l'image que vous spécifiez. Au lieu d'utiliser un nom d'image publique comme `nginx` ou `python:3.9`, vous utiliserez le nom et le tag que vous avez définis lors de l'étape `docker build -t nom_image:tag .`.

La syntaxe générale reste donc :

docker run [OPTIONS] VOTRE_IMAGE:VOTRE_TAG [COMMANDE_ALTERNATIVE] [ARGS...]

Supposons que lors du build, vous ayez tagué votre image avec `mon_app_web:1.0`. Pour lancer un conteneur basé sur cette image, vous feriez simplement :

docker run mon_app_web:1.0

Bien sûr, comme pour les images publiques, un simple `docker run` sans options n'est souvent pas suffisant pour les applications ou services. Vous voudrez probablement utiliser les mêmes options clés que nous avons déjà vues :

• `-d` : Pour lancer le conteneur en arrière-plan (mode détaché), essentiel pour les services.
• `-p HOTE:CONTENEUR` : Pour mapper un port de votre machine hôte à un port exposé par votre application dans le conteneur (défini implicitement par votre application ou documenté via `EXPOSE` dans le Dockerfile).
• `--name NOM_CONTENEUR` : Pour attribuer un nom facile à retenir à votre instance de conteneur.
• `--rm` : Pour que le conteneur soit automatiquement supprimé lorsqu'il s'arrête (utile pour les tests).
• `-it` : Si votre image est conçue pour être utilisée interactivement (par exemple, une image contenant un shell ou un outil CLI).

Ainsi, pour lancer votre application web `mon_app_web:1.0` (qui écoute sur le port 5000 à l'intérieur, comme défini dans son code ou son Dockerfile via `EXPOSE 5000`) en arrière-plan, en la rendant accessible sur le port 8080 de votre machine et en la nommant `mon_site_v1`, la commande complète serait :

docker run -d -p 8080:5000 --name mon_site_v1 mon_app_web:1.0

Vérifier et interagir avec votre conteneur personnalisé

Une fois la commande `docker run` exécutée (surtout avec l'option `-d`), comment savoir si tout fonctionne comme prévu ? Plusieurs commandes Docker vous permettent de vérifier l'état et d'interagir avec votre conteneur personnalisé :

1. Vérifier l'état : `docker ps`
Cette commande liste tous les conteneurs en cours d'exécution. Si vous avez lancé votre conteneur avec `-d`, il devrait apparaître dans cette liste, avec son ID, le nom de l'image (`mon_app_web:1.0`), la commande exécutée, son statut (ex: `Up 5 minutes`), les ports mappés (`0.0.0.0:8080->5000/tcp`), et le nom que vous lui avez donné (`mon_site_v1`). S'il n'apparaît pas, il s'est peut-être arrêté immédiatement après le démarrage (voir point suivant).

2. Consulter les logs : `docker logs`
Si votre conteneur s'arrête prématurément ou si vous voulez simplement voir la sortie standard de votre application (ce qu'elle écrirait normalement dans la console), utilisez `docker logs nom_conteneur` (ou `docker logs id_conteneur`). C'est souvent la première étape pour diagnostiquer un problème si le conteneur ne démarre pas correctement. Exemple : `docker logs mon_site_v1`. Vous pouvez ajouter l'option `-f` pour suivre les logs en temps réel (`docker logs -f mon_site_v1`).

3. Accéder à l'application : via le port mappé
Si votre conteneur exécute un service web ou une API et que vous avez utilisé l'option `-p HOTE:CONTENEUR`, vous devriez pouvoir y accéder via votre navigateur ou un outil comme `curl` en utilisant l'adresse de votre machine hôte et le port hôte spécifié. Pour notre exemple `-p 8080:5000`, vous accéderiez via `http://localhost:8080`.

4. Exécuter une commande à l'intérieur : `docker exec`
Si vous avez besoin d'inspecter l'intérieur d'un conteneur en cours d'exécution ou d'exécuter une commande ponctuelle (par exemple, pour vérifier un fichier de configuration), vous pouvez utiliser `docker exec`. Pour obtenir un shell interactif à l'intérieur du conteneur `mon_site_v1` :

docker exec -it mon_site_v1 /bin/bash

(Remplacez `/bin/bash` par `/bin/sh` si bash n'est pas disponible dans votre image de base). Tapez `exit` pour quitter le shell sans arrêter le conteneur.

5. Arrêter et supprimer : `docker stop` et `docker rm`
Pour arrêter proprement votre conteneur, utilisez `docker stop mon_site_v1`. Une fois arrêté, il ne tourne plus mais existe toujours (visible avec `docker ps -a`). Pour le supprimer définitivement (libérant le nom et l'espace disque associé), utilisez `docker rm mon_site_v1`. Si vous aviez lancé le conteneur avec `--rm`, il est automatiquement supprimé à l'arrêt.

Points clés et dépannage rapide

Lancer un conteneur depuis votre image personnalisée est la consécration de votre travail avec le Dockerfile et `docker build`. Retenez que la commande `docker run` s'utilise de la même manière, en remplaçant simplement le nom de l'image publique par le tag de votre image locale (`mon_image:mon_tag`).

N'oubliez pas l'importance des options `-d`, `-p` et `--name` pour gérer efficacement vos conteneurs de service. Assurez-vous que le port que vous essayez de mapper avec `-p ...:PORT_CONTENEUR` correspond bien au port sur lequel votre application écoute réellement à l'intérieur du conteneur.

Si votre conteneur ne démarre pas ou s'arrête immédiatement, le premier réflexe est de consulter les logs avec `docker logs nom_conteneur`. Les erreurs les plus courantes incluent : des problèmes dans le code de votre application, des fichiers manquants (erreur `COPY` dans le Dockerfile ?), des problèmes de permissions, ou une `CMD`/`ENTRYPOINT` incorrecte dans le Dockerfile.

En maîtrisant `docker build` et `docker run` avec vos propres images, vous avez acquis la compétence fondamentale pour encapsuler et déployer n'importe quelle application avec Docker. Vous êtes maintenant prêt à explorer des concepts plus avancés comme la gestion des données ou la composition de services multiples.