# Déploiement

## Vue d'ensemble

```
Gitea (git.mairie-grimaud.fr)
   │  push sur develop / Pull Request vers main
   ▼
Runner Gitea (windows:host, sur SRV-AD)
   │  tests, build, sauvegarde, mise à jour, santé, rollback
   ▼
C:\wamp64\www\PrintManager          (WAMP natif, Apache *:8101)
   ├── .env                         (secrets serveur, jamais versionné)
   ├── storage\                     (données applicatives, préservées)
   ├── public\storage               (lien ou copie, préservé)
   ├── backups\                     (dumps SQL + storage + .env)
   └── .deploy\                     (commit courant / précédent)
```

L'application reste servie par WAMP sur SRV-AD :

- URL : `http://192.168.1.2:8101/PrintManager/`
- santé : `http://192.168.1.2:8101/PrintManager/public/up`
- hôte de déploiement : `C:\wamp64\www\PrintManager`

Le `docker-compose.yml` fourni reste un artefact autonome pour lancer une copie
propre (poste de développement, vérification, autre serveur). Il ne remplace pas
la production WAMP actuelle.

## Prérequis

Sur SRV-AD :

- PHP 8.3 (`C:\wamp64\bin\php\php8.3.14`) avec `snmp`, `pdo_mysql`, `sqlite`
- Composer, Node.js 20+ et npm dans le `PATH` machine
- MySQL 9.1 (`C:\wamp64\bin\mysql\mysql9.1.0\bin`)
- Git pour Windows
- accès administrateur pour installer le runner

Les outils sont dans le `PATH` machine, donc accessibles au compte `SYSTEM` du
runner. Le script détecte `mysqldump.exe` et `mysql.exe` sous
`C:\wamp64\bin\mysql`.

## 1. Dépôt et protection de `main`

Créer le dépôt privé `d.pellegrino70/PrintManager` dans Gitea (interface ou API),
puis protéger `main`.

Avec un jeton API et Git Bash :

```bash
GITEA_URL=https://git.mairie-grimaud.fr \
GITEA_TOKEN=<jeton> \
REPO_OWNER=d.pellegrino70 \
REPO_NAME=PrintManager \
./scripts/configure-gitea.sh
```

La protection appliquée : pas de push direct, 1 approbation, statut `tests`
obligatoire, branche à jour, revues obsolètes ignorées.

Vérifier ensuite dans Gitea : `Settings > Branches`.

Alternative manuelle : `Settings > Branches > Add rule` avec les mêmes options.

## 2. Accès SSH

Une clé dédiée est utilisée :

```
C:\Users\pellegrino\.ssh\id_ed25519_printmanager
```

Sa clé publique doit être ajoutée au compte Gitea (`Settings > SSH Keys`). Le
bloc `Host git.mairie-grimaud.fr` de `~/.ssh/config` pointe déjà dessus.

Empreintes du serveur Gitea à vérifier lors du premier échange :

```
ED25519  SHA256:ckCu6dSo5mitG5IYBePpWw3e2MWDJdzscUc4rorO0IQ
ECDSA    SHA256:Glt4OLxl6KdWxvR1ZMb2Frfw6bRuOF7oeTmB6SSR5pA
```

Test :

```powershell
ssh -T git@git.mairie-grimaud.fr
```

Réponse attendue : `Hi <utilisateur>! You've successfully authenticated...`

## 3. Enregistrer le dépôt local et pousser

Le répertoire de production est déjà un dépôt Git. Ajouter le remote une fois :

```powershell
cd C:\wamp64\www\PrintManager
git remote add origin git@git.mairie-grimaud.fr:d.pellegrino70/PrintManager.git
git push -u origin main
git push -u origin develop
```

`main` reste protégée : les évolutions passent par une branche dédiée puis une
Pull Request. Voir `CONTRIBUTING.md`.

## 4. Installer le runner Gitea

Créer un jeton d'enregistrement : `Admin > Actions > Runners > Create runner`.

Puis, en administrateur sur SRV-AD :

```powershell
cd C:\wamp64\www\PrintManager
.\scripts\windows\setup-runner.ps1 `
  -GiteaUrl https://git.mairie-grimaud.fr `
  -RunnerToken <jeton-runner> `
  -RunnerName printmanager-srv-ad `
  -Labels windows:host
