TechradarDev/docs/app/deploiement.md

# Guide de déploiement

## Vue d'ensemble

Le projet peut être déployé de plusieurs façons :
- Docker Compose (recommandé pour la production)
- Docker simple
- Build statique avec serveur web
- Portainer (pour le Radar Business)

## Déploiement avec Docker

### Configuration Docker

Le projet contient plusieurs configurations Docker :

- `docker/Dockerfile` : Dockerfile principal avec multi-stage build
- `docker/docker-compose.yml` : Configuration de base
- `docker/docker-compose.labels.yml` : Labels pour le reverse proxy
- `docker/docker-compose.local.yml` : Configuration pour développement local
- `Dockerfile` (racine) : Dockerfile alternatif
- `docker-compose.yml` (racine) : Docker Compose alternatif
- `Dockerfile.business` : Dockerfile spécifique pour le Radar Business
- `docker-compose.business.yml` : Docker Compose pour le Radar Business (Portainer)

### Build de l'image Docker

#### Avec le Dockerfile principal

```bash
cd docker
docker compose build
```

#### Avec build args

```bash
docker build \
  --build-arg BASE_PATH="/techradar" \
  --build-arg UID=1000 \
  --build-arg GID=1000 \
  -f docker/Dockerfile \
  -t techradar:latest \
  .
```

### Variables d'environnement

- **BASE_PATH** : Chemin de base pour l'application (défaut: `/`)
- **UID** : User ID pour l'utilisateur dans le conteneur (défaut: 1000)
- **GID** : Group ID pour l'utilisateur dans le conteneur (défaut: 1000)

### Démarrage avec Docker Compose

```bash
cd docker
docker compose up -d
```

L'application sera accessible sur le port 3000.

### Configuration du basePath

Le script `docker-entrypoint.sh` modifie dynamiquement le `basePath` dans `config.json` au démarrage du conteneur en utilisant la variable d'environnement `BASE_PATH`.

## Déploiement statique

### Build des fichiers statiques

```bash
npm install
npm run build
```

Les fichiers sont générés dans le répertoire `build/`.

### Servir avec un serveur web

#### Nginx

```nginx
server {
    listen 80;
    server_name coeurbox.syoul.fr;
    root /chemin/vers/build;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }
}
```

#### Apache

```apache
<VirtualHost *:80>
    ServerName coeurbox.syoul.fr
    DocumentRoot /chemin/vers/build

    <Directory /chemin/vers/build>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>
```

## Déploiement du Radar Technologique Laplank avec Portainer

Le Radar Technologique Laplank est déployé via Portainer en utilisant une stack Docker Compose.

### Configuration Portainer

1. **Créer une nouvelle stack** dans Portainer
2. **Nom de la stack** : `laplank-radar-technologique` (ou autre nom)
3. **Méthode** : Git Repository
4. **Repository URL** : `https://git.open.us.org/AJR/TechradarDev.git`
5. **Reference** : `refs/heads/dev-tech` (branche actuelle)
6. **Compose path** : `docker-compose.business.yml`

**Note** : Si le dépôt est privé, utiliser un Personal Access Token dans l'URL :
- `https://<token>@git.open.us.org/AJR/TechradarDev.git`

### Configuration Docker Compose Laplank

