Bootstrapping d'un nouvel environnement¶

Ce runbook décrit les étapes pour créer un nouvel environnement (TEST ou PROD) from scratch. Ces étapes sont des prérequis avant que le pipeline GitLab CI/CD puisse fonctionner.

Vue d'ensemble¶

┌─────────────────────────────────────────────────────────────────────────────┐
│                     ORDRE DE BOOTSTRAPPING                                   │
│                                                                              │
│  1. Créer VPS (OVH Console)                                                 │
│         │                                                                    │
│         ▼                                                                    │
│  2. Configurer DNS (Terraform local ou OVH Console)                         │
│         │                                                                    │
│         ▼                                                                    │
│  3. Déployer Ansible (depuis machine locale)                                │
│     - Installe Vault, GitLab Runner, etc.                                   │
│         │                                                                    │
│         ▼                                                                    │
│  4. Initialiser Vault (secrets AWS, OVH)                                    │
│         │                                                                    │
│         ▼                                                                    │
│  5. Configurer GitLab Runner (tags)                                         │
│         │                                                                    │
│         ▼                                                                    │
│  6. Pipeline GitLab opérationnel ✅                                         │
└─────────────────────────────────────────────────────────────────────────────┘

Prérequis¶

Accès à la console OVH (création VPS)
Credentials OVH API (pour DNS)
Credentials AWS (pour S3/Glacier)
Clé SSH pour accès au VPS
Accès admin GitLab (pour enregistrer le runner)

