rsu-new-site/README.md

# Portail web du Registre Social Unique (ST-RSU)

Ce dépôt contient le portail public et l'espace d'administration du ST-RSU.

- `frontend-rsu` : application Angular 21 ;
- `backend-rsu` : API Spring Boot 3.2 / Java 17 ;
- PostgreSQL 15 : données éditoriales, utilisateurs et paramètres ;
- `backend-rsu/uploads` en local, ou `UPLOAD_BASE_PATH` en production : photos et documents téléversés.

> Important : un déploiement fidèle au site préparé en local exige **la base PostgreSQL et le dossier `uploads`**. La base contient les références des fichiers, mais pas les fichiers eux-mêmes.

> Livraison Git interne : exécuter `git lfs install` avant le clonage, puis `git lfs pull` après le clonage. Le JAR backend et la sauvegarde PostgreSQL sont stockés avec Git LFS. Les secrets de production ne font jamais partie du dépôt.

## 1. Informations à obtenir avant le déploiement

La personne chargée du serveur doit confirmer :

- le nom de domaine public définitif ;
- l'adresse et les accès du serveur PostgreSQL 15 ;
- le système d'exploitation du serveur (les exemples ci-dessous utilisent Ubuntu/Debian) ;
- l'adresse électronique technique pour le certificat HTTPS ;
- l'emplacement des sauvegardes ;
- si la publication Facebook doit être activée.

Le domaine officiel utilisé dans ce guide est `rsu.gov.bf`.

## 2. Prérequis

Sur le serveur :

- Java JDK/JRE 17 ;
- PostgreSQL 15 ;
- Nginx ;
- Certbot pour HTTPS ;
- au moins 2 Go de mémoire vive et un espace disque surveillé pour les fichiers.

Node.js n'est nécessaire que sur la machine qui compile Angular. Utiliser Node.js 22 LTS et npm 10 ou une version compatible avec Angular 21.

## 3. Préparer la version à livrer

Depuis la racine du dépôt :

```bash
cd backend-rsu
mvn clean package

cd ../frontend-rsu
npm ci
npm run build -- --configuration production
```

Fichiers produits :

- backend : `backend-rsu/target/rsu-api-1.0.0.jar` ;
- frontend : `frontend-rsu/dist/rsu-web/browser/`.

Avant toute livraison, vérifier que `git status` ne contient pas de secret, de mot de passe, de dump PostgreSQL ou de fichier provenant de `uploads`.

## 4. Exporter le contenu préparé en local

### 4.1 Base PostgreSQL

Sur la machine locale où se trouve la base `SITE_RSU` :

```powershell
& "C:\Program Files\PostgreSQL\15\bin\pg_dump.exe" `
  -h localhost -U postgres -d SITE_RSU -F c `
  -f "C:\chemin\de\livraison\SITE_RSU.dump"
```

### 4.2 Photos et documents

Copier intégralement `backend-rsu/uploads/` dans le paquet de livraison. Ne pas envoyer uniquement le code Git : les fichiers téléversés sont volontairement ignorés par Git.

Le paquet remis au responsable du déploiement doit contenir :

```text
livraison-rsu/
├── rsu-api-1.0.0.jar
├── frontend/                 # contenu de dist/rsu-web/browser
├── uploads/                  # photos et documents actuels
├── SITE_RSU.dump
└── README.md
```

## 5. Préparer le serveur Linux

Créer un utilisateur système et les dossiers permanents :

```bash
sudo useradd --system --home /opt/rsu --shell /usr/sbin/nologin rsu
sudo mkdir -p /opt/rsu/backend /opt/rsu/uploads /var/www/rsu /etc/rsu /var/backups/rsu
sudo chown -R rsu:rsu /opt/rsu
sudo chown -R www-data:www-data /var/www/rsu
sudo chmod 750 /etc/rsu
```

Installer les livrables :

