# Guide de Déploiement en Production - Neah

Ce document décrit les procédures pour déployer Neah en production avec Vercel (Next.js) et PostgreSQL auto-hébergé.

## Architecture de Production

```
┌─────────────────┐
│   Utilisateurs  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Vercel (Next.js)│
│  - Frontend     │
│  - API Routes   │
└────────┬────────┘
         │
         ├─────────────────┐
         │                 │
         ▼                 ▼
┌─────────────────┐  ┌─────────────────┐
│  PostgreSQL     │  │  Redis          │
│  (Auto-hébergé) │  │  (Auto-hébergé) │
└─────────────────┘  └─────────────────┘
```

## Prérequis

- Un compte Vercel
- Un serveur pour PostgreSQL et Redis (VPS, VM, ou conteneur Docker)
- Accès SSH au serveur de base de données
- Node.js 22+ installé localement (pour les migrations)

## Étape 1: Configuration PostgreSQL en Production

### 1.1 Déployer PostgreSQL avec Docker Compose

Sur votre serveur de production:

```bash
# Copier le fichier docker-compose.prod.yml
scp docker-compose.prod.yml user@your-server:/opt/neah/

# Se connecter au serveur
ssh user@your-server

# Créer un fichier .env pour les secrets
cd /opt/neah
cat > .env << EOF
POSTGRES_USER=neah_prod_user
POSTGRES_PASSWORD=$(openssl rand -base64 32)
POSTGRES_DB=calendar_db
REDIS_PASSWORD=$(openssl rand -base64 32)
EOF

# Démarrer les services
docker-compose -f docker-compose.prod.yml up -d

# Vérifier que les services sont en cours d'exécution
docker-compose -f docker-compose.prod.yml ps
```

### 1.2 Configurer l'accès réseau

**Option A: Tunnel SSH (Recommandé pour Vercel)**

Depuis votre machine locale ou un serveur bastion:

```bash
# Créer un tunnel SSH vers PostgreSQL
ssh -L 5432:localhost:5432 -N user@your-server

# Dans un autre terminal, tester la connexion
psql postgresql://neah_prod_user:password@localhost:5432/calendar_db
```

**Option B: Exposer PostgreSQL avec SSL**

Modifiez `docker-compose.prod.yml` pour activer SSL:

```yaml
db:
  environment:
    POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
  command: >
    postgres
    -c ssl=on
    -c ssl_cert_file=/var/lib/postgresql/server.crt
    -c ssl_key_file=/var/lib/postgresql/server.key
  volumes:
    - postgres_data:/var/lib/postgresql/data
    - ./ssl:/var/lib/postgresql
```

Puis exposez le port avec un firewall configuré pour n'accepter que les IPs Vercel.

### 1.3 Créer la base de données et appliquer les migrations

```bash
# Se connecter au conteneur PostgreSQL
docker exec -it neah-postgres-prod psql -U neah_prod_user -d calendar_db

# Ou depuis l'extérieur (si accessible)
export DATABASE_URL="postgresql://neah_prod_user:password@your-server:5432/calendar_db"
npx prisma migrate deploy
```

## Étape 2: Configuration Vercel

### 2.1 Créer un projet Vercel

