# Exemples Pratiques - 4NK Node

Ce document contient des exemples pratiques pour utiliser l'infrastructure 4NK Node.

## 🚀 Exemples de Démarrage

### 1. Démarrage complet de l'infrastructure

```bash
# Cloner et configurer
git clone git@git.4nkweb.com:4nk/4NK_node.git
cd 4NK_node

# Démarrer tous les services
docker-compose up -d

# Vérifier le statut
docker-compose ps

# Suivre les logs
docker-compose logs -f
```

### 2. Démarrage avec 3 relais pour tests

```bash
# Utiliser le script de démarrage spécialisé
./start_3_relays_docker.sh

# Ou manuellement
docker-compose up -d tor bitcoin blindbit
sleep 30  # Attendre la synchronisation Bitcoin
docker-compose up -d sdk_relay_1 sdk_relay_2 sdk_relay_3
```

### 3. Démarrage séquentiel pour debug

```bash
# 1. Démarrer Tor
docker-compose up -d tor
sleep 5

# 2. Démarrer Bitcoin Core
docker-compose up -d bitcoin
echo "Attendre la synchronisation Bitcoin (peut prendre 10-30 minutes)"
echo "Vérifier avec: docker exec bitcoin-signet bitcoin-cli -signet getblockchaininfo"

# 3. Démarrer Blindbit
docker-compose up -d blindbit
sleep 10

# 4. Démarrer les relais
docker-compose up -d sdk_relay_1 sdk_relay_2 sdk_relay_3
```

## 🧪 Exemples de Tests

### 1. Test de connectivité basique

```bash
# Vérifier que tous les services répondent
./test_final_sync.sh status

# Test de connectivité WebSocket
python3 test_websocket_messages.py

# Test des messages de synchronisation
./test_sync_logs.sh test
```

### 2. Test de synchronisation entre relais

```bash
# Test en continu
./test_sync_logs.sh continuous

# Test forcé avec redémarrage
./test_sync_logs.sh force

# Surveillance des logs de synchronisation
./monitor_sync.sh
```

### 3. Test de performance

```bash
# Test de charge WebSocket
for i in {1..10}; do
    python3 test_websocket_messages.py &
done
wait

# Test de connectivité multiple
netstat -tlnp | grep -E "(8090|8092|8094)"
```

## 🌐 Exemples d'Ajout de Nœuds Externes

### 1. Ajouter un nœud externe simple

```bash
# Ajouter un nœud externe
./add_external_node.sh add external-relay-1 external-relay-1.example.com:8090

# Vérifier la configuration
./add_external_node.sh list

# Tester la connectivité
./add_external_node.sh test external-relay-1

# Redémarrer les relais pour appliquer
docker-compose restart sdk_relay_1 sdk_relay_2 sdk_relay_3
```

### 2. Configuration d'un réseau multi-sites

```bash
# Site principal (4NK_node)
./add_external_node.sh add site-paris-1 paris-relay-1.4nk.net:8090
./add_external_node.sh add site-paris-2 paris-relay-2.4nk.net:8090

# Site secondaire
./add_external_node.sh add site-lyon-1 lyon-relay-1.4nk.net:8090
./add_external_node.sh add site-lyon-2 lyon-relay-2.4nk.net:8090

# Site de backup
./add_external_node.sh add backup-1 backup-relay-1.4nk.net:8090

# Vérifier la configuration complète
./add_external_node.sh list
```

### 3. Gestion des nœuds externes

```bash
# Supprimer un nœud problématique
./add_external_node.sh remove external-relay-1

# Valider une nouvelle adresse avant ajout
./add_external_node.sh validate 192.168.1.100:8090

# Tester tous les nœuds configurés
for relay in $(./add_external_node.sh list | grep "🔸" | cut -d' ' -f3); do
    echo "Testing $relay..."
    ./add_external_node.sh test $relay
done
```

## 🔧 Exemples de Configuration

### 1. Configuration Bitcoin Core personnalisée

```bash
# Modifier la configuration Bitcoin
cat > bitcoin/bitcoin.conf << EOF
signet=1
rpcuser=bitcoin
rpcpassword=your_secure_password
rpcbind=0.0.0.0
rpcallowip=172.19.0.0/16
zmqpubrawblock=tcp://0.0.0.0:29000
zmqpubrawtx=tcp://0.0.0.0:29000
txindex=1
server=1
listen=1
EOF

# Redémarrer Bitcoin Core
docker-compose restart bitcoin
```

### 2. Configuration sdk_relay personnalisée

```bash
# Créer une configuration personnalisée pour relay-1
cat > sdk_relay/.conf.docker.relay1 << EOF
core_url=http://bitcoin:18443
core_wallet=relay_wallet
ws_url=0.0.0.0:8090
wallet_name=relay_wallet.json
network=signet
blindbit_url=http://blindbit:8000
zmq_url=tcp://bitcoin:29000
data_dir=.4nk
cookie_path=/home/bitcoin/.4nk/bitcoin.cookie
dev_mode=true
standalone=false
relay_id=relay-1
EOF

# Redémarrer le relais
docker-compose restart sdk_relay_1
```

### 3. Configuration réseau personnalisée

```bash
# Créer un réseau Docker personnalisé
docker network create 4nk-network --subnet=172.20.0.0/16

# Modifier docker-compose.yml pour utiliser le réseau personnalisé
sed -i 's/4nk_default/4nk-network/g' docker-compose.yml

# Redémarrer tous les services
docker-compose down
docker-compose up -d
```

## 📊 Exemples de Monitoring

### 1. Monitoring en temps réel

```bash
# Suivre tous les logs
docker-compose logs -f --tail=100

# Suivre un service spécifique
docker logs -f sdk_relay_1

# Monitoring des ressources
docker stats

# Vérifier l'espace disque
docker system df
```

