# Exercice Dockerfile B

Créer un Dockerfile pour un projet Node.js simple afin de containeriser l'application, utilisant une image Alpine Linux, Nginx en tant que serveur web, et un cache rapide avec FastCGI. 

Cet exercice vous permettra de containeriser une application Node.js, la servir via Nginx, et configurer un cache performant.

**Objectif de l'exercice**

- Créer une application Node.js containerisée.
- Utiliser Nginx pour servir l'application.
- Configurer le cache rapide de Nginx pour améliorer les performances.

**Prérequis**
- Avoir Docker installé sur votre machine.
- Avoir Node JS installé sur votre machine.
- Connaissances de base de Node.js (installation de paquets, scripts npm, etc.).
- Connaissances de base du serveur Web Nginx, FastCGI

## Étape 1 : Préparer un projet Node.js simple

**Créer un répertoire pour votre projet**
Dans votre terminal, créez un nouveau dossier pour votre projet et accédez-y :

```
mkdir my-node-app-b
cd my-node-app-b
```

**Initialiser le projet Node.js**
Initialisez un nouveau projet Node.js dans ce dossier :

```
npm init -y

```

Cela crée un fichier `package.json` avec les configurations par défaut.


**Créer un fichier app.js**
Créez un fichier nommé app.js dans le dossier racine du projet avec le contenu suivant :

``` js
const express = require('express');
const app = express();

app.get('/', (req, res) => {
    res.send('Hello from Node.js with Nginx and FastCGI Cache!');
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});
```

**Installer Express.js**
Ajoutez Express.js comme dépendance de votre projet :

``` sh
npm install express
```

**Mettre à jour package.json**
Ajoutez un script de démarrage dans le fichier package.json :

``` json
"scripts": {
  "start": "node app.js"
}
```

Votre projet Node.js est maintenant prêt pour être containerisé avec Docker.


## Étape 2 : Créer un Dockerfile

**Créer un fichier Dockerfile**
Dans le même répertoire que package.json, créez un fichier nommé Dockerfile sans extension.
Puis ajoutez les instructions suivantes à votre fichier *Dockerfile* :

``` docker
# Étape 1 : Utiliser une image Node.js basée sur Alpine Linux
FROM node:14-alpine AS build

# Étape 2 : Installer les dépendances et construire l'application
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .

# Étape 3 : Construire une image Nginx basée sur Alpine
FROM nginx:alpine

# Étape 4 : Copier les fichiers de l'application Node.js
COPY --from=build /usr/src/app /usr/share/nginx/html

# Étape 5 : Supprimer le fichier de configuration par défaut de Nginx
RUN rm /etc/nginx/conf.d/default.conf

# Étape 6 : Copier notre propre configuration Nginx
COPY nginx.conf /etc/nginx/conf.d

# Étape 7 : Exposer le port 80 pour Nginx
EXPOSE 80

# Étape 8 : Démarrer Nginx
CMD ["nginx", "-g", "daemon off;"]
```

Voici une description de chaque étape :

- `FROM node:14-alpine AS build` : Utilise l'image Node.js basée sur Alpine pour construire l'application.
- `WORKDIR /usr/src/app` : Définit le répertoire de travail.
- `COPY et RUN` : Copie les fichiers et installe les dépendances dans le répertoire de travail.
- `FROM nginx` : Utilise une image Nginx basée sur Alpine pour servir l'application.
- `COPY --from=build` : Copie les fichiers de l'application construite dans le répertoire de Nginx.
- `RUN rm` : Supprime la configuration Nginx par défaut.
- `COPY nginx.conf` : Copie une configuration Nginx personnalisée (que vous allez créer) dans le conteneur.
- `EXPOSE 80` : Expose le port 80 pour accéder à l'application via HTTP.
- `CMD ["nginx", "-g", "daemon off;"]` : Lance Nginx en mode non-détaché pour que le conteneur reste actif.

<div style="page-break-after: always"></div>

## Étape 3 : Créer la configuration Nginx avec FastCGI Cache

**Créer un fichier nginx.conf**
Dans le répertoire du projet, créez un fichier nginx.conf avec le contenu suivant :

``` conf
server {
    listen 80;

    server_name localhost;

    # Répertoire racine de l'application
    root /usr/share/nginx/html;

    location / {
        # Paramètres FastCGI Cache
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_cache my_cache;
        proxy_cache_valid 200 10m;
        proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
        add_header X-Proxy-Cache $upstream_cache_status;

        # Paramètres supplémentaires de FastCGI
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # Configuration du cache
    proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m max_size=1g inactive=60m use_temp_path=off;
}
```

Ce fichier configure Nginx pour :

- Rediriger les requêtes vers le backend Node.js via proxy_pass.
- Configurer un cache FastCGI, stocké dans /var/cache/nginx, avec une durée de validité de 10 minutes pour les réponses HTTP 200.
- Ajouter un en-tête HTTP pour indiquer si la réponse a été servie à partir du cache (X-Proxy-Cache).


## Étape 4 : Construire et exécuter le conteneur

**Construire l'image Docker**
Dans le terminal, assurez-vous d'être dans le répertoire contenant le *Dockerfile*, puis exécutez la commande suivante pour construire l'image :

``` sh
docker build -t my-node-app-b .
```

**Exécuter le conteneur**
Après la création de l'image, exécutez un conteneur à partir de cette image :

``` sh
docker run -p 80:80 my-node-app-b
```

Cette commande mappe le port 80 du conteneur au port 80 de votre machine hôte, vous permettant d'accéder à l'application via `http://localhost`.

## Étape 5 : Tester l'application
1 - Vérifier que l'application fonctionne
Ouvrez votre navigateur et accédez à `http://localhost`. Vous devriez voir le message "Hello from Node.js with Nginx and FastCGI Cache!".

2 - Tester le cache Nginx
Vous pouvez utiliser des outils comme curl ou simplement rafraîchir la page pour voir l'en-tête X-Proxy-Cache dans les réponses HTTP. Il devrait indiquer si la réponse a été servie à partir du cache (HIT) ou si elle a été générée par le serveur (MISS).

## Étape 6 : Nettoyer les ressources

**Arrêter le conteneur**
Si vous avez démarré le conteneur en mode détaché (avec -d), vous pouvez l'arrêter avec :

``` sh
docker ps   # Pour lister les conteneurs en cours d'exécution
docker stop <CONTAINER_ID>  # Pour arrêter le conteneur
```

**Supprimer l'image Docker (facultatif)**
Si vous n'avez plus besoin de l'image Docker, vous pouvez la supprimer :

``` sh
docker rmi my-node-app-b
```

## Conclusion
Vous avez maintenant un projet Node.js plus complexe containerisé avec Docker, servi par Nginx avec un cache rapide grâce à FastCGI. Ce type de configuration est typique des environnements de production où des performances élevées sont requises. Vous pouvez ajuster le fichier de configuration Nginx pour des besoins spécifiques, comme la gestion des erreurs ou l'optimisation du cache.