Dépannage On-Premise

# Vérifier l'état de tous les conteneurs
docker ps -a

# Vérifier les conteneurs avec l'état de santé
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Health}}"

# Vérifier l'état d'un conteneur spécifique
docker ps -a | grep <container_name>

# Redémarrer un conteneur spécifique
docker restart <container_name>

# Redémarrer tous les conteneurs
docker compose restart

# Redémarrer un service spécifique
docker compose restart <service_name>

# Afficher les journaux récents (100 dernières lignes)
docker logs --tail 100 api

# Ou pour fastapi_backend
docker logs --tail 100 fastapi_backend

# Suivre les journaux en temps réel
docker logs -f api

# Afficher les journaux avec horodatage
docker logs -t api

# Afficher les journaux à partir d'une heure spécifique
docker logs --since 30m api

# Afficher les journaux entre deux horodatages
docker logs --since "2024-01-01T00:00:00" --until "2024-01-01T23:59:59" api

# Vérifier les journaux du worker
docker logs --tail 100 worker

# Ou pour celery_worker
docker logs --tail 100 celery_worker

# Vérifier toutes les instances de worker
docker ps | grep worker
docker logs <worker_container_name>

# Vérifier les journaux du conteneur web
docker logs --tail 100 web

# Suivre les journaux
docker logs -f web

# Vérifier l'état du conteneur de base de données
docker ps | grep -E "(db|postgres|supabase-db)"

# Vérifier les journaux du conteneur de base de données
docker logs --tail 100 supabase-db

# Ou pour le conteneur postgres
docker logs --tail 100 postgres

# Se connecter à la base de données (si psql est disponible)
docker exec -it supabase-db psql -U postgres

# Vérifier les connexions à la base de données
docker exec supabase-db psql -U postgres -c "SELECT count(*) FROM pg_stat_activity;"

# Vérifier la taille de la base de données
docker exec supabase-db psql -U postgres -c "SELECT pg_size_pretty(pg_database_size('postgres'));"

# Tester la connexion à la base de données à partir du conteneur API
docker exec api python -c "
import os
from sqlalchemy import create_engine
try:
    engine = create_engine(os.environ.get('DATABASE_URL'))
    conn = engine.connect()
    print('Database connection successful')
    conn.close()
except Exception as e:
    print(f'Database connection failed: {e}')
"

# Vérifier que les migrations sont à jour
docker exec api alembic current

# Vérifier l'historique des migrations
docker exec api alembic history

# Afficher les migrations en attente
docker exec api alembic heads

# Vérifier l'état du conteneur Redis
docker ps | grep redis

# Vérifier les journaux de Redis
docker logs --tail 100 redis

# Tester la connexion à Redis
docker exec redis redis-cli ping

# Doit retourner : PONG

# Vérifier les informations de Redis
docker exec redis redis-cli info

# Vérifier l'utilisation de la mémoire de Redis
docker exec redis redis-cli info memory

# Vérifier les clients connectés
docker exec redis redis-cli info clients

# Tester la connexion à Redis à partir de l'API
docker exec api python -c "
import redis
import os
try:
    r = redis.Redis(host='redis', port=6379, decode_responses=True)
    r.ping()
    print('Redis connection successful')
except Exception as e:
    print(f'Redis connection failed: {e}')
"

# Vérifier l'état du conteneur RabbitMQ
docker ps | grep rabbitmq

# Vérifier les journaux de RabbitMQ
docker logs --tail 100 rabbitmq

# Vérifier la gestion RabbitMQ (si accessible)
# Accès : http://<server-ip>:15672
# Identifiants par défaut : user/password

# Tester la connexion à RabbitMQ
docker exec api python -c "
import pika
try:
    connection = pika.BlockingConnection(
        pika.ConnectionParameters('rabbitmq', 5672, '/',
            pika.PlainCredentials('user', 'password'))
    )
    print('RabbitMQ connection successful')
    connection.close()
except Exception as e:
    print(f'RabbitMQ connection failed: {e}')
"

# Vérifier l'utilisation globale du disque
df -h

# Vérifier l'utilisation du disque pour les volumes Docker
docker system df