### 2. Monitoring de la synchronisation Bitcoin

```bash
# Vérifier la progression de synchronisation
docker exec bitcoin-signet bitcoin-cli -signet getblockchaininfo | jq '.verificationprogress'

# Vérifier les connexions
docker exec bitcoin-signet bitcoin-cli -signet getconnectioncount

# Vérifier l'utilisation mémoire
docker exec bitcoin-signet bitcoin-cli -signet getmemoryinfo
```

### 3. Monitoring des relais

```bash
# Vérifier l'état des relais
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" | grep sdk_relay

# Vérifier les ports WebSocket
netstat -tlnp | grep -E "(8090|8092|8094)"

# Vérifier les logs de synchronisation
for i in {1..3}; do
    echo "=== Relay $i ==="
    docker logs sdk_relay_$i --tail=5 | grep -E "(Sync|Relay|Mesh)"
done
```

## 🛠️ Exemples de Debug

### 1. Debug de connexion Bitcoin Core

```bash
# Vérifier la connectivité RPC
curl -u bitcoin:your_password --data-binary '{"jsonrpc": "1.0", "id": "curltest", "method": "getblockchaininfo", "params": []}' -H 'content-type: text/plain;' http://localhost:18443/

# Vérifier le cookie d'authentification
docker exec bitcoin-signet ls -la /home/bitcoin/.bitcoin/signet/.cookie

# Tester la connexion depuis un relais
docker exec sdk_relay_1 curl -s http://bitcoin:18443/
```

### 2. Debug de connectivité WebSocket

```bash
# Test de connectivité WebSocket basique
curl -v -H "Connection: Upgrade" -H "Upgrade: websocket" -H "Sec-WebSocket-Key: test" http://localhost:8090/

# Test avec wscat (si installé)
wscat -c ws://localhost:8090

# Test de connectivité depuis un autre conteneur
docker run --rm --network 4nk_default curlimages/curl curl -s http://sdk_relay_1:8090/
```

### 3. Debug de synchronisation

```bash
# Vérifier les logs de synchronisation
docker logs sdk_relay_1 | grep -E "(discover|sync|relay)" | tail -10

# Vérifier l'état du SyncManager
docker exec sdk_relay_1 ps aux | grep sdk_relay

# Vérifier les fichiers de données
docker exec sdk_relay_1 ls -la /home/bitcoin/.4nk/
```

## 🔒 Exemples de Sécurité

### 1. Configuration de pare-feu

```bash
# Autoriser seulement les ports nécessaires
sudo ufw allow 18443/tcp  # Bitcoin Core RPC
sudo ufw allow 8090/tcp   # sdk_relay WebSocket
sudo ufw allow 8000/tcp   # Blindbit API
sudo ufw enable

# Vérifier les règles
sudo ufw status numbered
```

### 2. Configuration SSL/TLS

```bash
# Générer un certificat auto-signé
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

# Configurer nginx comme proxy SSL
cat > nginx.conf << EOF
server {
    listen 443 ssl;
    server_name your-domain.com;
    
    ssl_certificate cert.pem;
    ssl_certificate_key key.pem;
    
    location / {
        proxy_pass http://localhost:8090;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host \$host;
    }
}
EOF
```

### 3. Monitoring de sécurité

```bash
# Vérifier les connexions suspectes
netstat -tuln | grep -E "(8090|8092|8094)"

# Vérifier les logs d'accès
docker logs sdk_relay_1 | grep -E "(ERROR|WARN)" | tail -20

# Vérifier l'utilisation des ressources
docker stats --no-stream | grep sdk_relay
```

## 📈 Exemples de Performance

### 1. Test de charge

```bash
# Script de test de charge simple
for i in {1..50}; do
    python3 test_websocket_messages.py &
    sleep 0.1
done
wait

# Vérifier les performances
docker stats --no-stream
```

### 2. Optimisation mémoire

```bash
# Limiter la mémoire des conteneurs
docker-compose down
sed -i 's/- memory: 2g/- memory: 1g/g' docker-compose.yml
docker-compose up -d

# Vérifier l'utilisation mémoire
docker stats --no-stream | grep sdk_relay
```

### 3. Monitoring des performances

```bash
# Script de monitoring continu
while true; do
    echo "=== $(date) ==="
    docker stats --no-stream | grep -E "(sdk_relay|bitcoin)"
    echo "WebSocket connections:"
    netstat -an | grep :8090 | wc -l
    sleep 30
done
```

## 🚀 Exemples de Déploiement

### 1. Déploiement en production

```bash
# Configuration production
export NODE_ENV=production
export RUST_LOG=info

# Démarrer avec restart automatique
docker-compose up -d --restart unless-stopped

# Vérifier la configuration
docker-compose config

# Monitoring de production
./monitor_sync.sh
```

### 2. Déploiement multi-environnements

```bash
# Environnement de développement
docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d

# Environnement de staging
docker-compose -f docker-compose.yml -f docker-compose.staging.yml up -d

# Environnement de production
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d
```

### 3. Backup et restauration

```bash
# Backup des données
docker exec bitcoin-signet tar czf /tmp/bitcoin-backup.tar.gz /home/bitcoin/.bitcoin
docker cp bitcoin-signet:/tmp/bitcoin-backup.tar.gz ./backup/

# Backup des configurations
tar czf config-backup.tar.gz sdk_relay/.conf* external_nodes.conf

# Restauration
docker cp ./backup/bitcoin-backup.tar.gz bitcoin-signet:/tmp/
docker exec bitcoin-signet tar xzf /tmp/bitcoin-backup.tar.gz -C /
```

Ces exemples couvrent les cas d'usage les plus courants pour l'infrastructure 4NK Node. Adaptez-les selon vos besoins spécifiques !