Passer au contenu principal
Ce guide fournit des étapes de diagnostic de niveau 1 (L1) pour le dépannage des problèmes dans les déploiements EKB On-Premise. Ces étapes aident à identifier les problèmes courants liés aux conteneurs, aux bases de données, aux services et aux ressources système.
Prérequis : Vous devez avoir accès SSH à la VM/serveur du client où EKB est déployé, ainsi que les autorisations appropriées pour exécuter des commandes Docker et accéder aux journaux des conteneurs.

​
Vérifications de l’État des Conteneurs

​
Vérifier l’État de Tous les Conteneurs

Commencez par vérifier quels conteneurs sont en cours d’exécution et leur état de santé : 
# 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>
Conteneurs Attendus :
  • web - Application frontend
  • api ou fastapi_backend - Serveur API backend
  • worker ou celery_worker - Worker(s) Celery
  • redis - Cache Redis
  • rabbitmq - File d’attente de messages RabbitMQ
  • supabase-studio - Supabase Studio
  • supabase-kong - Passerelle API Kong
  • supabase-auth - Service d’authentification
  • supabase-db ou postgres - Base de données PostgreSQL
  • Autres services Supabase (stockage, métadonnées, etc.)
Éléments à Vérifier :
  • Tous les conteneurs doivent être à l’état « Up »
  • Aucun conteneur ne doit être à l’état « Restarting » ou « Exited »
  • Les contrôles de santé doivent afficher « healthy » le cas échéant

​
Redémarrer les Conteneurs Défaillants

Si les conteneurs sont arrêtés ou redémarrent : 
# 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>

​
Journaux des Conteneurs Backend

​
Vérifier les Journaux du Conteneur API

Les journaux du conteneur API backend contiennent des informations critiques sur les erreurs, les connexions de base de données et les problèmes de service : 
# 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
Éléments à Rechercher :
  • Erreurs de connexion à la base de données
  • Échecs de connexion à Redis
  • Problèmes de connexion à RabbitMQ
  • Erreurs d’authentification
  • Erreurs des points de terminaison API (500, 503, etc.)
  • Erreurs d’import/export
  • Erreurs de traitement de la Knowledge Base
  • Défaillances des tâches de worker

​
Vérifier les Journaux du Conteneur Worker

Les conteneurs worker gèrent les tâches en arrière-plan (traitement KB, embeddings, etc.) : 
# 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>
Éléments à Rechercher :
  • Erreurs d’exécution de tâches
  • Problèmes de mémoire
  • Erreurs de délai d’expiration
  • Erreurs de connexion à la base de données dans les workers
  • Défaillances de synchronisation de la Knowledge Base
  • Erreurs de génération d’embeddings

​
Vérifier les Journaux du Conteneur Web

Les journaux du conteneur frontend peuvent révéler des problèmes de connexion à l’interface utilisateur et à l’API : 
# Vérifier les journaux du conteneur web
docker logs --tail 100 web

# Suivre les journaux
docker logs -f web
Éléments à Rechercher :
  • Erreurs de compilation
  • Défaillances de connexion à l’API
  • Problèmes de variables d’environnement
  • Erreurs de liaison de port

​
État de la Base de Données

​
Vérifier l’État de la Base de Données PostgreSQL/Supabase

# 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'));"
Éléments à Vérifier :
  • Le conteneur de base de données est en cours d’exécution
  • Aucune erreur de connexion dans les journaux
  • La base de données n’est pas pleine (vérifier l’espace disque)
  • Les connexions actives sont dans les limites
  • Aucune requête longue bloquant les opérations

​
Vérifier la Connectivité de la Base de Données à partir de l’API

# 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 les Migrations de Base de Données

# 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

​
État de Redis

​
Vérifier le Conteneur Redis

# 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
Éléments à Vérifier :
  • Redis répond à la requête ping
  • L’utilisation de la mémoire est dans les limites
  • Aucune erreur de connexion
  • Aucune erreur d’éviction (mémoire pleine)

​
Tester Redis à partir du Conteneur API

# 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}')
"

​
État de RabbitMQ

​
Vérifier le Conteneur RabbitMQ

# 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
Éléments à Vérifier :
  • Le conteneur est en cours d’exécution
  • Aucune erreur de connexion
  • Les files d’attente traitent les messages
  • Aucun arriéré de messages

​
Vérifier RabbitMQ à partir de l’API

# 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}')
"

​
Ressources Système

​
Vérifier l’Espace Disque

Un espace disque faible peut causer des problèmes de base de données, de stockage et de conteneurs : 
# 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
Éléments à Vérifier :
  • La partition racine a suffisamment d’espace (>20% d’espace libre recommandé)
  • Les volumes Docker ne sont pas pleins
  • Le répertoire des données de la base de données a de l’espace
  • Le stockage Supabase a de l’espace

