> For the complete documentation index, see [llms.txt](https://docs.verge.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.verge.io/learn-the-platform/fr/module-9-supervision-et-depannage/04-prometheus-grafana.md).

# Intégration Prometheus et Grafana

## Pourquoi les métriques externes sont importantes

Le tableau de bord VergeOS fournit un état de santé et des analyses en temps réel, mais les stratégies de supervision d’entreprise nécessitent généralement un stockage centralisé de séries temporelles capable d’agréger les métriques de plusieurs systèmes, de conserver les données au-delà de la fenêtre de 45 jours dans l’interface, et de déclencher des règles d’alerte sophistiquées. Le **vergeos-exporter** comble cette lacune en exposant les métriques VergeOS au format Prometheus -- le standard de fait pour la supervision cloud-native.

Avec l’exportateur en fonctionnement, vous bénéficiez d’une analyse des tendances à long terme, d’une corrélation entre systèmes et d’une intégration avec les pipelines d’alerte existants -- le tout sans modifier le système VergeOS lui-même.

```mermaid
graph LR
    subgraph vergeos["Environnement VergeOS"]
        API["API REST VergeOS"]
    end

    subgraph monitoring["Pile de supervision"]
        EXP["vergeos-exporter<br/>:9888/metrics"]
        PROM["Prometheus<br/>Collecte et stockage"]
        GRAF["Grafana<br/>Tableaux de bord"]
        ALERT["AlertManager<br/>Notifications"]
    end

    API -->|"Appels API<br/>(liste/lecture)"| EXP
    EXP -->|"Collecte<br/>basée sur le pull"| PROM
    PROM --> GRAF
    PROM --> ALERT
    ALERT -->|"E-mail, Slack,<br/>PagerDuty"| OPS["Équipe Ops"]

    style vergeos fill:#f0f4ff,stroke:#336
    style monitoring fill:#f0fff4,stroke:#363
```

## Le vergeos-exporter

Le **vergeos-exporter** est un outil open source maintenu par Verge dans le [verge-io/vergeos-exporter](https://github.com/verge-io/vergeos-exporter) dépôt GitHub. Il se connecte à l’API REST VergeOS, collecte les métriques d’infrastructure et les expose sur un point de terminaison HTTP que Prometheus collecte à un intervalle configurable.

### Métriques exposées

L’exportateur collecte trois catégories de métriques :

### Métriques de niveau vSAN

Capacité, utilisation et allocation par niveau. Comptes de transactions et de réparations. Surveillance de l’état des disques (en ligne, hors ligne, en réparation, initialisation, vérification, sans redondance, manque d’espace). Température des disques et données d’intégrité. Opérations de lecture/écriture et IOPS.

### Métriques du cluster

Nombre de nœuds par cluster. Utilisation de la RAM, du CPU et du disque. État de synchronisation et intégrité.

### Métriques des nœuds

Utilisation du CPU et de la mémoire par nœud. Débit réseau et latence. État des services par nœud.

Une référence complète des métriques est disponible dans le fichier `metrics.md` du dépôt de l’exportateur.

### Architecture : collecte basée sur le pull

Le vergeos-exporter suit le modèle pull standard de Prometheus. Prometheus initie la connexion en récupérant le `/metrics` point de terminaison de l’exportateur à un intervalle configuré (généralement 15 à 60 secondes). Cette approche signifie :

* **Aucune règle de pare-feu entrante** n’est requise sur le système VergeOS lui-même
* L’exportateur peut s’exécuter sur **n’importe quel hôte** ayant un accès réseau à l’API VergeOS
* Plusieurs instances Prometheus peuvent collecter le même exportateur pour la haute disponibilité
* L’exportateur est **compatible avec AlertManager** -- les règles d’alerte Prometheus fonctionnent nativement avec les métriques exposées

## Configuration du compte de service

Avant de déployer l’exportateur, créez un compte de service dédié dans VergeOS avec des privilèges minimaux.

### Étape par étape : créer le compte de service de l’exportateur

1. Accédez à **Système → Utilisateurs** dans l’interface VergeOS
2. Cliquez sur **Nouveau** pour créer un nouvel utilisateur
3. Remplissez le formulaire **Nouvel utilisateur** :
   * **Nom d’utilisateur :** `prometheus-exporter` (ou un nom descriptif similaire)
   * **Type :** `API`
   * **Mot de passe :** une valeur forte générée aléatoirement
   * **Authentification à deux facteurs :** laissez **désactivée** -- l’exportateur s’authentifie via le nom d’utilisateur et le mot de passe API
4. Cliquez sur **Soumettre** pour enregistrer

Les nouveaux utilisateurs Normal/API obtiennent **liste/lecture sur tout** par défaut, ce qui est exactement ce dont l’exportateur a besoin. Pour restreindre davantage le périmètre, réduisez les autorisations sous **Système → Permissions** après la création de l’utilisateur.

{% hint style="warning" %}
**Bonne pratique de sécurité**

N’utilisez jamais un compte administrateur pour l’exportateur. Le compte de service n’a besoin que des accès liste et lecture pour interroger les métriques, alors laissez les paramètres par défaut en place ou restreignez-les sous **Système → Permissions** -- et compensez l’identifiant machine-à-machine en utilisant un mot de passe fort généré aléatoirement et en limitant l’accès réseau à l’hôte de l’exportateur.
{% endhint %}

## Options de déploiement

Le vergeos-exporter prend en charge plusieurs modèles de déploiement. Choisissez celui qui correspond le mieux à votre infrastructure de supervision.

### Option 1 : binaire autonome

Des binaires précompilés sont disponibles pour Linux, Windows et macOS (amd64 et arm64) sur la [page des versions GitHub](https://github.com/verge-io/vergeos-exporter/releases) .

```bash
# Télécharger et extraire (exemple Linux amd64)
wget https://github.com/verge-io/vergeos-exporter/releases/latest/download/vergeos-exporter-linux-amd64.tar.gz
tar xzf vergeos-exporter-linux-amd64.tar.gz

# Exécuter avec les indicateurs requis
./vergeos-exporter \
  -verge.url https://your-vergeos-host \
  -verge.username prometheus-exporter \
  -verge.password 'YourStrongPassword'
```

L’exportateur écoute sur le port **9888** par défaut. Remplacez-le avec l’indicateur `-web.listen-address` si nécessaire.

### Option 2 : service systemd Linux

Pour les déploiements Linux en production, exécutez l’exportateur comme un service systemd géré :

```ini
# /etc/systemd/system/vergeos-exporter.service
[Unit]
Description=Exportateur Prometheus VergeOS
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=vergeos_exporter
ExecStart=/usr/local/bin/vergeos-exporter \
  -verge.url https://your-vergeos-host \
  -verge.username prometheus-exporter \
  -verge.password 'YourStrongPassword'
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
```

```bash
# Créer l’utilisateur du service, activer et démarrer
sudo useradd -r -s /usr/sbin/nologin vergeos_exporter
sudo systemctl daemon-reload
sudo systemctl enable --now vergeos-exporter
```

### Option 3 : service Windows (NSSM)

Sur les hôtes de supervision Windows, utilisez [NSSM (Non-Sucking Service Manager)](https://nssm.cc/) pour exécuter l’exportateur en tant que service Windows :

1. Téléchargez NSSM et placez `nssm.exe` dans un emplacement permanent (par ex. : `C:\Program Files\nssm\`)
2. Enregistrez le service :

```powershell
nssm install vergeos-exporter "C:\monitoring\vergeos-exporter.exe"
nssm set vergeos-exporter AppParameters "-verge.url https://your-vergeos-host -verge.username prometheus-exporter -verge.password YourStrongPassword"
nssm set vergeos-exporter Start SERVICE_AUTO_START
nssm start vergeos-exporter
```

### Option 4 : Docker Compose

Le dépôt inclut un exemple Docker Compose prêt à l’emploi sous `examples/docker-compose/` qui regroupe l’exportateur, Prometheus et Grafana dans une pile unique -- idéal pour une évaluation rapide ou des environnements de laboratoire.

```yaml
# Structure simplifiée de docker-compose.yml
services:
  vergeos-exporter:
    image: vergeos-exporter:latest
    ports:
      - "9888:9888"
    environment:
      - VERGE_URL=https://your-vergeos-host
      - VERGE_USERNAME=prometheus-exporter
      - VERGE_PASSWORD=YourStrongPassword

  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
```

L’exemple Docker Compose récupère automatiquement le binaire correct spécifique à la plateforme pour votre architecture.

## Configuration de Prometheus

Ajoutez l’exportateur comme cible de collecte dans votre `prometheus.yml`:

```yaml
scrape_configs:
  - job_name: "vergeos"
    scrape_interval: 30s
    scrape_timeout: 30s
    static_configs:
      - targets: ["exporter-host:9888"]
        labels:
          environment: "production"
          cluster: "site-a"
```

Pour superviser plusieurs environnements VergeOS, déployez un exportateur par environnement et ajoutez chacun comme cible distincte (ou utilisez le réétiquetage Prometheus pour la découverte dynamique).

## Tableau de bord Grafana

Le vergeos-exporter est livré avec un tableau de bord Grafana préconfiguré (`examples/grafana-dashboard.json`) couvrant d’emblée les métriques vSAN, cluster et nœud.

### Les panneaux du tableau de bord incluent

| Catégorie             | Panneaux                                                                                    |
| --------------------- | ------------------------------------------------------------------------------------------- |
| **Performances vSAN** | Jauges de capacité et d’utilisation des niveaux, graphiques IOPS, débit de lecture/écriture |
| **Santé du cluster**  | Nombre de nœuds, état de synchronisation, utilisation globale du CPU et de la RAM           |
| **Détails des nœuds** | CPU, mémoire, débit réseau et température par nœud                                          |
| **Santé du stockage** | États des disques, état de réparation, compteurs d’erreurs                                  |

### Importation du tableau de bord

1. Ouvrez Grafana et accédez à **Tableaux de bord → Importer**
2. Cliquez sur **Téléversez le fichier JSON** et sélectionnez `grafana-dashboard.json` dans le dépôt de l’exportateur
3. Sélectionnez votre **source de données Prometheus** dans la liste déroulante
4. Cliquez sur **Importation**

Le tableau de bord est immédiatement fonctionnel une fois que Prometheus reçoit les métriques de l’exportateur.

## Vérification

Après le déploiement, vérifiez que l’exportateur collecte bien les métriques :

```bash
# Tester directement le point de terminaison des métriques
curl -s http://localhost:9888/metrics | head -20

# La sortie attendue inclut des lignes comme :
# HELP vergeos_vsan_tier_capacity_bytes Capacité totale par niveau vSAN
# TYPE vergeos_vsan_tier_capacity_bytes gauge
# vergeos_vsan_tier_capacity_bytes{tier="1"} 1.234567e+12
```

Si le point de terminaison renvoie des métriques, Prometheus les collectera automatiquement à son prochain intervalle. Vérifiez la page **Cibles** (`http://prometheus:9090/targets`) pour confirmer que le `vergeos` job affiche un statut **UP**.

### Liste de contrôle de dépannage

| Symptôme                         | Cochez                                                                                                     |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| Aucune métrique renvoyée         | Vérifiez que l’URL, le nom d’utilisateur et le mot de passe VergeOS sont corrects                          |
| Connexion refusée                | Confirmez que le processus de l’exportateur est en cours d’exécution et écoute sur 9888                    |
| Erreur d’authentification        | Confirmez que le compte de service est **Type = API** avec **Authentification à deux facteurs** désactivée |
| Métriques partielles             | Vérifiez que le compte de service dispose des autorisations **liste et lecture** adéquates                 |
| Cible Prometheus DOWN            | Vérifiez la connectivité réseau entre Prometheus et l’hôte de l’exportateur                                |
| Dépassement du délai de collecte | Augmentez `-scrape.timeout` (30 s par défaut) pour les grands environnements                               |

## Intégration avec AlertManager

Parce que l’exportateur expose des métriques Prometheus standard, vous pouvez écrire des règles d’alerte qui se déclenchent lorsque des seuils sont dépassés :

```yaml
# Exemples de règles d’alerte pour les métriques VergeOS
groups:
  - name: vergeos_alerts
    rules:
      - alert: VSANTierNearCapacity
        expr: vergeos_vsan_tier_usage_bytes / vergeos_vsan_tier_capacity_bytes > 0.85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Le niveau vSAN {{ $labels.tier }} dépasse 85 % de capacité"

      - alert: DriveOffline
        expr: vergeos_vsan_drive_state{state="offline"} > 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Le disque {{ $labels.drive }} est hors ligne sur le nœud {{ $labels.node }}"
```

AlertManager peut acheminer ces alertes vers e-mail, Slack, PagerDuty, OpsGenie ou tout point de terminaison webhook -- intégrant la supervision VergeOS dans votre flux de gestion d’incidents existant.

## Alternative : intégration directe de l’API avec Zabbix

Si votre organisation utilise Zabbix plutôt que Prometheus, vous pouvez interroger directement l’API REST VergeOS à l’aide d’éléments Zabbix HTTP Agent :

1. Créez un jeton d’API via **Système → Documentation de l’API** (Swagger UI)
2. Utilisez des éléments Zabbix HTTP Agent pour interroger des points de terminaison comme `/api/v4/vms`, `/api/v4/nodes`, `/api/v4/vnets`
3. Authentifiez-vous en effectuant un POST vers `/api/sys/tokens` et en passant le jeton de session dans l’en-tête `x-yottabyte-token` Le

L’exportateur Prometheus reste l’approche recommandée pour la plupart des environnements en raison de son ensemble de métriques plus riche et de son tableau de bord préconstruit.

{% hint style="info" %}
**Vous venez de VMware ou de Nutanix ?**

VergeOS expose les métriques de la plateforme via le **vergeos-exporter**qui présente les données vSAN, cluster et nœud au format standard Prometheus. Prometheus effectue une collecte pull de l’exportateur sur le port **9888** et Grafana affiche le tableau de bord fourni -- ainsi, les métriques VergeOS s’intègrent dans la même pile Prometheus + Grafana que beaucoup d’équipes exécutent déjà à côté de leurs plateformes existantes.
{% endhint %}

## Points clés

* Le **vergeos-exporter** expose les métriques vSAN, cluster et nœud sur le port **9888** au format standard Prometheus
* Créez un **compte de service dédié de type API** -- l’accès liste/lecture sur tout est le comportement par défaut pour les nouveaux utilisateurs Normal/API
* Déployez comme binaire autonome, service systemd, service Windows (NSSM) ou pile Docker Compose
* Le **tableau de bord Grafana** fourni offre une visibilité immédiate sur la santé du stockage, du cluster et des nœuds
* Prometheus **AlertManager** l’intégration permet des alertes proactives sur la capacité, l’état des disques et les seuils de performance
* L’exportateur utilise **une collecte basée sur le pull** -- aucune modification du pare-feu entrant n’est nécessaire sur le système VergeOS


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.verge.io/learn-the-platform/fr/module-9-supervision-et-depannage/04-prometheus-grafana.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.