Set-OPS-Public/roles/serveur_ops_tenant/tasks/main.yml
Daniel Allaire 8890c997af
Some checks are pending
verifier / verifier (push) Waiting to run
runner : serveur_ops_tenant — le runner d'un tenant recoit enfin sa voute
La doctrine des runners decrit trois portees depuis le 2026-08-22 :

  calculer      plan -> inventaire        aucune voute        serveur_ops
  configurer    roles sur ses machines    voute du TENANT     <- revendiquee, jamais recue
  materialiser  creer/detruire des VM     voute du SITE       serveur_ops_site

La deuxieme ligne etait un trou. RIEN ne deposait jamais la voute d'un tenant sur
son runner. Un runner pouvait deriver son inventaire et ne rien pouvoir en faire :
chaque role qui demande un secret echouait sur son assertion, et l'echec ne disait
pas qu'il manquait un FICHIER, seulement que les valeurs etaient vides.

Decouvert en preparant la reconstruction de Chezlepro. Le runner du SITE peut
materialiser ses quinze machines ; il ne peut pas les configurer, parce que
Chezlepro a sa PROPRE autorite de certification — donc `client_pki` y reclame un
secret de Chezlepro. Le runner du site ne l'a pas, et NE DOIT PAS l'avoir : c'est
la ligne qui rend l'hebergement mutualise defendable.

`serveur_ops_tenant` est le symetrique exact de `serveur_ops_site` : un MARQUEUR,
pas un installateur. Il depose la voute `decrypt: false`, puis RELIT l'en-tete du
fichier depose — une voute dechiffree par accident est une fuite silencieuse. Le
dossier d'inventaire (`principal` ou `production`) se DECOUVRE sur la machine
plutot que d'etre ecrit.

Pourquoi un role a part et non une option de `serveur_ops` : donner sa voute a un
runner est un POUVOIR, pas un reglage. Le declarer au plan force a repondre a
« cette machine a-t-elle le droit de configurer cet ecosysteme ? » — une option
activee par defaut y repondrait a notre place.

CHEZLEPRO LISAIT ENCORE SON GENOME CHEZ PATIENT 0.

Trouve au passage, et bloquant pour la reconstruction : `serveur_ops_forge_amont`
pointait sur `10.29.16.11` — la forge de patient 0, l'amont d'avant que le site
ait la sienne. D-81 a tranche depuis. Laisse tel quel, Chezlepro se serait
reconstruit depuis un moteur perime, sur un reseau que le decoupage en zones a de
toute facon deplace.

Corrige vers la forge du site, PAR SON IP — `forge.genese.internal` appartient a
la zone souveraine du site, et un tenant ne resout que la sienne ; le certificat
SERVI porte bien `IP Address:10.0.33.11`. La racine de l'AC du site est desormais
versionnee a cote de la carte de la fabric a laquelle elle appartient, et son
chemin se DERIVE du symlink `underlay.yml` : il vaut depuis le poste comme depuis
un runner.

Le role est inscrit dans les quatre registres qui l'exigeaient — couches de
deploiement, graphe des dependances, catalogue des services, carte d'orientation.
Ce sont les preuves P08, P38 et P48 qui l'ont reclame, chacune a son tour.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-26 15:30:51 -04:00

113 lines
4.7 KiB
YAML

