Etapes : build de l'image, run du conteneur, test de l'application

Etape 3 : construire l'image Docker personnalisée (Build)

Maintenant que nous disposons du code source minimal et du `Dockerfile` décrivant comment l'empaqueter, il est temps de demander à Docker de construire l'image. Cette opération s'effectue avec la commande `docker build`. Elle prend en argument le chemin vers le "contexte de build" (le dossier contenant le `Dockerfile` et les fichiers à inclure) et permet de spécifier un nom et une étiquette (tag) pour l'image créée.

Ouvrez votre terminal et placez-vous dans le répertoire racine de votre projet (soit `hello-python`, soit `hello-node`). La commande générale est `docker build -t nom_image:tag .`. L'option `-t` permet de taguer l'image, ce qui la rend plus facile à identifier et à utiliser par la suite. Le `.` final indique que le contexte de build est le répertoire courant.

Pour l'application Python/Flask :

# Assurez-vous d'être dans le dossier hello-python
docker build -t mon-app-python:1.0 .

Pour l'application Node.js/Express :

# Assurez-vous d'être dans le dossier hello-node
docker build -t mon-app-node:1.0 .

Pendant l'exécution, Docker va lire le `Dockerfile` et exécuter chaque instruction étape par étape. Vous verrez des messages indiquant l'utilisation de l'image de base, la copie des fichiers, l'installation des dépendances, etc. Docker utilise un système de cache intelligent : si une instruction et les fichiers qu'elle utilise n'ont pas changé depuis la dernière construction, il réutilisera la couche correspondante, accélérant ainsi les builds suivants. Une fois la commande terminée sans erreur, votre image personnalisée (`mon-app-python:1.0` ou `mon-app-node:1.0`) est prête. Vous pouvez vérifier sa présence avec la commande `docker images`.

Etape 4 : lancer un conteneur à partir de votre image (Run)

L'image étant construite, nous pouvons maintenant l'utiliser pour lancer un ou plusieurs conteneurs. Le processus est très similaire à celui utilisé pour l'image Nginx, mais nous utilisons le nom et le tag de notre propre image.

Nous utiliserons à nouveau la commande `docker run`, avec les options `-d` (détaché) et `-p` (publication de port). Il est crucial de mapper le port interne exposé par l'application (défini par `EXPOSE` dans le Dockerfile et utilisé dans le code) à un port sur votre machine hôte. Rappelez-vous : l'application Flask écoute sur le port 5000 et l'application Express sur le port 8080 à l'intérieur du conteneur.

Pour lancer le conteneur Python/Flask (mappage du port 5000 interne au port 5000 externe) :

docker run -d -p 5000:5000 --name mon-hello-python mon-app-python:1.0

Pour lancer le conteneur Node.js/Express (mappage du port 8080 interne au port 8080 externe) :

docker run -d -p 8080:8080 --name mon-hello-node mon-app-node:1.0

Si les ports 5000 ou 8080 sont déjà utilisés sur votre machine, choisissez un autre port hôte (par exemple, `-p 5001:5000` pour Python ou `-p 8081:8080` pour Node). Comme précédemment, l'option `--name` donne un nom plus pratique au conteneur. Après l'exécution, Docker affiche l'ID du conteneur. Vous pouvez vérifier qu'il tourne avec `docker ps`.

Etape 5 : tester l'application conteneurisée

La dernière étape consiste à vérifier que notre application "Hello World", maintenant isolée dans son conteneur, fonctionne comme prévu et est accessible depuis notre machine hôte.

Le moyen le plus simple est d'utiliser votre navigateur web. Ouvrez-le et naviguez vers l'URL `http://localhost` suivi du port hôte que vous avez utilisé lors du `docker run`.

Si vous avez lancé le conteneur Python/Flask avec `-p 5000:5000` :

Allez sur `http://localhost:5000`. Vous devriez voir le message : `Hello World from Flask!`

Si vous avez lancé le conteneur Node.js/Express avec `-p 8080:8080` :

Allez sur `http://localhost:8080`. Vous devriez voir le message : `Hello World from Node.js/Express!`

Si vous avez utilisé un port hôte différent (par exemple 5001 ou 8081), adaptez l'URL en conséquence (`http://localhost:5001` ou `http://localhost:8081`).

Une autre méthode consiste à utiliser un outil en ligne de commande comme `curl` directement dans votre terminal :

# Pour l'application Python (port hôte 5000)
curl http://localhost:5000

# Pour l'application Node (port hôte 8080)
curl http://localhost:8080

Vous devriez voir le message "Hello World..." s'afficher directement dans le terminal.

Si l'application n'est pas accessible, vérifiez : 1. Que le conteneur tourne bien (`docker ps`). 2. Le mappage de port utilisé lors du `docker run`. 3. Les logs du conteneur avec `docker logs nom_du_conteneur` (par ex. `docker logs mon-hello-python`) pour y déceler d'éventuelles erreurs au démarrage de l'application. Félicitations, vous avez réussi à dockeriser, construire, lancer et tester votre première application !