From 4a1d0836d044c797395ca87c33494accc9762bec Mon Sep 17 00:00:00 2001 From: Daniel Allaire Date: Wed, 29 Jul 2026 11:32:06 -0400 Subject: [PATCH] =?UTF-8?q?docs=20:=20un=20README=20par=20r=C3=B4le=20(12?= =?UTF-8?q?=20manquants)=20+=20carte=20remise=20=C3=A0=20l'=C3=A9tat=20du?= =?UTF-8?q?=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Solde la dette documentaire repérée à l'audit du 2026-07-03. Tous les rôles ont désormais un README, au format maison (intention → rôle → variables → notes/limites → prérequis). Ils documentent ce qui ne se lit PAS dans les tâches : - serveur_debian : rôle-catégorie sans tâches — il ne porte que le flux SSH du plan de gestion, sans quoi les nftables générés couperaient l'accès Ansible à toute la flotte ; le vrai travail est dans le playbook de groupe. - hosts_statiques : le plancher /etc/hosts comme CONDITION de l'ordre de reconstruction (résolution par nom avant que PowerDNS existe) ; fichier entièrement géré, alias d'exposition best-effort. - resoudre_base / resoudre_annuaire : entrées, sorties (facts), et pourquoi le FQDN plutôt que le nom court (fédération + nom canonique pour verify-full). - serveur_dovecot : les 3 réglages Dovecot 2.4 qui conditionnent la remise (static_allow_all_users, mail_inbox_path vide, mail_path par utilisateur) et le local-part seul comme chemin commun LMTP/IMAP ; limite mono-domaine. - serveur_postfix : liens mailstore/milter, recopie de /etc/hosts dans le chroot. - serveur_rspamd : clé DKIM idempotente ; le domaine signé doit être PUBLIC en prod, sinon la signature ne vaut rien pour les MX distants. - client_backup / serveur_backup : jobs déclaratifs, chiffrement côté client, deux pièges (jobs vides = silencieux ; dépôt neuf vide après un from-zero) ; hors-nœud n'est pas hors-site. - serveur_oauth2_proxy : le patron réutilisable Keycloak-devant-n'importe-quoi, et pourquoi allow_unverified_email est nécessaire avec un annuaire LDAP. - serveur_icingaweb2 : modes ldap vs external, écoute à restreindre en SSO. - client_unbound : le garde-fou de bascule (apply ET confirm, validation réelle avant de toucher /etc/resolv.conf). docs/carte-set-ops.md ne décrivait plus l'état du code : - expose EST consommé au déploiement (annoncé comme « Phase 3 à venir ») : expositions_des_applications + expositions.conf.j2, alias /etc/hosts, SANs d'edge dérivés par instancier.py ; - 3 mécanismes transverses ajoutés (résolution d'annuaire, plancher de résolution, resoudre_base nommé dans les bindings app→base) ; - 5 entrées d'index ajoutées : réseau/pare-feu, ordre de déploiement, preuve/recette, exploitation courante, wiki — pans du corpus non indexés ; - ce qui reste ouvert est marqué : meta/liens.yml sur le seul serveur_postfix, requiert non consommé au déploiement (l'ordre vient des couches + du graphe). make verifier vert : ansible-lint 514 fichiers, tests, syntax-check, 23 preuves CONFORME / 0 échec / 0 sauté. Co-Authored-By: Claude Opus 5 --- CHANGELOG.md | 40 ++++++++++++++++++ docs/carte-set-ops.md | 40 +++++++++++++----- roles/client_backup/README.md | 62 ++++++++++++++++++++++++++++ roles/client_unbound/README.md | 53 ++++++++++++++++++++++++ roles/hosts_statiques/README.md | 42 +++++++++++++++++++ roles/resoudre_annuaire/README.md | 49 ++++++++++++++++++++++ roles/resoudre_base/README.md | 46 +++++++++++++++++++++ roles/serveur_backup/README.md | 44 ++++++++++++++++++++ roles/serveur_debian/README.md | 39 +++++++++++++++++ roles/serveur_dovecot/README.md | 54 ++++++++++++++++++++++++ roles/serveur_icingaweb2/README.md | 58 ++++++++++++++++++++++++++ roles/serveur_oauth2_proxy/README.md | 59 ++++++++++++++++++++++++++ roles/serveur_postfix/README.md | 57 +++++++++++++++++++++++++ roles/serveur_rspamd/README.md | 40 ++++++++++++++++++ 14 files changed, 672 insertions(+), 11 deletions(-) create mode 100644 roles/client_backup/README.md create mode 100644 roles/client_unbound/README.md create mode 100644 roles/hosts_statiques/README.md create mode 100644 roles/resoudre_annuaire/README.md create mode 100644 roles/resoudre_base/README.md create mode 100644 roles/serveur_backup/README.md create mode 100644 roles/serveur_debian/README.md create mode 100644 roles/serveur_dovecot/README.md create mode 100644 roles/serveur_icingaweb2/README.md create mode 100644 roles/serveur_oauth2_proxy/README.md create mode 100644 roles/serveur_postfix/README.md create mode 100644 roles/serveur_rspamd/README.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 6be932d..d1945da 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,45 @@ # CHANGELOG — Set-OPS +## 2026-07-29 — dette documentaire soldée (un README par rôle) + carte revue + +### Ajouté — les 12 README de rôles manquants +**Tous les rôles ont désormais un README.** Les 12 restants sont écrits, au format maison +(intention → rôle → variables → notes/limites → prérequis), et documentent surtout ce qui +ne se lit pas dans les tâches : + +- **Socle et résolution** — `serveur_debian` (rôle-catégorie sans tâches : il ne porte que le + flux SSH du plan de gestion, *sans quoi les nftables couperaient l'accès Ansible*), + `hosts_statiques` (le plancher `/etc/hosts` qui rend l'ordre de reconstruction possible). +- **Rôles utilitaires** — `resoudre_base` et `resoudre_annuaire` : entrées/sorties (facts), + et *pourquoi* le FQDN plutôt que le nom court (fédération + `verify-full`). +- **Courriel** — `serveur_dovecot` (les trois réglages Dovecot 2.4 qui conditionnent la + remise ; le local-part seul comme chemin commun LMTP/IMAP), `serveur_postfix` (liens + `mailstore`/`milter`, recopie de `/etc/hosts` dans le chroot), `serveur_rspamd` (clé DKIM + idempotente ; le domaine signé doit être **public** en prod). +- **Sauvegardes** — `client_backup` (jobs déclaratifs, chiffrement côté client, *le dépôt + neuf est vide tant qu'une première sauvegarde n'a pas tourné*) et `serveur_backup` + (hors-nœud ≠ hors-site). +- **SSO et supervision** — `serveur_oauth2_proxy` (le patron réutilisable Keycloak-devant- + n'importe-quoi ; pourquoi `allow_unverified_email` est nécessaire avec un annuaire LDAP) + et `serveur_icingaweb2` (modes `ldap` vs `external`, et l'écoute à restreindre en SSO). +- **`client_unbound`** — le garde-fou de bascule du résolveur (`apply` **et** `confirm`, + validation avant de toucher `/etc/resolv.conf`). + +### Corrigé — `docs/carte-set-ops.md` ne décrivait plus l'état du code +- **`expose` est consommé au déploiement** (la carte l'annonçait encore comme « Phase 3 à + venir ») : vhosts nginx dérivés via `expositions_des_applications` + + `expositions.conf.j2`, alias `/etc/hosts`, SANs d'edge dérivés par `instancier.py`. +- **Trois mécanismes transverses ajoutés au catalogue** : résolution d'annuaire + (`resoudre_annuaire`), plancher de résolution (`hosts_statiques`), et `resoudre_base` + nommé dans la ligne des bindings app→base. +- **Cinq entrées d'index ajoutées** : réseau/pare-feu, ordre de déploiement, preuve/recette, + exploitation courante, wiki — des pans entiers du corpus n'étaient pas indexés. +- Reste ouvert, explicitement : `meta/liens.yml` sur le seul `serveur_postfix`, et `requiert` + non consommé au déploiement (indice applicatif ; l'ordre, lui, vient des couches+graphe). + +Validation : `make verifier` vert (ansible-lint 514 fichiers, tests, syntax-check, +**23 preuves CONFORME**). + ## 2026-07-28 — figures annotées dans le wiki (console d'exploitation) ### Ajouté — les 8 vues de la console illustrées, dans le wiki diff --git a/docs/carte-set-ops.md b/docs/carte-set-ops.md index cb3cc48..2bf3f46 100644 --- a/docs/carte-set-ops.md +++ b/docs/carte-set-ops.md @@ -2,9 +2,11 @@ > **À lire en premier.** Point d'entrée vers le corpus documentaire, et **catalogue des > mécanismes transverses** — ceux qui vivent dans le code et qu'on *re-découvre* sinon. -> Créée le 2026-07-03 après un audit du dépôt. But : ne plus re-déterrer ce qui existe. +> Créée le 2026-07-03 après un audit du dépôt, **revue le 2026-07-29**. But : ne plus +> re-déterrer ce qui existe. -Le dépôt est **déjà bien documenté** (~22 docs). Le manque n'était pas la doc du *modèle*, +Le dépôt est **déjà bien documenté** (26 docs + 7 pièces d'audit + 21 unités de wiki, et un +README par rôle). Le manque n'était pas la doc du *modèle*, mais (a) un index « par où commencer » et (b) une carte des *mécanismes* (dispersés dans le code + les README de rôles). Cette page comble ces deux trous. @@ -17,6 +19,11 @@ code + les README de rôles). Cette page comble ces deux trous. | **Services, maturité, dette** | `docs/catalogue-services.md` (**la carte de maturité + la cruft y sont déjà**) | | **Exploitation / VM** | `docs/vm-lifecycle.md`, `docs/procedure-template-debian13-proxmox.md`, `docs/config-proxmox.md`, `docs/nomenclature-vm.md`, `docs/multi-instances.md` | | **Conceptions de domaine** | `docs/identite-sso.md`, `docs/courriel-conception.md`, `docs/bindings-conception.md`, `docs/dns-interne.md`, `docs/dimensionnement-ressources.md`, `docs/integrations-vm.md` | +| **Réseau / pare-feu** | `docs/flux-conception.md` (le modèle) → `docs/registre-flux.md` (**généré**, matrice d'audit) ; underlay : `underlay.yml.example` + `make underlay` | +| **Ordre de déploiement** | `docs/couches-deploiement.yml` (couches) + `docs/dependances-groupes.yml` (graphe) → `playbooks/site.yml` (**généré**, `make site`) | +| **Preuve / recette** | `docs/audit/affirmations.md` (registre), `make prouver` → `docs/audit/preuve-.md`, `docs/audit/plan-de-recette.md` (**généré** du wiki), `docs/audit/protocole-operateur-independant.md` | +| **Exploitation courante** | `docs/runbooks-exploitation.md`, `docs/intrants-communs.md`, `docs/intrants-base-gui-conception.md`, `docs/theme-forgejo-hors-flotte.md` | +| **Pédagogie (le wiki)** | `wiki/` — 21 unités (+ `_Sidebar`) publiées par `make wiki-publier` ; entrer par `wiki/Home.md` | | **Vision / positionnement** | `docs/ecosysteme-chezlepro.md`, `docs/positionnement.md`, `docs/pouvoirs-set-ops.md` | ## 2. Les mécanismes transverses (et OÙ ils vivent) @@ -29,7 +36,9 @@ Ce que je re-découvre sinon. **Consulter avant de concevoir un nouveau mécanis | Nomenclature dérivée | VMID / IP / VLAN / FQDN dérivés | `inventory_rules.deriver_nomenclature` + `plan/nomenclature.yml` | `nomenclature-vm.md` | | Dimensionnement | RAM/CPU/disque sommés par logiciel | `roles/*/meta/empreinte.yml` → `deriver_ressources` | `dimensionnement-ressources.md` | | **Bindings app→app** | lien **côté app** (`liens`) résolu en host_vars | `plan/applications.yml` `liens:` + `roles/*/meta/liens.yml` + `instancier.resoudre_liens` | `bindings-conception.md` | -| **Bindings app→base** | lien **côté base** (`consommateur`/`portee`) résolu **dans le rôle** | `plan/bases-donnees.yml` + `include_vars`/`lookup('vars', secret)` dans les rôles consommateurs | `bindings-conception.md` §5 | +| **Bindings app→base** | lien **côté base** (`consommateur`/`portee`) résolu **dans le rôle** | `plan/bases-donnees.yml` + rôle utilitaire `resoudre_base` (`lookup('vars', secret)`, `no_log`) inclus par le consommateur | `bindings-conception.md` §5 | +| Résolution d'annuaire | connexion LDAP (uri/base DN/bind) **dérivée**, jamais recopiée | rôle utilitaire `resoudre_annuaire` (inclus par dovecot/postfix/keycloak/icingaweb2) | `identite-sso.md` | +| Plancher de résolution | `/etc/hosts` généré depuis l'inventaire + alias d'`expose` → l'écosystème se résout **DNS éteint** | rôle `hosts_statiques` (appliqué dans la couche socle) | `dns-interne.md` | | Pont de certificat | cert step_ca → service, resync au renouvellement | script `*-cert-sync` + unité `.path`, dans chaque rôle serveur ; cert déposé par `client_pki` | — | | Ordonnancement socle-first | socle/durci avant les `client_*` | `serveur_debian`/`serveur_durci` d'abord (posent `/etc/hosts` via `hosts_statiques`) | — | | Sûreté check-mode | dry-run fiable | `when: not ansible_check_mode` sur les tâches de service + handlers | — | @@ -45,14 +54,23 @@ Ce que je re-découvre sinon. **Consulter avant de concevoir un nouveau mécanis - **Maturité des rôles, échafaudages, rôles-catégories inertes** : voir `docs/catalogue-services.md` « État d'implémentation » (source de vérité, tenue à jour). -- **Dette repérée en plus (audit 2026-07-03)** : - - README manquants sur les rôles récents : `serveur_dovecot`, `serveur_postfix`, - `serveur_rspamd`, et `hosts_statiques` ; - - `meta/liens.yml` seulement sur `serveur_postfix` (les autres liens app→app viendront) ; - - `requiert` / `expose` : câblés **côté GUI** (édition + validation `valider_applications`) - mais **pas encore consommés au déploiement** — `expose`→vhost nginx = Phase 3 des bindings ; - `requiert` = indice de dépendance (les dépendances de *groupes* sont dans - `docs/dependances-groupes.yml`, lues par la GUI). +- **Dette (audit 2026-07-03, revu le 2026-07-29)** : + - ✅ **soldé** — README de rôles : **tous les rôles en ont un** (les 12 manquants écrits le + 2026-07-29 : `serveur_debian`, `hosts_statiques`, `resoudre_base`, `resoudre_annuaire`, + `serveur_dovecot`, `serveur_postfix`, `serveur_rspamd`, `client_backup`, `serveur_backup`, + `client_unbound`, `serveur_oauth2_proxy`, `serveur_icingaweb2`). + - ✅ **soldé** — `expose` **est** consommé au déploiement : `plan/applications.yml` → + filtre `expositions_des_applications` → vhosts nginx dérivés + (`roles/serveur_nginx/tasks/main.yml`, template `expositions.conf.j2`, drapeau + `serveur_nginx_publier_expositions`), + alias `/etc/hosts` posés par `hosts_statiques`, + + SANs des certificats d'edge dérivés par `scripts/instancier.py`. + - ⏳ **ouvert** — `meta/liens.yml` seulement sur `serveur_postfix` (`mailstore`, `milter`) : + les autres liens app→app viendront. + - ⏳ **ouvert** — `requiert` : câblé **côté GUI** (édition + validation + `valider_applications`) mais pas consommé au déploiement ; c'est un indice de dépendance + *applicative*. Les dépendances de **groupes** (celles qui pilotent l'ordre) vivent dans + `docs/dependances-groupes.yml` + `docs/couches-deploiement.yml`, et sont bel et bien + consommées par l'orchestrateur (`scripts/orchestrer.py` → `playbooks/site.yml`). ## 4. Discipline (pour ne plus re-déterrer) diff --git a/roles/client_backup/README.md b/roles/client_backup/README.md new file mode 100644 index 0000000..725e46d --- /dev/null +++ b/roles/client_backup/README.md @@ -0,0 +1,62 @@ +# client_backup + +Intégration cliente **sauvegarde** : le nœud pousse ses **données** (pas sa VM) vers le dépôt +restic hors-nœud (`serveur_backup`), chiffrées côté client, sur un timer systemd. + +## Principe +L'infrastructure est **reconstructible par le code** (`make reconstruire`). Ce qui ne se +reconstruit pas, c'est l'**état** : clés de l'AC, annuaire, bases, courrier, dépôts Git. +C'est cet état — et lui seul — que ce rôle sauvegarde. + +## Rôle +- Installe `restic`. +- Dépose la clé SSH privée de sauvegarde et le mot de passe restic dans `/etc/setops` + (`0600`), depuis la voûte. +- Configure l'accès SSH vers la cible (utilisateur restreint `restic`). +- Déploie `sauvegarder.sh` + l'unité et le **timer** systemd, et l'active. + +## Jobs déclaratifs +Chaque nœud déclare ses `client_backup_jobs` (en `group_vars`/`host_vars`) : + +```yaml +client_backup_jobs: + - nom: step_ca + chemins: [/etc/step-ca] + - nom: postgresql + commande: "sudo -u postgres pg_dumpall > /var/backups/setops/postgresql/all.sql" + chemins: [/var/backups/setops/postgresql] +``` + +Le script exécute, dans l'ordre : les `commande` (dumps vers le *staging*) → `restic init` +si le dépôt est neuf → `restic backup` de tous les `chemins` → `restic forget --prune` +(rétention). + +## Secrets requis (Vault) +```yaml +vault_restic_password # mot de passe du dépôt restic (le chiffrement) +vault_backup_ssh_privkey # clé privée SSH vers la cible (publique côté serveur_backup) +``` +Sans eux, le rôle refuse de s'exécuter (assertion). + +## Variables principales +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `client_backup_cible` | `backup-01.{{ domaine_interne }}` | Nœud dépôt | +| `client_backup_repo` | `sftp:restic@:` | Un sous-dossier par nœud | +| `client_backup_staging` | `/var/backups/setops` | Préparation des dumps | +| `client_backup_retention` | `--keep-daily 7 --keep-weekly 4 --keep-monthly 6` | `restic forget` | +| `client_backup_horaire` | `*-*-* 02:30:00` | Timer systemd | +| `client_backup_jobs` | `[]` | **À déclarer par nœud** | + +## Notes / limites +- **Chiffrement côté client** : la cible ne voit que des blocs chiffrés — elle n'a donc pas + besoin d'être aussi protégée que les sources. +- `client_backup_jobs: []` = le timer tourne mais ne sauvegarde rien. C'est silencieux : + vérifier que chaque nœud porteur d'état déclare ses jobs. +- Un dépôt neuf est **vide jusqu'à la première exécution** : après une reconstruction + from-zero, déclencher une première sauvegarde plutôt que d'attendre 02:30. +- Restauration : `restic restore` avec le même mot de passe (cf. `docs/runbooks-exploitation.md`). + +## Prérequis +- `serveur_backup` déployé, et sa `serveur_backup_pubkey` correspondant à la clé privée de + la voûte. Couche **agents** (après les services). diff --git a/roles/client_unbound/README.md b/roles/client_unbound/README.md new file mode 100644 index 0000000..09c0941 --- /dev/null +++ b/roles/client_unbound/README.md @@ -0,0 +1,53 @@ +# client_unbound + +**Résolveur local** par nœud (Unbound) : cache + récursion, avec une **stub-zone** vers +l'autoritatif interne (PowerDNS). Rend la résolution *dynamique* sans casser Internet. +Troisième et dernière couche du DNS interne (`docs/dns-interne.md`). + +## Les trois couches +1. `hosts_statiques` — plancher `/etc/hosts`, toujours là, indépendant de tout service ; +2. `serveur_powerdns` — autoritatif de la zone interne ; +3. **ce rôle** — résolveur local, **opt-in**, qui rend la résolution dynamique par nœud. + +## Rôle +- Installe `unbound` et `bind9-dnsutils` (`dig`, pour valider **avant** de basculer). +- Déploie `setops.conf` : écoute sur `127.0.0.1`, stub-zone vers l'autoritatif interne, + récursion (ou transitaires) pour le reste d'Internet. +- Valide la configuration (`unbound-checkconf`), active le service. +- **Bascule** `/etc/resolv.conf` vers `127.0.0.1` — protégée (voir ci-dessous). + +## Garde-fou de bascule (anti-coupure) +Changer le résolveur d'un nœud à distance, c'est risquer de le rendre muet. Le rôle exige +donc **deux** interrupteurs, et vérifie avant d'agir : + +```yaml +client_unbound_apply: true +client_unbound_confirm: true +``` + +Sans les deux, le rôle installe et démarre Unbound mais **ne touche pas** à `/etc/resolv.conf` +(refus explicite). Avec les deux, il applique d'abord les redémarrages en attente, puis +**valide qu'Unbound résout réellement** (un nom interne *et* un nom Internet) — et ne bascule +qu'ensuite. Même doctrine que la règle 4 d'`AGENTS.md` : action risquée = confirmation explicite. + +## Variables +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `client_unbound_ecoute` | `127.0.0.1` | Écoute (boucle locale) | +| `client_unbound_zone_interne` | `{{ domaine_interne }}` | Zone en stub | +| `client_unbound_dns_autoritatif` | dérivé du groupe `serveur_powerdns` | Cible de la stub-zone | +| `client_unbound_transitaires` | `[]` | Vide = récursion propre (racine + DNSSEC) | +| `client_unbound_apply` / `_confirm` | `false` / `false` | Bascule de `/etc/resolv.conf` | + +## Flux (`meta/flux.yml`) +`53/udp` entrant en **localhost** · `53/tcp` sortant vers `serveur_powerdns`. + +## Notes / limites +- Transitaires vides = Unbound **récurse lui-même** (racine + DNSSEC). Si la récursion + sortante est bloquée par le réseau, renseigner `client_unbound_transitaires`. +- Le rôle exige l'IP de l'autoritatif interne (assertion) : `serveur_powerdns` doit être + dans l'inventaire avec un `ansible_host`. +- DoT (DNS chiffré) n'est pas encore branché — c'est un des flux restants du zéro-confiance. + +## Prérequis +- `serveur_powerdns` actif. Couche **agents**. diff --git a/roles/hosts_statiques/README.md b/roles/hosts_statiques/README.md new file mode 100644 index 0000000..1f69dcd --- /dev/null +++ b/roles/hosts_statiques/README.md @@ -0,0 +1,42 @@ +# hosts_statiques + +**Plancher de résolution** : génère `/etc/hosts` depuis l'inventaire, pour que tout +l'écosystème se résolve par nom **même DNS éteint**. + +## Rôle +- Génère `/etc/hosts` (template `hosts.j2`) à partir des hôtes actifs de l'inventaire : + IP, nom court, FQDN interne. +- **Alias d'exposition** (optionnel, actif par défaut) : pose ` ` + pour chaque application qui déclare un `expose` dans le plan — la résolution des services + publiés ne dépend donc pas non plus du DNS. + +## Pourquoi +C'est ce qui rend l'**ordre de reconstruction** possible : appliqué dans la couche **socle** +(via `playbooks/groupes/serveur_debian.yml`), il donne la résolution par nom avant que +`serveur_powerdns` n'existe. Sans lui, tout service référençant un FQDN interne +(`resoudre_base`, `resoudre_annuaire`, certificats step_ca…) échouerait au premier +déploiement d'une instance neuve. + +Les trois couches de résolution : ce plancher → PowerDNS autoritatif → Unbound local +(`client_unbound`, opt-in). Cf. `docs/dns-interne.md`. + +## Variables +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `hosts_statiques_actif` | `true` | Génère (ou non) `/etc/hosts` | +| `hosts_statiques_domaine` | `{{ domaine_interne }}` | Suffixe des FQDN | +| `hosts_statiques_publier_expositions` | `true` | Ajoute les alias `expose` → edge | +| `hosts_statiques_expositions` | `[]` | Calculé par le rôle (filtre `expositions_des_applications`) | + +## Notes / limites +- Les alias d'exposition sont **best-effort** : le rôle lit `applications.yml` et + `domaines.yml` sur le **nœud de contrôle** (`delegate_to: localhost`, `stat` d'abord). + Plan absent (ex. préparation du golden template) → alias simplement omis, pas d'échec. +- Le fichier est **entièrement géré** par Ansible : toute ligne ajoutée à la main sur un + nœud est écrasée au prochain passage. C'est voulu (source unique = le plan). +- Postfix tourne en chroot : `serveur_postfix` recopie ce `/etc/hosts` dans + `/var/spool/postfix/etc/` pour que le MTA bénéficie du même plancher. + +## Prérequis +- `domaine_interne` défini ; `setops_plan_dir` pour les alias d'exposition. +- Filtre `expositions_des_applications` (`filter_plugins/`). diff --git a/roles/resoudre_annuaire/README.md b/roles/resoudre_annuaire/README.md new file mode 100644 index 0000000..4f8326d --- /dev/null +++ b/roles/resoudre_annuaire/README.md @@ -0,0 +1,49 @@ +# resoudre_annuaire + +**Rôle utilitaire** (pas un groupe déployable) : dérive la connexion à l'annuaire interne +(OpenLDAP) de façon déclarative, à partir du `domaine_interne` et de l'hôte d'annuaire. + +Remplace le câblage LDAP qui était répété dans `serveur_dovecot`, `serveur_postfix`, +`serveur_keycloak` et `serveur_icingaweb2`. **Un seul endroit** fixe le nom de l'hôte +d'annuaire. + +## Usage +```yaml +- name: Résoudre l'annuaire (rôle partagé) + ansible.builtin.include_role: + name: resoudre_annuaire + +- name: Adopter la connexion annuaire pour + ansible.builtin.set_fact: + _ldap_uri: "{{ resoudre_annuaire_uri }}" + _ldap_base_dn: "{{ resoudre_annuaire_base_dn }}" +``` + +## Sorties (facts, persistent après `include_role`) +| Fact | Exemple | +| --- | --- | +| `resoudre_annuaire_fqdn` | `id-ldap-01.exemple.internal` | +| `resoudre_annuaire_uri` | `ldaps://id-ldap-01.exemple.internal` | +| `resoudre_annuaire_base_dn` | `dc=exemple,dc=internal` | +| `resoudre_annuaire_users_dn` | `ou=people,dc=exemple,dc=internal` | +| `resoudre_annuaire_bind_dn` | `cn=admin,dc=exemple,dc=internal` | +| `resoudre_annuaire_bind_password` | Déréférencé de la voûte (`no_log`) | + +## Variables +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `resoudre_annuaire_hote` | `id-ldap-01` | **Le** point où le nom d'hôte est fixé (surchargeable par instance) | +| `resoudre_annuaire_port` | `636` | Port LDAPS | +| `resoudre_annuaire_encryption` | `ldaps` | Schéma de l'URI | +| `resoudre_annuaire_bind_cn` | `admin` | CN du compte de bind | +| `resoudre_annuaire_secret` | `vault_openldap_admin` | **Nom** de la variable de voûte | + +## Notes +- Les sorties sont posées en `set_fact` (pas en `defaults`) : les defaults d'un rôle inclus + ne survivent pas à la fin de son exécution, contrairement aux facts. +- Le base DN est **dérivé** du `domaine_interne` (`a.b` → `dc=a,dc=b`) : aucun DN codé en dur. +- Le rôle exige un `domaine_interne` non vide (assertion). +- LDAPS suppose la confiance step_ca posée par `client_pki` sur le nœud consommateur. + +## Prérequis +- `domaine_interne` défini ; voûte déverrouillée (`ANSIBLE_VAULT_PASSWORD_FILE`). diff --git a/roles/resoudre_base/README.md b/roles/resoudre_base/README.md new file mode 100644 index 0000000..c2009c3 --- /dev/null +++ b/roles/resoudre_base/README.md @@ -0,0 +1,46 @@ +# resoudre_base + +**Rôle utilitaire** (pas un groupe déployable) : résout l'entrée de base de données d'un +consommateur depuis le registre partagé `instance/plan/bases-donnees.yml`. + +C'est la moitié « **binding app→base** » de la conception des liaisons — le lien est déclaré +**côté base** (le registre nomme son `consommateur`), et résolu **dans le rôle consommateur**, +pour que le secret ne quitte jamais ce rôle. Cf. `docs/bindings-conception.md` §5. + +## Usage +```yaml +- name: Résoudre la base depuis le registre (rôle partagé) + ansible.builtin.include_role: + name: resoudre_base + vars: + resoudre_base_groupe: serveur_keycloak +``` + +## Entrée +| Variable | Rôle | +| --- | --- | +| `resoudre_base_groupe` | Le groupe consommateur cherché dans le registre | + +## Sorties (facts, persistent après `include_role`) +| Fact | Contenu | +| --- | --- | +| `resoudre_base_entree` | L'entrée du registre (`base`, `proprietaire`, `secret`, `serveur`…) | +| `resoudre_base_db_password` | Mot de passe déréférencé de la voûte (`no_log`) | +| `resoudre_base_db_host` | **FQDN** du serveur de base | +| `resoudre_base_db_port` | Port (défaut `5432`) | + +## Pourquoi le FQDN (et pas le nom court) +Décision d'architecture : non ambigu en fédération (`data-sql-01` existe chez plusieurs +tenants) **et** nom canonique pour la vérification TLS `verify-full`. Résolu par le plancher +`/etc/hosts` (`hosts_statiques`). + +## Notes / limites +- Le rôle **assère** la présence d'une entrée (`base`, `proprietaire`, `secret`) : aucun + consommateur ne peut être déployé sans sa déclaration dans le plan. Message d'erreur + explicite pointant `instance/plan/bases-donnees.yml`. +- Le secret est déréférencé par `lookup('vars', )` : le registre ne contient que le + **nom** de la variable de voûte, jamais sa valeur. +- Un seul consommateur par entrée (le premier trouvé gagne). + +## Prérequis +- `setops_plan_dir` défini ; voûte déverrouillée (`ANSIBLE_VAULT_PASSWORD_FILE`). diff --git a/roles/serveur_backup/README.md b/roles/serveur_backup/README.md new file mode 100644 index 0000000..9d3b9d8 --- /dev/null +++ b/roles/serveur_backup/README.md @@ -0,0 +1,44 @@ +# serveur_backup + +**Cible des sauvegardes** : héberge les dépôts restic (un sous-dossier par nœud source), +servis en **SFTP/SSH** à un utilisateur restreint. Le pendant de `client_backup`. + +## Rôle +- Crée l'utilisateur système `restic` et la racine des dépôts `/srv/restic`. +- Sécurise cette racine (droits stricts). +- Autorise la **clé publique** de sauvegarde dans son `authorized_keys`. + +C'est tout : le rôle est délibérément minimal. Aucun démon, aucune logique de sauvegarde — +tout se passe côté client (dumps, chiffrement, rétention). + +## Sécurité +Le **chiffrement est fait par le client** (restic) : ce nœud ne détient que des blocs +chiffrés et n'a jamais le mot de passe des dépôts. Compromettre la cible ne donne pas accès +aux données. + +La clé **privée** correspondante vit dans la voûte, côté `client_backup` +(`vault_backup_ssh_privkey`) ; seule la publique est déclarée ici. + +## Variables +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `serveur_backup_utilisateur` | `restic` | Compte de dépôt | +| `serveur_backup_racine` | `/srv/restic` | Racine des dépôts | +| `serveur_backup_pubkey` | *(vide — **obligatoire**)* | Clé publique autorisée | + +Le rôle **exige** `serveur_backup_pubkey` (assertion) : sans elle, la cible serait déployée +mais inaccessible. + +## Flux (`meta/flux.yml`) +`22/tcp` entrant depuis `client_backup` (SSH, clé dédiée). Aucun autre port. + +## Notes / limites +- **Hors-nœud, pas hors-site** : la cible protège de la perte d'une VM, pas de la perte du + cluster. Une copie hors-site reste à faire. +- Dimensionner le disque en conséquence (`meta/empreinte.yml` : 64 Go par défaut) — c'est la + ressource critique de ce nœud. +- Le compte `restic` n'est pas confiné à un shell restreint (`rrsync`/`ForceCommand`) : + durcissement possible si la cible venait à sortir du périmètre de confiance. + +## Prérequis +- Couche **services** (avant les agents `client_backup`). diff --git a/roles/serveur_debian/README.md b/roles/serveur_debian/README.md new file mode 100644 index 0000000..70f9dbd --- /dev/null +++ b/roles/serveur_debian/README.md @@ -0,0 +1,39 @@ +# serveur_debian + +**Rôle-catégorie** du socle : il ne porte **aucune tâche**. Son unique contenu est +`meta/flux.yml` — la déclaration du **plan de gestion** (SSH) de tout nœud de la flotte. + +## Pourquoi un rôle sans tâches +Le résolveur de flux (`scripts/resoudre_flux.py`, `make flux`) agrège les +`roles//meta/flux.yml` **par nom de groupe**. Le groupe `serveur_debian` est le socle +appliqué à tous les hôtes ; c'est donc ici que se déclare le flux SSH d'administration. + +> ⚠️ **Critique** : sans cette déclaration, les rulesets nftables générés +> (`nftables_baseline`, `policy drop`) couperaient l'accès Ansible/SSH à toute la flotte. + +## Le travail réel +Il est fait par le playbook du groupe, `playbooks/groupes/serveur_debian.yml`, qui applique +dans l'ordre : + +| Rôle | Apport | +| --- | --- | +| `common_packages` | Paquets de base | +| `hosts_statiques` | Plancher de résolution `/etc/hosts` (indépendant du DNS) | +| `qemu_guest_agent` | Agent invité Proxmox | +| `cloud_init` | Cohérence du premier démarrage | +| `sudo_ansible` | Compte de déploiement | +| `chrony` | Horloge (`fuseau_horaire`) | +| `ssh_baseline` | Base SSH | +| `systemd_ssh_auto` | Démarrage SSH fiable | +| `motd` | Bannière | + +Le playbook refuse toute cible non-Debian (assertion `ansible_facts.distribution`). + +## Place dans l'ordre +Couche **socle** (`docs/couches-deploiement.yml`) — la première. Le durcissement +(`serveur_durci`) vient juste après, tout le reste ensuite. + +## Notes +- Ajouter un flux réseau **du socle** (pas d'un service) se fait ici, pas ailleurs. +- `hosts_statiques` étant appliqué ici, la résolution par nom fonctionne dès le socle, + avant que PowerDNS existe — c'est ce qui permet l'ordre de reconstruction from-zero. diff --git a/roles/serveur_dovecot/README.md b/roles/serveur_dovecot/README.md new file mode 100644 index 0000000..ea38ea7 --- /dev/null +++ b/roles/serveur_dovecot/README.md @@ -0,0 +1,54 @@ +# serveur_dovecot + +**Mailstore** : Dovecot 2.4 (Debian 13) — IMAP pour les utilisateurs, LMTP pour la remise +depuis Postfix, authentification et résolution des comptes sur l'annuaire OpenLDAP. +Stockage **Maildir** de boîtes virtuelles. Cf. `docs/courriel-conception.md`. + +## Rôle +- Installe `dovecot-core`, `-imapd`, `-lmtpd`, `-ldap`. +- Crée l'utilisateur/groupe système `vmail` (uid/gid 5000) et `/var/vmail`. +- **TLS** : pont de certificat step_ca (`client_pki`) — script `setops-dovecot-cert-sync` + + unités `.service`/`.path` qui recopient le certificat d'hôte dans `/etc/dovecot/tls` + et rechargent Dovecot **à chaque renouvellement**. +- **Annuaire** : connexion fournie par le rôle partagé `resoudre_annuaire` (uri, base, + bind_dn, bind_password) — rien de codé en dur. +- Déploie toute la configuration en **un drop-in** `conf.d/99-setops.conf` (syntaxe 2.4), + valide avec `doveconf` avant d'activer le service. +- Désactive l'auth système par défaut : **LDAP est l'unique autorité**. + +## Réglages Dovecot 2.4 qui comptent +La 2.4 a changé la donne par rapport à la 2.3 ; ces trois points conditionnent la remise : +- `static_allow_all_users` pour le userdb static ; +- `mail_inbox_path` laissé **vide** ; +- `mail_path` **par utilisateur** — `{{ vmail_base }}/%{user | username}`. + +Le local-part seul (`| username`) donne le **même chemin** pour la remise LMTP (destinataire +local-part) et l'accès IMAP (adresse complète) — c'est ce qui fait fonctionner le flux +bout-en-bout en mono-domaine. + +## Variables principales +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `serveur_dovecot_vmail_base` | `/var/vmail` | Racine des boîtes | +| `serveur_dovecot_mail_path` | `/%{user \| username}` | Chemin Maildir par compte | +| `serveur_dovecot_ldap_filter` | `(&(objectClass=inetOrgPerson)(mail=%{user}))` | Login = adresse courriel | +| `serveur_dovecot_tls_actif` | `true` | Pont de certificat step_ca | +| `serveur_dovecot_lmtp_reseau` | `true` | LMTP :24 pour un MTA **distant** (edge-mta) | +| `serveur_dovecot_sasl_reseau` | `false` | Auth SASL réseau :12345 pour la soumission :587 | + +## Flux (`meta/flux.yml`) +`993/tcp` IMAPS (utilisateurs) · `24/tcp` LMTP ← Postfix (TLS vérifié) · +`12345/tcp` SASL ← Postfix · `636/tcp` → OpenLDAP (userdb/passdb). + +## Notes / limites +- **Mono-domaine** : le chemin ne conserve pas le domaine. Le multi-domaine demandera de le + préserver des deux côtés (raffinement Étape B). +- LMTP et SASL **réseau** doivent être restreints au nœud MTA par pare-feu — c'est ce que + fait `nftables_baseline` à partir de `meta/flux.yml` (`pair: serveur_postfix`). +- Si Postfix est **co-localisé**, le rôle bascule sur les sockets sous le chroot + (`/var/spool/postfix/private`) plutôt que sur le réseau (détection automatique). +- Le certificat est **exigé** : sans `client_pki` sur le nœud, le rôle échoue explicitement. + +## Prérequis +- `serveur_dovecot requiert serveur_openldap actif` (`docs/dependances-groupes.yml`). +- `client_pki` appliqué sur le nœud (couche `pki_client`, avant la couche `services`). diff --git a/roles/serveur_icingaweb2/README.md b/roles/serveur_icingaweb2/README.md new file mode 100644 index 0000000..ca0e8e6 --- /dev/null +++ b/roles/serveur_icingaweb2/README.md @@ -0,0 +1,58 @@ +# serveur_icingaweb2 + +**Frontal de supervision** : Icinga Web 2 + module IcingaDB + module *Business Process*, +co-localisé avec le moteur `serveur_icinga`. Application PHP servie par un nginx **local** +et php-fpm ; l'edge nginx proxifie par nom. + +## Rôle +- Résout sa base IcingaDB via `resoudre_base` (même consommateur que le moteur) et + l'annuaire via `resoudre_annuaire` — aucun câblage en dur. +- Installe `icingadb-web` (qui tire `icingaweb2`), le module BPM, PHP 8.4 (fpm, pgsql, ldap, + intl, gd, curl, xml, mbstring) et nginx. +- Déploie la configuration `.ini` (ressources, authentification, rôles, IcingaDB, Redis), + active les modules, déploie le vhost nginx local et retire le site par défaut. +- **Processus métier (BPM)** : peut en semer en IaC (`serveur_icingaweb2_bpm_processes`), tout + en laissant le répertoire éditable depuis l'UI. + +## Deux modes d'authentification +| `serveur_icingaweb2_auth` | Fonctionnement | +| --- | --- | +| `ldap` (défaut) | Connexion directe à OpenLDAP (LDAPS) — Icinga Web 2 n'a pas d'OIDC natif | +| `external` | L'utilisateur est fourni par une passerelle SSO devant (`serveur_oauth2_proxy` → Keycloak) ; nginx pose `REMOTE_USER` | + +En mode `external`, restreindre l'écoute de nginx à la boucle locale +(`serveur_icingaweb2_nginx_bind: "127.0.0.1:"`) — sinon l'application reste joignable en +contournant la passerelle. + +## Variables principales +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `serveur_icingaweb2_hostname` | `icinga.{{ domaine_interne }}` | Nom servi | +| `serveur_icingaweb2_http_port` | `8080` | nginx local (l'edge proxifie ici) | +| `serveur_icingaweb2_auth` | `ldap` | Backend d'authentification | +| `serveur_icingaweb2_remote_user` | `$remote_user` | Variable nginx source de `REMOTE_USER` | +| `serveur_icingaweb2_nginx_bind` | `""` | `"127.0.0.1:"` derrière une passerelle | +| `serveur_icingaweb2_admins` | `testmail` | uid recevant le rôle Administrateur (liste séparée par virgules) | +| `serveur_icingaweb2_redis_port` | `6380` | Redis IcingaDB **local** | +| `serveur_icingaweb2_modules` | `[icingadb, businessprocess]` | Modules activés | +| `serveur_icingaweb2_bpm_processes` | `{}` | Processus métier semés en IaC | + +## Flux (`meta/flux.yml`) +`8080/tcp` entrant depuis l'edge · `5432/tcp` → PostgreSQL (IcingaDB, `verify-full`) · +`636/tcp` → OpenLDAP. Icinga 2 (API `5665`) et le Redis IcingaDB (`6380`) sont +**co-localisés** : consommés en localhost, donc absents du registre des flux. + +## Notes / limites +- `serveur_icingaweb2_admins` doit désigner de vrais uid de l'annuaire — sinon plus personne + n'est administrateur de l'interface. +- Les versions PHP sont **épinglées à 8.4** (Debian 13) dans les noms de paquets, de service et + de socket : une montée de Debian demandera de les changer ensemble. +- Le Redis IcingaDB (`6380`) est distinct du groupe `serveur_redis` (cache applicatif) et du + Redis de `serveur_rspamd`. +- Semer un processus BPM ici le met **sous gestion Ansible** : il sera réécrit à chaque + passage, même modifié dans l'UI. Par défaut, le rôle n'en sème aucun. + +## Prérequis +- `serveur_icingaweb2 requiert serveur_icinga, serveur_postgresql, serveur_openldap actifs` + (`docs/dependances-groupes.yml`). +- `client_pki` (LDAPS + PostgreSQL `verify-full`). Couche **apps**. diff --git a/roles/serveur_oauth2_proxy/README.md b/roles/serveur_oauth2_proxy/README.md new file mode 100644 index 0000000..5a78c02 --- /dev/null +++ b/roles/serveur_oauth2_proxy/README.md @@ -0,0 +1,59 @@ +# serveur_oauth2_proxy + +**Passerelle SSO générique** : place Keycloak **devant n'importe quelle application** qui n'a +pas d'OIDC natif. L'utilisateur s'authentifie une fois auprès de Keycloak ; l'application +le reçoit via un **en-tête** (authentification « external »). + +C'est le patron réutilisable qui évite d'écrire une intégration OIDC par application. +Éprouvé devant Icinga Web 2. + +## Comment ça s'assemble +``` +navigateur → edge nginx (TLS) → oauth2-proxy :4180 → application (127.0.0.1:8080) + ↓ + Keycloak (OIDC) +``` +L'application passe en `auth: external` et lit `REMOTE_USER`, posé par nginx depuis l'en-tête +de la passerelle. Elle n'a **aucune** connaissance d'OIDC. + +## Rôle +- Installe le binaire Go officiel depuis les *releases* GitHub (pas d'apt), sous + `/usr/local/bin/oauth2-proxy`, avec un utilisateur système dédié. +- Déploie la configuration et l'unité systemd, active le service. +- **Assère** d'entrée toute la configuration OIDC obligatoire — pas de démarrage à moitié + configuré. + +## Variables obligatoires (par instance) +| Variable | Rôle | +| --- | --- | +| `serveur_oauth2_proxy_client_id` | Client OIDC déclaré dans Keycloak | +| `serveur_oauth2_proxy_client_secret` | Secret du client (**voûte**) | +| `serveur_oauth2_proxy_redirect_url` | `https:///oauth2/callback` | +| `serveur_oauth2_proxy_upstream` | Application protégée (ex. `http://127.0.0.1:8080`) | +| `serveur_oauth2_proxy_cookie_secret` | 32 octets base64 (**voûte**, `vault_oauth2_cookie`) | + +## Autres variables +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `serveur_oauth2_proxy_version` | `v7.15.3` | Version épinglée | +| `serveur_oauth2_proxy_ecoute` | `0.0.0.0:4180` | L'edge proxifie ici | +| `serveur_oauth2_proxy_realm` | `{{ identite_realm }}` | Realm applicatif | +| `serveur_oauth2_proxy_issuer` | `https://keycloak./realms/` | Émetteur OIDC | +| `serveur_oauth2_proxy_email_domains` | `*` | Tout utilisateur authentifié par Keycloak | +| `serveur_oauth2_proxy_allow_unverified_email` | `true` | Voir ci-dessous | +| `serveur_oauth2_proxy_ca_bundle` | `/etc/ssl/certs/ca-certificates.crt` | Racine step_ca (via `client_pki`) | + +## Notes / limites +- **`allow_unverified_email: true` est nécessaire ici** : les comptes viennent de l'annuaire + LDAP, qui ne porte pas de drapeau `email_verified`. L'IdP est interne et de confiance ; + sans ce réglage, aucune connexion ne passe. +- La version est **épinglée** : une montée de version est un geste délibéré (relire les notes + de version d'oauth2-proxy, les options changent de nom entre majeures). +- Le service écoute en clair sur `:4180` — le TLS est terminé à l'edge. À restreindre à l'edge + par pare-feu (`meta/flux.yml`, `pair: edge`). +- Une instance protège **une** application (upstream unique). Deux applications = deux + instances (ou un déploiement par nœud applicatif). + +## Prérequis +- `client_pki` (confiance step_ca pour joindre Keycloak en HTTPS) et `serveur_keycloak` actif. +- Le client OIDC doit exister dans le realm Keycloak, avec la bonne URL de redirection. diff --git a/roles/serveur_postfix/README.md b/roles/serveur_postfix/README.md new file mode 100644 index 0000000..778987f --- /dev/null +++ b/roles/serveur_postfix/README.md @@ -0,0 +1,57 @@ +# serveur_postfix + +**MTA** : Postfix 3.x (Debian 13) sur le nœud *edge-mta* — réception SMTP :25, cartes LDAP +(domaines, boîtes, alias), remise **LMTP réseau** vers le mailstore (`serveur_dovecot`). +**Ne stocke aucune boîte.** Cf. `docs/courriel-conception.md`. + +## Rôle +- Préconfigure Postfix par **debconf** (installation non interactive), installe + `postfix` + `postfix-ldap`. +- **Chroot** : recopie `/etc/hosts` dans `/var/spool/postfix/etc/` — le MTA hérite du + plancher de résolution (`hosts_statiques`), sinon il ne résout aucun nom interne. +- **TLS** : pont de certificat step_ca (`client_pki`) — script `setops-postfix-cert-sync` + + unités `.service`/`.path`, recharge Postfix à chaque renouvellement. +- **Annuaire** : connexion fournie par `resoudre_annuaire` ; carte `ldap-mailboxes.cf` + (validation des destinataires contre LDAP). +- Soumission `:587` optionnelle, avec **SASL délégué à Dovecot** (passdb LDAP). +- Valide la configuration (`postfix check`) avant d'activer le service. + +## Liaisons (`meta/liens.yml`) +Le rôle **accepte** deux liens déclarés côté application dans `plan/applications.yml` : + +| Lien | Effet | +| --- | --- | +| `mailstore` | Injecte `serveur_postfix_mailstore_hote` = FQDN de la cible (Dovecot LMTP) | +| `milter` | Passe `serveur_postfix_rspamd_milter` à `true` (rspamd co-localisé) | + +C'est le sens « **app→app** », résolu par `scripts/instancier.py`. Cf. +`docs/bindings-conception.md`. + +## Variables principales +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `serveur_postfix_mailstore_hote` | *(vide — **obligatoire**)* | Nœud Dovecot, normalement injecté par le lien `mailstore` | +| `serveur_postfix_lmtp_port` | `24` | LMTP vers le mailstore | +| `serveur_postfix_reseaux_confiance` | `127.0.0.0/8 [::1]/128` | `mynetworks` (relais autorisé) | +| `serveur_postfix_submission_actif` | `false` | Soumission :587 (SASL Dovecot) | +| `serveur_postfix_rspamd_milter` | `false` | Milter antispam/DKIM co-localisé | +| `serveur_postfix_lmtp_tls_verify` | `false` | Zéro-confiance : vérifier le certificat du mailstore | + +## Flux (`meta/flux.yml`) +`25/tcp` entrant (externe + `client_smtp`) · `587/tcp` soumission (flotte) · +`24/tcp` → Dovecot (TLS vérifié) · `12345/tcp` → Dovecot (SASL) · +`11332/tcp` → rspamd local · `636/tcp` → OpenLDAP · `25/tcp` sortant (MX distants). + +## Notes / limites +- Le rôle **exige** `serveur_postfix_mailstore_hote` (assertion) : pas de remise locale, la + remise finale appartient au mailstore. C'est la scission edge-mta / mail-store. +- `serveur_postfix_reseaux_confiance` est à adapter au réseau de l'instance — laissé au + strict minimum par défaut. +- `serveur_postfix_lmtp_tls_verify: true` demande que la racine step_ca soit lisible + (`/etc/step/certs/root_ca.crt`, posée en `0644` par `client_pki`). +- La frontière publique (MX, SPF/DKIM/DMARC publics, filtrage entrant) relève de + l'OPNsense — Étape B, hors flotte Ansible. + +## Prérequis +- `serveur_postfix requiert serveur_dovecot actif` (`docs/dependances-groupes.yml`). +- `client_pki` appliqué sur le nœud. diff --git a/roles/serveur_rspamd/README.md b/roles/serveur_rspamd/README.md new file mode 100644 index 0000000..49c7b10 --- /dev/null +++ b/roles/serveur_rspamd/README.md @@ -0,0 +1,40 @@ +# serveur_rspamd + +**Antispam + signature DKIM** : rspamd 3.x (Debian 13), branché en **milter** sur Postfix +(nœud *edge-mta*), avec Redis local comme backend. **Ne stocke aucune boîte.** +Cf. `docs/courriel-conception.md`. + +## Rôle +- Installe `rspamd` et `redis-server` (backend local, non partagé). +- **Clé DKIM** : génération **idempotente** — la clé n'est créée que si elle est absente, + puis ses droits sont fixés. Un redéploiement ne casse jamais une signature en place. +- Affiche l'**enregistrement DNS DKIM à publier** (`._domainkey`) — la publication + relève de la frontière publique (Étape B). +- Configure par **surcharges** `local.d/` uniquement (`redis.conf`, `worker-proxy.inc`, + `dkim_signing.conf`) : les fichiers Debian d'origine ne sont jamais édités. + +## Variables +| Variable | Défaut | Rôle | +| --- | --- | --- | +| `serveur_rspamd_redis_serveur` | `127.0.0.1:6379` | Backend Redis local | +| `serveur_rspamd_milter_port` | `11332` | Worker proxy consommé par Postfix | +| `serveur_rspamd_dkim_actif` | `true` | Signature DKIM | +| `serveur_rspamd_dkim_domaine` | `{{ domaine_interne }}` | Domaine signé (**public** en prod) | +| `serveur_rspamd_dkim_selecteur` | `setops` | Sélecteur DKIM | +| `serveur_rspamd_dkim_repertoire` | `/var/lib/rspamd/dkim` | Clés | + +## Flux (`meta/flux.yml`) +`11332/tcp` milter et `11334/tcp` interface de contrôle — **`localhost` uniquement**. +Le couplage à Postfix est une co-localisation, pas un flux réseau. + +## Notes / limites +- Le Redis d'ici est **local au nœud** et distinct du groupe `serveur_redis` (cache + applicatif) : ne pas les confondre ni les fusionner. +- Le domaine signé par défaut est le domaine **interne** (bac à sable). En production, il + doit être le domaine **public**, et l'enregistrement DKIM publié dans la zone publique — + sinon la signature ne vaut rien pour les MX distants. +- Côté Postfix, l'activation passe par le lien `milter` (`meta/liens.yml` de + `serveur_postfix`), pas par une variable saisie à la main. + +## Prérequis +- Postfix co-localisé sur le même nœud (le milter n'écoute qu'en local).