# 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 Business avec Portainer

Le Radar Business 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-business` (ou autre nom)
3. **Méthode** : Git Repository
4. **Repository URL** : URL du dépôt Git (ex: `https://git.open.us.org/AJR/TechradarDev.git`)
5. **Branch** : `dev-biz` (ou la branche appropriée)
6. **Compose path** : `docker-compose.business.yml`

### Configuration Docker Compose Business

Le fichier `docker-compose.business.yml` configure :
- **Port** : 3004 (mappé depuis le port 3000 du conteneur)
- **Image** : Construite depuis `Dockerfile.business`
- **Environnement** : `NODE_ENV=production`
- **Restart policy** : `unless-stopped`

### 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 : `https://<token>@git.open.us.org/AJR/TechradarDev.git`

### Mise à jour

Pour mettre à jour le Radar Business dans Portainer :
1. **Pull latest image** : Dans Portainer, utiliser "Pull latest image"
2. **Rebuild** : Ou reconstruire la stack depuis Git

## 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 Business** : Expose le port 3004 (mappé depuis 3000). Vérifier avec :

```bash
curl http://localhost:3004/
```

Note : Le Radar Business 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`