```

Le script télécharge `gitea-runner` (v5.4.1), génère `C:\gitea-runner\config.yaml`,
enregistre le runner, puis crée la tâche planifiée `Gitea Runner PrintManager`
(démarrage automatique, compte `SYSTEM`).

Vérifier :

```powershell
Get-ScheduledTask -TaskName 'Gitea Runner PrintManager' | Get-ScheduledTaskInfo
```

Le runner doit apparaître en ligne dans `Admin > Actions > Runners` avec le label
`windows`.

Le compte `SYSTEM` n'est pas propriétaire du dépôt : les scripts Git utilisent
`-c safe.directory=...` pour éviter l'erreur « dubious ownership ».

## 5. Pipeline

`.gitea/workflows/pipeline.yml` :

1. **tests** (push `develop`, `main`, et Pull Requests) : Composer, npm, build,
   `php artisan test`.
2. **deploy** (push sur `main` uniquement, après `tests`) :
   - sauvegarde MySQL, `.env` et `storage\app` ;
   - tests et build depuis le checkout du runner ;
   - récupération du commit dans le dépôt de production (`git fetch` local puis
     `git reset --hard`) ;
   - dépendances PHP de production, assets, migrations ;
   - `config:cache`, `view:cache` ;
   - contrôle de santé sur `/PrintManager/public/up` ;
   - rollback automatique vers le commit précédent en cas d'échec.

Le déploiement ne supprime jamais `.env`, `storage\`, `public\storage`, la base,
`backups\` ni `.deploy\` : ces éléments sont ignorés par Git.

## 6. Premier déploiement

### Vérifier une copie propre (sans Docker)

```powershell
$tmp = 'C:\Users\pellegrino\AppData\Local\Temp\printmanager-clean'
git clone C:\wamp64\www\PrintManager $tmp
cd $tmp
Copy-Item .env.example .env
php artisan key:generate --force
composer install --no-interaction
npm ci
npm run build
php artisan test
```

Le pipeline exécute ces mêmes étapes dans son espace de travail avant de toucher
la production.

### Lancer le déploiement

Après fusion dans `main`, le job `deploy` s'exécute automatiquement. Pour le
premier passage, vérifier :

```powershell
Get-Content C:\wamp64\www\PrintManager\.deploy\current_sha
Invoke-WebRequest http://127.0.0.1:8101/PrintManager/public/up -UseBasicParsing
```

Puis contrôler que les données, les comptes et la configuration sont intacts :

- l'application répond sur `http://192.168.1.2:8101/PrintManager/` ;
- les écrans utilisent toujours la même base (matériels, fournitures, stocks) ;
- `.env` est inchangé (comparer avec `backups\env_<date>.backup`) ;
- `storage\app` et `public\storage` sont toujours présents.

## 7. Opérations manuelles

Sauvegarde :

```powershell
.\scripts\windows\backup.ps1 -DeployPath C:\wamp64\www\PrintManager
```

Contenu : `backups\db_<date>.sql.gz`, `storage_<date>.zip`,
`env_<date>.backup`. Rétention : 30 jours (`-RetentionDays`).

Déploiement manuel d'un commit déjà présent localement :

```powershell
.\scripts\windows\deploy.ps1 `
  -SourcePath C:\wamp64\www\PrintManager `
  -DeployPath C:\wamp64\www\PrintManager `
  -CommitSha (git -C C:\wamp64\www\PrintManager rev-parse HEAD) `
  -HealthUrl http://127.0.0.1:8101/PrintManager/public/up
```

Rollback manuel :

```powershell
.\scripts\windows\rollback.ps1 -DeployPath C:\wamp64\www\PrintManager
```

Restauration de la base en plus du code (destructif, à utiliser en dernier
recours) :

```powershell
.\scripts\windows\rollback.ps1 `
  -DeployPath C:\wamp64\www\PrintManager `
  -RestoreDatabase `
  -BackupFile C:\wamp64\www\PrintManager\backups\db_<date>.sql.gz
```

Restauration MySQL manuelle :

```powershell
$env:MYSQL_PWD = '<mot de passe>'
& C:\wamp64\bin\mysql\mysql9.1.0\bin\mysql.exe `
  -u <utilisateur> --default-character-set=utf8mb4 printmanager `
  -e "source C:/chemin/vers/dump.sql"
Remove-Item Env:\MYSQL_PWD
```

## 8. Règles d'exploitation

- Ne jamais versionner `.env`, `backups\`, `.deploy\`, les dumps SQL ou les PDF réels.
- Ne pas modifier le vhost Apache : l'application reste sur `*:8101`.
- Les migrations doivent rester compatibles avec la version précédente, pour que
  le rollback du code fonctionne sans restauration de base.
- Conserver au moins 30 jours de sauvegardes et surveiller l'espace disque.
- Le runner tourne en `SYSTEM` ; ne pas y stocker de secrets en clair en dehors de
  `.env` (déjà protégé par les droits du serveur).

## 9. Artefact Docker autonome

Pour lancer une copie propre sans WAMP :

```powershell
Copy-Item .env.example .env
# renseigner APP_KEY, DB_PASSWORD, DB_ROOT_PASSWORD
docker compose up -d --build
docker compose exec app php artisan migrate --force
```

Volumes nommés : `printmanager_db-data`, `printmanager_storage-app`,
`printmanager_storage-logs`. Ne jamais exécuter `docker compose down -v`.

## 10. Sécurité

L'application n'applique pas de middleware d'authentification sur ses routes et
reste limitée au réseau interne. Ne pas l'exposer sur Internet sans reverse proxy
authentifiant (SSO/Keycloak ou restriction IP) et sans TLS.
