Daniel Allaire
441dd284bb
Ajoute docs/config-proxmox.md : référence champ par champ des 16 paramètres Proxmox non sensibles + les secrets API demandés par l'assistant (sens, défaut, quoi saisir, constante vs défaut surchargeable), plus l'annexe de création du token API. Renvois ajoutés depuis make help et QUICKSTART.md. Ces invites n'étaient expliquées nulle part de façon pérenne. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
105 lines
4.5 KiB
Markdown
105 lines
4.5 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...
|
|
```
|
|
Chaque paramètre demandé est expliqué dans [`docs/config-proxmox.md`](docs/config-proxmox.md).
|
|
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`.
|