Prérequis sur le Runner (installés à l'étape 5)¶

Ces outils doivent être installés sur le VPS pour que les pipelines CI/CD fonctionnent :

Ansible (pour les jobs ansible:*) - installé via pipx
Terraform (pour les jobs terraform:*) - installé via tfenv
pipx (gestionnaire de packages Python isolés)

Étape 1 : Créer le VPS sur OVH¶

1.1 Via OVH Console¶

Aller sur https://www.ovh.com/manager/
Cloud > Serveurs > VPS > Commander
Choisir :
Localisation : Gravelines (GRA) ou Roubaix (RBX)
OS : Ubuntu 22.04 LTS
Taille : VPS Starter (2 vCPU, 2 GB RAM) minimum
Noter l'IP publique IPv4 et IPv6

1.2 Informations à collecter¶

# Exemple pour environnement TEST
VPS_NAME="probatiovault-test"
VPS_IPV4="xxx.xxx.xxx.xxx"
VPS_IPV6="2001:xxxx:xxxx:xxxx::xxxx"
VPS_GATEWAY="2001:xxxx:xxxx:xxxx::1"
ENV_NAME="test"

Étape 2 : Configurer les entrées DNS¶

2.1 DNS requis pour le nouvel environnement¶

Sous-domaine	Type	Cible	Description
`test`	A	`{VPS_IPV4}`	Domaine principal
`api.test`	CNAME	`test`	API Backend
`vault.test`	CNAME	`test`	HashiCorp Vault
`id.test`	CNAME	`test`	Keycloak IdP
`grafana.test`	CNAME	`test`	Monitoring
`docs.test`	CNAME	`test`	Documentation

2.2 Option A : Via Terraform (recommandé)¶

Créer/mettre à jour terraform/environments/test.tfvars :

# terraform/environments/test.tfvars
environment = "test"

vps_name    = "probatiovault-test"
vps_ipv4    = "xxx.xxx.xxx.xxx"
vps_ipv6    = "2001:xxxx:xxxx:xxxx::xxxx"
vps_gateway = "2001:xxxx:xxxx:xxxx::1"

ssh_user = "ubuntu"
app_domain = "test.probatiovault.com"

install_gitlab_runner = true
install_sonarqube     = false
install_postgresql    = true
postgresql_mode       = "local"
install_keycloak      = true

server_role = "all-in-one"

Exécuter Terraform localement avec les credentials :

cd terraform

# Charger les credentials (depuis ton .env local)
export OVH_APPLICATION_KEY="xxx"
export OVH_APPLICATION_SECRET="xxx"
export OVH_CONSUMER_KEY="xxx"
export OVH_ENDPOINT="ovh-eu"

# Plan et Apply
terraform init
terraform plan -var-file="environments/test.tfvars"
terraform apply -var-file="environments/test.tfvars"

2.3 Option B : Via OVH Console (manuel)¶

Aller sur https://www.ovh.com/manager/
Web Cloud > Domaines > probatiovault.com > Zone DNS
Ajouter les enregistrements listés ci-dessus

2.4 Vérifier la propagation DNS¶

# Attendre quelques minutes puis vérifier
dig +short test.probatiovault.com
dig +short vault.test.probatiovault.com
dig +short id.test.probatiovault.com

Étape 3 : Déployer Ansible (installation initiale)¶

3.1 Préparer l'inventaire¶

Créer/vérifier ansible/inventory/test/hosts.ini :

[vps]
probatiovault-test ansible_host=xxx.xxx.xxx.xxx

[vps:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/id_rsa
env_name=test
app_domain=test.probatiovault.com

# Composants à installer
install_gitlab_runner=true
install_sonarqube=false
install_postgresql=true
postgresql_mode=local
install_keycloak=true
install_vault=true

# Vault configuration
vault_domain=vault.test.probatiovault.com
vault_ui_enabled=true

3.2 Créer le fichier de variables Vault¶

Créer ansible/inventory/test/group_vars/all/vault.yml (chiffré avec Ansible Vault) :

cd ansible

# Créer le fichier chiffré
ansible-vault create inventory/test/group_vars/all/vault.yml

Contenu :

# Vault secrets pour TEST
vault_gitlab_runner_shell_token: "glrt-xxx"  # Token GitLab Runner
vault_gitlab_runner_docker_token: "glrt-xxx"
vault_postgresql_password: "xxx"
vault_keycloak_admin_password: "xxx"

3.3 Premier déploiement Ansible¶

cd ansible

# Test de connexion
ansible -i inventory/test/hosts.ini all -m ping

# Dry-run pour vérifier
ansible-playbook -i inventory/test/hosts.ini playbook.yml --check --diff

# Déploiement réel
ansible-playbook -i inventory/test/hosts.ini playbook.yml --ask-vault-pass

3.4 Vérifier l'installation¶

ssh ubuntu@test.probatiovault.com

# Vérifier les services
sudo systemctl status vault
sudo systemctl status docker
sudo systemctl status nginx
sudo systemctl status gitlab-runner

# Vérifier Vault
export VAULT_ADDR="https://vault.test.probatiovault.com"
vault status

Étape 4 : Initialiser HashiCorp Vault¶

4.1 Initialisation de Vault (première fois uniquement)¶

ssh ubuntu@test.probatiovault.com

export VAULT_ADDR="https://vault.test.probatiovault.com"

# Initialiser Vault (génère les clés de déverrouillage)
vault operator init -key-shares=5 -key-threshold=3

# IMPORTANT: Sauvegarder les 5 clés et le root token de manière sécurisée !
# Exemple de sortie :
# Unseal Key 1: xxx
# Unseal Key 2: xxx
# Unseal Key 3: xxx
# Unseal Key 4: xxx
# Unseal Key 5: xxx
# Initial Root Token: hvs.xxx

4.2 Déverrouiller Vault¶

# Déverrouiller avec 3 clés (threshold)
vault operator unseal  # Entrer clé 1
vault operator unseal  # Entrer clé 2
vault operator unseal  # Entrer clé 3

# Vérifier le statut
vault status
# Sealed: false ✅

4.3 Configurer le token root¶

# Se connecter avec le root token
vault login hvs.xxx

# Stocker le token pour les jobs CI
echo "hvs.xxx" | sudo tee /root/.vault-token
sudo chmod 600 /root/.vault-token

4.4 Activer le moteur KV¶

# Activer le moteur de secrets KV v2
vault secrets enable -path=kv kv-v2

4.5 Ajouter les secrets pour le CI¶

export VAULT_ADDR="https://vault.test.probatiovault.com"
export VAULT_TOKEN="$(sudo cat /root/.vault-token)"

# AWS credentials (pour Terraform - S3/Glacier)
vault kv put kv/app/aws-storage \
  access_key_id="AKIA..." \
  secret_access_key="..." \
  region="eu-west-3"

# OVH credentials (pour Terraform - DNS)
vault kv put kv/ovh/api-credentials \
  application_key="..." \
  application_secret="..." \
  consumer_key="..." \
  endpoint="ovh-eu"

# Ansible Vault password (optionnel)
vault kv put kv/ansible/vault \
  password="..."

# GitLab API token (pour gestion runners)
vault kv put kv/ci/gitlab-api \
  access_token="glpat-xxx"

4.6 Vérifier les secrets¶

vault kv list kv/
vault kv get kv/app/aws-storage
vault kv get kv/ovh/api-credentials

Étape 5 : Configurer GitLab Runner¶

5.1 Enregistrer le Shell Runner¶

ssh ubuntu@test.probatiovault.com

sudo gitlab-runner register \
  --url https://gitlab.com/ \
  --registration-token "GR1348941xxx" \
  --executor shell \
  --description "ProbatioVault TEST Shell Runner" \
  --tag-list "ovh-shell-test" \
  --run-untagged=false \
  --locked=false

5.2 Enregistrer le Docker Runner¶

sudo gitlab-runner register \
  --url https://gitlab.com/ \
  --registration-token "GR1348941xxx" \
  --executor docker \
  --description "ProbatioVault TEST Docker Runner" \
  --tag-list "ovh-docker-test" \
  --docker-image "alpine:latest" \
  --docker-privileged=true \
  --docker-volumes "/var/run/docker.sock:/var/run/docker.sock" \
  --run-untagged=false \
  --locked=false

5.3 Configurer les permissions¶

# Ajouter gitlab-runner aux groupes nécessaires
sudo usermod -aG docker gitlab-runner
sudo usermod -aG sudo gitlab-runner

# Permettre sudo sans mot de passe pour gitlab-runner
echo "gitlab-runner ALL=(ALL) NOPASSWD: ALL" | sudo tee /etc/sudoers.d/gitlab-runner

# Redémarrer le runner
sudo gitlab-runner restart
sudo gitlab-runner verify

5.4 Installer les outils CI pour gitlab-runner¶

# Installer pipx (gestionnaire de packages Python isolés)
sudo apt-get install -y pipx

# Installer Ansible pour l'utilisateur gitlab-runner
sudo -u gitlab-runner bash -c "pipx ensurepath && pipx install ansible-core && pipx inject ansible-core passlib hvac"

# Ajouter le PATH à .profile (pour les jobs CI)
echo 'export PATH="$PATH:/home/gitlab-runner/.local/bin"' | sudo tee -a /home/gitlab-runner/.profile
sudo chown gitlab-runner:gitlab-runner /home/gitlab-runner/.profile

# Vérifier l'installation
sudo -u gitlab-runner bash -c "source ~/.profile && ansible --version"

5.5 Vérifier dans GitLab¶

Aller sur GitLab > Settings > CI/CD > Runners
Vérifier que les runners avec tags ovh-shell-test et ovh-docker-test sont actifs

Étape 6 : Tester le pipeline¶

6.1 Créer la branche test¶

git checkout dev
git checkout -b test
git push -u origin test

6.2 Vérifier l'exécution du pipeline¶

Aller sur GitLab > CI/CD > Pipelines
Vérifier que terraform:plan:test s'exécute
Vérifier les logs : "✅ AWS credentials loaded from Vault"

Checklist finale¶

Troubleshooting¶

Vault sealed après reboot¶

# Vault se verrouille après chaque reboot
# Déverrouiller avec 3 clés
vault operator unseal
vault operator unseal
vault operator unseal

Runner ne trouve pas Vault¶

# Vérifier le token
sudo cat /root/.vault-token

# Vérifier la connexion
export VAULT_ADDR="https://vault.test.probatiovault.com"
export VAULT_TOKEN="$(sudo cat /root/.vault-token)"
vault status
vault kv list kv/

Certificat SSL invalide¶

# Vérifier que certbot a généré les certificats
sudo certbot certificates

# Renouveler si nécessaire
sudo certbot renew --dry-run

DNS non résolu¶

# Vérifier la propagation
dig +trace vault.test.probatiovault.com

# Flush le cache DNS local
# macOS
sudo dscacheutil -flushcache
# Linux
sudo systemd-resolve --flush-caches