```bash
sudo install -o rsu -g rsu -m 750 rsu-api-1.0.0.jar /opt/rsu/backend/rsu-api.jar
sudo cp -a uploads/. /opt/rsu/uploads/
sudo chown -R rsu:rsu /opt/rsu/uploads
sudo cp -a frontend/. /var/www/rsu/
sudo chown -R www-data:www-data /var/www/rsu
```

## 6. Créer et restaurer PostgreSQL

Créer un compte applicatif distinct du compte administrateur `postgres` :

```bash
sudo -u postgres psql
```

```sql
CREATE ROLE rsu_app LOGIN PASSWORD 'MOT_DE_PASSE_TRES_FORT';
CREATE DATABASE "SITE_RSU" OWNER rsu_app ENCODING 'UTF8';
\q
```

Restaurer la base préparée en local :

```bash
sudo -u postgres pg_restore \
  --dbname=SITE_RSU \
  --no-owner \
  --role=rsu_app \
  SITE_RSU.dump
```

Si la base doit être totalement vide, ne pas restaurer de dump. Le premier démarrage créera le schéma et les comptes initiaux à partir des variables `SUPER_ADMIN_PASSWORD`, `ADMIN_PASSWORD`, `EDITOR_PASSWORD` et `USER_PASSWORD`.

## 7. Configurer les variables secrètes

Copier `.env.example` vers `/etc/rsu/rsu.env`, puis remplacer toutes les valeurs d'exemple :

```bash
sudo cp .env.example /etc/rsu/rsu.env
sudo chown root:rsu /etc/rsu/rsu.env
sudo chmod 640 /etc/rsu/rsu.env
```

Générer le secret JWT avec `openssl rand -base64 64`.

Variables indispensables :

```dotenv
SERVER_PORT=8096
DB_URL=jdbc:postgresql://localhost:5432/SITE_RSU
DB_USERNAME=rsu_app
DB_PASSWORD=mot-de-passe-fort-de-la-base
JWT_SECRET=secret-base64-genere-par-openssl
UPLOAD_BASE_PATH=/opt/rsu/uploads
PUBLIC_SITE_URL=https://rsu.gov.bf
CORS_ALLOWED_ORIGINS=https://rsu.gov.bf
HIBERNATE_DDL_AUTO=validate
SWAGGER_ENABLED=false
```

Les variables `FACEBOOK_PAGE_ID` et `FACEBOOK_PAGE_ACCESS_TOKEN` sont facultatives. Le jeton Facebook doit rester uniquement sur le serveur.

Utiliser `HIBERNATE_DDL_AUTO=validate` lorsque `SITE_RSU.dump` a été restauré. Utiliser temporairement `update` uniquement pour initialiser une base vide, puis revenir à `validate` après le premier démarrage réussi.

## 8. Lancer le backend avec systemd

Créer `/etc/systemd/system/rsu-backend.service` :

```ini
[Unit]
Description=API du portail ST-RSU
After=network.target postgresql.service

[Service]
Type=simple
User=rsu
Group=rsu
WorkingDirectory=/opt/rsu/backend
EnvironmentFile=/etc/rsu/rsu.env
ExecStart=/usr/bin/java -jar /opt/rsu/backend/rsu-api.jar --spring.profiles.active=prod
Restart=on-failure
RestartSec=5
SuccessExitStatus=143
NoNewPrivileges=true

[Install]
WantedBy=multi-user.target
```