# Vérifier l'utilisation d'un volume spécifique
docker volume inspect <volume_name>

# Vérifier les tailles des répertoires
du -sh /var/lib/docker/volumes/*
du -sh ./supabase/docker/volumes/*

# Vérifier l'utilisation du disque dans le conteneur (pour la base de données)
docker exec supabase-db df -h

# Vérifier la mémoire du système
free -h

# Vérifier l'utilisation de la mémoire des conteneurs
docker stats --no-stream

# Vérifier la mémoire d'un conteneur spécifique
docker stats <container_name> --no-stream

# Vérifier l'utilisation du processeur
top
# ou
htop

# Vérifier l'utilisation du processeur des conteneurs
docker stats --no-stream

# Vérifier le réseau Docker
docker network ls

# Inspecter la configuration du réseau
docker network inspect <network_name>

# Vérifier si les conteneurs peuvent communiquer
docker exec api ping -c 3 redis
docker exec api ping -c 3 rabbitmq
docker exec api ping -c 3 supabase-db

# Vérifier si les ports sont utilisés
netstat -tulpn | grep -E "(3001|8001|6379|5672|5432|8000)"

# Ou utilisant ss
ss -tulpn | grep -E "(3001|8001|6379|5672|5432|8000)"

# Vérifier le port à partir du conteneur
docker exec api curl -I http://localhost:8001/health

# Vérifier les variables d'environnement pour un conteneur
docker exec api env | grep -E "(DATABASE|REDIS|RABBITMQ|API)"

# Vérifier les fichiers .env (s'ils sont accessibles)
cat ./env/.env.server | grep -v "PASSWORD\|SECRET\|KEY"  # Exclure les données sensibles
cat ./env/.env.web | grep -v "PASSWORD\|SECRET\|KEY"

# Vérifier l'environnement depuis docker-compose
docker compose config

# Vérifier les permissions sur les répertoires clés
ls -la ./alignment-project-server
ls -la ./ai-content-creator
ls -la ./supabase/docker/volumes

# Vérifier les permissions de la socket Docker
ls -la /var/run/docker.sock

# Vérifier les fichiers de certificats (si vous utilisez HTTPS)
ls -la ./certs/

# Vérifier les journaux du worker pour le traitement KB
docker logs --tail 200 worker | grep -i "knowledge\|kb\|embedding"

# Vérifier les problèmes de modèle d'embedding
docker logs api | grep -i "embedding\|model"

# Vérifier le stockage Supabase
docker logs supabase-storage

# Vérifier les limites de téléchargement de fichiers
docker exec supabase-db psql -U postgres -c "
SELECT name, file_size_limit 
FROM storage.buckets;
"

# Vérifier les journaux de l'API pour les erreurs d'agent
docker logs --tail 200 api | grep -i "agent\|chat\|llm"

# Vérifier les journaux du worker pour les tâches d'agent
docker logs --tail 200 worker | grep -i "agent\|chat"

# Vérifier les journaux du service d'authentification
docker logs --tail 100 supabase-auth

# Vérifier la base de données pour les problèmes d'authentification
docker exec supabase-db psql -U postgres -c "
SELECT * FROM auth.users LIMIT 5;
"

#!/bin/bash
echo "=== Diagnostics EKB On-Premise ==="
echo ""
echo "1. État des Conteneurs :"
docker ps --format "table {{.Names}}\t{{.Status}}"
echo ""
echo "2. Espace Disque :"
df -h | grep -E "(Filesystem|/dev/)"
echo ""
echo "3. Mémoire :"
free -h
echo ""
echo "4. Redis :"
docker exec redis redis-cli ping 2>/dev/null || echo "Redis not responding"
echo ""
echo "5. Base de Données :"
docker exec supabase-db psql -U postgres -c "SELECT version();" 2>/dev/null || echo "Database not responding"
echo ""
echo "6. Erreurs Récentes de l'API (20 dernières lignes) :"
docker logs --tail 20 api 2>/dev/null | grep -i error || echo "No recent errors"
echo ""
echo "=== Diagnostics Terminés ==="