rahim237cm Claude Opus 5.5 commited on
Commit
1342bbd
·
1 Parent(s): 57c8117

feat(deploiement): le front tourne en serveur Node (rendu serveur), derriere Caddy

Browse files

Le front passe d'un site statique, servi par Caddy depuis front/, a un
serveur Node (SvelteKit, adapter-node) qui rend les pages. Servie comme
avant, la sortie d'adapter-node aurait donne / et /_app/* en 404, et
try_files aurait rendu le code serveur telechargeable.

- docker-compose.yml : service front (node:24.21.0-alpine, build/ et
package.json COPIES dans l'image depuis front-node/, utilisateur node,
sans env_file). ORIGIN=https://${JURIX_DOMAINE}, API_INTERNE=
http://api:8000 (le rendu appelle l'API par le reseau interne),
KEEP_ALIVE_TIMEOUT 125 s (au-dela des 2 min de Caddy : pas de 502 sur
une connexion fermee au meme instant), SHUTDOWN_TIMEOUT 8 s, tas de V8
plafonne a 256 Mo sous mem_limit 384m, sonde sur /favicon.svg.
Rotation des journaux (3 x 10 Mo) sur les quatre services ; db arretee
avec 1 min de grace.
- Caddyfile : /api et /health inchanges ; tout le reste vers front:3000,
avec 10 s de nouvelles tentatives pendant un redemarrage. Front ou API
injoignable : page d'attente en 503 (maintenance.html, Retry-After,
en-tetes de securite compris), qui se recharge seule au retour du site,
une fois, et jamais sur un telechargement. Un 503 rendu par le front
lui-meme passe tel quel.
- deployer.sh, avant tout envoi : domaine local et domaine de la VM
identiques (un front fige pour un autre domaine cassait les appels du
navigateur sans que rien ne le voie), valeurs sans guillemets ni
espaces, deploiement/oracle commite (sinon HEAD partirait sans les
fichiers en cours), front commite et sans "dependencies", npm ci puis
build, front inchange pendant la construction, domaine fige dans le
JavaScript. jurix_dev est controle contre le commit ENVOYE (git
archive), et de nouveau juste avant le dump.
- Envoi atomique du front : front-node.nouveau rempli, VERSION ecrit en
dernier, puis bascule ; le build precedent reste dans front-node.ancien
(seulement s'il etait complet et d'un autre commit). Une coupure ne
laisse jamais un front a moitie envoye en place. Le code part en
tar.gz (un flux coupe echoue au lieu de passer pour complet, avant le
rsync --delete), dans un dossier propre a chaque envoi, avec
BACKEND_VERSION : demarrer.sh refuse un code et un front de deux envois
differents.
- demarrer.sh : front-node/ complet, domaine et maintenance.html exiges
avant toute operation sur la base. La base n'est jetee que dans trois
cas : premier deploiement (aucune loi et initial.dump), restauration
demandee a ce lancement (JURIX_RESTAURER, ou deployer.sh --restaurer,
apres une sauvegarde si la base a des lois), ou reprise d'une
restauration interrompue. Le temoin n'est ecrit que par le script,
juste avant le DROP, avec le chemin du dump : aucune demande ne reste
armee pour un deploiement suivant. Un initial.dump inutile sur une base
peuplee est mis de cote. Verrou (flock) partage avec sauvegarde.sh, qui
refuse aussi de sauvegarder une base en pleine restauration. Etape 7,
depuis le conteneur du front : /laws doit lier des fiches sans son bloc
d'erreur, et une fiche repondre 200 avec un titre. Journal
sauvegardes/deploiements.log : une ligne « tentative » avant la mise a
jour, une ligne « ok » apres, avec les commits, la sauvegarde d'avant
et la revision alembic d'avant.
- README : schema, reglages du front, refus de deployer.sh et demarrer.sh,
retour arriere (downgrade, ou restauration de la sauvegarde dont la
revision est celle de N-1, jamais avec le code de N en place), bascule
d'urgence du front idempotente, restauration reprenable, valeurs pour
une VM de 6 Go.

