Daniel Allaire
f8e5e4d928
creer-vm HOTE=<hote> ne prend plus qu'un argument : il lit VMID/IP/CIDR/passerelle/VLAN/stockage/disque/noeud dans l'inventaire genere (nouvelle sous-commande inventory_host parametres-proxmox), comme deployer lit ses groupes, et n'ecrit plus dans l'inventaire (plus de hote-ajouter). Les 3 cibles legacy hote-ajouter/planifier/groupes sont neutralisees (refus -> plan). Aide + docs alignees. Premier test stdlib du depot + cible make test, cablee dans make verifier. Verifie : make verifier exit 0 (4 tests), extraction testee sur l'inventaire reel + chemins de refus. Clonage reel non execute (Proxmox). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
104 lines
4.4 KiB
Markdown
104 lines
4.4 KiB
Markdown
# Démarrage rapide — de zéro à ton écosystème souverain
|
|
|
|
Tu débarques avec une **grappe Proxmox vierge** et tu veux monter ton écosystème
|
|
numérique. Voici le chemin, de bout en bout. Set-OPS est le **moteur** ; tu vas
|
|
créer **ton instance** à partir d'un modèle, puis déployer.
|
|
|
|
> Concepts en 10 s : tu **décris un plan** (quelles VM, quels services), le moteur
|
|
> **génère l'inventaire**, et Ansible **déploie**. Tu n'édites jamais l'inventaire
|
|
> à la main. Détails : `docs/plan-et-generation.md`.
|
|
|
|
## 0. Prérequis (à toi de fournir)
|
|
- une **grappe Proxmox** où tu es admin (API activée) ;
|
|
- une machine de pilotage Linux avec **Ansible**, **Python 3**, **make**, `git`
|
|
(et `node` pour le garde-fou JS du GUI, optionnel) ;
|
|
- un **token API Proxmox** ;
|
|
- une **paire de clés SSH** (la publique ira dans les VM via cloud-init) ;
|
|
- un **mot de passe Ansible Vault** (pour chiffrer tes secrets).
|
|
|
|
## 1. Cloner le moteur
|
|
```bash
|
|
git clone <url-de-Set-OPS> Set-OPS && cd Set-OPS
|
|
```
|
|
|
|
## 2. Choisir un modèle et créer ton instance
|
|
Les modèles sont dans `exemples/modeles/` (voir leur README). Choisis selon ton offre :
|
|
`socle`, `presence-web`, `forge`, `identite`, `observabilite`, `integral`.
|
|
|
|
```bash
|
|
cp -r exemples/modeles/presence-web ../mon-instance # ton instance, ailleurs
|
|
ln -s ../mon-instance instance # le moteur la trouve via ce lien
|
|
```
|
|
*(Alternative au symlink : `export SETOPS_INSTANCE=../mon-instance`.)*
|
|
|
|
## 3. Renseigner ton instance (« tes couleurs »)
|
|
- `instance/inventories/production/group_vars/all.yml` → **`domaine_interne`** (ex. `monorg.internal`) ;
|
|
- `instance/plan/nomenclature.yml` → ton **supernet** (ex. `10.20.0.0/16`) ;
|
|
- `instance/plan/domaines.yml` → ton **domaine public** ;
|
|
- `instance/plan/serveurs.yml` → **placement Proxmox** (nœud, stockage, disque, mémoire, cœurs).
|
|
|
|
Tu peux aussi le faire dans le GUI plus tard (`make inventaire-ui`).
|
|
|
|
## 4. Configurer Proxmox et tes secrets
|
|
```bash
|
|
make config # renseigne API host/user/port, nœud, stockage, VMID du template...
|
|
```
|
|
Place ton **token API** et tes secrets dans le Vault de l'instance
|
|
(`instance/inventories/lab/group_vars/proxmox.vault.yml`, à partir du `.example`,
|
|
chiffré avec `ansible-vault`). Exporte ton mot de passe Vault, ex. :
|
|
```bash
|
|
export ANSIBLE_VAULT_PASSWORD_FILE=~/.config/setops-vault-pass
|
|
```
|
|
|
|
## 5. Construire le golden template Debian 13 (UNE seule fois)
|
|
Une grappe vierge n'a aucun template. Crée une VM **Debian 13 vanille**, rends-la
|
|
joignable par Ansible, puis :
|
|
```bash
|
|
make preparer-modele # socle + durcissement + cloud-init + qemu-guest-agent...
|
|
make verifier-modele
|
|
make nettoyer-modele CONFIRMER=true
|
|
```
|
|
Convertis ensuite la VM en **template Proxmox** nommé `modele-debian13` (le nom de
|
|
clone source par défaut). Détails et procédure : `docs/vm-lifecycle.md` et
|
|
`docs/procedure-template-debian13-proxmox.md`.
|
|
|
|
## 6. Générer ton inventaire depuis le plan
|
|
```bash
|
|
make instancier # montre ce que le plan produit (diff)
|
|
make instancier-appliquer FORCE=1 # 1re génération : écrit instance/inventories/production/hosts.yml
|
|
```
|
|
Tes hôtes sont là, en état `planifie`. `make serveurs` te montre leurs VMID/IP dérivés.
|
|
|
|
## 7. Créer les VM (clone du template + cloud-init)
|
|
Pour chaque hôte — `creer-vm` lit ses VMID/IP/VLAN/passerelle directement dans
|
|
l'inventaire généré (`make serveurs` te les montre) :
|
|
```bash
|
|
make creer-vm HOTE=infra-dns-01
|
|
```
|
|
*(Les valeurs de nœud/stockage/template viennent de `make config`. La création
|
|
suit désormais le plan de bout en bout : un seul argument, `HOTE`.)*
|
|
|
|
## 8. Activer puis déployer
|
|
Passe l'hôte en `etat: actif` dans `instance/plan/serveurs.yml`, régénère, déploie :
|
|
```bash
|
|
make instancier-appliquer
|
|
make deployer HOTE=infra-dns-01 # configure l'hôte selon ses groupes
|
|
# ou, par couche :
|
|
make deployer-groupe GROUPE=serveur_postgresql
|
|
```
|
|
Les déploiements de groupe ne ciblent **que** les hôtes actifs.
|
|
|
|
## 9. Ensuite : tu vis dans le plan
|
|
Édite le plan (GUI `make inventaire-ui`, ou les registres `instance/plan/`),
|
|
`make instancier-appliquer`, `make deployer`. Tu ne touches jamais `hosts.yml`.
|
|
|
|
## Valider à tout moment
|
|
```bash
|
|
make inventaire-verifier # registres + inventaire + garde-fous
|
|
make verifier # + ansible-lint + --syntax-check
|
|
```
|
|
|
|
---
|
|
|
|
Ordre de mise en place des services : `docs/catalogue-services.md`. Modèle,
|
|
registres et règle d'or : `docs/plan-et-generation.md` et `AGENTS.md`.
|