# 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 :

**Option 1 : Rebuild depuis Git (recommandé)**
1. Aller dans **Stacks** → Sélectionner la stack `laplank-radar-technologique`
2. Cliquer sur **Editor**
3. Cliquer sur **Update the stack**
4. Portainer va reconstruire l'image depuis la dernière version de la branche `dev-tech`

**Option 2 : Pull & Redeploy**
1. Aller dans **Containers** → Sélectionner `laplank-radar-business`
2. Cliquer sur **Recreate** (si l'image a été rebuild ailleurs)

**Vérification après mise à jour :**
- Vérifier les logs : **Containers** → `laplank-radar-business` → **Logs**
- Tester l'application : `http://<votre-serveur>:3006`

## 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`