Verifie : docker compose config, caddy validate et fmt, bash -n et
shellcheck sur les quatre scripts, et un essai fonctionnel de chaque
chemin dans des conteneurs et des dossiers jetables (503 du front qui
traverse Caddy, page d'attente, refus de deployer.sh, rotation et
coupure de l'envoi, temoin de restauration, ligne du journal). Rien n'a
ete deploye. Trois revues adversariales (20, 12 puis 10 constats
confirmes), toutes corrigees.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

deploiement/oracle/README.md CHANGED
@@ -8,11 +8,21 @@ disque, gratuite tant qu'on reste dans ces limites.
8
  navigateur ──https──> Caddy (ports 80/443, certificat automatique)
9
  ├── /api/*, /health ──> api (FastAPI) ──https──> Voyage AI (embeddings)
10
  │ └──> db (PostgreSQL 16 + pgvector)
11
- └── tout le reste ──────> front statique (SvelteKit)
 
12
  ```
13
 
14
  - **Un seul domaine** — le sous-domaine, par exemple `jurix.exemple.cm` — sert
15
  le front et l'API (sous `/api/v1`). Pas de CORS, un seul certificat.
 
 
 
 
 
 
 
 
 
16
  - **Aucun port de la base n'est exposé** : seule l'API la voit.
17
  - Mistral, Groq et Voyage AI (les embeddings de la recherche sémantique)
18
  restent des API externes ; rien ne tourne pour eux ici. L'API a donc besoin
@@ -22,7 +32,34 @@ navigateur ──https──> Caddy (ports 80/443, certificat automatique)
22
 
23
  Besoins : ~2 à 3 Go pour PostgreSQL, et bien moins pour l'API depuis qu'elle ne
24
  garde plus de modèle d'embeddings en mémoire (EmbeddingGemma prenait ~1,5 Go) :
25
- à mesurer par `docker stats` après le premier déploiement.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
26
 
27
  ## 1. Le compte Oracle (une fois, par toi)
28
 
@@ -77,7 +114,7 @@ Depuis la machine de développement, à la racine du dépôt backend :
77
 
78
  ```bash
79
  IP=1.2.3.4 # l'IP publique de la VM
80
- export JURIX_DOMAINE=jurix.exemple.cm
81
 
82
  # a. Le code, puis la préparation de la VM (Docker, pare-feu, swap, sauvegardes)
83
  git archive HEAD | ssh -i ~/.ssh/jurix_oracle ubuntu@$IP "mkdir -p jurix && tar -x -C jurix"
@@ -95,12 +132,49 @@ exit
95
  deploiement/oracle/deployer.sh ubuntu@$IP --avec-donnees
96
  ```
97
 
98
- Prérequis sur la machine de développement : le dépôt du front à côté de celui-ci
99
- (ou `JURIX_FRONT`), avec ses `node_modules` ; le conteneur `jurix-pg` démarré ;
100
- `jurix_dev` à la dernière migration, ses vecteurs Voyage chargés
 
 
 
 
101
  (`deployer.sh` refuse de l'envoyer sinon : la migration viderait les vecteurs
102
  sur la VM, qui n'a pas de quoi les recharger sans tout recalculer).
103
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
104
  Une clé changée dans `.env` ne prend effet qu'avec `docker compose up -d api`,
105
  qui recrée le conteneur : `docker compose restart` ne relit pas le fichier.
106
 
@@ -109,11 +183,22 @@ Connexion Google (facultative) : `GOOGLE_CLIENT_ID` dans le `.env` de la VM
109
  Cloud, `https://jurix.exemple.cm` ajouté aux **origines JavaScript autorisées**
110
  de cet identifiant. Sans cela, le bouton Google échoue.
111
 
112
- La base de la VM est restaurée depuis un dump de `jurix_dev`, **seulement si
113
- elle ne contient aucune loi**, et **sans les comptes ni les conversations** de
114
- développement : le corpus seulement. Une fois restauré, le dump est renommé
115
- `initial.restaure_….dump` : aucune mise à jour ne pourra plus le rejouer. Une
116
- restauration interrompue est reprise de zéro à la relance. Le compte
 
 
 
 
 
 
 
 
 
 
 
117
  administrateur de `.env` est créé ensuite ; si un compte ordinaire existe déjà
118
  à cette adresse, `create_admin.py` refuse de le promouvoir sans `--promouvoir`.
119
  `demarrer.sh` refuse de démarrer si un secret du `.env` est vide ou recopié de
@@ -129,18 +214,170 @@ Vérifier : `https://jurix.exemple.cm`, `https://jurix.exemple.cm/health`, et
129
  `embedding_service` à `ready` (`demarrer.sh` le contrôle aussi et prévient,
130
  sinon la recherche sémantique serait coupée sans bruit).
131
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
132
  ## 5. Mettre à jour
133
 
134
  ```bash
135
  JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@$IP
136
  ```
137
 
138
- Envoie l'état **commité** du backend (`git archive` : jamais un `.env` local),
139
- et efface sur la VM les fichiers retirés du dépôt. Reconstruit le front, fait
140
- une sauvegarde de la base, puis relance avec `docker compose up -d --build` (les
141
- migrations s'appliquent au démarrage de l'API). Les données de la VM (PDF,
142
- sauvegardes, `.env`) ne sont pas touchées ; la base, seulement par les
143
- migrations.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
144
 
145
  ### Une VM déployée avant la bascule vers Voyage
146
 
@@ -161,35 +398,57 @@ en porte encore, sauf demande explicite. Dans l'ordre :
161
 
162
  ## 6. Sauvegardes
163
 
164
- Chaque nuit à 03:15, et avant chaque mise à jour, `sauvegarde.sh` écrit
165
- `sauvegardes/jurix_AAAAMMJJ_HHMM.dump`, gardé 14 jours. Rien ne prévient d'un
 
 
 
166
  échec : jeter un œil de temps en temps à `sauvegardes/sauvegarde.log`. À la main :
167
 
168
  ```bash
169
  bash sauvegarde.sh
170
  ```
171
 
172
- Restaurer une sauvegarde (la base actuelle est **remplacée**) :
 
 
173
 
174
  ```bash
175
- docker compose stop api caddy
176
- docker compose exec -T db psql -U jurix -d postgres -c "DROP DATABASE jurix WITH (FORCE)" -c "CREATE DATABASE jurix OWNER jurix"
177
- docker compose exec -T db pg_restore -U jurix -d jurix --no-owner --exit-on-error < sauvegardes/jurix_….dump
178
- bash demarrer.sh
179
  ```
180
 
 
 
 
 
 
 
 
 
 
 
181
  Copier de temps en temps une sauvegarde hors de la VM :
182
  `scp -i ~/.ssh/jurix_oracle ubuntu@$IP:jurix/deploiement/oracle/sauvegardes/<fichier> .`
183
 
184
  ## 7. Surveiller et dépanner
185
 
186
  ```bash
187
- docker compose ps # état des trois conteneurs
188
  docker compose logs -f api # journal de l'API (une ligne par appel Mistral/Groq)
 
189
  docker compose logs caddy # certificat HTTPS, accès
 
 
190
  free -h ; df -h # mémoire et disque
191
  ```
192
 
 
 
 
 
 
 
 
193
  - **Pas de certificat** : le DNS ne pointe pas encore sur la VM, ou le port 80
194
  est fermé (liste de sécurité Oracle **et** pare-feu de la VM, que
195
  `installer.sh` ouvre).
@@ -199,8 +458,8 @@ free -h ; df -h # mémoire et disque
199
  passer sous ce seuil : surveiller la métrique mémoire dans la console Oracle
200
  la première semaine.
201
  - **Déménager** : tout est dans Docker. Sur la nouvelle machine : y copier le
202
- dossier `jurix/` entier (le code et ce dossier, avec `.env` et
203
- `donnees/`), placer la dernière sauvegarde sous `sauvegardes/initial.dump`,
204
  lancer `installer.sh`, **se reconnecter** (le groupe `docker` ne vaut que
205
  pour une nouvelle session), puis `bash demarrer.sh` : la base, vide, est
206
  restaurée avant le démarrage de l'API. Enfin, faire pointer le DNS sur la
 
8
  navigateur ──https──> Caddy (ports 80/443, certificat automatique)
9
  ├── /api/*, /health ──> api (FastAPI) ──https──> Voyage AI (embeddings)
10
  │ └──> db (PostgreSQL 16 + pgvector)
11
+ └── tout le reste ──────> front (Node : SvelteKit, rendu serveur)
12
+ └──> api, par le réseau interne (http://api:8000)
13
  ```
14
 
15
  - **Un seul domaine** — le sous-domaine, par exemple `jurix.exemple.cm` — sert
16
  le front et l'API (sous `/api/v1`). Pas de CORS, un seul certificat.
17
+ - **Le front est un serveur Node** (SvelteKit, adapter-node) : les pages
18
+ publiques arrivent remplies, lisibles par un moteur de recherche ou un aperçu
19
+ de lien. Pour les remplir, il appelle l'API par le réseau interne de Docker,
20
+ sans repasser par Caddy. Son build vit dans `front-node/`, envoyé par
21
+ `deployer.sh`.
22
+ - **Front ou API injoignable** (conteneur arrêté, ou qui redémarre pendant une
23
+ mise à jour) : Caddy sert `caddy/maintenance.html`, en 503, au lieu d'une
24
+ erreur 502 vide. Une page en 503 rendue par le front lui-même (l'API ne lui
25
+ répond pas) passe telle quelle.
26
  - **Aucun port de la base n'est exposé** : seule l'API la voit.
27
  - Mistral, Groq et Voyage AI (les embeddings de la recherche sémantique)
28
  restent des API externes ; rien ne tourne pour eux ici. L'API a donc besoin
 
32
 
33
  Besoins : ~2 à 3 Go pour PostgreSQL, et bien moins pour l'API depuis qu'elle ne
34
  garde plus de modèle d'embeddings en mémoire (EmbeddingGemma prenait ~1,5 Go) :
35
+ à mesurer par `docker stats` après le premier déploiement. Le front Node est
36
+ plafonné à 384 Mo.
37
+
38
+ Les limites de mémoire de `docker-compose.yml` (base 4 Go, API 5 Go, front
39
+ 384 Mo, Caddy 256 Mo : 9,6 Go en tout) supposent une VM de 12 Go. `mem_limit`
40
+ est un plafond, pas une réservation : rien n'est retenu d'avance, mais un
41
+ conteneur qui atteint le sien est tué, puis redémarre.
42
+
43
+ **Vérifier d'abord la mémoire de la VM avec `free -g`.** Si elle n'a que 6 Go
44
+ (créée en 1 OCPU et 6 Go, §2), réduire ces limites dans le `docker-compose.yml`
45
+ **du dépôt**, et commiter avant de lancer `deployer.sh` : une modification
46
+ faite sur la VM est écrasée à chaque déploiement. Pour 6 Go :
47
+
48
+ | Service | 12 Go (actuel) | 6 Go |
49
+ |---|---|---|
50
+ | `db` | `mem_limit: 4g`, `shared_buffers=1GB`, `effective_cache_size=4GB` | `mem_limit: 2g`, `shared_buffers=512MB`, `effective_cache_size=1536MB` |
51
+ | `api` | `mem_limit: 5g` | `mem_limit: 1536m` |
52
+ | `front` | `mem_limit: 384m` | inchangé |
53
+ | `caddy` | `mem_limit: 256m` | inchangé |
54
+
55
+ Pour l'API, 1,5 Go : l'image n'installe ni Docling ni torch (absents de
56
+ `requirements.txt`), et son seul modèle en mémoire est celui de fastText
57
+ (126 Mo) ; le même code tient ~250 Mo mesurés en développement. La marge sert à
58
+ l'OCR de l'administration (`/api/v1/ocr`), qui rend en mémoire toutes les pages
59
+ d'un PDF à 300 dpi, ~25 Mo chacune : au-delà d'une quarantaine de pages, le
60
+ conteneur serait tué. Les gros scans s'OCRisent sur la machine de
61
+ développement, comme le reste de l'ingestion. Après le premier déploiement,
62
+ comparer avec `docker stats --no-stream`.
63
 
64
  ## 1. Le compte Oracle (une fois, par toi)
65
 
 
114
 
115
  ```bash
116
  IP=1.2.3.4 # l'IP publique de la VM
117
+ export JURIX_DOMAINE=jurix.exemple.cm # le vrai domaine : deployer.sh refuse cet exemple
118
 
119
  # a. Le code, puis la préparation de la VM (Docker, pare-feu, swap, sauvegardes)
120
  git archive HEAD | ssh -i ~/.ssh/jurix_oracle ubuntu@$IP "mkdir -p jurix && tar -x -C jurix"
 
132
  deploiement/oracle/deployer.sh ubuntu@$IP --avec-donnees
133
  ```
134
 
135
+ Prérequis sur la machine de développement : `deploiement/oracle` **entièrement
136
+ commité** (la VM reçoit HEAD) ; le dépôt du front à côté de celui-ci (ou
137
+ `JURIX_FRONT`), sur la branche du rendu serveur (adapter-node), **sans
138
+ modification non commitée** ; l'accès à npm : `deployer.sh` lance `npm ci`
139
+ dans le front, ce qui **remplace ses `node_modules`** par ceux de son
140
+ `package-lock.json` ; le conteneur `jurix-pg` démarré ; `jurix_dev` à la
141
+ dernière migration **du commit envoyé**, ses vecteurs Voyage chargés
142
  (`deployer.sh` refuse de l'envoyer sinon : la migration viderait les vecteurs
143
  sur la VM, qui n'a pas de quoi les recharger sans tout recalculer).
144
 
145
+ `deployer.sh` s'arrête **avant tout envoi** :
146
+
147
+ - si `deploiement/oracle` a des modifications non commitées ou des fichiers non
148
+ suivis (ailleurs dans le backend, il prévient seulement : seul HEAD part) ;
149
+ - si la VM ne répond pas, si son `.env` n'a pas le **même `JURIX_DOMAINE`**
150
+ qu'ici (le domaine figé dans le front doit être celui d'`ORIGIN` et
151
+ d'`ALLOWED_ORIGINS`), ou si c'est le domaine d'exemple `jurix.exemple.cm` ;
152
+ - si `JURIX_DOMAINE` (ici ou sur la VM) ou `GOOGLE_CLIENT_ID` contient des
153
+ guillemets, des espaces, `$`, `#` ou `/` : ces valeurs sont lues telles
154
+ quelles, là où docker compose les nettoierait ;
155
+ - avec `--avec-donnees`, si `jurix_dev` n'est pas à la tête des migrations
156
+ **du commit envoyé** (extrait par `git archive`, et non pris dans la copie de
157
+ travail), ou s'il lui manque des vecteurs. Le contrôle est refait juste avant
158
+ le dump : une migration appliquée à `jurix_dev` pendant l'envoi des PDF
159
+ arrête le déploiement ;
160
+ - si le dépôt du front a des modifications non commitées (le front envoyé doit
161
+ être un commit, qu'on sait reconstruire), des `dependencies` dans son
162
+ `package.json` (l'image n'a pas de `node_modules`), ou s'il a changé pendant
163
+ la construction (nouveau commit, fichier modifié) ;
164
+ - si le build n'a pas `build/index.js` et `build/client` (build statique), ou si
165
+ le domaine n'est pas figé dans `build/client/_app`.
166
+
167
+ Le front est construit avec `VITE_API_URL=https://<domaine>` et `VITE_WS_URL`
168
+ vide : une valeur du `.env` local du front ne s'y glisse pas. Seuls `build/` et
169
+ `package.json` partent, dans `front-node.nouveau/`, échangé avec `front-node/`
170
+ une fois l'envoi complet ; `front-node/VERSION`, écrit en dernier, décrit ce
171
+ **dernier front envoyé** (commit du backend, commit du front, date d'envoi). Le
172
+ build remplacé passe dans `front-node.ancien/` seulement s'il était complet
173
+ (avec son `VERSION`) et d'un autre commit du front : un envoi coupé est jeté,
174
+ et renvoyer le même front ne chasse pas ce secours. L'image du front **copie**
175
+ ces fichiers à sa construction : le conteneur en place n'est pas touché pendant
176
+ l'envoi.
177
+
178
  Une clé changée dans `.env` ne prend effet qu'avec `docker compose up -d api`,
179
  qui recrée le conteneur : `docker compose restart` ne relit pas le fichier.
180
 
 
183
  Cloud, `https://jurix.exemple.cm` ajouté aux **origines JavaScript autorisées**
184
  de cet identifiant. Sans cela, le bouton Google échoue.
185
 
186
+ La base de la VM n'est jetée (DROP), par `demarrer.sh`, que dans trois cas :
187
+
188
+ - elle n'a **aucune loi** et `sauvegardes/initial.dump` existe : le premier
189
+ déploiement, avec le dump de `jurix_dev`, **sans les comptes ni les
190
+ conversations** de développement (le corpus seulement) ;
191
+ - une restauration est **demandée à ce lancement**, par `JURIX_RESTAURER` ou
192
+ `deployer.sh --restaurer` (§6) : une base qui a des lois est d'abord
193
+ sauvegardée ;
194
+ - une restauration **interrompue** reprend, de zéro, avec le même dump, au
195
+ lancement suivant de `demarrer.sh`.
196
+
197
+ Une fois restauré, `initial.dump` est renommé `initial.restaure_….dump` : aucune
198
+ mise à jour ne pourra plus le rejouer. Un `initial.dump` qui arrive sur une base
199
+ déjà peuplée n'est pas restauré, et devient `initial.ignore_….dump` : une
200
+ relance qui trouverait plus tard la base sans loi ne pourra pas le rejouer non
201
+ plus. Le compte
202
  administrateur de `.env` est créé ensuite ; si un compte ordinaire existe déjà
203
  à cette adresse, `create_admin.py` refuse de le promouvoir sans `--promouvoir`.
204
  `demarrer.sh` refuse de démarrer si un secret du `.env` est vide ou recopié de
 
214
  `embedding_service` à `ready` (`demarrer.sh` le contrôle aussi et prévient,
215
  sinon la recherche sémantique serait coupée sans bruit).
216
 
217
+ ### Réglages du front
218
+
219
+ Le service `front` ne lit **pas** le `.env` (il porte les secrets de l'API) :
220
+ ses réglages sont dans `docker-compose.yml`, dérivés de `JURIX_DOMAINE`. Rien à
221
+ ajouter au `.env`.
222
+
223
+ | Variable | Valeur | Rôle |
224
+ |---|---|---|
225
+ | `ORIGIN` | `https://${JURIX_DOMAINE}` | l'origine publique, annoncée à l'API, dont `ALLOWED_ORIGINS` vient du même domaine ; `VITE_API_URL` doit la désigner aussi |
226
+ | `API_INTERNE` | `http://api:8000` | le rendu serveur appelle l'API par le réseau interne (`src/hooks.server.ts` du front) |
227
+ | `KEEP_ALIVE_TIMEOUT`, `HEADERS_TIMEOUT` | `125`, `126` (secondes) | Node garde ses connexions plus longtemps que Caddy (2 min) : pas de 502 sur une connexion fermée au mauvais moment |
228
+ | `SHUTDOWN_TIMEOUT` | `8` | arrêt propre en moins des 10 s que Docker accorde |
229
+ | `NODE_OPTIONS` | `--max-old-space-size=256` | le tas de Node sous la limite de 384 Mo du conteneur |
230
+ | `PORT`, `HOST` | `3000`, `0.0.0.0` | l'adresse que Caddy joint (`front:3000`) |
231
+
232
+ `VITE_API_URL` et `VITE_GOOGLE_CLIENT_ID`, eux, sont figés **au build** par
233
+ `deployer.sh` : en changer demande un nouveau déploiement. `VITE_WS_URL` y est
234
+ forcée vide : le front en dérive l'adresse de `VITE_API_URL`.
235
+
236
  ## 5. Mettre à jour
237
 
238
  ```bash
239
  JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@$IP
240
  ```
241
 
242
+ Construit et contrôle d'abord le front (état **commité** lui aussi), l'envoie
243
+ dans `front-node/`, puis envoie l'état **commité** du backend (`git archive` :
244
+ jamais un `.env` local), et efface sur la VM les fichiers retirés du dépôt.
245
+ Fait une sauvegarde de la base, puis relance avec `docker compose up -d
246
+ --build` (les migrations s'appliquent au démarrage de l'API ; le front est
247
+ reconstruit si son build a changé, et Caddy fait patienter les visiteurs
248
+ jusqu'à 10 s pendant son redémarrage). Les données de la VM (PDF, sauvegardes,
249
+ `.env`, et l'ancien `front/` statique) ne sont pas touchées ; la base,
250
+ seulement par les migrations, sauf avec `--restaurer` (§6). Le code part en
251
+ `tar.gz`, extrait à part sur la VM : un envoi coupé échoue sans rien effacer.
252
+
253
+ `demarrer.sh` tient le journal `sauvegardes/deploiements.log` sur la VM, qu'il
254
+ soit lancé par `deployer.sh` ou à la main : une ligne `tentative` juste avant de
255
+ remplacer l'API et le front, une ligne `ok` une fois le rendu contrôlé.
256
+
257
+ ```
258
+ <date> <tentative|ok> <commit du backend> <commit du front> <sauvegarde d'avant> <révision d'avant>
259
+ ```
260
+
261
+ - **Sauvegarde d'avant** : la base telle qu'elle était avant ce passage, chemin
262
+ prêt pour `JURIX_RESTAURER` ou `--restaurer`. `-` quand ce passage n'avait
263
+ rien à sauvegarder : premier déploiement (le dump restauré est gardé en
264
+ `initial.restaure_….dump`), ou reprise d'une restauration interrompue.
265
+ - **Révision d'avant** : la révision alembic de cette même base (`-` : pas de
266
+ table `alembic_version`, ou reprise d'une restauration).
267
+
268
+ La **version en place** est la dernière ligne, `tentative` ou `ok` : après un
269
+ `ECHEC` aux étapes 5 à 7, c'est bien la nouvelle version qui tourne. Une ligne
270
+ `secours` note l'échange de front d'urgence (plus bas). `front-node/VERSION` ne
271
+ décrit que le dernier front envoyé.
272
+
273
+ Le premier déploiement de cette version recrée une fois le conteneur de la base
274
+ (rotation des journaux, délai d'arrêt porté à une minute), comme ceux de l'API
275
+ et de Caddy : quelques secondes de coupure, les données restant dans le volume
276
+ `db`.
277
+
278
+ `demarrer.sh` refuse de démarrer, avant de toucher à la base : si un autre
279
+ `demarrer.sh` ou une sauvegarde tourne (verrou `sauvegardes/.verrou`) ; un
280
+ `front-node/` sans `VERSION` (envoi incomplet), d'un autre envoi que le code
281
+ (le `BACKEND_VERSION` que `deployer.sh` ajoute à l'archive doit valoir le
282
+ premier champ de `front-node/VERSION`), ou construit pour un autre domaine que
283
+ le `JURIX_DOMAINE` de son `.env` ; un `JURIX_DOMAINE` ou un `GOOGLE_CLIENT_ID`
284
+ avec guillemets, espaces, `$`, `#` ou `/` ; un `JURIX_RESTAURER` qui n'est pas
285
+ un fichier `sauvegardes/….dump` existant ; ou une VM sans
286
+ `caddy/maintenance.html`. Il
287
+ contrôle enfin le rendu serveur, depuis le conteneur du front : `/laws` doit
288
+ lier des fiches, sans son bloc d'erreur, et une de ces fiches répondre 200 avec
289
+ un `<title>`. Sinon, il s'arrête en `ECHEC` : voir `docker compose logs front
290
+ api`.
291
+
292
+ ### Revenir en arrière
293
+
294
+ Revenir en arrière, c'est redéployer un état précédent : un commit du backend
295
+ **et** le commit du front qui allait avec, lus dans
296
+ `sauvegardes/deploiements.log` sur la VM. La version en place, N, est sa
297
+ dernière ligne ; N-1 est la dernière ligne `ok` d'un **autre** commit du
298
+ backend. Les sauvegardes qu'il nomme sont gardées 14 jours, comme toutes (§6).
299
+
300
+ Si N n'a **pas** appliqué de migration :
301
+
302
+ 1. Sur la machine de développement, ramener le backend au commit de N-1
303
+ (`git switch --detach <commit>`), et le front au sien
304
+ (`git switch --detach <commit>`, puis `npm ci`).
305
+ 2. Relancer `deployer.sh` : il renvoie ce code, reconstruit `front-node/` depuis
306
+ ce front, et `demarrer.sh` reconstruit l'image et contrôle le rendu.
307
+ 3. Revenir ensuite sur les branches de travail : `git switch -` dans les deux
308
+ dépôts, puis `npm ci` dans le front, dont `deployer.sh` a remplacé les
309
+ `node_modules` par ceux du commit déployé.
310
+
311
+ Si N **a appliqué une migration**, la base doit revenir aussi. La tête de
312
+ N-1 : `.venv/bin/alembic heads` au commit N-1, sur la machine de développement.
313
+
314
+ 0. Si la migration de N a un `downgrade` qui fonctionne, sur la VM :
315
+ 1. `docker compose stop api front` : plus rien n'écrit dans la base, et
316
+ Caddy sert `maintenance.html` (arrêtés ainsi, les conteneurs le restent
317
+ même si Docker redémarre) ;
318
+ 2. `docker compose run --rm --no-deps api alembic downgrade <tête de N-1>`,
319
+ avec l'image de N, qui porte ce `downgrade` ;
320
+ 3. déployer N-1 comme ci-dessus. Pas de restauration.
321
+ 1. Sinon, restaurer. La sauvegarde à prendre est la plus récente du journal
322
+ dont la révision d'avant vaut la tête de N-1. Déployer N-1 comme ci-dessus,
323
+ mais avec `--restaurer` (le `deployer.sh` de N-1 doit le connaître : à
324
+ partir de cette version du déploiement) :
325
+
326
+ ```bash
327
+ deploiement/oracle/deployer.sh ubuntu@$IP --restaurer sauvegardes/jurix_….dump
328
+ ```
329
+
330
+ Le `demarrer.sh` de N-1 sauvegarde d'abord la base de N (les comptes et
331
+ conversations créés depuis N restent dans ce fichier), la remplace par ce
332
+ dump, puis démarre l'API de N-1.
333
+
334
+ Ne jamais restaurer une base d'avant N avec le code de N en place
335
+ (`JURIX_RESTAURER=… bash demarrer.sh` sur la VM) : l'API de N réappliquerait
336
+ sa migration. Le retour passe par le `deployer.sh` de N-1.
337
+
338
+ En urgence, le front seul, sans la machine de développement :
339
+ `front-node.ancien/` garde le dernier build complet d'un autre commit du front.
340
+ Valable seulement à partir du deuxième déploiement avec le rendu serveur (il
341
+ n'existe pas avant), et seulement pour un front construit pour le **backend en
342
+ place** (`BACKEND_VERSION`) ; sinon, redéployer en entier, ou revenir au site
343
+ statique. Sur la VM, la commande se relance sans risque : déjà en place, le
344
+ front voulu est seulement reconstruit, sans nouvelle ligne au journal.
345
+
346
+ ```bash
347
+ cible=<commit du front voulu> # tel que dans VERSION (12 caractères)
348
+ if [ "$(cut -d' ' -f2 front-node/VERSION)" = "$cible" ]; then
349
+ docker compose up -d --build --no-deps front
350
+ elif [ -f front-node.ancien/build/index.js ] \
351
+ && [ "$(cut -d' ' -f2 front-node.ancien/VERSION 2>/dev/null)" = "$cible" ] \
352
+ && [ "$(cut -d' ' -f1 front-node.ancien/VERSION)" = "$(cat BACKEND_VERSION)" ]; then
353
+ mv front-node front-node.tmp && mv front-node.ancien front-node && mv front-node.tmp front-node.ancien \
354
+ && printf '%s secours %s %s - -\n' "$(date -Is)" "$(cat BACKEND_VERSION)" "$cible" >> sauvegardes/deploiements.log \
355
+ && docker compose up -d --build --no-deps front \
356
+ || echo "Echange inacheve. Si front-node.tmp existe, le remettre : mv front-node.tmp front-node (ou, si front-node existe deja, mv front-node.tmp front-node.ancien), puis relancer."
357
+ else
358
+ echo "Refuse : front-node.ancien ne porte pas le front $cible pour le backend en place ($(cat BACKEND_VERSION))"
359
+ fi
360
+ ```
361
+
362
+ Revenir au **site statique** d'avant le rendu serveur :
363
+
364
+ 1. Sur la machine de développement, ramener le backend au commit d'avant la
365
+ bascule, et le front au sien ; dans le front, `npm ci`, puis s'assurer que
366
+ `VITE_API_URL=https://<domaine> npm run build` réussit **avant** de lancer
367
+ l'ancien `deployer.sh`. Celui-ci remplace en effet sur la VM le
368
+ `docker-compose.yml` et le Caddyfile, et efface `front-node/` (et ses
369
+ copies) et `caddy/maintenance.html`, qu'il ne connaît pas, **avant** de
370
+ construire le front : un build en échec à ce moment laisserait la VM à
371
+ moitié revenue.
372
+ 2. Lancer l'ancien `deployer.sh` : il reconstruit `front/` et l'envoie.
373
+ 3. Sur la VM, retirer le conteneur du front, que l'ancienne composition ignore :
374
+ `docker compose up -d --remove-orphans`.
375
+ 4. Revenir sur les branches de travail : `git switch -` dans les deux dépôts,
376
+ puis `npm ci` dans le front.
377
+
378
+ L'ancien `front/` est resté intact sur une VM déployée avant la bascule ; une
379
+ VM déployée d'emblée avec le rendu serveur n'en a pas, et c'est l'ancien
380
+ `deployer.sh` qui le crée.
381
 
382
  ### Une VM déployée avant la bascule vers Voyage
383
 
 
398
 
399
  ## 6. Sauvegardes
400
 
401
+ Chaque nuit à 03:15, et avant chaque mise à jour ou restauration,
402
+ `sauvegarde.sh` écrit `sauvegardes/jurix_AAAAMMJJ_HHMMSS.dump`, gardé 14 jours.
403
+ Il ne tourne jamais en même temps que `demarrer.sh` (verrou
404
+ `sauvegardes/.verrou`), ni pendant une restauration interrompue : la sauvegarde
405
+ de nuit est alors sautée, avec une ligne dans `sauvegarde.log`. Rien ne prévient d'un
406
  échec : jeter un œil de temps en temps à `sauvegardes/sauvegarde.log`. À la main :
407
 
408
  ```bash
409
  bash sauvegarde.sh
410
  ```
411
 
412
+ Restaurer une sauvegarde **à version égale** (la base actuelle est
413
+ **remplacée**) ; pour revenir à une version antérieure, voir « Revenir en
414
+ arrière » (§5) :
415
 
416
  ```bash
417
+ JURIX_RESTAURER=sauvegardes/jurix_….dump bash demarrer.sh
 
 
 
418
  ```
419
 
420
+ La demande ne vaut que pour ce lancement : rien n'est posé à l'avance, rien
421
+ n'est à annuler. `demarrer.sh` sauvegarde d'abord la base en place si elle a
422
+ des lois (son nom va au journal, comme sauvegarde d'avant), arrête l'API, le
423
+ front et Caddy, écrit lui-même le témoin `sauvegardes/.restauration_en_cours`
424
+ (le chemin du dump) juste avant de jeter la base, la restaure, puis redémarre
425
+ tout. Interrompue (coupure, mémoire), la restauration reprend de zéro au
426
+ prochain `bash demarrer.sh`, sans `JURIX_RESTAURER` ; d'ici là, `deployer.sh`
427
+ et `sauvegarde.sh` refusent de tourner. Le témoin ne se pose ni ne se retire
428
+ jamais à la main.
429
+
430
  Copier de temps en temps une sauvegarde hors de la VM :
431
  `scp -i ~/.ssh/jurix_oracle ubuntu@$IP:jurix/deploiement/oracle/sauvegardes/<fichier> .`
432
 
433
  ## 7. Surveiller et dépanner
434
 
435
  ```bash
436
+ docker compose ps # état des quatre conteneurs
437
  docker compose logs -f api # journal de l'API (une ligne par appel Mistral/Groq)
438
+ docker compose logs front # rendu serveur du front
439
  docker compose logs caddy # certificat HTTPS, accès
440
+ cat front-node/VERSION # dernier front envoyé (commits, date d'envoi)
441
+ tail -3 sauvegardes/deploiements.log # la dernière ligne : la version en place
442
  free -h ; df -h # mémoire et disque
443
  ```
444
 
445
+ Les journaux de chaque conteneur tournent : 3 fichiers de 10 Mo au plus.
446
+
447
+ - **Page « JuriX revient dans un instant »** : Caddy ne joint plus le front
448
+ (ou l'API, pour `/api`). `docker compose ps`, puis `docker compose logs
449
+ front` ; `docker compose up -d` relance un conteneur arrêté.
450
+ - **Page d'erreur 503 aux couleurs du site** : le front tourne, mais l'API ne
451
+ lui répond pas (`docker compose logs api`).
452
  - **Pas de certificat** : le DNS ne pointe pas encore sur la VM, ou le port 80
453
  est fermé (liste de sécurité Oracle **et** pare-feu de la VM, que
454
  `installer.sh` ouvre).
 
458
  passer sous ce seuil : surveiller la métrique mémoire dans la console Oracle
459
  la première semaine.
460
  - **Déménager** : tout est dans Docker. Sur la nouvelle machine : y copier le
461
+ dossier `jurix/` entier (le code et ce dossier, avec `.env`, `donnees/` et
462
+ `front-node/`), placer la dernière sauvegarde sous `sauvegardes/initial.dump`,
463
  lancer `installer.sh`, **se reconnecter** (le groupe `docker` ne vaut que
464
  pour une nouvelle session), puis `bash demarrer.sh` : la base, vide, est
465
  restaurée avant le démarrage de l'API. Enfin, faire pointer le DNS sur la
deploiement/oracle/caddy/Caddyfile CHANGED
@@ -2,6 +2,18 @@
2
  # Caddy obtient et renouvelle seul le certificat HTTPS (Let's Encrypt) des que
3
  # le DNS du domaine pointe sur la VM et que les ports 80 et 443 sont ouverts.
4
 
 
 
 
 
 
 
 
 
 
 
 
 
5
  {$JURIX_DOMAINE} {
6
  encode zstd gzip
7
 
@@ -23,35 +35,33 @@
23
  reverse_proxy api:8000
24
  }
25
 
26
- # Les fichiers construits du front. Ceux de /_app/immutable portent leur
27
- # empreinte dans leur nom : en cache un an. Un fichier absent repond 404, et
28
- # non index.html : apres une mise a jour, un onglet ouvert qui reclamait un
29
- # ancien morceau recevait du HTML a la place du JavaScript.
30
- handle /_app/* {
31
- root * /srv/front
32
- header /_app/immutable/* Cache-Control "public, max-age=31536000, immutable"
33
- file_server
34
- }
35
-
36
- # Le reste de l'application monopage : toute route inconnue rend
37
- # index.html, sans quoi un lien profond (/laws/123) repondrait 404.
38
- # no-cache : le navigateur revalide index.html a chaque visite. Sans
39
- # en-tete, il le gardait selon son heuristique et, apres une mise a jour,
40
- # reclamait des morceaux supprimes : page blanche.
41
  handle {
42
- root * /srv/front
43
- header Cache-Control "no-cache"
44
- try_files {path} {path}/ /index.html
45
- file_server
46
  }
47
 
48
- header {
49
- Strict-Transport-Security "max-age=31536000; includeSubDomains"
50
- X-Content-Type-Options "nosniff"
51
- Referrer-Policy "strict-origin-when-cross-origin"
52
- -Server
 
 
 
 
 
 
 
 
53
  }
54
 
 
 
55
  # Pas de journal d'acces : il ecrirait les URL entieres, dont le jeton
56
  # d'administration du WebSocket (?token=...) et les liens de
57
  # reinitialisation de mot de passe. Les erreurs de Caddy restent dans
 
2
  # Caddy obtient et renouvelle seul le certificat HTTPS (Let's Encrypt) des que
3
  # le DNS du domaine pointe sur la VM et que les ports 80 et 443 sont ouverts.
4
 
5
+ # En-tetes de securite, importes deux fois : avec -Server, le bloc est differe,
6
+ # applique quand la route normale ecrit sa reponse. Une erreur part par
7
+ # handle_errors, qui ne passe pas par lui : la page d'attente les perdait.
8
+ (securite) {
9
+ header {
10
+ Strict-Transport-Security "max-age=31536000; includeSubDomains"
11
+ X-Content-Type-Options "nosniff"
12
+ Referrer-Policy "strict-origin-when-cross-origin"
13
+ -Server
14
+ }
15
+ }
16
+
17
  {$JURIX_DOMAINE} {
18
  encode zstd gzip
19
 
 
35
  reverse_proxy api:8000
36
  }
37
 
38
+ # Tout le reste : le serveur Node du front, qui rend les pages et sert les
39
+ # fichiers du build (deja compresses, et /_app/immutable en cache un an :
40
+ # rien a ajouter ici). Pendant qu'il redemarre (mise a jour), Caddy retente
41
+ # la connexion jusqu'a 10 s au lieu de repondre aussitot 502.
 
 
 
 
 
 
 
 
 
 
 
42
  handle {
43
+ reverse_proxy front:3000 {
44
+ lb_try_duration 10s
45
+ }
 
46
  }
47
 
48
+ # Front ou API injoignable (conteneur arrete, ou qui redemarre) : une page
49
+ # d'attente en 503, et non une 502 vide. Seules les erreurs levees par Caddy
50
+ # arrivent ici : une reponse du front, meme un 503 qu'il rend lui-meme
51
+ # quand l'API ne repond pas, passe telle quelle.
52
+ handle_errors 502 503 504 {
53
+ import securite
54
+ root * /etc/caddy
55
+ rewrite * /maintenance.html
56
+ header Retry-After 30
57
+ header Cache-Control no-store
58
+ file_server {
59
+ status 503
60
+ }
61
  }
62
 
63
+ import securite
64
+
65
  # Pas de journal d'acces : il ecrirait les URL entieres, dont le jeton
66
  # d'administration du WebSocket (?token=...) et les liens de
67
  # reinitialisation de mot de passe. Les erreurs de Caddy restent dans
deploiement/oracle/caddy/maintenance.html ADDED
@@ -0,0 +1,123 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+ <!--
3
+ Servie par Caddy, en 503 avec Retry-After, quand le front ou l'API ne répond
4
+ pas : conteneur arrêté, ou qui redémarre pendant une mise à jour. Autonome :
5
+ ni police, ni image, ni fichier externe, que le front injoignable ne pourrait
6
+ pas servir.
7
+
8
+ Pas de balise meta refresh : un rechargement minuté, que le visiteur ne
9
+ peut ni arrêter ni prolonger, est l'échec F41 de WCAG 2.2.1. Le lien
10
+ « Réessayer » lui laisse la main ; le script, lui, ne recharge la page
11
+ qu'une fois, le site de retour (statut sous 500), et seulement si l'adresse
12
+ rend une page HTML : une adresse de téléchargement (PDF, pièce jointe)
13
+ serait sinon rechargée, donc téléchargée, sans que le visiteur l'ait
14
+ demandé. Dans ce cas, la page cesse d'interroger et garde le lien.
15
+ -->
16
+ <html lang="fr">
17
+ <head>
18
+ <meta charset="utf-8" />
19
+ <meta name="viewport" content="width=device-width, initial-scale=1" />
20
+ <meta name="robots" content="noindex" />
21
+ <title>JuriX revient dans un instant</title>
22
+ <style>
23
+ :root {
24
+ color-scheme: light dark;
25
+ }
26
+ body {
27
+ margin: 0;
28
+ min-height: 100vh;
29
+ display: grid;
30
+ place-items: center;
31
+ font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
32
+ background: #f8f9fa;
33
+ color: #0f172a;
34
+ }
35
+ main {
36
+ max-width: 32rem;
37
+ padding: 2rem 1.5rem;
38
+ text-align: center;
39
+ }
40
+ .marque {
41
+ font-weight: 700;
42
+ font-size: 1.25rem;
43
+ color: #2563eb;
44
+ margin: 0 0 1.5rem;
45
+ }
46
+ h1 {
47
+ font-size: 1.5rem;
48
+ margin: 0 0 0.75rem;
49
+ }
50
+ p {
51
+ line-height: 1.6;
52
+ margin: 0 0 0.5rem;
53
+ color: #475569;
54
+ }
55
+ .reessayer {
56
+ display: inline-block;
57
+ margin-top: 1rem;
58
+ padding: 0.625rem 1.25rem;
59
+ border-radius: 0.75rem;
60
+ background: #2563eb;
61
+ color: #ffffff;
62
+ font-weight: 600;
63
+ text-decoration: none;
64
+ }
65
+ .reessayer:hover {
66
+ background: #1d4ed8;
67
+ }
68
+ .reessayer:focus-visible {
69
+ outline: 3px solid #93c5fd;
70
+ outline-offset: 3px;
71
+ }
72
+ @media (prefers-color-scheme: dark) {
73
+ body {
74
+ background: #0a1628;
75
+ color: #f1f5f9;
76
+ }
77
+ p {
78
+ color: #cbd5e1;
79
+ }
80
+ .marque {
81
+ color: #60a5fa;
82
+ }
83
+ }
84
+ </style>
85
+ </head>
86
+ <body>
87
+ <main>
88
+ <p class="marque">JuriX</p>
89
+ <h1>JuriX revient dans un instant</h1>
90
+ <p>Le site est en cours de mise à jour ou de redémarrage.</p>
91
+ <p>Réessayez dans quelques instants.</p>
92
+ <a class="reessayer" href="">Réessayer</a>
93
+ </main>
94
+ <script>
95
+ // Toutes les 30 s, le rythme du Retry-After. Une seule requete a la
96
+ // fois : une reponse qui tarde ne doit pas en empiler d'autres.
97
+ if (window.fetch) {
98
+ var enCours = false;
99
+ var minuterie = setInterval(function () {
100
+ if (enCours) return;
101
+ enCours = true;
102
+ fetch(location.href, { cache: "no-store" })
103
+ .then(function (reponse) {
104
+ enCours = false;
105
+ if (reponse.status >= 500) return;
106
+ // Le site repond : plus d'interrogation, et le corps (peut-etre
107
+ // un gros PDF) n'est pas lu.
108
+ clearInterval(minuterie);
109
+ if (reponse.body && reponse.body.cancel) reponse.body.cancel();
110
+ var type = reponse.headers.get("Content-Type") || "";
111
+ var disposition = reponse.headers.get("Content-Disposition") || "";
112
+ if (/^text\/html/i.test(type) && !/attachment/i.test(disposition)) {
113
+ location.reload();
114
+ }
115
+ })
116
+ .catch(function () {
117
+ enCours = false;
118
+ });
119
+ }, 30000);
120
+ }
121
+ </script>
122
+ </body>
123
+ </html>
deploiement/oracle/demarrer.sh CHANGED
@@ -2,6 +2,7 @@
2
  # Demarre (ou met a jour) JuriX, SUR la VM. deployer.sh le lance apres avoir
3
  # envoye le code ; a la main, depuis ce dossier :
4
  # bash demarrer.sh
 
5
  #
6
  # Chaque commande `docker compose exec` qui n'a rien a lire recoit </dev/null :
7
  # lance par `ssh ... bash -s`, un exec qui garde l'entree standard avalait la
@@ -9,7 +10,16 @@
9
  set -euo pipefail
10
  cd "$(dirname "$0")"
11
 
12
- echo "== 1. Le .env : present, et sans secret oublie"
 
 
 
 
 
 
 
 
 
13
  [ -f .env ] || { echo "Pas de .env : cp env.production.exemple .env, puis le renseigner (README §4)"; exit 1; }
14
  valeur() { grep -E "^$1=" .env | tail -1 | cut -d= -f2- || true; }
15
  manquants=()
@@ -25,6 +35,17 @@ if [ "${#manquants[@]}" -gt 0 ]; then
25
  echo ".env incomplet : ${manquants[*]}"
26
  exit 1
27
  fi
 
 
 
 
 
 
 
 
 
 
 
28
  # Un .env d'avant la bascule (EMBEDDING_PROVIDER=gemma, GEMMA_*) : la
29
  # composition fige voyage, mais la ligne trompe qui lit le fichier.
30
  if grep -qE '^(EMBEDDING_PROVIDER=gemma|GEMMA_)' .env; then
@@ -54,6 +75,44 @@ if [ -n "$mdp" ] && ! { [ "${#mdp}" -ge 8 ] && [ "${#mdp}" -le 100 ] \
54
  echo "ADMIN_PASSWORD refuse : 8 a 100 caracteres, dont une majuscule, une minuscule et un chiffre"
55
  exit 1
56
  fi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
57
 
58
  echo "== 2. La base, seule d'abord"
59
  docker compose up -d db
@@ -64,66 +123,117 @@ until docker compose exec -T db pg_isready -h 127.0.0.1 -U jurix -d jurix </dev/
64
  sleep 2
65
  done
66
  requete() { docker compose exec -T db psql -U jurix -d "${2:-jurix}" -tAc "$1" </dev/null; }
 
 
 
 
 
 
 
 
 
67
 
68
- echo "== 3. Restauration initiale, seulement si la base n'a AUCUNE loi"
69
- # Le nombre de lois, et non l'existence de la table : l'API cree le schema
70
- # (vide) a chaque demarrage, et un premier demarrage avant la restauration la
71
- # faisait sauter pour toujours, sans un mot.
72
- # Deux requetes, et non un CASE : PostgreSQL resout `laws` a l'analyse, meme
73
- # dans la branche non prise, et sur une base neuve la requete echouait.
74
- # Une affectation seule, puis un `case` qui n'accepte que t ou f : dans la
75
- # condition d'un `if`, `set -e` ne s'applique pas, et un psql en echec
76
- # (conteneur qui redemarre, demon Docker) passait pour « aucune table », donc
77
- # pour une base a restaurer : DROP DATABASE de la production, puis retour au
78
- # corpus du premier jour, sans un compte.
79
- existe=$(requete "SELECT to_regclass('public.laws') IS NOT NULL")
80
- case "$existe" in
81
- t) lois=$(requete "SELECT count(*) FROM laws") ;;
82
- f) lois=0 ;;
83
- *) echo "Reponse inattendue de la base (« $existe ») : arret, rien n'est touche"; exit 1 ;;
84
- esac
85
-
86
- # Un temoin pose avant le DROP, retire apres une restauration complete. Sans
87
- # lui, une restauration interrompue (coupure, memoire pendant l'index HNSW)
88
- # laissait des lois sans index ni contraintes, et la relance, qui ne compte
89
- # que les lois, prenait cette base pour saine.
90
  temoin=sauvegardes/.restauration_en_cours
91
- a_restaurer=0
92
  peuplee=0
 
 
93
  if [ -f "$temoin" ]; then
94
- [ -f sauvegardes/initial.dump ] || {
95
- echo "Restauration interrompue, et plus de sauvegardes/initial.dump : restaurer a la main (README §6)"
 
 
 
96
  exit 1
97
- }
98
- echo "La restauration precedente n'a pas abouti : elle reprend de zero"
99
- a_restaurer=1
100
- elif [ "$lois" = "0" ] && [ -f sauvegardes/initial.dump ]; then
101
- a_restaurer=1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
102
  fi
103
 
104
- if [ "$a_restaurer" = 1 ]; then
105
- echo "Restauration de sauvegardes/initial.dump dans une base neuve"
106
- touch "$temoin"
107
- docker compose stop api caddy >/dev/null 2>&1 || true
108
  requete "DROP DATABASE IF EXISTS jurix WITH (FORCE)" postgres >/dev/null
109
  requete "CREATE DATABASE jurix OWNER jurix" postgres >/dev/null
110
  # --exit-on-error : une restauration partielle ne doit pas passer pour
111
  # reussie. Dans une base neuve, aucune erreur n'est attendue.
112
  docker compose exec -T db pg_restore -U jurix -d jurix --no-owner --no-privileges \
113
- --exit-on-error < sauvegardes/initial.dump
114
  lois=$(requete "SELECT count(*) FROM laws")
115
  [ "$lois" -gt 0 ] || { echo "Restauration en echec : aucune loi"; exit 1; }
116
- # Consomme : plus aucune mise a jour ne pourra la rejouer, quoi qu'il
117
- # arrive a la base ensuite. Gardee pour memoire, sous un autre nom (hors de
118
- # la rotation de sauvegarde.sh).
119
- mv sauvegardes/initial.dump "sauvegardes/initial.restaure_$(date +%Y%m%d_%H%M).dump"
120
  rm -f "$temoin"
 
 
 
 
 
 
121
  echo "$lois lois restaurees"
122
  elif [ "$lois" = "0" ]; then
123
  echo "ATTENTION : base sans aucune loi, et pas de sauvegardes/initial.dump"
124
  else
125
  echo "Base deja peuplee ($lois lois) : pas de restauration"
126
  peuplee=1
 
 
 
 
 
 
 
 
 
 
127
  fi
128
 
129
  # La migration a8b9c0d1e2f3 (embeddings Voyage, halfvec(1024)) VIDE les
@@ -143,12 +253,21 @@ if [ "$lois" != "0" ]; then
143
  fi
144
  fi
145
 
146
- echo "== 4. API (reconstruite si le code a change) et Caddy"
147
  # Une sauvegarde AVANT une mise a jour : l'API applique les migrations a son
148
  # demarrage, et la sauvegarde nocturne peut avoir jusqu'a 24 h.
149
  if [ "$peuplee" = 1 ]; then
150
- bash sauvegarde.sh
151
  fi
 
 
 
 
 
 
 
 
 
152
  docker compose up -d --build
153
  # Caddy ne relit pas sa configuration tout seul.
154
  docker compose exec -T caddy caddy reload --config /etc/caddy/Caddyfile </dev/null >/dev/null 2>&1 \
@@ -198,4 +317,39 @@ else
198
  echo "$admins administrateur(s) deja present(s)"
199
  fi
200
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
201
  docker compose ps
 
2
  # Demarre (ou met a jour) JuriX, SUR la VM. deployer.sh le lance apres avoir
3
  # envoye le code ; a la main, depuis ce dossier :
4
  # bash demarrer.sh
5
+ # JURIX_RESTAURER=sauvegardes/<fichier>.dump bash demarrer.sh (README §6)
6
  #
7
  # Chaque commande `docker compose exec` qui n'a rien a lire recoit </dev/null :
8
  # lance par `ssh ... bash -s`, un exec qui garde l'entree standard avalait la
 
10
  set -euo pipefail
11
  cd "$(dirname "$0")"
12
 
13
+ # Un seul passage a la fois, et aucune sauvegarde pendant qu'il tourne : deux
14
+ # demarrer.sh restaureraient ou migreraient la meme base ensemble, et la
15
+ # sauvegarde de nuit copierait une base en pleine restauration. sauvegarde.sh
16
+ # prend le meme verrou, sauf lancee d'ici (JURIX_VERROU_TENU) ; le
17
+ # descripteur 9 le tient jusqu'a la fin du script.
18
+ [ -d sauvegardes ] || { echo "Pas de dossier sauvegardes/ : lancer installer.sh d'abord"; exit 1; }
19
+ exec 9>sauvegardes/.verrou
20
+ flock -n 9 || { echo "Un autre demarrer.sh, ou une sauvegarde, tourne deja : relancer une fois fini"; exit 1; }
21
+
22
+ echo "== 1. Le .env (present, et sans secret oublie) et le front envoye"
23
  [ -f .env ] || { echo "Pas de .env : cp env.production.exemple .env, puis le renseigner (README §4)"; exit 1; }
24
  valeur() { grep -E "^$1=" .env | tail -1 | cut -d= -f2- || true; }
25
  manquants=()
 
35
  echo ".env incomplet : ${manquants[*]}"
36
  exit 1
37
  fi
38
+ # Lus tels quels ici et par deployer.sh (grep, cut), alors que docker compose
39
+ # en retire guillemets et espaces : « "jurix.cm" » ne serait pas le domaine
40
+ # fige dans le front, et le controle du front plus bas echouerait sans dire
41
+ # pourquoi.
42
+ for cle in JURIX_DOMAINE GOOGLE_CLIENT_ID; do
43
+ case "$(valeur "$cle")" in
44
+ *[[:space:]\"\'\$#/]*)
45
+ printf '%s refuse dans .env : %q (ni guillemets, ni espaces, ni $, ni #, ni /)\n' "$cle" "$(valeur "$cle")"
46
+ exit 1 ;;
47
+ esac
48
+ done
49
  # Un .env d'avant la bascule (EMBEDDING_PROVIDER=gemma, GEMMA_*) : la
50
  # composition fige voyage, mais la ligne trompe qui lit le fichier.
51
  if grep -qE '^(EMBEDDING_PROVIDER=gemma|GEMMA_)' .env; then
 
75
  echo "ADMIN_PASSWORD refuse : 8 a 100 caracteres, dont une majuscule, une minuscule et un chiffre"
76
  exit 1
77
  fi
78
+ # Une restauration ne se demande qu'au lancement, jamais par un fichier pose a
79
+ # l'avance : une demande oubliee ferait sinon, au deploiement suivant, un DROP
80
+ # de la production. Verifiee ici, avant que la base ne soit touchee.
81
+ restaurer=${JURIX_RESTAURER:-}
82
+ if [ -n "$restaurer" ]; then
83
+ if [[ ! $restaurer =~ ^sauvegardes/[A-Za-z0-9._-]+\.dump$ ]] || [ ! -f "$restaurer" ]; then
84
+ printf 'JURIX_RESTAURER refuse : %q (un fichier existant, sauvegardes/<fichier>.dump)\n' "$restaurer"
85
+ exit 1
86
+ fi
87
+ fi
88
+ # Le front, envoye par deployer.sh. Controle ici, avant que la base ne soit
89
+ # touchee : la construction de son image, a l'etape 4, echouerait apres une
90
+ # eventuelle restauration. VERSION, que deployer.sh ecrit en dernier, prouve
91
+ # un envoi complet ; lu une seule fois, ici, pour le journal des deploiements.
92
+ if [ ! -f front-node/VERSION ] || [ ! -f front-node/build/index.js ] || [ ! -f front-node/package.json ]; then
93
+ echo "front-node/ incomplet (VERSION, build/index.js ou package.json manquant) : le front s'envoie par deployer.sh (README §5)"
94
+ exit 1
95
+ fi
96
+ read -r backend_envoye front_envoye date_envoi < front-node/VERSION
97
+ echo "Front : commit $front_envoye, envoye le $date_envoi avec le backend $backend_envoye"
98
+ # Le code et le front d'un meme envoi : deployer.sh ajoute BACKEND_VERSION a
99
+ # l'archive du code. Un deploiement coupe entre l'envoi du front et celui du
100
+ # code laisserait sinon l'un d'un envoi, l'autre du precedent.
101
+ [ -f BACKEND_VERSION ] || { echo "Pas de BACKEND_VERSION : ce code n'a pas ete envoye par deployer.sh"; exit 1; }
102
+ if [ "$(cat BACKEND_VERSION)" != "$backend_envoye" ]; then
103
+ echo "Code du backend $(cat BACKEND_VERSION), front envoye avec le backend $backend_envoye : deux envois differents, relancer deployer.sh"
104
+ exit 1
105
+ fi
106
+ # Construit pour le domaine de CE .env, d'ou viennent ORIGIN et
107
+ # ALLOWED_ORIGINS : sinon les pages s'affichent, mais le navigateur envoie ses
108
+ # appels a l'API (recherche, connexion, chat) a un autre domaine.
109
+ if ! grep -rqF -- "https://$(valeur JURIX_DOMAINE)" front-node/build/client/_app; then
110
+ echo "front-node/ n'est pas construit pour https://$(valeur JURIX_DOMAINE), le JURIX_DOMAINE du .env : relancer deployer.sh avec ce domaine"
111
+ exit 1
112
+ fi
113
+ # La page d'attente de Caddy : absente, une panne du front ou de l'API
114
+ # s'afficherait en erreur vide.
115
+ [ -f caddy/maintenance.html ] || { echo "Pas de caddy/maintenance.html : redeployer depuis un depot ou elle est commitee"; exit 1; }
116
 
117
  echo "== 2. La base, seule d'abord"
118
  docker compose up -d db
 
123
  sleep 2
124
  done
125
  requete() { docker compose exec -T db psql -U jurix -d "${2:-jurix}" -tAc "$1" </dev/null; }
126
+ # sauvegarde.sh, sous le verrou deja tenu, et le nom du fichier, lu dans la
127
+ # ligne qu'il ecrit : le journal le donne tel que JURIX_RESTAURER l'attend.
128
+ sauvegarder() {
129
+ local rapport motif=' sauvegarde (sauvegardes/jurix_[0-9_]+\.dump) '
130
+ rapport=$(JURIX_VERROU_TENU=1 bash sauvegarde.sh)
131
+ echo "$rapport"
132
+ [[ $rapport =~ $motif ]] || { echo "Nom de la sauvegarde introuvable dans : $rapport"; exit 1; }
133
+ sauvegarde_avant=${BASH_REMATCH[1]}
134
+ }
135
 
136
+ echo "== 3. Restauration : premier deploiement, demande, ou reprise"
137
+ # La base n'est jetee (DROP) que dans trois cas : elle n'a aucune loi et
138
+ # sauvegardes/initial.dump existe (premier deploiement) ; JURIX_RESTAURER le
139
+ # demande a ce lancement (une base qui a des lois est d'abord sauvegardee) ;
140
+ # ou une restauration interrompue reprend.
141
+ # Le temoin n'est ecrit que par ce script, juste avant le DROP, et porte le
142
+ # chemin du dump : la relance apres une coupure (memoire pendant l'index HNSW,
143
+ # reseau) reprend la meme restauration, de zero, sans qu'on la redemande. Lu
144
+ # AVANT toute requete sur la base jurix : coupee entre le DROP et le CREATE,
145
+ # la restauration laisse une base absente, que la premiere requete ferait
146
+ # echouer.
 
 
 
 
 
 
 
 
 
 
 
147
  temoin=sauvegardes/.restauration_en_cours
148
+ a_restaurer=
149
  peuplee=0
150
+ sauvegarde_avant=-
151
+ revision_avant=-
152
  if [ -f "$temoin" ]; then
153
+ a_restaurer=$(cat "$temoin")
154
+ # Vide : un temoin d'une version precedente, qui ne portait pas de chemin.
155
+ [ -n "$a_restaurer" ] || a_restaurer=sauvegardes/initial.dump
156
+ if [ -n "$restaurer" ] && [ "$restaurer" != "$a_restaurer" ]; then
157
+ echo "Restauration interrompue de $a_restaurer : la terminer d'abord (bash demarrer.sh, sans JURIX_RESTAURER)"
158
  exit 1
159
+ fi
160
+ [ -f "$a_restaurer" ] || { echo "Restauration interrompue de $a_restaurer, introuvable : restaurer a la main (README §6)"; exit 1; }
161
+ echo "Restauration interrompue de $a_restaurer : elle reprend de zero"
162
+ else
163
+ # Le nombre de lois, et non l'existence de la table : l'API cree le schema
164
+ # (vide) a chaque demarrage, et un premier demarrage avant la restauration
165
+ # la faisait sauter pour toujours, sans un mot.
166
+ # Deux requetes, et non un CASE : PostgreSQL resout `laws` a l'analyse,
167
+ # meme dans la branche non prise, et sur une base neuve la requete
168
+ # echouait.
169
+ # Une affectation seule, puis un `case` qui n'accepte que t ou f : dans la
170
+ # condition d'un `if`, `set -e` ne s'applique pas, et un psql en echec
171
+ # (conteneur qui redemarre, demon Docker) passait pour « aucune table »,
172
+ # donc pour une base a restaurer : DROP DATABASE de la production, puis
173
+ # retour au corpus du premier jour, sans un compte.
174
+ existe=$(requete "SELECT to_regclass('public.laws') IS NOT NULL")
175
+ case "$existe" in
176
+ t) lois=$(requete "SELECT count(*) FROM laws") ;;
177
+ f) lois=0 ;;
178
+ *) echo "Reponse inattendue de la base (« $existe ») : arret, rien n'est touche"; exit 1 ;;
179
+ esac
180
+ # La revision de la base avant ce passage, pour le journal : avec la
181
+ # sauvegarde d'avant, elle dit quel etat restaurer pour revenir en arriere.
182
+ alembic=$(requete "SELECT to_regclass('public.alembic_version') IS NOT NULL")
183
+ case "$alembic" in
184
+ t) revision_avant=$(requete "SELECT coalesce(string_agg(version_num, ','), '-') FROM alembic_version") ;;
185
+ f) revision_avant=- ;;
186
+ *) echo "Reponse inattendue de la base (« $alembic ») : arret, rien n'est touche"; exit 1 ;;
187
+ esac
188
+ if [ -n "$restaurer" ]; then
189
+ if [ "$lois" != "0" ]; then
190
+ echo "Base peuplee ($lois lois) : sauvegardee avant de restaurer $restaurer"
191
+ sauvegarder
192
+ fi
193
+ a_restaurer=$restaurer
194
+ elif [ "$lois" = "0" ] && [ -f sauvegardes/initial.dump ]; then
195
+ a_restaurer=sauvegardes/initial.dump
196
+ fi
197
  fi
198
 
199
+ if [ -n "$a_restaurer" ]; then
200
+ echo "Restauration de $a_restaurer dans une base neuve"
201
+ docker compose stop api front caddy >/dev/null 2>&1 || true
202
+ printf '%s\n' "$a_restaurer" > "$temoin"
203
  requete "DROP DATABASE IF EXISTS jurix WITH (FORCE)" postgres >/dev/null
204
  requete "CREATE DATABASE jurix OWNER jurix" postgres >/dev/null
205
  # --exit-on-error : une restauration partielle ne doit pas passer pour
206
  # reussie. Dans une base neuve, aucune erreur n'est attendue.
207
  docker compose exec -T db pg_restore -U jurix -d jurix --no-owner --no-privileges \
208
+ --exit-on-error < "$a_restaurer"
209
  lois=$(requete "SELECT count(*) FROM laws")
210
  [ "$lois" -gt 0 ] || { echo "Restauration en echec : aucune loi"; exit 1; }
211
+ # Le temoin d'abord : coupe juste apres, le script laisse au pire un
212
+ # initial.dump sans temoin, que la relance, devant une base peuplee, met
213
+ # de cote (initial.ignore_), et non un temoin sans son dump.
 
214
  rm -f "$temoin"
215
+ # initial.dump consomme : plus aucune mise a jour ne pourra le rejouer,
216
+ # quoi qu'il arrive a la base ensuite. Garde pour memoire, sous un autre
217
+ # nom (hors de la rotation de sauvegarde.sh).
218
+ if [ "$a_restaurer" = sauvegardes/initial.dump ]; then
219
+ mv sauvegardes/initial.dump "sauvegardes/initial.restaure_$(date +%Y%m%d_%H%M%S).dump"
220
+ fi
221
  echo "$lois lois restaurees"
222
  elif [ "$lois" = "0" ]; then
223
  echo "ATTENTION : base sans aucune loi, et pas de sauvegardes/initial.dump"
224
  else
225
  echo "Base deja peuplee ($lois lois) : pas de restauration"
226
  peuplee=1
227
+ # Un initial.dump arrive sur une base deja peuplee (deployer.sh relance
228
+ # avec --avec-donnees) n'a pas servi. Laisse la, il serait restaure par la
229
+ # premiere relance qui trouverait la base sans loi : DROP DATABASE, et
230
+ # retour a ce corpus, sans les comptes crees depuis. Le fichier reste, sous
231
+ # un autre nom, hors de la rotation de sauvegarde.sh.
232
+ if [ -f sauvegardes/initial.dump ]; then
233
+ ignore="sauvegardes/initial.ignore_$(date +%Y%m%d_%H%M%S).dump"
234
+ mv sauvegardes/initial.dump "$ignore"
235
+ echo "sauvegardes/initial.dump inutilise, la base etant deja peuplee : renomme en $ignore"
236
+ fi
237
  fi
238
 
239
  # La migration a8b9c0d1e2f3 (embeddings Voyage, halfvec(1024)) VIDE les
 
253
  fi
254
  fi
255
 
256
+ echo "== 4. API et front (reconstruits si leur code a change), et Caddy"
257
  # Une sauvegarde AVANT une mise a jour : l'API applique les migrations a son
258
  # demarrage, et la sauvegarde nocturne peut avoir jusqu'a 24 h.
259
  if [ "$peuplee" = 1 ]; then
260
+ sauvegarder
261
  fi
262
+ # Le journal des deploiements (README §5) : « tentative » avant de remplacer
263
+ # l'API et le front, « ok » une fois le rendu controle. La derniere ligne,
264
+ # l'une ou l'autre, est la version qui tourne ; la sauvegarde et la revision
265
+ # d'avant disent quel etat restaurer pour revenir avant ce passage.
266
+ journal() {
267
+ printf '%s %s %s %s %s %s\n' "$(date -Is)" "$1" "$backend_envoye" "$front_envoye" \
268
+ "$sauvegarde_avant" "$revision_avant" >> sauvegardes/deploiements.log
269
+ }
270
+ journal tentative
271
  docker compose up -d --build
272
  # Caddy ne relit pas sa configuration tout seul.
273
  docker compose exec -T caddy caddy reload --config /etc/caddy/Caddyfile </dev/null >/dev/null 2>&1 \
 
317
  echo "$admins administrateur(s) deja present(s)"
318
  fi
319
 
320
+ echo "== 7. Rendu serveur du front"
321
+ # La sonde du front ne lit qu'un fichier du build : un front qui ne joint pas
322
+ # l'API la passe, et sert pourtant ses pages en 503. Controle depuis son
323
+ # conteneur, sans Caddy : /laws (load serveur) doit lier des fiches, sans son
324
+ # bloc d'erreur, et une fiche (load universel, l'autre chemin vers l'API)
325
+ # repondre 200 avec un titre. Un front construit pour un autre domaine
326
+ # passerait ici (seuls les appels du navigateur se trompent d'adresse) :
327
+ # l'etape 1 le refuse.
328
+ # -T 15 : sans delai, wget attendrait jusqu'a 900 s une reponse qui ne vient pas.
329
+ page() { docker compose exec -T front wget -q -T 15 -O- "http://127.0.0.1:3000$1" </dev/null; }
330
+ # Le front vient peut-etre d'etre recree : il a une minute pour repondre.
331
+ limite=$((SECONDS + 60))
332
+ liste=""
333
+ until liste=$(page /laws 2>&1); do
334
+ erreur=$liste
335
+ liste=""
336
+ [ "$SECONDS" -lt "$limite" ] || break
337
+ sleep 2
338
+ done
339
+ [ -n "$liste" ] || { echo "ECHEC : le front ne rend pas /laws (${erreur:-?}) : docker compose logs front api"; exit 1; }
340
+ if [[ $liste == *laws-retry* ]]; then
341
+ echo "ECHEC : /laws porte son bloc d'erreur (laws-retry) : le front n'a pas eu la reponse de l'API"
342
+ exit 1
343
+ fi
344
+ lien='href="/laws/([0-9]+)"'
345
+ [[ $liste =~ $lien ]] || { echo "ECHEC : /laws ne lie aucune fiche (href=\"/laws/<numero>\") : base vide, ou rendu casse"; exit 1; }
346
+ id=${BASH_REMATCH[1]}
347
+ fiche=$(page "/laws/$id" 2>&1) || { echo "ECHEC : /laws/$id ne repond pas 200 ($fiche) : docker compose logs front api"; exit 1; }
348
+ titre='<title>[^<]+</title>'
349
+ [[ $fiche =~ $titre ]] || { echo "ECHEC : /laws/$id rendue sans <title>"; exit 1; }
350
+ echo "Rendu serveur : /laws et /laws/$id complets"
351
+
352
+ journal ok
353
+ echo "Journal des deploiements : $(tail -n 1 sauvegardes/deploiements.log)"
354
+
355
  docker compose ps
deploiement/oracle/deployer.sh CHANGED
@@ -3,28 +3,75 @@
3
  #
4
  # JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@IP
5
  # JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@IP --avec-donnees
 
6
  #
7
- # Sans option : le code COMMITE du backend (git archive, jamais les fichiers
8
- # locaux, donc jamais un .env), le front reconstruit pour le domaine, puis
9
- # `docker compose up -d --build`.
10
  # --avec-donnees, au premier deploiement : en plus, les PDF (rsync,
11
  # reprenable) et la base (dump de jurix_dev, restaure seulement si la base de
12
  # la VM est vide).
 
 
 
13
  #
14
  # Prerequis :
15
  # - sur la VM : installer.sh deja lance, et deploiement/oracle/.env renseigne
16
- # (voir env.production.exemple) ;
17
- # - ici : le depot du front a cote de celui-ci (ou JURIX_FRONT), sur la branche
18
- # du site statique, avec ses node_modules ; pour --avec-donnees, le conteneur
19
- # local jurix-pg demarre, et jurix_dev a la derniere migration, ses vecteurs
20
- # Voyage charges (scripts/regenerate_embeddings.py --depuis-lots ou --all).
 
 
21
  # JURIX_GOOGLE_CLIENT_ID : l'identifiant OAuth Google (fige dans le front au
22
  # build). Facultatif : a defaut, GOOGLE_CLIENT_ID du .env de la VM.
23
  set -euo pipefail
24
 
25
- CIBLE=${1:?usage : JURIX_DOMAINE=... deployer.sh utilisateur@ip [--avec-donnees]}
26
- AVEC_DONNEES=${2:-}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
27
  : "${JURIX_DOMAINE:?renseigner JURIX_DOMAINE (le domaine du site)}"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
28
 
29
  RACINE=$(cd "$(dirname "$0")/../.." && pwd)
30
  FRONT=${JURIX_FRONT:-$RACINE/../JuriX-frontend-main}
@@ -36,36 +83,36 @@ RSYNC=(rsync -az --partial --info=progress2 -e "ssh -i $CLE -o StrictHostKeyChec
36
  # pas forcement celui de la VM : l'envoi se fait en root, cote VM.
37
  RSYNC_ROOT=("${RSYNC[@]}" --rsync-path="sudo rsync")
38
 
39
- # jurix_dev doit etre a la derniere migration du code COMMITE, ses vecteurs
40
- # tous a jour pour le modele du code commite. Un dump d'avant la bascule serait
41
  # restaure, puis migre au demarrage du conteneur : la migration a8b9c0d1e2f3
42
  # viderait ses vecteurs EN PRODUCTION, et la VM n'a pas data/mesure_voyage
43
  # pour les recharger. Un vecteur manquant y resterait manquant : rien, sur la
44
  # VM, ne le calcule.
45
  controler_jurix_dev() {
46
- # Le code envoye est celui de HEAD : une modification non commitee de
47
- # alembic/ ou de app/ (modele, empreinte) fausserait le controle.
48
- if [ -n "$(git -C "$RACINE" status --porcelain -- alembic app)" ]; then
49
- echo "Modifications non commitees sous alembic/ ou app/ : commiter d'abord, le code envoye est celui de HEAD"
50
- exit 1
51
- fi
52
- # Lance depuis un dossier vide : sans le .env local, la tete et
53
- # l'empreinte sont celles des reglages par defaut du code, ceux de la VM.
54
  # `|| true` : un echec laisse les variables vides, et le controle plus bas
55
  # le dit, au lieu d'un arret muet de `set -e`.
56
  local vide tete empreinte version etrangers manquants vectorises
57
  vide=$(mktemp -d)
 
 
58
  read -r tete empreinte < <(cd "$vide" && env -u VOYAGE_EMBEDDING_MODEL -u EMBEDDING_PROVIDER \
59
- PYTHONPATH="$RACINE" "$RACINE/.venv/bin/python" -c "
60
  from alembic.config import Config
61
  from alembic.script import ScriptDirectory
62
  from app.core.config import settings
63
  from app.services.embedding_service import empreinte_voyage
64
- config = Config('$RACINE/alembic.ini')
65
- config.set_main_option('script_location', '$RACINE/alembic')
66
  print('TETE', ScriptDirectory.from_config(config).get_current_head(), empreinte_voyage(settings.VOYAGE_EMBEDDING_MODEL))" 2>/dev/null \
67
  | grep '^TETE ' | cut -d' ' -f2-) || true
68
- rmdir "$vide"
69
  read -r version etrangers manquants vectorises < <(docker exec jurix-pg psql -U jurix -d jurix_dev -tA -F ' ' -c \
70
  "SELECT (SELECT version_num FROM alembic_version),
71
  count(*) FILTER (WHERE embedding IS NOT NULL AND embedding_model IS DISTINCT FROM '$empreinte'),
@@ -74,26 +121,193 @@ print('TETE', ScriptDirectory.from_config(config).get_current_head(), empreinte_
74
  FROM articles") || true
75
  if [ -z "$tete" ] || [ -z "$empreinte" ] || [ "$version" != "$tete" ] \
76
  || [ "$etrangers" != "0" ] || [ "$manquants" != "0" ] || [ "${vectorises:-0}" = "0" ]; then
77
- echo "jurix_dev n'est pas pret : migration ${version:-?} (attendue ${tete:-?}), ${etrangers:-?} vecteur(s) hors ${empreinte:-?}, ${manquants:-?} manquant(s), ${vectorises:-?} vecteur(s)"
78
- echo " -> scripts/regenerate_embeddings.py --all (puis --reindex) sur jurix_dev"
 
 
 
 
79
  exit 1
80
  fi
81
  }
82
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
83
  if [ "$AVEC_DONNEES" = "--avec-donnees" ]; then
84
- echo "== 0. jurix_dev : derniere migration, vecteurs a jour (avant tout envoi)"
85
  controler_jurix_dev
86
  fi
87
 
88
- echo "== 1. Code du backend (etat commite de $(git -C "$RACINE" rev-parse --short HEAD))"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
89
  # Extrait a cote, puis aligne avec rsync --delete : un `tar -x` direct n'effacait
90
  # rien, et un fichier supprime du depot restait sur la VM, jusque dans l'image.
91
- # Les donnees de la VM (.env, PDF, sauvegardes, front, et l'ancien modele
92
- # EmbeddingGemma d'une VM d'avant la bascule, que son API en place monte
93
- # encore) sont exclues :
94
- # rsync ne les touche pas.
95
- git -C "$RACINE" archive --format=tar HEAD | "${SSH[@]}" "$CIBLE" 'set -e
96
- rm -rf jurix.nouveau && mkdir jurix.nouveau && tar -x -C jurix.nouveau
 
 
 
 
 
 
 
 
 
 
 
 
97
  mkdir -p jurix
98
  rsync -a --delete \
99
  --exclude=/deploiement/oracle/.env \
@@ -101,27 +315,20 @@ git -C "$RACINE" archive --format=tar HEAD | "${SSH[@]}" "$CIBLE" 'set -e
101
  --exclude=/deploiement/oracle/donnees/ \
102
  --exclude=/deploiement/oracle/sauvegardes/ \
103
  --exclude=/deploiement/oracle/front/ \
104
- jurix.nouveau/ jurix/
105
- rm -rf jurix.nouveau'
106
-
107
- echo "== 2. Front, construit pour https://$JURIX_DOMAINE"
108
- # L'identifiant Google est fige dans le front a la construction. Sans
109
- # JURIX_GOOGLE_CLIENT_ID ici, il est repris du .env de la VM : sinon chaque
110
- # mise a jour faite sans la variable retirait la connexion Google, en silence.
111
- GOOGLE_ID=${JURIX_GOOGLE_CLIENT_ID:-$("${SSH[@]}" "$CIBLE" \
112
- "grep -E '^GOOGLE_CLIENT_ID=' $DISTANT/.env 2>/dev/null | tail -1 | cut -d= -f2-" || true)}
113
- echo "Connexion Google : $([ -n "$GOOGLE_ID" ] && echo activee || echo absente)"
114
- ( cd "$FRONT" && VITE_API_URL="https://$JURIX_DOMAINE" \
115
- VITE_GOOGLE_CLIENT_ID="$GOOGLE_ID" npm run build >/dev/null )
116
- "${RSYNC[@]}" --delete "$FRONT/build/" "$CIBLE:$DISTANT/front/"
117
 
118
  if [ "$AVEC_DONNEES" = "--avec-donnees" ]; then
119
- echo "== 3. PDF d'origine (reprenable : relancer en cas de coupure)"
120
  "${RSYNC_ROOT[@]}" "$RACINE/data/uploads/" "$CIBLE:$DISTANT/donnees/uploads/"
121
 
122
- echo "== 4. Base : dump de jurix_dev, SANS les comptes ni les conversations"
123
- # Le meme controle qu'a l'etape 0, refait : l'envoi des PDF dure des
124
- # heures, et jurix_dev a pu changer entre-temps.
 
125
  controler_jurix_dev
126
  # Le corpus seulement. Les comptes de developpement (et leurs mots de
127
  # passe d'essai), leurs conversations, jetons et caches resteraient sinon
@@ -139,12 +346,13 @@ if [ "$AVEC_DONNEES" = "--avec-donnees" ]; then
139
  rm -f "$dump"
140
  fi
141
 
142
- echo "== 5. Demarrage sur la VM (demarrer.sh)"
143
  # Un FICHIER lance par ssh, et non un script passe sur l'entree standard : un
144
  # `docker compose exec` y avalait la suite, et rien apres lui ne s'executait.
145
- # JURIX_PURGER_VECTEURS : seule la VM le lit (demarrer.sh), ssh ne transmet
146
- # pas l'environnement local.
147
- "${SSH[@]}" "$CIBLE" "sudo chown -R 1000:1000 $DISTANT/donnees && JURIX_PURGER_VECTEURS=${JURIX_PURGER_VECTEURS:-} bash $DISTANT/demarrer.sh"
 
148
 
149
  echo
150
  echo "Verifier : https://$JURIX_DOMAINE et https://$JURIX_DOMAINE/health"
 
3
  #
4
  # JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@IP
5
  # JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@IP --avec-donnees
6
+ # JURIX_DOMAINE=jurix.exemple.cm deploiement/oracle/deployer.sh ubuntu@IP --restaurer sauvegardes/<fichier>.dump
7
  #
8
+ # Sans option : le front construit pour le domaine, d'abord, puis le code
9
+ # COMMITE du backend (git archive, jamais les fichiers locaux, donc jamais un
10
+ # .env), et `docker compose up -d --build`.
11
  # --avec-donnees, au premier deploiement : en plus, les PDF (rsync,
12
  # reprenable) et la base (dump de jurix_dev, restaure seulement si la base de
13
  # la VM est vide).
14
+ # --restaurer : demarrer.sh restaure ce dump de la VM (apres avoir sauvegarde
15
+ # la base en place) avant de demarrer la nouvelle API ; le retour en arriere
16
+ # par-dessus une migration (README §5).
17
  #
18
  # Prerequis :
19
  # - sur la VM : installer.sh deja lance, et deploiement/oracle/.env renseigne
20
+ # (voir env.production.exemple), avec le MEME JURIX_DOMAINE qu'ici ;
21
+ # - ici : deploiement/oracle tout commite ; le depot du front a cote de
22
+ # celui-ci (ou JURIX_FRONT), sur la branche du rendu serveur (adapter-node),
23
+ # tout commite (`npm ci` y remplace ses node_modules) ; pour --avec-donnees,
24
+ # le conteneur local jurix-pg demarre, et jurix_dev a la derniere migration
25
+ # du commit envoye, ses vecteurs Voyage charges
26
+ # (scripts/regenerate_embeddings.py --depuis-lots ou --all).
27
  # JURIX_GOOGLE_CLIENT_ID : l'identifiant OAuth Google (fige dans le front au
28
  # build). Facultatif : a defaut, GOOGLE_CLIENT_ID du .env de la VM.
29
  set -euo pipefail
30
 
31
+ CIBLE=${1:?usage : JURIX_DOMAINE=... deployer.sh utilisateur@ip [--avec-donnees | --restaurer sauvegardes/<fichier>.dump]}
32
+ shift
33
+ AVEC_DONNEES=
34
+ RESTAURER=
35
+ while [ "$#" -gt 0 ]; do
36
+ case "$1" in
37
+ --avec-donnees) AVEC_DONNEES=--avec-donnees ;;
38
+ --restaurer) RESTAURER=${2:?--restaurer : donner sauvegardes/<fichier>.dump}; shift ;;
39
+ *) echo "Option inconnue : $1"; exit 1 ;;
40
+ esac
41
+ shift
42
+ done
43
+ # Le chemin part dans la commande ssh de l'etape 8 : un nom de fichier sous
44
+ # sauvegardes/, rien d'autre. Et l'un ou l'autre : --avec-donnees remplace
45
+ # initial.dump, --restaurer en restaure un autre.
46
+ if [ -n "$RESTAURER" ]; then
47
+ if [[ ! $RESTAURER =~ ^sauvegardes/[A-Za-z0-9._-]+\.dump$ ]]; then
48
+ printf -- '--restaurer refuse : %q (attendu : sauvegardes/<fichier>.dump)\n' "$RESTAURER"
49
+ exit 1
50
+ fi
51
+ if [ -n "$AVEC_DONNEES" ]; then
52
+ echo "--avec-donnees et --restaurer ensemble : l'un ou l'autre"
53
+ exit 1
54
+ fi
55
+ fi
56
  : "${JURIX_DOMAINE:?renseigner JURIX_DOMAINE (le domaine du site)}"
57
+ # Valeurs lues telles quelles, ici et dans le .env de la VM (grep, cut), alors
58
+ # que docker compose en retire guillemets et espaces : « "jurix.cm" » ne
59
+ # serait pas le meme domaine des deux cotes, et partirait tel quel dans le
60
+ # front. Refusees plutot que nettoyees : un seul texte fait foi.
61
+ refuser_si_brute() {
62
+ case "$2" in
63
+ *[[:space:]\"\'\$#/]*)
64
+ printf '%s refuse : %q (ni guillemets, ni espaces, ni $, ni #, ni /)\n' "$1" "$2"
65
+ exit 1 ;;
66
+ esac
67
+ }
68
+ refuser_si_brute JURIX_DOMAINE "$JURIX_DOMAINE"
69
+ # Le domaine d'exemple, fige dans le front, enverrait le navigateur vers un
70
+ # domaine que n'importe qui peut acheter.
71
+ if [ "$JURIX_DOMAINE" = "jurix.exemple.cm" ]; then
72
+ echo "JURIX_DOMAINE vaut jurix.exemple.cm, le domaine d'exemple : donner celui du site"
73
+ exit 1
74
+ fi
75
 
76
  RACINE=$(cd "$(dirname "$0")/../.." && pwd)
77
  FRONT=${JURIX_FRONT:-$RACINE/../JuriX-frontend-main}
 
83
  # pas forcement celui de la VM : l'envoi se fait en root, cote VM.
84
  RSYNC_ROOT=("${RSYNC[@]}" --rsync-path="sudo rsync")
85
 
86
+ # jurix_dev doit etre a la derniere migration du commit ENVOYE, ses vecteurs
87
+ # tous a jour pour le modele de ce commit. Un dump d'avant la bascule serait
88
  # restaure, puis migre au demarrage du conteneur : la migration a8b9c0d1e2f3
89
  # viderait ses vecteurs EN PRODUCTION, et la VM n'a pas data/mesure_voyage
90
  # pour les recharger. Un vecteur manquant y resterait manquant : rien, sur la
91
  # VM, ne le calcule.
92
  controler_jurix_dev() {
93
+ # Le code du commit envoye ($backend_sha), extrait a part, et non la copie
94
+ # de travail : une migration ajoutee depuis, commitee ou non, passerait
95
+ # sinon pour attendue, et la VM recevrait un dump plus migre que son code.
96
+ # Le dossier n'a pas de .env : la tete et l'empreinte sont celles des
97
+ # reglages par defaut de ce code, ceux de la VM ; le venv local ne fournit
98
+ # que les bibliotheques.
 
 
99
  # `|| true` : un echec laisse les variables vides, et le controle plus bas
100
  # le dit, au lieu d'un arret muet de `set -e`.
101
  local vide tete empreinte version etrangers manquants vectorises
102
  vide=$(mktemp -d)
103
+ git -C "$RACINE" archive "$backend_sha" alembic alembic.ini app | tar -x -C "$vide" \
104
+ || { rm -rf "$vide"; echo "Extraction d'alembic/ et d'app/ du commit $backend_sha impossible"; exit 1; }
105
  read -r tete empreinte < <(cd "$vide" && env -u VOYAGE_EMBEDDING_MODEL -u EMBEDDING_PROVIDER \
106
+ PYTHONPATH="$vide" "$RACINE/.venv/bin/python" -c "
107
  from alembic.config import Config
108
  from alembic.script import ScriptDirectory
109
  from app.core.config import settings
110
  from app.services.embedding_service import empreinte_voyage
111
+ config = Config('$vide/alembic.ini')
112
+ config.set_main_option('script_location', '$vide/alembic')
113
  print('TETE', ScriptDirectory.from_config(config).get_current_head(), empreinte_voyage(settings.VOYAGE_EMBEDDING_MODEL))" 2>/dev/null \
114
  | grep '^TETE ' | cut -d' ' -f2-) || true
115
+ rm -rf "$vide"
116
  read -r version etrangers manquants vectorises < <(docker exec jurix-pg psql -U jurix -d jurix_dev -tA -F ' ' -c \
117
  "SELECT (SELECT version_num FROM alembic_version),
118
  count(*) FILTER (WHERE embedding IS NOT NULL AND embedding_model IS DISTINCT FROM '$empreinte'),
 
121
  FROM articles") || true
122
  if [ -z "$tete" ] || [ -z "$empreinte" ] || [ "$version" != "$tete" ] \
123
  || [ "$etrangers" != "0" ] || [ "$manquants" != "0" ] || [ "${vectorises:-0}" = "0" ]; then
124
+ echo "jurix_dev n'est pas pret pour le commit $backend_sha : migration ${version:-?} (attendue ${tete:-?}), ${etrangers:-?} vecteur(s) hors ${empreinte:-?}, ${manquants:-?} manquant(s), ${vectorises:-?} vecteur(s)"
125
+ if [ -n "$tete" ] && [ "${version:-}" != "$tete" ]; then
126
+ echo " -> jurix_dev et le commit envoye doivent avoir la meme tete : commiter puis deployer la migration, ou ramener jurix_dev (alembic downgrade)"
127
+ else
128
+ echo " -> scripts/regenerate_embeddings.py --all (puis --reindex) sur jurix_dev"
129
+ fi
130
  exit 1
131
  fi
132
  }
133
 
134
+ echo "== 1. Fichiers de deploiement commites, VM joignable, meme domaine"
135
+ # La VM recoit le code de HEAD (git archive), mais ce script se lit dans la
136
+ # copie de travail : un fichier de deploiement modifie partirait dans sa
137
+ # version de HEAD, et un fichier non suivi (une page, un script) pas du tout.
138
+ etat_deploiement=$(git -C "$RACINE" status --porcelain -- deploiement/oracle)
139
+ if [ -n "$etat_deploiement" ]; then
140
+ echo "Modifications non commitees sous deploiement/oracle : commiter d'abord, la VM recoit HEAD"
141
+ printf '%s\n' "$etat_deploiement"
142
+ exit 1
143
+ fi
144
+ # Ailleurs dans le backend, un simple avertissement : seul HEAD part.
145
+ autres=$(git -C "$RACINE" status --porcelain | wc -l)
146
+ if [ "$autres" -gt 0 ]; then
147
+ echo "ATTENTION : $autres fichier(s) modifie(s) ou non suivi(s) dans le backend : ils ne partent pas, seul HEAD est envoye"
148
+ fi
149
+ # Le commit envoye, releve une fois pour toutes, avant le premier controle de
150
+ # jurix_dev : l'archive (etape 5), VERSION et ces controles nomment le meme,
151
+ # meme si HEAD bouge pendant le deploiement.
152
+ backend_sha=$(git -C "$RACINE" rev-parse --short=12 HEAD)
153
+ echo "Backend : etat commite de $backend_sha"
154
+ # L'archive de l'etape 5 porte BACKEND_VERSION (--add-virtual-file, git 2.39
155
+ # au moins). Essaye ici, sur un seul fichier : un git trop ancien echouerait
156
+ # sinon a l'etape 5, le front deja echange sur la VM.
157
+ git -C "$RACINE" archive --add-virtual-file=essai:x "$backend_sha" -- deploiement/oracle/demarrer.sh >/dev/null 2>&1 \
158
+ || { echo "$(git --version) : git archive --add-virtual-file manque (git 2.39 au moins)"; exit 1; }
159
+ # Le domaine fige dans le front (VITE_API_URL) doit etre celui de la VM, d'ou
160
+ # viennent ORIGIN et ALLOWED_ORIGINS : sinon les pages s'affichent, mais le
161
+ # navigateur envoie ses appels a l'API (recherche, connexion, chat) a un autre
162
+ # domaine. Lu dans le .env de la VM, ou il n'est pas un secret ; premier
163
+ # contact ssh, il verifie aussi que la VM repond, avant tout travail.
164
+ domaine_vm=$("${SSH[@]}" "$CIBLE" "grep -E '^JURIX_DOMAINE=' $DISTANT/.env 2>/dev/null | tail -1 | cut -d= -f2-") \
165
+ || { echo "VM injoignable ($CIBLE) : ssh a echoue"; exit 1; }
166
+ if [ -z "$domaine_vm" ]; then
167
+ echo "Pas de JURIX_DOMAINE dans $DISTANT/.env sur la VM : le renseigner d'abord (README §4)"
168
+ exit 1
169
+ fi
170
+ refuser_si_brute "JURIX_DOMAINE du .env de la VM" "$domaine_vm"
171
+ if [ "$domaine_vm" != "$JURIX_DOMAINE" ]; then
172
+ printf 'JURIX_DOMAINE differe : %q ici, %q dans le .env de la VM\n' "$JURIX_DOMAINE" "$domaine_vm"
173
+ exit 1
174
+ fi
175
+ # Une restauration coupee sur la VM se termine avec le code qui l'a
176
+ # commencee : envoyer un autre code d'abord, c'est la reprendre avec lui, ou
177
+ # l'abandonner sur une base jetee.
178
+ temoin_vm=$("${SSH[@]}" "$CIBLE" "if [ -e $DISTANT/sauvegardes/.restauration_en_cours ]; then echo present; fi") \
179
+ || { echo "VM injoignable ($CIBLE) : ssh a echoue"; exit 1; }
180
+ if [ -n "$temoin_vm" ]; then
181
+ echo "Restauration interrompue sur la VM : la terminer d'abord (bash demarrer.sh sur la VM)"
182
+ exit 1
183
+ fi
184
+ if [ -n "$RESTAURER" ]; then
185
+ "${SSH[@]}" "$CIBLE" "test -f $DISTANT/$RESTAURER" \
186
+ || { echo "--restaurer : $RESTAURER introuvable sur la VM (ou ssh en echec)"; exit 1; }
187
+ fi
188
+
189
  if [ "$AVEC_DONNEES" = "--avec-donnees" ]; then
190
+ echo "== 2. jurix_dev : derniere migration, vecteurs a jour (avant tout envoi)"
191
  controler_jurix_dev
192
  fi
193
 
194
+ echo "== 3. Front, construit pour https://$JURIX_DOMAINE (avant tout envoi)"
195
+ # Construit et controle avant que rien ne parte vers la VM : un build en echec
196
+ # apres l'envoi du code y laisserait une composition qui attend un front-node/
197
+ # absent ou perime.
198
+ # L'etat commite seulement, comme pour le backend : un build fait d'une copie
199
+ # de travail modifiee ne correspondrait a aucun commit, et on ne saurait plus
200
+ # le refaire pour revenir en arriere.
201
+ etat_front=$(git -C "$FRONT" status --porcelain) \
202
+ || { echo "$FRONT n'est pas un depot git : JURIX_FRONT doit designer le depot du front"; exit 1; }
203
+ if [ -n "$etat_front" ]; then
204
+ echo "Modifications non commitees dans le front ($FRONT) : commiter d'abord, le front envoye doit etre un commit"
205
+ printf '%s\n' "$etat_front"
206
+ exit 1
207
+ fi
208
+ front_sha=$(git -C "$FRONT" rev-parse --short=12 HEAD)
209
+ echo "Front : etat commite de $front_sha"
210
+ # L'image du front n'a pas de node_modules : adapter-node integre au build les
211
+ # devDependencies, mais laisse les "dependencies" en import externe, que
212
+ # `node build` ne trouverait pas (arret au demarrage, en boucle).
213
+ dependances=$(node -e '
214
+ const p = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8"));
215
+ console.log(Object.keys(p.dependencies || {}).join(" "));' "$FRONT/package.json")
216
+ if [ -n "$dependances" ]; then
217
+ echo "\"dependencies\" dans le package.json du front ($dependances) : l'image n'a pas de node_modules, les passer en devDependencies"
218
+ exit 1
219
+ fi
220
+ # Les versions du package-lock.json commite, et non celles qu'a laissees le
221
+ # developpement : le build doit sortir de ce commit, et de lui seul.
222
+ ( cd "$FRONT" && npm ci --no-audit --no-fund >/dev/null )
223
+ # L'identifiant Google est fige dans le front a la construction. Sans
224
+ # JURIX_GOOGLE_CLIENT_ID ici, il est repris du .env de la VM : sinon chaque
225
+ # mise a jour faite sans la variable retirait la connexion Google, en silence.
226
+ # Un ssh en echec arrete donc le deploiement ; une cle absente, elle, rend une
227
+ # chaine vide.
228
+ GOOGLE_ID=${JURIX_GOOGLE_CLIENT_ID:-$("${SSH[@]}" "$CIBLE" \
229
+ "grep -E '^GOOGLE_CLIENT_ID=' $DISTANT/.env 2>/dev/null | tail -1 | cut -d= -f2-")} \
230
+ || { echo "Lecture de GOOGLE_CLIENT_ID sur la VM en echec (ssh) : arret"; exit 1; }
231
+ refuser_si_brute "GOOGLE_CLIENT_ID (ou JURIX_GOOGLE_CLIENT_ID)" "$GOOGLE_ID"
232
+ echo "Connexion Google : $([ -n "$GOOGLE_ID" ] && echo activee || echo absente)"
233
+ # VITE_WS_URL impose vide : une valeur du .env local du front (hors de git)
234
+ # serait figee dans le build ; vide, le front la derive de VITE_API_URL.
235
+ ( cd "$FRONT" && VITE_API_URL="https://$JURIX_DOMAINE" VITE_WS_URL='' \
236
+ VITE_GOOGLE_CLIENT_ID="$GOOGLE_ID" npm run build >/dev/null )
237
+ # Le build dure : un commit ou une modification faite entre-temps dans le
238
+ # front ferait partir un build qui ne correspond plus au commit enregistre.
239
+ if [ -n "$(git -C "$FRONT" status --porcelain)" ] \
240
+ || [ "$(git -C "$FRONT" rev-parse --short=12 HEAD)" != "$front_sha" ]; then
241
+ echo "Le front a change pendant la construction : relancer"
242
+ exit 1
243
+ fi
244
+ # Un build d'adapter-node : un build statique (adapter-static) n'a ni serveur
245
+ # ni build/client, et `node build` n'aurait rien a lancer.
246
+ if [ ! -f "$FRONT/build/index.js" ] || [ ! -d "$FRONT/build/client" ]; then
247
+ echo "build/index.js ou build/client manquant : le front n'est pas sur la branche du rendu serveur (adapter-node)"
248
+ exit 1
249
+ fi
250
+ # VITE_API_URL est figee dans le JavaScript du navigateur : sans le domaine
251
+ # dedans, ses appels a l'API partiraient ailleurs (localhost par defaut).
252
+ if ! grep -rqF -- "https://$JURIX_DOMAINE" "$FRONT/build/client/_app"; then
253
+ echo "https://$JURIX_DOMAINE absent de build/client/_app : VITE_API_URL n'a pas ete figee dans le front"
254
+ exit 1
255
+ fi
256
+
257
+ echo "== 4. Front envoye dans front-node/ (build/ et package.json seulement)"
258
+ # Seuls ces deux-la servent a l'execution. Envoyes dans front-node.nouveau/,
259
+ # copie de l'actuel (rsync n'envoie que les differences), puis echanges d'un
260
+ # coup : en place, un envoi coupe laisserait un front-node/ moitie neuf, moitie
261
+ # ancien, que demarrer.sh construirait. VERSION, ecrit en dernier, marque
262
+ # un envoi complet. Le conteneur en place n'en voit rien : l'image COPIE ces
263
+ # fichiers, et seul demarrer.sh la reconstruit. L'ancien front/ statique n'est
264
+ # plus touche.
265
+ horodatage=$(date -Is)
266
+ "${SSH[@]}" "$CIBLE" "set -e; cd $DISTANT
267
+ rm -rf front-node.nouveau
268
+ if [ -d front-node ]; then cp -a front-node front-node.nouveau; else mkdir front-node.nouveau; fi
269
+ rm -f front-node.nouveau/VERSION"
270
+ "${RSYNC[@]}" --delete "$FRONT/build" "$FRONT/package.json" "$CIBLE:$DISTANT/front-node.nouveau/"
271
+ # Script passe sur l'entree standard, entre apostrophes : rien n'y est
272
+ # developpe ici, les valeurs arrivent en arguments. Aucune de ses commandes ne
273
+ # lit l'entree standard (le piege decrit a l'etape 8).
274
+ # front-node.ancien/ garde le dernier build COMPLET d'un AUTRE front : un
275
+ # front-node/ sans VERSION (envoi coupe, dossier vide d'installer.sh) est jete,
276
+ # et la relance d'un meme front n'evince pas le precedent, seul secours.
277
+ "${SSH[@]}" "$CIBLE" "bash -s -- $DISTANT $backend_sha $front_sha $horodatage" <<'FIN'
278
+ set -e
279
+ cd "$1"
280
+ printf '%s %s %s\n' "$2" "$3" "$4" > front-node.nouveau/VERSION
281
+ if [ -f front-node/VERSION ] && [ "$(cut -d' ' -f2 front-node/VERSION)" != "$3" ]; then
282
+ rm -rf front-node.ancien
283
+ mv front-node front-node.ancien
284
+ else
285
+ rm -rf front-node
286
+ fi
287
+ mv front-node.nouveau front-node
288
+ FIN
289
+
290
+ echo "== 5. Code du backend (etat commite de $backend_sha)"
291
  # Extrait a cote, puis aligne avec rsync --delete : un `tar -x` direct n'effacait
292
  # rien, et un fichier supprime du depot restait sur la VM, jusque dans l'image.
293
+ # Les donnees de la VM (.env, PDF, sauvegardes, les front-node*, l'ancien front
294
+ # statique, et l'ancien modele EmbeddingGemma d'une VM d'avant la bascule, que
295
+ # son API en place monte encore) sont exclues : rsync ne les touche pas.
296
+ # Le commit releve a l'etape 1, et non HEAD relu ici : VERSION, le journal des
297
+ # deploiements et le controle de jurix_dev doivent nommer ce qui part vraiment.
298
+ # BACKEND_VERSION, ajoute a l'archive, le dit a demarrer.sh, qui le compare a
299
+ # front-node/VERSION.
300
+ # En tar.gz : un flux coupe en route fait echouer gzip (somme de controle,
301
+ # longueur), alors qu'un tar coupe entre deux fichiers pouvait passer pour
302
+ # complet, et rsync --delete aurait efface ce qui manquait. Extrait dans un
303
+ # dossier propre a ce passage, retire dans tous les cas. Entre apostrophes :
304
+ # $nouveau se developpe sur la VM, pas ici.
305
+ # shellcheck disable=SC2016
306
+ git -C "$RACINE" archive --format=tar.gz \
307
+ --add-virtual-file="deploiement/oracle/BACKEND_VERSION:$backend_sha" "$backend_sha" \
308
+ | "${SSH[@]}" "$CIBLE" 'set -e
309
+ nouveau=$(mktemp -d jurix.nouveau.XXXXXX)
310
+ tar -xz -C "$nouveau" || { rm -rf "$nouveau"; exit 1; }
311
  mkdir -p jurix
312
  rsync -a --delete \
313
  --exclude=/deploiement/oracle/.env \
 
315
  --exclude=/deploiement/oracle/donnees/ \
316
  --exclude=/deploiement/oracle/sauvegardes/ \
317
  --exclude=/deploiement/oracle/front/ \
318
+ --exclude=/deploiement/oracle/front-node/ \
319
+ --exclude=/deploiement/oracle/front-node.ancien/ \
320
+ --exclude=/deploiement/oracle/front-node.nouveau/ \
321
+ "$nouveau"/ jurix/ || { rm -rf "$nouveau"; exit 1; }
322
+ rm -rf "$nouveau"'
 
 
 
 
 
 
 
 
323
 
324
  if [ "$AVEC_DONNEES" = "--avec-donnees" ]; then
325
+ echo "== 6. PDF d'origine (reprenable : relancer en cas de coupure)"
326
  "${RSYNC_ROOT[@]}" "$RACINE/data/uploads/" "$CIBLE:$DISTANT/donnees/uploads/"
327
 
328
+ echo "== 7. Base : dump de jurix_dev, SANS les comptes ni les conversations"
329
+ # Le meme controle qu'a l'etape 2, refait, toujours contre le commit
330
+ # envoye : l'envoi des PDF dure des heures, et une migration appliquee a
331
+ # jurix_dev entre-temps doit arreter ici, avant le dump.
332
  controler_jurix_dev
333
  # Le corpus seulement. Les comptes de developpement (et leurs mots de
334
  # passe d'essai), leurs conversations, jetons et caches resteraient sinon
 
346
  rm -f "$dump"
347
  fi
348
 
349
+ echo "== 8. Demarrage sur la VM (demarrer.sh)"
350
  # Un FICHIER lance par ssh, et non un script passe sur l'entree standard : un
351
  # `docker compose exec` y avalait la suite, et rien apres lui ne s'executait.
352
+ # JURIX_PURGER_VECTEURS et JURIX_RESTAURER : seule la VM les lit (demarrer.sh),
353
+ # ssh ne transmet pas l'environnement local. demarrer.sh ecrit lui-meme les
354
+ # lignes du journal des deploiements : une relance a la main y figure aussi.
355
+ "${SSH[@]}" "$CIBLE" "sudo chown -R 1000:1000 $DISTANT/donnees && JURIX_PURGER_VECTEURS=${JURIX_PURGER_VECTEURS:-} JURIX_RESTAURER=$RESTAURER bash $DISTANT/demarrer.sh"
356
 
357
  echo
358
  echo "Verifier : https://$JURIX_DOMAINE et https://$JURIX_DOMAINE/health"
deploiement/oracle/docker-compose.yml CHANGED
@@ -1,12 +1,16 @@
1
  # JuriX en production sur UNE machine : une VM ARM d'Oracle Cloud (palier
2
  # « Always Free » : 2 coeurs, 12 Go de memoire, 200 Go de disque).
3
  #
4
- # Trois conteneurs :
5
  # db PostgreSQL 16 + pgvector. Aucun port publie : seule l'API le voit.
6
  # api l'image du Dockerfile du depot (FastAPI). Les embeddings viennent
7
  # de l'API Voyage AI, en HTTPS sortant : aucun modele en memoire.
8
- # caddy le seul expose (80 et 443) : certificats HTTPS automatiques, front
9
- # statique, et l'API sous /api sur le MEME domaine (pas de CORS).
 
 
 
 
10
  #
11
  # Lancement, depuis ce dossier :
12
  # docker compose up -d --build
@@ -14,6 +18,14 @@
14
 
15
  name: jurix
16
 
 
 
 
 
 
 
 
 
17
  services:
18
  db:
19
  # Version EPINGLEE, celle de developpement : la colonne articles.embedding
@@ -48,7 +60,12 @@ services:
48
  interval: 10s
49
  timeout: 5s
50
  retries: 12
 
 
 
 
51
  mem_limit: 4g
 
52
 
53
  api:
54
  build:
@@ -90,6 +107,70 @@ services:
90
  # Migrations au demarrage, puis sonde de Voyage.
91
  start_period: 120s
92
  mem_limit: 5g
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
93
 
94
  caddy:
95
  image: caddy:2
@@ -102,14 +183,16 @@ services:
102
  JURIX_DOMAINE: ${JURIX_DOMAINE:?renseigner JURIX_DOMAINE dans .env}
103
  volumes:
104
  # Le DOSSIER, pas le fichier : un fichier monte seul garde l'ancienne
105
- # version quand une mise a jour le remplace.
 
106
  - ./caddy:/etc/caddy:ro
107
- - ./front:/srv/front:ro
108
  - caddy_data:/data
109
  - caddy_config:/config
110
  depends_on:
111
  - api
 
112
  mem_limit: 256m
 
113
 
114
  volumes:
115
  db:
 
1
  # JuriX en production sur UNE machine : une VM ARM d'Oracle Cloud (palier
2
  # « Always Free » : 2 coeurs, 12 Go de memoire, 200 Go de disque).
3
  #
4
+ # Quatre conteneurs :
5
  # db PostgreSQL 16 + pgvector. Aucun port publie : seule l'API le voit.
6
  # api l'image du Dockerfile du depot (FastAPI). Les embeddings viennent
7
  # de l'API Voyage AI, en HTTPS sortant : aucun modele en memoire.
8
+ # front le serveur Node du front (SvelteKit, adapter-node) : pages rendues
9
+ # par le serveur, et fichiers du build. deployer.sh l'envoie dans
10
+ # front-node/.
11
+ # caddy le seul expose (80 et 443) : certificats HTTPS automatiques, l'API
12
+ # sous /api et le front pour tout le reste, sur le MEME domaine (pas
13
+ # de CORS).
14
  #
15
  # Lancement, depuis ce dossier :
16
  # docker compose up -d --build
 
18
 
19
  name: jurix
20
 
21
+ # Le pilote json-file de Docker ne fait tourner aucun journal par defaut :
22
+ # chacun grossirait jusqu'a remplir le disque. 3 x 10 Mo par conteneur.
23
+ x-journaux: &journaux
24
+ driver: json-file
25
+ options:
26
+ max-size: "10m"
27
+ max-file: "3"
28
+
29
  services:
30
  db:
31
  # Version EPINGLEE, celle de developpement : la colonne articles.embedding
 
60
  interval: 10s
61
  timeout: 5s
62
  retries: 12
63
+ # A l'arret, PostgreSQL ecrit un dernier point de controle, qui peut
64
+ # depasser les 10 s que Docker accorde avant de le tuer ; tue, il rejoue
65
+ # son journal au demarrage suivant.
66
+ stop_grace_period: 1m
67
  mem_limit: 4g
68
+ logging: *journaux
69
 
70
  api:
71
  build:
 
107
  # Migrations au demarrage, puis sonde de Voyage.
108
  start_period: 120s
109
  mem_limit: 5g
110
+ logging: *journaux
111
+
112
+ front:
113
+ # Le build COPIE dans l'image, et non monte : deployer.sh remplace
114
+ # front-node/ pendant que le conteneur en place tourne encore, et un
115
+ # montage lui changerait ses fichiers en pleine marche. Ni npm ni
116
+ # node_modules : adapter-node integre au build les devDependencies, et
117
+ # deployer.sh refuse des "dependencies", qu'il laisserait en import
118
+ # externe. package.json ne sert que pour son "type": "module".
119
+ build:
120
+ context: ./front-node
121
+ dockerfile_inline: |
122
+ FROM node:24.21.0-alpine
123
+ WORKDIR /app
124
+ COPY package.json ./
125
+ COPY build ./build
126
+ USER node
127
+ CMD ["node", "build"]
128
+ restart: unless-stopped
129
+ # Pas d'env_file : le .env porte les secrets de l'API, et le rendu
130
+ # serveur, qui lit tout son environnement ($env/dynamic/private), n'en a
131
+ # besoin d'aucun.
132
+ environment:
133
+ # L'origine publique : le serveur en tire l'URL de chaque requete (liens
134
+ # canoniques) et l'annonce a l'API, dont ALLOWED_ORIGINS vient du meme
135
+ # domaine. VITE_API_URL, figee au build, doit le designer aussi : sinon
136
+ # les pages s'affichent, mais le navigateur envoie ses appels a l'API
137
+ # (recherche, connexion, chat) ailleurs. deployer.sh et demarrer.sh le
138
+ # verifient.
139
+ ORIGIN: https://${JURIX_DOMAINE}
140
+ # Le rendu serveur appelle l'API par le reseau interne, au lieu de
141
+ # ressortir par l'IP publique et de revenir par Caddy
142
+ # (src/hooks.server.ts du front).
143
+ API_INTERNE: http://api:8000
144
+ # Caddy garde ses connexions vers le front 2 min sans activite, Node 5 s
145
+ # par defaut : Caddy pourrait reutiliser une connexion que Node ferme au
146
+ # meme instant, et le visiteur recevrait une 502. Node les garde donc
147
+ # plus longtemps ; HEADERS_TIMEOUT doit depasser KEEP_ALIVE_TIMEOUT.
148
+ KEEP_ALIVE_TIMEOUT: "125"
149
+ HEADERS_TIMEOUT: "126"
150
+ # Les requetes en cours finissent a l'arret, dans les 10 s que Docker
151
+ # accorde avant de tuer le conteneur.
152
+ SHUTDOWN_TIMEOUT: "8"
153
+ # Le tas de V8 plafonne sous mem_limit : Node ramasse ses dechets avant
154
+ # que le noyau ne tue le conteneur.
155
+ NODE_OPTIONS: --max-old-space-size=256
156
+ PORT: "3000"
157
+ HOST: 0.0.0.0
158
+ expose:
159
+ - "3000"
160
+ # Sans attendre que l'API soit prete : sans elle, le front rend ses pages
161
+ # en 503, et demarrer.sh attend l'API puis controle le rendu.
162
+ depends_on:
163
+ - api
164
+ healthcheck:
165
+ # Un fichier du build, et non une page : une panne de l'API ne doit pas
166
+ # faire passer le front pour malade. 127.0.0.1 et non localhost, qui
167
+ # peut se resoudre en ::1, ou Node n'ecoute pas.
168
+ test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:3000/favicon.svg"]
169
+ interval: 30s
170
+ timeout: 5s
171
+ retries: 3
172
+ mem_limit: 384m
173
+ logging: *journaux
174
 
175
  caddy:
176
  image: caddy:2
 
183
  JURIX_DOMAINE: ${JURIX_DOMAINE:?renseigner JURIX_DOMAINE dans .env}
184
  volumes:
185
  # Le DOSSIER, pas le fichier : un fichier monte seul garde l'ancienne
186
+ # version quand une mise a jour le remplace. Il porte aussi
187
+ # maintenance.html, la page servie quand le front ou l'API ne repond pas.
188
  - ./caddy:/etc/caddy:ro
 
189
  - caddy_data:/data
190
  - caddy_config:/config
191
  depends_on:
192
  - api
193
+ - front
194
  mem_limit: 256m
195
+ logging: *journaux
196
 
197
  volumes:
198
  db:
deploiement/oracle/env.production.exemple CHANGED
@@ -9,7 +9,10 @@
9
  # ============================================================
10
 
11
  # ---- Domaine et base (lus par docker compose) ----
12
- # Le sous-domaine qui pointe sur l'adresse IP publique de la VM.
 
 
 
13
  JURIX_DOMAINE=jurix.exemple.cm
14
  # Mot de passe de PostgreSQL, interne a la VM. Generer :
15
  # openssl rand -hex 24
@@ -58,4 +61,6 @@ BREVO_SENDER_EMAIL=
58
  BREVO_SENDER_NAME=JuriX
59
 
60
  # ---- Connexion Google, facultative ----
 
 
61
  GOOGLE_CLIENT_ID=
 
9
  # ============================================================
10
 
11
  # ---- Domaine et base (lus par docker compose) ----
12
+ # Le sous-domaine qui pointe sur l'adresse IP publique de la VM, seul (sans
13
+ # https://), sans guillemets ni espaces : deployer.sh et demarrer.sh le lisent
14
+ # tel quel, et le figent dans le front. Le meme que JURIX_DOMAINE au moment de
15
+ # lancer deployer.sh, qui refuse sinon.
16
  JURIX_DOMAINE=jurix.exemple.cm
17
  # Mot de passe de PostgreSQL, interne a la VM. Generer :
18
  # openssl rand -hex 24
 
61
  BREVO_SENDER_NAME=JuriX
62
 
63
  # ---- Connexion Google, facultative ----
64
+ # Sans guillemets ni espaces : deployer.sh la lit telle quelle pour la figer
65
+ # dans le front.
66
  GOOGLE_CLIENT_ID=
deploiement/oracle/installer.sh CHANGED
@@ -46,8 +46,9 @@ fi
46
 
47
  echo "== 4. Dossiers des donnees"
48
  # Avant tout `docker compose up` : sinon Docker cree les dossiers montes, en
49
- # root, et les envois echouent ensuite sur un refus d'acces.
50
- mkdir -p donnees/uploads sauvegardes front
 
51
  # L'API tourne sous l'utilisateur 1000 dans son conteneur : elle doit pouvoir
52
  # ecrire les PDF envoyes.
53
  sudo chown -R 1000:1000 donnees
 
46
 
47
  echo "== 4. Dossiers des donnees"
48
  # Avant tout `docker compose up` : sinon Docker cree les dossiers montes, en
49
+ # root, et les envois echouent ensuite sur un refus d'acces. front-node/
50
+ # recoit le front construit par deployer.sh.
51
+ mkdir -p donnees/uploads sauvegardes front-node
52
  # L'API tourne sous l'utilisateur 1000 dans son conteneur : elle doit pouvoir
53
  # ecrire les PDF envoyes.
54
  sudo chown -R 1000:1000 donnees
deploiement/oracle/sauvegarde.sh CHANGED
@@ -1,18 +1,39 @@
1
  #!/usr/bin/env bash
2
  # Sauvegarde de la base de production, gardee 14 jours.
3
- # Lancee chaque nuit par cron (voir installer.sh) ; a la main :
 
4
  # bash sauvegarde.sh
5
  set -euo pipefail
6
  cd "$(dirname "$0")"
7
 
8
- horodatage=$(date +%Y%m%d_%H%M)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9
  cible="sauvegardes/jurix_${horodatage}.dump"
10
 
11
- # Ecrite sous un nom provisoire puis renommee : une sauvegarde interrompue ne
12
- # se fait jamais passer pour une sauvegarde complete.
13
- docker compose exec -T db pg_dump -U jurix -Fc jurix > "${cible}.partiel"
14
- mv "${cible}.partiel" "${cible}"
 
15
 
16
  find sauvegardes -name 'jurix_*.dump' -mtime +14 -delete
17
  find sauvegardes -name 'jurix_*.partiel' -mtime +1 -delete
 
 
18
  echo "$(date -Is) sauvegarde ${cible} ($(du -h "${cible}" | cut -f1))"
 
1
  #!/usr/bin/env bash
2
  # Sauvegarde de la base de production, gardee 14 jours.
3
+ # Lancee chaque nuit par cron (voir installer.sh), et par demarrer.sh avant
4
+ # chaque mise a jour ou restauration ; a la main :
5
  # bash sauvegarde.sh
6
  set -euo pipefail
7
  cd "$(dirname "$0")"
8
 
9
+ # Pendant une restauration, la base est partielle, ou absente : la sauvegarder
10
+ # donnerait un jurix_*.dump d'apparence saine, que la rotation garderait.
11
+ if [ -e sauvegardes/.restauration_en_cours ]; then
12
+ echo "$(date -Is) restauration en cours (sauvegardes/.restauration_en_cours) : pas de sauvegarde, la terminer d'abord (bash demarrer.sh)"
13
+ exit 1
14
+ fi
15
+ # Le verrou de demarrer.sh : pas de sauvegarde pendant qu'il restaure ou migre
16
+ # la base. Lancee par lui (JURIX_VERROU_TENU=1), elle le tient deja par son
17
+ # descripteur herite ; le reprendre ici l'attendrait en vain.
18
+ if [ "${JURIX_VERROU_TENU:-}" != 1 ]; then
19
+ exec 9>sauvegardes/.verrou
20
+ flock -n 9 || { echo "$(date -Is) demarrer.sh ou une autre sauvegarde tourne : sauvegarde non faite"; exit 1; }
21
+ fi
22
+
23
+ # A la seconde : deux sauvegardes de la meme minute portaient le meme nom, et
24
+ # la seconde ecrasait la sauvegarde d'avant mise a jour que nomme le journal
25
+ # des deploiements.
26
+ horodatage=$(date +%Y%m%d_%H%M%S)
27
  cible="sauvegardes/jurix_${horodatage}.dump"
28
 
29
+ # Ecrite sous un nom provisoire, propre a ce passage, puis renommee : une
30
+ # sauvegarde interrompue ne se fait jamais passer pour une sauvegarde complete.
31
+ partiel="${cible}.$$.partiel"
32
+ docker compose exec -T db pg_dump -U jurix -Fc jurix </dev/null > "$partiel"
33
+ mv "$partiel" "$cible"
34
 
35
  find sauvegardes -name 'jurix_*.dump' -mtime +14 -delete
36
  find sauvegardes -name 'jurix_*.partiel' -mtime +1 -delete
37
+ # demarrer.sh lit le nom du fichier dans cette ligne, pour le journal des
38
+ # deploiements : en garder la forme « sauvegarde <chemin> ».
39
  echo "$(date -Is) sauvegarde ${cible} ($(du -h "${cible}" | cut -f1))"