Le fichier `docker-compose.business.yml` configure :
- **Port** : `3006:3000` (port 3006 de l'hôte mappé vers le port 3000 du conteneur)
- **Container name** : `laplank-radar-business`
- **Image** : Construite depuis `Dockerfile.business` lors du déploiement
- **Environnement** : `NODE_ENV=production`
- **Restart policy** : `unless-stopped` (redémarre automatiquement en cas d'arrêt)

**Accès à l'application :**
- URL : `http://<votre-serveur>:3006`
- Mot de passe : `laplank-radar`

### Dockerfile Business

Le `Dockerfile.business` :
- Utilise Node.js 20 Alpine
- Configure les variables d'environnement pour désactiver Husky
- Installe les dépendances avec `--ignore-scripts`
- Patche le package `aoe_technology_radar` pour inclure `gray-matter`
- Pré-installe `.techradar` pendant le build
- Applique la configuration business (`config-business.json`)
- Expose le port 3000
- Démarre via `scripts/start-business.sh`

### Authentification Git pour Portainer

Si le dépôt est privé, utiliser un **Personal Access Token** (Gitea) :
1. Créer un token dans Gitea avec les permissions de lecture
2. Utiliser l'URL avec le token : `https://<token>@git.open.us.org/AJR/TechradarDev.git`
3. Exemple : `https://glpat-xxxxxxxxxxxx@git.open.us.org/AJR/TechradarDev.git`

**Configuration complète pour dépôt privé :**
- **Repository URL** : `https://<token>@git.open.us.org/AJR/TechradarDev.git`
- **Reference** : `refs/heads/dev-tech`
- **Compose path** : `docker-compose.business.yml`

### Mise à jour

Pour mettre à jour le Radar Technologique Laplank dans Portainer :

**⚠️ IMPORTANT : Pour que les mises à jour soient effectives, il faut forcer le rebuild sans cache !**

**Option 1 : Rebuild avec --no-cache (RECOMMANDÉ)**
1. Aller dans **Stacks** → Sélectionner la stack `laplank-radar-technologique`
2. Cliquer sur **Editor**
3. **Cocher la case "Always pull image"** (si disponible)
4. **Cocher la case "Rebuild"** ou utiliser l'option "Rebuild the stack"
5. **Dans les options avancées, cocher "No cache"** ou utiliser `--no-cache` dans les build args
6. Cliquer sur **Update the stack**
7. Portainer va reconstruire l'image complètement sans utiliser le cache

**Option 2 : Rebuild manuel via l'interface**
1. Aller dans **Stacks** → Sélectionner la stack `laplank-radar-technologique`
2. Cliquer sur **Editor**
3. Cliquer sur **Update the stack**
4. **Avant de confirmer**, dans les options de build, ajouter `--no-cache` ou cocher "No cache"
5. Confirmer la mise à jour

**Option 3 : Supprimer l'image et rebuild (si les options ci-dessus ne fonctionnent pas)**
1. Aller dans **Containers** → Sélectionner `laplank-radar-technolologique`
2. Cliquer sur **Stop** pour arrêter le conteneur
3. Aller dans **Images** → Trouver l'image de la stack
4. Cliquer sur **Remove** pour supprimer l'image
5. Retourner dans **Stacks** → Sélectionner la stack
6. Cliquer sur **Editor** → **Update the stack**
7. L'image sera reconstruite depuis zéro

**Option 4 : Utiliser le CACHE_BUST automatique**
Le `docker-compose.business.yml` inclut maintenant un `CACHE_BUST` avec timestamp qui change automatiquement. Cependant, Portainer peut ne pas interpréter les variables shell `$(date +%s)`. Dans ce cas :
1. Utiliser l'**Option 1** avec `--no-cache`
2. Ou modifier manuellement le `CACHE_BUST` dans le compose avant de mettre à jour

**Vérification après mise à jour :**
- Vérifier les logs : **Containers** → `laplank-radar-technolologique` → **Logs**
- Tester l'application : `http://<votre-serveur>:3006`
- Vérifier que les changements sont visibles (par exemple, le contenu de `about.md` ou `custom.css`)

**Pourquoi le cache pose problème ?**
Docker utilise un système de cache par couches. Si les fichiers copiés n'ont pas changé selon l'algorithme de détection de Docker, il réutilise les couches en cache. C'est pourquoi il faut forcer un rebuild complet avec `--no-cache` pour garantir que tous les fichiers sont bien copiés et que l'application est reconstruite avec les dernières modifications.

## Déploiement avec Drone CI

Le projet est configuré pour le déploiement automatique via Drone CI (`.drone.yml`).

### Pipeline de déploiement

1. **Build** : Construction de l'image Docker
2. **Déploiement** : Lancement du conteneur avec Docker Compose
3. **Notification** : Envoi d'une notification Telegram

### Configuration Drone

Le pipeline utilise :
- Variables d'environnement dynamiques basées sur le dépôt Git
- Labels pour le reverse proxy (Traefik)
- Notifications Telegram en cas de succès/échec

### Variables d'environnement Drone

- `DRONE_REPO_OWNER` : Propriétaire du dépôt
- `DRONE_REPO_NAME` : Nom du dépôt
- `DRONE_COMMIT_BRANCH` : Branche du commit

Ces variables sont utilisées pour générer le `BASE_PATH` dynamiquement.

## Déploiement en production

### Étapes recommandées

1. **Préparer l'environnement**
   ```bash
   git clone https://git.open.us.org/AJR/TechradarDev.git
   cd TechradarDev
   ```

2. **Configurer les variables**
   - Définir `BASE_PATH` selon votre configuration
   - Ajuster les ports si nécessaire

3. **Build et démarrage**
   ```bash
   cd docker
   docker compose -f docker-compose.yml -f docker-compose.labels.yml up -d --build
   ```

4. **Vérifier le déploiement**
   - Accéder à l'URL configurée
   - Vérifier les logs : `docker compose logs -f`

### Reverse proxy

Le projet est configuré pour fonctionner derrière un reverse proxy (Traefik) via les labels dans `docker-compose.labels.yml`.

### Sécurité

- Utiliser HTTPS en production
- Configurer les headers de sécurité appropriés
- Limiter l'accès si nécessaire
- Surveiller les logs

## Mise à jour

### Mettre à jour le contenu

1. Modifier les fichiers dans `radar/`
2. Rebuild l'image :
   ```bash
   docker compose build
   docker compose up -d
   ```

### Mettre à jour les dépendances

1. Modifier `package.json` si nécessaire
2. Rebuild l'image complète

## Monitoring

### Logs Docker

```bash
# Voir les logs
docker compose logs -f

# Logs du dernier démarrage
docker compose logs --tail=100
```

### Santé de l'application

**Radar Principal** : Expose le port 3000. Vérifier avec :

```bash
curl http://localhost:3000/techradar
```

**Radar Technologique Laplank** : Expose le port 3006 (mappé depuis 3000). Vérifier avec :

```bash
curl http://localhost:3006/
```

Note : Le Radar Technologique Laplank est protégé par un mot de passe, donc la réponse peut être l'écran d'authentification.

## Rollback

En cas de problème, revenir à une version précédente :

```bash
# Arrêter le conteneur actuel
docker compose down

# Checkout une version précédente
git checkout <commit-hash>

# Rebuild et redémarrer
docker compose build
docker compose up -d
```

## Troubleshooting

### Problème de basePath

Si l'application ne se charge pas correctement :
- Vérifier la variable `BASE_PATH`
- Vérifier les logs du conteneur
- Vérifier la configuration du reverse proxy

### Problème de permissions

Si des erreurs de permissions apparaissent :
- Vérifier les UID/GID dans le Dockerfile
- Vérifier les permissions des volumes montés

### Problème de build

Si le build échoue :
- Vérifier la version de Node.js
- Vérifier les dépendances npm
- Nettoyer le cache : `docker system prune -a`