---
- name: Exiger les intrants du runner de tenant
ansible.builtin.assert:
that:
- serveur_ops_tenant_depot | length > 0
- (not (serveur_ops_tenant_voute_deposer | bool))
or (serveur_ops_tenant_voute_source | length > 0)
fail_msg: >-
serveur_ops_tenant exige `serveur_ops_tenant_depot` (le dossier de CET écosystème
chez le runner, cloné par serveur_ops — il vaut `serveur_ops_instance` par défaut)
et, si le dépôt de la voûte est demandé, `serveur_ops_tenant_voute_source`
(le chemin de son `vault.yml` sur le contrôleur).
- name: Le plan de l'écosystème est-il bien là ?
ansible.builtin.stat:
path: "{{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot }}/plan/serveurs.yml"
register: serveur_ops_tenant_plan
- name: Refuser si le plan de l'écosystème manque
ansible.builtin.assert:
that:
- serveur_ops_tenant_plan.stat.exists
fail_msg: >-
{{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot }}/plan/serveurs.yml est
absent. Déclarer ce dépôt dans `serveur_ops_depots` (role: instance) et rejouer
serveur_ops : donner sa voûte à un runner qui n'a pas le plan qu'elle ouvre ne
configure rien — ça ne fait que déposer un secret.
when: not ansible_check_mode
# LE DOSSIER D'INVENTAIRE SE DÉCOUVRE. Deux noms existent dans le dépôt (`principal`,
# `production`) et l'écrire en dur le ferait mentir pour l'écosystème qui emploie l'autre.
- name: Chercher le dossier d'inventaire de cet écosystème
ansible.builtin.stat:
path: "{{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot }}/inventories/{{ item }}"
register: serveur_ops_tenant_candidats
loop: "{{ serveur_ops_tenant_inventaires_connus }}"
loop_control:
label: "{{ item }}"
- name: Retenir le premier qui existe
ansible.builtin.set_fact:
serveur_ops_tenant_inventaire: >-
{{ (serveur_ops_tenant_candidats.results | selectattr('stat.exists')
| map(attribute='item') | list | first) | default('') }}
- name: Refuser si aucun inventaire n'est reconnu
ansible.builtin.assert:
that:
- serveur_ops_tenant_inventaire | length > 0
fail_msg: >-
Aucun dossier d'inventaire trouvé sous
{{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot }}/inventories/ parmi
{{ serveur_ops_tenant_inventaires_connus | join(', ') }}. Sans lui, on ne saurait pas
où déposer la voûte — et la déposer au mauvais endroit revient à ne pas la déposer,
en laissant croire le contraire.
when: not ansible_check_mode
- name: Préparer le dossier des variables communes
ansible.builtin.file:
path: >-
{{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot }}/inventories/{{
serveur_ops_tenant_inventaire }}/group_vars/all
state: directory
owner: "{{ serveur_ops_tenant_utilisateur }}"
group: "{{ serveur_ops_tenant_utilisateur }}"
mode: "0700"
when:
- serveur_ops_tenant_voute_deposer | bool
- not ansible_check_mode
# LES SECRETS DE L'ÉCOSYSTÈME, DE DROIT ET NON PAR EMPRUNT.
#
# `decrypt: false` : voir defaults/main.yml. Le fichier reste chiffré ; seul le mot de
# passe, tapé à l'exécution, l'ouvre.
- name: Déposer la voûte de l'écosystème (chiffrée)
ansible.builtin.copy:
src: "{{ serveur_ops_tenant_voute_source }}"
dest: >-
{{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot }}/inventories/{{
serveur_ops_tenant_inventaire }}/group_vars/all/vault.yml
owner: "{{ serveur_ops_tenant_utilisateur }}"
group: "{{ serveur_ops_tenant_utilisateur }}"
mode: "0600"
decrypt: false
when:
- serveur_ops_tenant_voute_deposer | bool
- not ansible_check_mode
# ÉCRIRE, PUIS RELIRE (D-68). Une voûte déchiffrée par accident est une fuite silencieuse :
# le fichier existe, le rôle se dit satisfait, et les secrets de l'écosystème dorment en
# clair sur une machine.
- name: Relire l'en-tête de la voûte déposée
ansible.builtin.command:
cmd: >-
head -c 21 {{ serveur_ops_tenant_racine }}/{{ serveur_ops_tenant_depot
}}/inventories/{{ serveur_ops_tenant_inventaire }}/group_vars/all/vault.yml
register: serveur_ops_tenant_entete
changed_when: false
when:
- serveur_ops_tenant_voute_deposer | bool
- not ansible_check_mode
- name: Exiger que la voûte déposée soit CHIFFRÉE
ansible.builtin.assert:
that:
- "'$ANSIBLE_VAULT' in serveur_ops_tenant_entete.stdout"
fail_msg: >-
La voûte déposée n'est PAS chiffrée — elle a été déchiffrée en transit.
Vérifier `decrypt: false` sur la copie. Détruire le fichier au shred et considérer
les secrets de cet écosystème comme exposés.
when:
- serveur_ops_tenant_voute_deposer | bool
- not ansible_check_mode