1. Connectez-vous à [Vercel](https://vercel.com)
2. Importez votre repository GitHub/GitLab
3. Configurez le projet:
   - **Framework Preset**: Next.js
   - **Build Command**: `npm run build`
   - **Output Directory**: `.next` (par défaut)
   - **Install Command**: `npm ci`

### 2.2 Configurer les variables d'environnement

Dans Vercel Dashboard → Project Settings → Environment Variables, ajoutez:

#### Variables obligatoires

```env
# Environnement
NODE_ENV=production
NEXTAUTH_URL=https://votre-domaine.vercel.app
NEXTAUTH_SECRET=<généré avec: openssl rand -base64 32>

# Base de données (via tunnel SSH ou URL publique avec SSL)
DATABASE_URL=postgresql://user:password@host:5432/calendar_db?sslmode=require

# Keycloak
KEYCLOAK_BASE_URL=https://keycloak.example.com
KEYCLOAK_REALM=neah
KEYCLOAK_CLIENT_ID=neah-app
KEYCLOAK_CLIENT_SECRET=<secret depuis Keycloak>
KEYCLOAK_ISSUER=https://keycloak.example.com/realms/neah
NEXT_PUBLIC_KEYCLOAK_ISSUER=https://keycloak.example.com/realms/neah

# Redis (si accessible depuis Vercel)
REDIS_URL=redis://:password@your-server:6379
# OU
REDIS_HOST=your-server
REDIS_PORT=6379
REDIS_PASSWORD=<password>
REDIS_ENCRYPTION_KEY=<généré avec: openssl rand -base64 32>
```

#### Variables optionnelles (selon vos intégrations)

```env
# Leantime
LEANTIME_API_URL=https://leantime.example.com
LEANTIME_TOKEN=<token>

# RocketChat
ROCKET_CHAT_TOKEN=<token>
ROCKET_CHAT_USER_ID=<user-id>
ROCKET_CHAT_CREATE_TOKEN_SECRET=<secret> # Required for RocketChat 8.0.2+ (must match CREATE_TOKENS_FOR_USERS_SECRET on RocketChat server)
NEXT_PUBLIC_IFRAME_PAROLE_URL=https://rocketchat.example.com/channel/general

# N8N
N8N_API_KEY=<api-key>
N8N_WEBHOOK_URL=https://brain.slm-lab.net/webhook/mission-created
N8N_ROLLBACK_WEBHOOK_URL=https://brain.slm-lab.net/webhook/mission-rollback
N8N_DELETE_WEBHOOK_URL=https://brain.slm-lab.net/webhook/mission-delete
NEXT_PUBLIC_API_URL=https://api.slm-lab.net/api

# Dolibarr
DOLIBARR_API_URL=https://dolibarr.example.com
DOLIBARR_API_KEY=<api-key>

# S3 / MinIO
S3_BUCKET=missions
MINIO_S3_UPLOAD_BUCKET_URL=https://dome-api.slm-lab.net
MINIO_AWS_REGION=us-east-1
MINIO_AWS_S3_UPLOAD_BUCKET_NAME=missions
MINIO_ACCESS_KEY=<access-key>
MINIO_SECRET_KEY=<secret-key>

# Iframes (selon vos besoins)
NEXT_PUBLIC_IFRAME_CARNET_URL=https://carnet.example.com
NEXT_PUBLIC_IFRAME_DRIVE_URL=https://drive.example.com
# ... (voir .env.example pour la liste complète)
```

### 2.3 Configurer le domaine personnalisé (optionnel)

1. Dans Vercel Dashboard → Settings → Domains
2. Ajoutez votre domaine
3. Configurez les enregistrements DNS selon les instructions Vercel

## Étape 3: Migrations Prisma en Production

### 3.1 Préparer les migrations

```bash
# Vérifier l'état des migrations
npx prisma migrate status

# Créer une nouvelle migration (si nécessaire)
npx prisma migrate dev --name nom_de_la_migration
```

### 3.2 Appliquer les migrations en production

**Méthode 1: Via Vercel Build Hook (Recommandé)**

Créez un script de migration dans `package.json`:

```json
{
  "scripts": {
    "migrate:deploy": "prisma migrate deploy",
    "postbuild": "npm run migrate:deploy"
  }
}
```

**Méthode 2: Manuellement avant chaque déploiement**

```bash
# Depuis votre machine locale (avec tunnel SSH actif)
export DATABASE_URL="postgresql://user:password@localhost:5432/calendar_db"
npx prisma migrate deploy
```

**Méthode 3: Via GitHub Actions (CI/CD)**

Créez `.github/workflows/migrate.yml`:

```yaml
name: Database Migrations

on:
  push:
    branches: [main]

jobs:
  migrate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '22'
      - run: npm ci
      - run: npx prisma migrate deploy
        env:
          DATABASE_URL: ${{ secrets.DATABASE_URL }}
```

## Étape 4: Vérification et Tests

### 4.1 Vérifier la connexion à la base de données

```bash
# Tester la connexion PostgreSQL
psql $DATABASE_URL -c "SELECT version();"

# Vérifier les tables Prisma
npx prisma db pull
```

### 4.2 Vérifier les services externes

- Testez l'authentification Keycloak
- Vérifiez la connexion Redis (si utilisée)
- Testez les intégrations (Leantime, RocketChat, etc.)

### 4.3 Tests de bout en bout

1. Accédez à votre application Vercel
2. Testez la connexion
3. Testez les fonctionnalités critiques:
   - Création de compte
   - Authentification
   - Création de mission
   - Upload de fichiers
   - Notifications

## Étape 5: Monitoring et Maintenance

### 5.1 Logs Vercel

- Consultez les logs dans Vercel Dashboard → Deployments → [Déploiement] → Logs
- Configurez des alertes pour les erreurs

### 5.2 Monitoring PostgreSQL

```bash
# Vérifier l'état de PostgreSQL
docker exec neah-postgres-prod pg_isready

# Vérifier l'utilisation des ressources
docker stats neah-postgres-prod

# Vérifier les connexions actives
docker exec neah-postgres-prod psql -U neah_prod_user -d calendar_db -c "SELECT count(*) FROM pg_stat_activity;"
```

### 5.3 Sauvegardes

**Sauvegarde PostgreSQL:**

```bash
# Sauvegarde complète
docker exec neah-postgres-prod pg_dump -U neah_prod_user calendar_db > backup_$(date +%Y%m%d).sql

# Sauvegarde avec compression
docker exec neah-postgres-prod pg_dump -U neah_prod_user calendar_db | gzip > backup_$(date +%Y%m%d).sql.gz
```

**Restauration:**

```bash
# Restaurer depuis une sauvegarde
cat backup_20240112.sql | docker exec -i neah-postgres-prod psql -U neah_prod_user calendar_db
```

## Procédures de Rollback

### Rollback Vercel

1. Dans Vercel Dashboard → Deployments
2. Trouvez le déploiement précédent
3. Cliquez sur "..." → "Promote to Production"

### Rollback de migration Prisma

```bash
# Lister les migrations
npx prisma migrate status

# Rollback manuel (si nécessaire)
# ATTENTION: Testez d'abord en staging !
psql $DATABASE_URL -f prisma/migrations/[migration_to_rollback]/migration.sql
```

## Dépannage

### Problème: Connexion PostgreSQL échoue depuis Vercel

- Vérifiez que le tunnel SSH est actif (si utilisé)
- Vérifiez les credentials dans Vercel
- Vérifiez les règles de firewall
- Testez la connexion depuis votre machine locale

### Problème: Migrations échouent

- Vérifiez que `DATABASE_URL` est correcte
- Vérifiez les permissions de l'utilisateur PostgreSQL
- Consultez les logs: `npx prisma migrate deploy --verbose`

### Problème: Erreurs NextAuth

- Vérifiez que `NEXTAUTH_URL` correspond à votre domaine Vercel
- Vérifiez que `NEXTAUTH_SECRET` est défini
- Vérifiez la configuration Keycloak

## Ressources

- [Documentation Vercel](https://vercel.com/docs)
- [Documentation Prisma](https://www.prisma.io/docs)
- [Documentation NextAuth](https://next-auth.js.org)
- [Documentation Docker Compose](https://docs.docker.com/compose/)