lecoffre_node/docs/retours_experience/REX_CONFIGURATION_MANAGEMENT.md

Retour d'Expérience : Gestion des configurations

Problème initial

• Erreurs : Fichiers de configuration non écrits correctement
• Impact : Services ne démarrent pas avec les bonnes configurations
• Cause : Écriture non effective des fichiers de configuration

Erreurs rencontrées

1. Fichiers de configuration non écrits

# ❌ Problème : Écriture non effective
echo "bootstrap_url=wss://dev3.4nkweb.com/ws/" >> relay/sdk_relay.conf
# Le fichier n'était pas mis à jour correctement

2. Permissions insuffisantes

# ❌ Erreur
sed: cannot rename /home/bitcoin/sedktvYLI: Device or resource busy

3. Variables d'environnement non prises en compte

# ❌ Problème : .env override docker-compose.yml
# docker-compose.yml
environment:
  - SIGNER_WS_URL=ws://dev3.4nkweb.com:9090

# .env (override)
SIGNER_WS_URL=ws://sdk_signer:9090

Solutions implémentées

1. Vérification systématique des écritures

#!/bin/bash
# verify_config_writing.sh

# Fonction de vérification
verify_config_file() {
    local file="$1"
    local expected_content="$2"

    echo "Vérification de $file..."

    if [ -f "$file" ]; then
        if grep -q "$expected_content" "$file"; then
            echo "✅ $file contient '$expected_content'"
            return 0
        else
            echo "❌ $file ne contient pas '$expected_content'"
            return 1
        fi
    else
        echo "❌ $file n'existe pas"
        return 1
    fi
}

# Vérifications
verify_config_file "relay/sdk_relay.conf" "bootstrap_url=\"wss://dev3.4nkweb.com/ws/\""
verify_config_file "relay/sdk_relay.conf" "sp_address="
verify_config_file ".env" "RELAY_URLS=ws://sdk_relay:8090"

2. Écriture atomique des configurations

#!/bin/bash
# atomic_config_update.sh

# Fonction d'écriture atomique
atomic_write_config() {
    local file="$1"
    local content="$2"
    local temp_file="${file}.tmp"

    echo "Mise à jour atomique de $file..."

    # Écriture dans un fichier temporaire
    echo "$content" > "$temp_file"

    # Vérification de l'écriture
    if [ -f "$temp_file" ] && [ -s "$temp_file" ]; then
        # Remplacement atomique
        mv "$temp_file" "$file"
        echo "✅ $file mis à jour avec succès"
        return 0
    else
        echo "❌ Échec de l'écriture de $file"
        rm -f "$temp_file"
        return 1
    fi
}

# Exemple d'utilisation
atomic_write_config "relay/sdk_relay.conf" "bootstrap_url=\"wss://dev3.4nkweb.com/ws/\""

3. Gestion des permissions

#!/bin/bash
# fix_config_permissions.sh

# Correction des permissions
fix_permissions() {
    local file="$1"

    echo "Correction des permissions pour $file..."

    # Vérifier si le fichier existe
    if [ -f "$file" ]; then
        # Corriger les permissions
        chmod 644 "$file"
        chown $(whoami):$(whoami) "$file"
        echo "✅ Permissions corrigées pour $file"
    else
        echo "❌ $file n'existe pas"
        return 1
    fi
}

# Correction des permissions pour tous les fichiers de config
fix_permissions "relay/sdk_relay.conf"
fix_permissions ".env"
fix_permissions "docker-compose.yml"

Règles Cursor ajoutées

Règle de vérification des configurations

# RÈGLE CRITIQUE : Vérification des Fichiers de Configuration
- TOUJOURS vérifier l'écriture effective des fichiers de configuration critiques après modification
- Fichiers à vérifier systématiquement : nginx.conf, bitcoin.conf, package.json, Cargo.toml
- Utiliser des commandes de vérification (cat, jq, syntax check) pour s'assurer que l'écriture a été effective
- Cette règle évite les erreurs de configuration dues à des écritures non effectives

Scripts de vérification

Vérification complète des configurations

#!/bin/bash
# verify_all_configs.sh

echo "=== Vérification des configurations ==="

# Vérification des fichiers de configuration
config_files=(
    "relay/sdk_relay.conf"
    ".env"
    "docker-compose.yml"
    "miner/.env"
)

for file in "${config_files[@]}"; do
    if [ -f "$file" ]; then
        echo "✅ $file existe"

        # Vérification de la syntaxe
        case "$file" in
            *.conf)
                echo "  Vérification de la syntaxe..."
                # Pas de vérification spécifique pour .conf
                ;;
            *.yml|*.yaml)
                echo "  Vérification de la syntaxe YAML..."
                if command -v yq >/dev/null 2>&1; then
                    yq eval '.' "$file" >/dev/null && echo "  ✅ Syntaxe YAML valide" || echo "  ❌ Syntaxe YAML invalide"
                fi
                ;;
            *.json)
                echo "  Vérification de la syntaxe JSON..."
                jq '.' "$file" >/dev/null && echo "  ✅ Syntaxe JSON valide" || echo "  ❌ Syntaxe JSON invalide"
                ;;
        esac
    else
        echo "❌ $file n'existe pas"
    fi
done

Vérification des variables d'environnement

#!/bin/bash
# verify_env_vars.sh

echo "=== Vérification des variables d'environnement ==="

# Vérification des variables critiques
critical_vars=(
    "SIGNER_WS_URL"
    "RELAY_URLS"
    "SIGNER_BASE_URL"
    "VITE_BOOTSTRAPURL"
)

for var in "${critical_vars[@]}"; do
    if [ -f ".env" ]; then
        if grep -q "^$var=" ".env"; then
            value=$(grep "^$var=" ".env" | cut -d'=' -f2-)
            echo "✅ $var=$value"
        else
            echo "❌ $var non définie dans .env"
        fi
    else
        echo "❌ Fichier .env non trouvé"
    fi
done

Bonnes pratiques

1. Écriture des configurations

• Utiliser des écritures atomiques avec fichiers temporaires
• Vérifier l'écriture après chaque modification
• Corriger les permissions si nécessaire

2. Validation des configurations

• Vérifier la syntaxe des fichiers (JSON, YAML, etc.)
• Tester les configurations avant déploiement
• Documenter les changements de configuration

3. Gestion des variables d'environnement

• Centraliser les variables dans .env
• Vérifier les overrides entre .env et docker-compose.yml
• Documenter les variables critiques

Scripts automatisés

Mise à jour et vérification complète

#!/bin/bash
# update_and_verify_configs.sh

echo "=== Mise à jour et vérification des configurations ==="

# 1. Mise à jour des configurations
echo "Mise à jour des configurations..."
./atomic_config_update.sh

# 2. Correction des permissions
echo "Correction des permissions..."
./fix_config_permissions.sh

# 3. Vérification des configurations
echo "Vérification des configurations..."
./verify_all_configs.sh

# 4. Vérification des variables d'environnement
echo "Vérification des variables d'environnement..."
./verify_env_vars.sh

echo "=== Vérification terminée ==="

Actions préventives

1. Toujours vérifier l'écriture effective des fichiers de configuration
2. Utiliser des écritures atomiques pour éviter les corruptions
3. Corriger les permissions après modification
4. Valider la syntaxe des fichiers de configuration
5. Documenter les changements de configuration

Date

• Créé : 2025-09-20
• Problème résolu : Gestion des configurations et écriture effective
• Impact : Amélioration de la fiabilité des configurations