​
Vérifier l’Utilisation de la Mémoire

# 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
Éléments à Vérifier :
  • Le système dispose de mémoire disponible
  • Les conteneurs ne dépassent pas les limites de mémoire
  • Aucune suppression OOM (Out of Memory) dans les journaux

​
Vérifier l’Utilisation du Processeur

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

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

​
Connectivité Réseau

​
Vérifier le Réseau du Conteneur

# 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 la Disponibilité des Ports

# 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

​
Variables d’Environnement

​
Vérifier la Configuration de l’Environnement

# 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
Éléments à Vérifier :
  • Les chaînes de connexion à la base de données sont correctes
  • Les noms d’hôtes Redis et RabbitMQ sont corrects
  • Les URL de l’API sont correctement configurées
  • Les variables d’environnement requises sont définies
  • Aucune faute de frappe dans les noms de variables

​
Permissions des Fichiers

​
Vérifier les Permissions des Fichiers et Répertoires

# 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/
Éléments à Vérifier :
  • Les répertoires d’application sont lisibles
  • La socket Docker a les permissions correctes
  • Les montages de volumes ont les permissions appropriées
  • Les fichiers de certificats sont accessibles

​
Vérifications Spécifiques au Service

​
Problèmes de Knowledge Base

Si la Knowledge Base ne se met pas à jour ou ne traite pas : 
# 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;
"

​
Problèmes de Chat/Agent

# 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"

​
Problèmes d’Authentification

# 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;
"

​
Modèles d’Erreurs Courants

​
Erreurs de Connexion à la Base de Données

Symptômes :
  • Erreurs « Connection refused »
  • Erreurs « Too many connections »
  • Erreurs de délai d’expiration
Étapes de Diagnostic :
  1. Vérifier que le conteneur de base de données est en cours d’exécution : docker ps | grep db
  2. Vérifier les journaux de la base de données : docker logs supabase-db
  3. Vérifier les limites de connexion : docker exec supabase-db psql -U postgres -c "SHOW max_connections;"
  4. Vérifier les connexions actives : docker exec supabase-db psql -U postgres -c "SELECT count(*) FROM pg_stat_activity;"
  5. Vérifier la DATABASE_URL dans les variables d’environnement

​
Erreurs de Connexion à Redis

Symptômes :
  • « Connection refused » vers Redis
  • Absences de cache
  • Problèmes de session
Étapes de Diagnostic :
  1. Vérifier le conteneur Redis : docker ps | grep redis
  2. Tester Redis : docker exec redis redis-cli ping
  3. Vérifier les journaux de Redis : docker logs redis
  4. Vérifier le nom d’hôte de Redis dans les variables d’environnement

​
Défaillances des Tâches de Worker

Symptômes :
  • Les tâches ne se complètent pas
  • La Knowledge Base ne se synchronise pas
  • Les tâches en arrière-plan échouent
Étapes de Diagnostic :
  1. Vérifier les journaux du worker : docker logs worker
  2. Vérifier l’état du conteneur worker : docker ps | grep worker
  3. Vérifier les files d’attente RabbitMQ : Accéder à l’interface de gestion RabbitMQ
  4. Vérifier les problèmes de mémoire : docker stats worker

​
Problèmes de Stockage/Téléchargement de Fichiers

Symptômes :
  • Défaillances du téléchargement de fichiers
  • Erreurs « File too large »
  • Quota de stockage dépassé
Étapes de Diagnostic :
  1. Vérifier l’espace disque : df -h
  2. Vérifier les journaux du stockage Supabase : docker logs supabase-storage
  3. Vérifier les limites de taille de fichier dans la configuration Supabase
  4. Vérifier la configuration du bucket de stockage

​
Script de Diagnostic Rapide

Créez un script de diagnostic pour exécuter toutes les vérifications à la fois : 
#!/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 ==="
Enregistrez sous diagnostics.sh, rendez exécutable : chmod +x diagnostics.sh, et exécutez : ./diagnostics.sh

​
Informations d’Escalade

Lors de l’escalade au support L2, fournissez :
  1. État des Conteneurs : Résultat de docker ps -a
  2. Journaux Récents : Dernières 100-200 lignes des conteneurs pertinents
  3. Ressources Système : Résultat de df -h et free -h
  4. Messages d’Erreur : Messages d’erreur spécifiques des journaux
  5. Configuration : Noms des variables d’environnement (pas les valeurs) qui sont définies
  6. Chronologie : Quand le problème a commencé
  7. Impact : Quelles fonctionnalités sont affectées
Contacter le Support : support@automationanywhere.com

​
Ressources Supplémentaires