Etapes : écriture du code source minimal, création du Dockerfile

Etape 1 : préparer le code source de la micro-application

Avant de pouvoir créer une image Docker, nous avons besoin de l'application à encapsuler. Pour cet exercice, nous allons créer une application web extrêmement simple qui affiche un message "Hello World!" ou similaire. L'objectif est de se concentrer sur le processus Docker, pas sur la complexité de l'application. Nous allons proposer deux versions : une en Python avec Flask et une en Node.js avec Express.

Option 1 : Python avec Flask

Créez un dossier pour votre projet, par exemple `hello-python`. A l'intérieur, créez deux fichiers :

1. `app.py` (le code de l'application) :

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello World from Flask!\n"

if __name__ == '__main__':
    # Ecoute sur toutes les interfaces réseau sur le port 5000
    app.run(host='0.0.0.0', port=5000)

2. `requirements.txt` (liste des dépendances) :

Flask==2.0.1

Ce code définit un serveur web simple qui répond "Hello World from Flask!" quand on accède à la racine (`/`) et écoute sur le port 5000.

Option 2 : Node.js avec Express

Créez un dossier pour votre projet, par exemple `hello-node`. A l'intérieur, créez deux fichiers :

1. `server.js` (le code de l'application) :

const express = require('express');

// Constants
const PORT = 8080;
const HOST = '0.0.0.0';

// App
const app = express();
app.get('/', (req, res) => {
  res.send('Hello World from Node.js/Express!\n');
});

app.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);

2. `package.json` (description du projet et dépendances) :

{
  "name": "docker_hello_world",
  "version": "1.0.0",
  "description": "Node.js Hello World app on Docker",
  "author": "Your Name",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Ce code crée un serveur similaire qui répond "Hello World from Node.js/Express!" sur le port 8080. N'oubliez pas d'exécuter `npm install` dans ce dossier si vous voulez tester localement, mais ce n'est pas nécessaire pour la dockerisation car l'installation se fera dans l'image.

Choisissez l'une des deux options pour la suite de l'exercice.

Etape 2 : rédiger le Dockerfile

Le `Dockerfile` est la recette de cuisine pour construire notre image Docker. C'est un fichier texte nommé simplement `Dockerfile` (sans extension) que nous allons créer dans le même dossier que notre code source (`hello-python` ou `hello-node`). Il contient une série d'instructions exécutées séquentiellement.

Dockerfile pour l'application Python/Flask (`hello-python/Dockerfile`) :

# 1. Choisir l'image de base
FROM python:3.9-slim

# 2. Définir le répertoire de travail dans l'image
WORKDIR /app

# 3. Copier le fichier des dépendances
COPY requirements.txt .

# 4. Installer les dépendances
RUN pip install --no-cache-dir -r requirements.txt

# 5. Copier le reste du code de l'application
COPY . .

# 6. Indiquer le port sur lequel l'application écoute
EXPOSE 5000

# 7. Définir la commande à exécuter au démarrage du conteneur
CMD ["python", "app.py"]

Dockerfile pour l'application Node.js/Express (`hello-node/Dockerfile`) :

# 1. Choisir l'image de base
FROM node:16-alpine

# 2. Définir le répertoire de travail dans l'image
WORKDIR /usr/src/app

# 3. Copier les fichiers de description et de dépendances
# Copie package.json ET package-lock.json (si existant) pour optimiser le cache
COPY package*.json ./

# 4. Installer les dépendances
RUN npm install --production
# Si vous utilisez npm >= 5, préférez 'npm ci' pour une installation plus rapide et fiable
# RUN npm ci --only=production

# 5. Copier le reste du code de l'application
COPY . .

# 6. Indiquer le port sur lequel l'application écoute
EXPOSE 8080

# 7. Définir la commande à exécuter au démarrage du conteneur
CMD ["node", "server.js"]

Analysons les instructions communes :

• `FROM`: Spécifie l'image de base sur laquelle construire. Nous utilisons des images officielles légères (`slim` pour Python, `alpine` pour Node).
• `WORKDIR`: Définit le répertoire de travail par défaut pour les commandes suivantes (`COPY`, `RUN`, `CMD`).
• `COPY`: Copie des fichiers ou dossiers depuis le contexte de build (votre machine) vers le système de fichiers de l'image. Nous copions d'abord le fichier de dépendances, puis le reste.
• `RUN`: Exécute une commande pendant la construction de l'image. Principalement utilisé ici pour installer les dépendances (`pip install` ou `npm install`).
• `EXPOSE`: Informe Docker que le conteneur écoutera sur le port spécifié au moment de l'exécution. C'est une métadonnée, cela n'ouvre pas réellement le port (c'est le rôle de l'option `-p` de `docker run`).
• `CMD`: Fournit la commande par défaut qui sera exécutée lorsque le conteneur démarrera. Il ne peut y avoir qu'une seule instruction `CMD` effective dans un Dockerfile.

Ces deux fichiers (`Dockerfile` et le code source minimal) sont maintenant prêts. L'étape suivante consistera à utiliser ces fichiers pour construire l'image Docker personnalisée.