Activer et contrôler le service :

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now rsu-backend
sudo systemctl status rsu-backend
sudo journalctl -u rsu-backend -n 100 --no-pager
```

Le port `8096` ne doit pas être exposé publiquement ; seul Nginx doit y accéder localement.

## 9. Configurer Nginx

Créer `/etc/nginx/sites-available/rsu` :

```nginx
server {
    listen 80;
    server_name rsu.gov.bf;

    root /var/www/rsu;
    index index.html;
    client_max_body_size 25M;

    location /api/ {
        proxy_pass http://127.0.0.1:8096;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        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;
    }

    location /uploads/ {
        proxy_pass http://127.0.0.1:8096;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        expires 1h;
    }

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

Activer le site :

```bash
sudo ln -s /etc/nginx/sites-available/rsu /etc/nginx/sites-enabled/rsu
sudo nginx -t
sudo systemctl reload nginx
```

La directive `try_files ... /index.html` est indispensable pour que les adresses Angular telles que `/auth/login` fonctionnent après actualisation de la page.

## 10. Activer HTTPS

Après avoir dirigé le domaine vers le serveur :

```bash
sudo certbot --nginx -d rsu.gov.bf
sudo certbot renew --dry-run
```

Ne pas ouvrir l'administration en HTTP. Après activation du certificat, vérifier que toutes les requêtes HTTP sont redirigées vers HTTPS.

## 11. Vérifications après déploiement

Contrôler au minimum :

1. la page d'accueil : `https://rsu.gov.bf/` ;
2. la connexion : `https://rsu.gov.bf/auth/login` ;
3. la consultation des articles et documents ;
4. l'affichage des anciennes photos provenant de `uploads` ;
5. l'ajout puis l'affichage d'une nouvelle photo ;
6. la création, modification et suppression d'un contenu ;
7. les messages, plaintes, commentaires et leurs notifications ;
8. les rôles Administrateur et Éditeur ;
9. la carte de couverture territoriale ;
10. la visualisation et le téléchargement des PDF ;
11. l'affichage sur téléphone ;
12. les journaux : `journalctl -u rsu-backend` et `/var/log/nginx/error.log`.

## 12. Sauvegardes obligatoires

La sauvegarde doit toujours associer la base et les fichiers.

```bash
sudo -u postgres pg_dump -F c SITE_RSU \
  -f /var/backups/rsu/SITE_RSU_$(date +%F_%H-%M).dump

sudo tar -C /opt/rsu -czf \
  /var/backups/rsu/uploads_$(date +%F_%H-%M).tar.gz uploads
```

Recommandation : une sauvegarde quotidienne, conservée sur un autre serveur ou support, avec un test de restauration périodique. Une sauvegarde stockée uniquement sur le serveur du site ne protège pas contre la perte du serveur.

## 13. Mise à jour ultérieure

Avant chaque mise à jour :

1. sauvegarder PostgreSQL et `uploads` ;
2. compiler la nouvelle version ;
3. conserver le JAR et le frontend précédents pour un retour arrière ;
4. remplacer les fichiers ;
5. redémarrer le backend et recharger Nginx ;
6. exécuter la liste de vérifications.

Ne jamais supprimer ou écraser `/opt/rsu/uploads` pendant une mise à jour applicative.

## 14. Sécurité avant ouverture publique

- changer tous les mots de passe temporaires ;
- ne jamais pousser `.env`, un dump ou un jeton Facebook sur GitHub ;
- limiter PostgreSQL à l'adresse locale ou au réseau privé ;
- garder Swagger désactivé en production ;
- n'exposer publiquement que les ports 80 et 443 ;
- appliquer les mises à jour de sécurité du système ;
- tester la restauration des sauvegardes ;
- vérifier les droits du dossier `uploads` et du fichier `/etc/rsu/rsu.env`.

## 15. Développement local

Backend :

```powershell
$env:DB_USERNAME = "postgres"
$env:DB_PASSWORD = "votre-mot-de-passe"
$env:JWT_SECRET = "votre-secret-base64"
cd backend-rsu
mvn spring-boot:run
```

Frontend :

```powershell
cd frontend-rsu
npm install
npm start
```

- site : `http://localhost:4200` ;
- administration : `http://localhost:4200/auth/login` ;
- API : `http://localhost:8096` ;
- Swagger local : `http://localhost:8096/swagger-ui.html`.

Le proxy Angular local transmet automatiquement `/api` et `/uploads` au backend sur le port `8096`.