> ## Documentation Index
> Fetch the complete documentation index at: https://ai-kb.automationanywhere.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Dépannage On-Premise

> Étapes de diagnostic L1 pour le dépannage des déploiements EKB On-Premise

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.

<Warning>
  **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.
</Warning>

## 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é :

```bash theme={null}
# 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 :

```bash theme={null}
# 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 :

```bash theme={null}
# 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.) :

```bash theme={null}
# 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 :

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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 :

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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 :

```bash theme={null}
# 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

```bash theme={null}
# 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

```bash theme={null}
# 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 :

```bash theme={null}
#!/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](mailto:support@automationanywhere.com)

## Ressources Supplémentaires

* [Guide d'Installation On-Premise](/offerings/on-premise/installation)
* [Documentation Docker](https://docs.docker.com/)