---
title: "Observabilité sur OPCP"
description: "Découvrez la pile d'observabilité d'OPCP : métriques avec Prometheus et Grafana Mimir, logs avec Loki et Grafana Alloy, tableaux de bord, durées de rétention et droits d'accès"
url: https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/observability-overview
lang: fr
lastUpdated: 2026-11-16
---
> For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt.

# Observabilité sur OPCP

## Objectif

Votre **OVHcloud On-Prem Cloud Platform (OPCP)** intègre une pile d'observabilité qui collecte, stocke et expose les métriques et les logs de l'ensemble de la plateforme : le plan de contrôle, les services OpenStack, les clusters Ceph, le Cloud Store, les serveurs bare metal et les hyperviseurs de calcul.

Ce guide décrit cette pile : les composants qui la constituent, les interfaces auxquelles vous pouvez accéder, la durée de conservation de vos données et les comportements que vous pouvez adapter à vos besoins.

## Prérequis

- Disposer d'un service [On-Prem Cloud Platform](https://www.ovhcloud.com/fr/hosted-private-cloud/onprem-cloud-platform/) livré et opérationnel
- Disposer d'un compte Keycloak doté au minimum du rôle `dc_operator` (consultez le guide « [Gestion des droits IAM](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/iam-rights-management.md) »)
- Disposer du nom de domaine de base (`base_dns_name`) attribué à votre plateforme lors de la livraison
- Disposer d'un accès administrateur au contrôleur OPCP avec `opcp-cli`, si vous administrez vous-même votre plateforme (consultez le guide « [Comment gérer la configuration d'OPCP avec opcp-cli](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/how-to-manage-configuration.md) »)

## En pratique

### Architecture de l'observabilité

La pile repose intégralement sur des composants open source issus des projets Grafana Labs et Prometheus, dans leurs éditions communautaires (OSS). Elle se divise en deux chaînes indépendantes — l'une pour les métriques, l'autre pour les logs — qui convergent vers une interface **Grafana** unique. Une couche d'alerte s'appuie sur la chaîne des métriques : le **ruler Mimir** évalue les règles d'alerte livrées avec la plateforme et transmet les alertes actives à **Alertmanager**, composant optionnel qui achemine les notifications vers vos propres outils (reportez-vous à la section « [Alerting](#alerting) »).

#### Chaîne des métriques

| Étape        | Composant                           | Rôle                                                                                                                  |
| ------------ | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| Collecte     | **Prometheus** (plan de contrôle)   | Interroge le plan de contrôle, les services OpenStack, le cluster Ceph du plan de contrôle et les serveurs bare metal |
| Collecte     | **Grafana Alloy** (nœuds de calcul) | Interroge les hyperviseurs et leurs charges de travail                                                                |
| Stockage     | **Grafana Mimir**                   | Backend de métriques longue durée, scalable horizontalement, adossé à Object Storage                                  |
| Consultation | **Grafana**                         | Tableaux de bord et requêtes ponctuelles                                                                              |

Les deux collecteurs transmettent leurs séries à Mimir via le protocole `remote_write` de Prometheus, sur le point d'entrée `metrics.<base_dns_name>`. Mimir constitue donc le point unique où les métriques de toute la plateforme — plan de contrôle _et_ calcul — sont consolidées.

Les exportateurs qui alimentent cette chaîne comprennent notamment `node-exporter` (hôtes du plan de contrôle et de calcul), `kube-state-metrics` (charges de travail du plan de contrôle), `openstack-exporter` (services OpenStack), les exportateurs Ceph, `blackbox-exporter` (sondage de points d'entrée) et `x509-certificate-exporter` (expiration des certificats).

#### Chaîne des logs

| Étape        | Composant         | Rôle                                                                                                         |
| ------------ | ----------------- | ------------------------------------------------------------------------------------------------------------ |
| Collecte     | **Grafana Alloy** | Agent présent sur chaque nœud du plan de contrôle : collecte le journal `systemd` et les logs des conteneurs |
| Stockage     | **Loki**          | Backend d'agrégation de logs                                                                                 |
| Consultation | **Grafana**       | Exploration des logs et corrélation avec les métriques                                                       |

Alloy transmet ses flux à Loki sur le point d'entrée `loki.<base_dns_name>`. Les logs des nœuds de calcul ne sont pas envoyés à Loki par défaut : reportez-vous à la section « [Centraliser les logs des nœuds de calcul dans Loki](#compute-logs-loki) ».

#### Alerting

Un ensemble prédéfini de règles d'alerte est livré avec le produit, prêt à l'emploi sans configuration de votre part. Ces règles couvrent le plan de contrôle, les services OpenStack, Ceph, les contrôleurs bare metal (BMC), le moteur GitOps et les certificats. Elles sont évaluées de manière centralisée par le **ruler Mimir**, qui les lit depuis la plateforme et les applique aux métriques consolidées.

Les alertes actives sont transmises à **Alertmanager**, qui prend en charge la déduplication, les mises en silence et le routage des notifications vers votre système d'astreinte. Alertmanager est un composant optionnel qui n'est pas déployé par défaut. Il est déployé lorsque les notifications d'alerte sont activées sur votre plateforme, ou lorsque la plateforme est surveillée par l'équipe d'astreinte OVHcloud ; son interface est alors publiée sur `alertmanager.<base_dns_name>`. Lorsqu'il n'est pas déployé, les règles sont bien évaluées mais aucune notification n'est émise. Pour envoyer les notifications vers vos propres outils, reportez-vous à la section « [Envoyer les notifications d'alerte](#alert-notifications) ».

Dans Grafana, les règles évaluées par le ruler Mimir sont listées dans `Alerting
` > `Alert rules
`, avec leur état (normal, en attente ou déclenché).

### Accéder aux interfaces

Toutes les interfaces ci-dessous sont publiées sous le nom de domaine de base de votre plateforme et sont protégées par une authentification **Keycloak**.

| Interface        | Adresse                                | Usage                                                                                                                    |
| ---------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| **Grafana**      | `https://grafana.<base_dns_name>`      | Tableaux de bord, exploration des métriques et des logs. L'interface que vous utiliserez au quotidien                    |
| **Prometheus**   | `https://prometheus.<base_dns_name>`   | Vue brute du collecteur du plan de contrôle : cibles, état de collecte, requêtes court terme                             |
| **Alertmanager** | `https://alertmanager.<base_dns_name>` | Alertes actives et mises en silence. Publiée uniquement si les notifications d'alerte sont activées sur votre plateforme |

Deux points d'entrée supplémentaires sont utilisés pour l'ingestion : ils acceptent les écritures des agents de la plateforme et ne sont pas des interfaces consultables.

- `https://metrics.<base_dns_name>` — ingestion des métriques dans Mimir. Lorsque l'[API de requête en lecture seule](#external-grafana) est activée, il sert également les requêtes PromQL sous `/prometheus`.
- `https://loki.<base_dns_name>` — ingestion des logs dans Loki

**Attention :** Il est interdit d'envoyer des données depuis des agents tiers vers les points d'entrée d'ingestion : ils sont réservés à la collecte propre de la plateforme.

### Droits d'accès

L'accès à Grafana est déterminé par le rôle que détient votre compte dans Keycloak. La correspondance est réévaluée à chaque connexion, et un compte ne disposant d'aucun rôle d'observabilité se voit refuser l'accès.

| Rôle Keycloak  | Permission Grafana | Actions possibles                                                 |
| -------------- | ------------------ | ----------------------------------------------------------------- |
| `dc_operator`  | Viewer             | Consulter les tableaux de bord existants et exécuter des requêtes |
| `it_admin`     | Editor             | Idem, plus la création et la modification de tableaux de bord     |
| `master_admin` | Grafana admin      | Idem, plus l'administration de l'instance Grafana                 |

Le rôle `reader` dispose d'un accès en lecture à Prometheus mais pas à Grafana. La matrice complète, pour l'ensemble des applications de la plateforme, est documentée dans le guide « [Gestion des droits IAM](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/iam-rights-management.md) ».

### Explorer vos données dans Grafana

#### Sources de données

Trois sources de données sont provisionnées dans Grafana :

| Source de données        | Contenu                                                           | Quand l'utiliser                                                                  |
| ------------------------ | ----------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| **Mimir** _(par défaut)_ | Toutes les métriques de la plateforme, plan de contrôle et calcul | Presque toujours : analyse de tendance, dimensionnement, investigation historique |
| **Prometheus**           | Le tampon court terme du collecteur du plan de contrôle           | Débogage en direct, vérification qu'une cible est bien collectée                  |
| **Loki**                 | Logs des nœuds et des conteneurs                                  | Lecture des logs, corrélation d'un incident avec ses métriques                    |

Mimir étant la source de données par défaut, un nouveau panneau interroge le stockage consolidé et à longue rétention tant que vous ne changez pas ce réglage. Mimir et Prometheus utilisent tous deux PromQL : une requête écrite pour l'un s'exécute telle quelle sur l'autre.

#### Explorer les logs

Pour lire les logs, ouvrez `Explore
` dans le menu de Grafana et sélectionnez la source de données `Loki
` :
1. Utilisez le « Label browser », ou le mode « Builder », pour sélectionner les logs par label, par exemple par `namespace` ou par `container`.
2. Ajoutez si besoin un filtre sur le contenu des lignes. En mode « Code », la requête `{component="api"} |= "error"` renvoie les lignes contenant `error` dans les logs des conteneurs d'API.
3. Sélectionnez la période et cliquez sur « Run query ».

   Grafana affiche le volume de logs sur la période, puis les lignes correspondantes. Cliquez sur une ligne pour afficher ses labels.

#### Dossiers de tableaux de bord

Les tableaux de bord livrés avec la plateforme sont organisés en dossiers :

| Dossier                      | Contenu                                                                                                   |
| ---------------------------- | --------------------------------------------------------------------------------------------------------- |
| **Openstack**                | Services OpenStack, dont les répartiteurs de charge Octavia                                               |
| **Ceph**                     | Cluster Ceph, pools, OSD, hôtes et passerelle Object Storage                                              |
| **Kubernetes**               | Charges de travail du plan de contrôle, consommation de ressources par namespace et par charge de travail |
| **Node exporter**            | Vue système des hôtes : processeur, mémoire, disques, réseau                                              |
| **Control plane components** | Composants internes du plan de contrôle                                                                   |
| **Observability**            | Santé de la pile d'observabilité elle-même, dont la cardinalité des métriques                             |

Par exemple, le tableau de bord **Baremetal nodes overview** du dossier **Openstack** donne une vue du parc de serveurs bare metal : températures, ventilateurs et alimentations de chaque nœud.

Avec un compte `it_admin`
 ou supérieur, vous pouvez créer vos propres tableaux de bord directement dans l'interface Grafana, ou les importer depuis un fichier JSON (`Dashboards
` > `New
` > `Import
`). Rangez-les dans un dossier qui vous est propre : les dossiers listés ci-dessus sont provisionnés par la plateforme et réconciliés avec elle, si bien que toute modification manuelle y est annulée.
Les tableaux de bord que vous créez sont stockés dans la base de données de Grafana, sur un volume persistant inclus dans les sauvegardes des volumes persistants de la plateforme (consultez le guide « [Comment mettre à jour les buckets S3<sup>1</sup> de sauvegarde](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/how-to-update-backup-s3-buckets.md)
 »). Ils sont donc restaurés avec la plateforme, dans l'état de la dernière sauvegarde. Pour en conserver une copie versionnée, ou pour déployer les mêmes tableaux de bord sur plusieurs plateformes, exportez-les également au format JSON (`Share
` > `Export
`) et conservez-les dans un dépôt qui vous est propre.

### Rétention des données

Chaque étage de la chaîne conserve les données pendant une durée différente. La valeur qui compte pour l'analyse historique est celle de Mimir.

| Données                          | Emplacement | Rétention par défaut |
| -------------------------------- | ----------- | -------------------- |
| Métriques — longue durée         | Mimir       | **60 jours**         |
| Métriques — tampon du collecteur | Prometheus  | 7 jours              |
| Logs                             | Loki        | 7 jours              |

**Note :** Prometheus ne conserve qu'un tampon local court, car chaque série qu'il collecte est immédiatement transmise à Mimir. Les requêtes portant sur plus de quelques jours doivent cibler la source de données Mimir.

### Adapter la pile à vos besoins

Les comportements suivants peuvent être adaptés sur votre plateforme. Sur une plateforme infogérée par OVHcloud, demandez la modification via votre canal de support habituel ; sur une plateforme que vous administrez vous-même, appliquez-la dans la configuration de votre plateforme.

- **Rétention des logs** — la durée pendant laquelle Loki conserve vos logs, soit 7 jours par défaut, reportez-vous à la section « [Rétention des logs](#log-retention) ».
- **Export des logs** — la plateforme peut transmettre ses logs à un collecteur externe, vers vos propres serveurs syslog ou vers le service OVHcloud [Logs Data Platform](https://docs.ovhcloud.com/fr/guides/manage-and-operate/observability/logs-data-platform/getting-started-quick-start.md), reportez-vous à la section « [Transmettre les logs vers un collecteur externe](#log-forwarding) ».
- **Règles d'alerte personnalisées** — les règles d'alerte et d'enregistrement peuvent provenir d'un dépôt Git qui vous appartient, à la place des règles livrées avec la plateforme, reportez-vous à la section « [Lire les règles d'alerte depuis un dépôt Git](#prometheus-rules-repository) ».
- **Stockage des métriques** — les métriques à long terme peuvent être stockées dans un bucket externe compatible S3, tel qu'un bucket Object Storage Public Cloud OVHcloud, plutôt que sur le stockage objet de la plateforme, consultez le guide « [Comment stocker les métriques OPCP dans un bucket S3 externe](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/how-to-store-metrics-in-external-s3-bucket.md) ».
- **Tableaux de bord personnalisés** — vous pouvez créer et gérer vos propres tableaux de bord dans l'interface Grafana, reportez-vous à la section « [Dossiers de tableaux de bord](#dashboard-folders) ». Ils sont inclus dans les sauvegardes de la plateforme, sans nécessiter de dépôt Git. Les tableaux de bord et les règles d'alerte livrés avec la plateforme sont gérés sous forme de code (IaC, _Infrastructure as Code_) : ils sont définis dans la configuration de la plateforme et réconciliés en continu, si bien que toute modification manuelle y est annulée. Rangez vos propres tableaux de bord dans un dossier qui vous est propre, et vos propres règles d'alerte dans votre propre dépôt Git (voir ci-dessus).
- **Capacité d'ingestion** — la chaîne d'ingestion des métriques est dimensionnée à la livraison pour la taille de votre plateforme. L'ajout d'un nombre important de nœuds peut nécessiter son redimensionnement, reportez-vous à la section « [Limites par défaut](#default-limits) ». Elle est réservée à la collecte propre de la plateforme : l'envoi de métriques depuis vos propres charges de travail n'est pas autorisé.
- **Grafana externe** — les métriques consolidées peuvent être interrogées depuis une instance Grafana qui vous appartient, reportez-vous à la section « [Interroger les métriques depuis un Grafana externe](#external-grafana) ».
- **Export des métriques** — une copie des métriques du plan de contrôle peut être envoyée vers un point d'entrée externe compatible Prometheus, reportez-vous à la section « [Exporter les métriques vers un point d'entrée externe](#external-remote-write) ».
- **Logs des nœuds de calcul** — les logs des nœuds de calcul peuvent être centralisés dans le Loki de la plateforme, reportez-vous à la section « [Centraliser les logs des nœuds de calcul dans Loki](#compute-logs-loki) ».
- **Notifications d'alerte** — les alertes peuvent être envoyées vers vos propres outils de messagerie, de discussion ou de gestion d'incidents, reportez-vous à la section « [Envoyer les notifications d'alerte](#alert-notifications) ».

**Attention :** Il n'est pas autorisé d'intégrer vos propres composants d'observabilité dans la pile de la plateforme : ne déployez pas vos propres exportateurs, agents de collecte, plugins Grafana ou tableaux de bord provisionnés au sein de la plateforme, et ne modifiez pas ses composants de supervision. Ces modifications ne sont pas prises en charge, peuvent être annulées lors de la prochaine réconciliation ou mise à jour, et peuvent perturber la supervision de la plateforme. Pour aller plus loin, utilisez les points d'intégration décrits dans ce guide : Grafana externe, export des métriques ou des logs, notifications d'alerte.

### Intégrations optionnelles

Les intégrations ci-dessous sont désactivées par défaut. Sur une plateforme que vous administrez vous-même, vous les activez depuis le contrôleur OPCP avec `opcp-cli` :

- les paramètres se modifient avec `sudo opcp-cli config edit`, puis s'appliquent avec `sudo opcp-cli deploy --system` ;
- les identifiants sont stockés dans les secrets de la plateforme, que vous consultez et modifiez avec `sudo opcp-cli secrets passwords --edit` (clés sous `stringData`).

Sur une plateforme infogérée par OVHcloud, demandez la modification via votre canal de support habituel.

**Note :** Les clés de secrets mentionnées ci-dessous sont créées par `sudo opcp-cli secrets passwords --generate`. Si une clé est absente de votre plateforme, exécutez cette commande une fois avec un `opcp-cli` à jour : les secrets existants sont conservés, seules les clés manquantes sont ajoutées.

#### Interroger les métriques depuis un Grafana externe

Mimir peut exposer une API de requête Prometheus **en lecture seule** sur le point d'entrée des métriques, pour qu'une instance Grafana qui vous appartient puisse interroger les métriques consolidées de la plateforme. Seuls les chemins de requête (`/prometheus/api/v1/...`) sont publiés : l'API de configuration des règles Mimir reste inaccessible, et l'API est protégée par des identifiants distincts de ceux de l'ingestion ainsi que par une limite de débit par adresse IP source.

1\. Activez l'API avec `sudo opcp-cli config edit` :

```yaml
monitoring:
  mimir:
    read_api:
      enabled: true
      username: grafana       # valeur par défaut
      rate_limit:             # par IP source, en requêtes par seconde
        average: 50
        burst: 100
```

Appliquez ensuite la configuration avec `sudo opcp-cli deploy --system`.

2\. Récupérez le mot de passe avec `sudo opcp-cli secrets passwords --edit` : il est stocké sous la clé `metrics_read_password`. Pour le modifier, changez la valeur dans le même éditeur et enregistrez.

3\. Dans votre Grafana, ajoutez une source de données **Prometheus** :

| Champ            | Valeur                                                                                                                     |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------- |
| URL              | `https://metrics.<base_dns_name>/prometheus`                                                                               |
| Authentification | Authentification basique, avec l'utilisateur configuré dans `read_api.username` et le mot de passe `metrics_read_password` |
| TLS              | Si votre plateforme utilise une autorité de certification privée, ajoutez-la comme certificat d'AC de confiance            |

**Attention :** L'URL doit se terminer par `/prometheus`, sans barre oblique finale. Tout autre chemin, comme `https://metrics.<base_dns_name>` seul, renvoie une erreur `404 Not Found` lors du test de la source de données.

Vous pouvez vérifier l'accès depuis n'importe quel hôte avec `curl` :

```bash
curl -u grafana:<metrics_read_password> 'https://metrics.<base_dns_name>/prometheus/api/v1/query?query=up'
```

#### Exporter les métriques vers un point d'entrée externe

Le Prometheus du plan de contrôle peut envoyer une copie de ses séries vers un point d'entrée externe compatible Prometheus (un Mimir central, Prometheus, Thanos, etc.) via le protocole `remote_write`, en plus du Mimir de la plateforme. Cette copie dispose de sa propre file d'attente : une indisponibilité du point d'entrée externe ne retarde pas l'ingestion dans le Mimir de la plateforme. Le même filtre de cardinalité que pour le Mimir de la plateforme est appliqué.

1\. Configurez le point d'entrée avec `sudo opcp-cli config edit` :

```yaml
monitoring:
  external_remote_write:
    controller:
      enabled: true
      url: https://mimir.example.com/api/v1/push
      tenant: anonymous       # envoyé dans l'en-tête X-Scope-OrgID ; laissez vide pour ne pas l'envoyer
```

2\. Renseignez les identifiants d'authentification basique du point d'entrée externe avec `sudo opcp-cli secrets passwords --edit`, sous les clés `metrics_external_remote_write_username` et `metrics_external_remote_write_password`. Ces clés sont générées avec des valeurs aléatoires provisoires : remplacez-les par les identifiants fournis par le propriétaire du point d'entrée. La même commande vous permet de les consulter ou de les modifier par la suite.

3\. Appliquez la configuration avec `sudo opcp-cli deploy --system`.

Le point d'entrée externe doit :

- être joignable depuis le plan de contrôle en HTTPS, via un nom d'hôte (une adresse IP n'est pas acceptée) ;
- présenter un certificat reconnu par la plateforme : émis par une autorité de certification publique, ou par une AC que vous avez ajoutée au magasin de confiance de la plateforme.

Pour vérifier l'export, interrogez la série `up` sur le point d'entrée externe, ou consultez la métrique `prometheus_remote_storage_samples_failed_total` du Prometheus du plan de contrôle.

#### Transmettre les logs vers un collecteur externe

Le transmetteur de logs est un agent déployé sur chaque nœud du plan de contrôle et chaque nœud de calcul. Il collecte le journal `systemd` et les logs des conteneurs du nœud, et les envoie vers vos propres serveurs syslog, vers le service OVHcloud [Logs Data Platform](https://docs.ovhcloud.com/fr/guides/manage-and-operate/observability/logs-data-platform/getting-started-quick-start.md), ou vers les deux. Il est indépendant de la chaîne Loki : les logs du plan de contrôle restent consultables dans Grafana quelles que soient les destinations de transmission.

Les logs sont mis en tampon sur le nœud (jusqu'à 4 Go par destination) et renvoyés lorsqu'une destination est temporairement injoignable.

##### Transmettre vers des serveurs syslog

1\. Déclarez vos serveurs syslog avec `sudo opcp-cli config edit` :

```yaml
monitoring:
  logs:
    forwarder:
      enabled: true
      syslog:
        enabled: true
        endpoints:
          - host: syslog.example.com   # nom d'hôte ou adresse IPv4
            port: 6514
            mode: tls
          - host: 192.0.2.10
            port: 514
            mode: tcp
          - host: 192.0.2.20
            port: 514
            mode: udp
```

| Paramètre    | Description                                                                                                     |
| ------------ | --------------------------------------------------------------------------------------------------------------- |
| `host`       | Nom d'hôte ou adresse IPv4 du serveur syslog                                                                    |
| `port`       | Port du serveur syslog                                                                                          |
| `mode`       | `tcp` (par défaut), `tls` ou `udp` (depuis la version 3.1.3 d'OPCP)                                             |
| `tls_verify` | Mode `tls` uniquement : `on` (par défaut) pour vérifier le certificat du serveur, `off` pour ne pas le vérifier |
| `tls_vhost`  | Mode `tls` uniquement : nom d'hôte envoyé en SNI et vérifié sur le certificat, lorsqu'il diffère de `host`      |

2\. Appliquez la configuration avec `sudo opcp-cli deploy --system`.

Les messages sont envoyés au format RFC 5424. Aucun secret n'est nécessaire : les serveurs syslog doivent accepter sans authentification les connexions provenant de la plateforme. En mode `tls`, le certificat du serveur doit être émis par une autorité de certification publique, sauf si `tls_verify` vaut `off`.

##### Transmettre vers Logs Data Platform

1\. Dans votre compte Logs Data Platform, créez un flux et récupérez son **jeton d'écriture** ainsi que l'adresse de votre cluster.

2\. Enregistrez le jeton dans les secrets de la plateforme avec `sudo opcp-cli secrets passwords --edit`, sous la clé `ldp_token` (ajoutez la clé sous `stringData` si elle n'existe pas encore). La même commande vous permet ensuite de consulter ou de renouveler le jeton.

3\. Activez la destination avec `sudo opcp-cli config edit` :

```yaml
monitoring:
  logs:
    forwarder:
      enabled: true
      ldp:
        enabled: true
        endpoint:
          fqdn: <votre-cluster>.logs.ovh.com
          port: 12202           # GELF sur TLS
```

4\. Appliquez la configuration avec `sudo opcp-cli deploy --system`.

Chaque enregistrement porte un champ `LOG_SOURCE` contenant le nom de région de la plateforme, ce qui permet de distinguer plusieurs plateformes dans un même flux.

**Note :** Lorsqu'Octavia est activé, les logs des instances de répartition de charge (amphorae) sont transmis vers les mêmes destinations.

Pour vérifier la transmission, ouvrez le tableau de bord `Fluent Bit
` du dossier `Control plane components
` de Grafana, qui affiche le débit, les erreurs et les nouvelles tentatives de chaque sortie. L'alerte `LogForwarder-NoOutputBytesProcessed`
 se déclenche lorsqu'une sortie n'envoie plus de logs.

#### Centraliser les logs des nœuds de calcul dans Loki

Par défaut, les logs des nœuds de calcul sont uniquement envoyés vers les [destinations du transmetteur de logs](#log-forwarding) (syslog ou Logs Data Platform). Ils peuvent également être poussés vers le Loki de la plateforme, pour être explorés dans Grafana à côté des logs du plan de contrôle.

Activez cette intégration avec `sudo opcp-cli config edit`, puis appliquez-la avec `sudo opcp-cli deploy --system` :

```yaml
monitoring:
  logs:
    forwarder:
      enabled: true           # le transmetteur de logs doit être activé
      loki:
        enabled: true
```

Aucun secret n'est à renseigner pour cette intégration : les nœuds de calcul s'authentifient auprès de Loki avec les identifiants d'ingestion internes de la plateforme, gérés automatiquement. Il n'y a donc rien à consulter ni à modifier avec `sudo opcp-cli secrets passwords`.

Dans Grafana, les logs des nœuds de calcul se trouvent dans la source de données **Loki** avec le label `opcp_context="compute"`, et chaque nœud de calcul est identifié par le label `cluster`. Les labels `host`, `unit`, `level`, `namespace` et `container` suivent le même nommage que pour les logs du plan de contrôle.

**Attention :** Les logs des nœuds de calcul partagent le stockage et la rétention Loki des logs du plan de contrôle. Sur une plateforme de grande taille, le volume supplémentaire peut nécessiter d'adapter le stockage ou la rétention de Loki.

#### Envoyer les notifications d'alerte

Alertmanager peut notifier vos propres outils des alertes levées par la plateforme : e-mail, messagerie instantanée (Slack, Microsoft Teams, Mattermost, etc.), gestion d'incidents (PagerDuty, OpsGenie, etc.) ou tout webhook HTTP. Les intégrations disponibles nativement dans l'édition communautaire d'Alertmanager sont listées dans la [documentation officielle](https://prometheus.io/docs/alerting/latest/configuration/#receiver-integration-settings) (en anglais) ; pour un outil qui n'est pas pris en charge nativement, le projet Prometheus recense des [récepteurs webhook tiers](https://prometheus.io/docs/operating/integrations/#alertmanager-webhook-receiver) (en anglais). L'activation des notifications d'alerte publie également l'interface Alertmanager sur `alertmanager.<base_dns_name>`, depuis laquelle vous pouvez suivre les alertes actives et créer des mises en silence.

Les destinataires (_receivers_) et les routes s'écrivent dans la [syntaxe de configuration d'Alertmanager](https://prometheus.io/docs/alerting/latest/configuration/#receiver) (en anglais). Les alertes sont notamment regroupées par `alertname`, `namespace`, `severity` et `opcp_context`, labels que vous pouvez utiliser dans les routes.

1\. Enregistrez les identifiants de vos destinataires dans les secrets de la plateforme avec `sudo opcp-cli secrets passwords --edit` : ajoutez une clé par identifiant sous `stringData`, par exemple `alertmanager_smtp_password`. Le nom est libre, composé de lettres minuscules, de chiffres et de tirets bas. La même commande vous permet ensuite de les consulter ou de les renouveler. Les clés que vous ajoutez sont conservées lorsque `sudo opcp-cli secrets passwords --generate` est de nouveau exécuté, sauf avec son option `--clean`.

2\. Décrivez les destinataires avec `sudo opcp-cli config edit`, en référençant chaque identifiant sous la forme `${<clé>}` :

```yaml
monitoring:
  alertmanager:
    enabled: true
    default_receiver: ops-email          # reçoit toutes les alertes qu'aucune route ne capte
    receivers:
      - name: ops-email
        email_configs:
          - to: ops@example.com
            from: alertmanager@example.com
            smarthost: smtp.example.com:587
            auth_username: alertmanager@example.com
            auth_password: "${alertmanager_smtp_password}"
      - name: oncall-webhook
        webhook_configs:
          - url: https://hooks.example.com/alertmanager
            http_config:
              authorization:
                credentials: "${alertmanager_webhook_token}"
    routes:                              # optionnel
      - receiver: oncall-webhook
        matchers:
          - severity = "critical"
    egress:                              # chaque serveur contacté par vos destinataires
      - host: smtp.example.com
        port: 587
      - host: hooks.example.com
        port: 443
```

| Paramètre          | Description                                                                                                                                                                                                                                                                          |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `enabled`          | Déploie Alertmanager avec vos destinataires                                                                                                                                                                                                                                          |
| `default_receiver` | Destinataire des alertes qui ne correspondent à aucune de vos routes. `null` (par défaut) les ignore                                                                                                                                                                                 |
| `receivers`        | Vos destinataires, dans la syntaxe d'Alertmanager. Les noms `null` et `heartbeat` sont réservés                                                                                                                                                                                      |
| `routes`           | Routes optionnelles envoyant une partie des alertes vers un destinataire donné. Toutes les routes sont évaluées : pour envoyer une alerte à plusieurs destinataires, ajoutez une route par destinataire. Les alertes captées par une route ne sont pas envoyées à `default_receiver` |
| `templates`        | Fichiers de modèles de notification optionnels, reportez-vous à la section « [Personnaliser le contenu des notifications](#alert-templates) »                                                                                                                                        |
| `egress`           | Nom d'hôte ou adresse IPv4 et port TCP de chaque serveur contacté par vos destinataires : le trafic sortant d'Alertmanager est bloqué par défaut                                                                                                                                     |

3\. Appliquez la configuration avec `sudo opcp-cli deploy --system`.

**Attention :** Les paramètres des destinataires passent par la substitution de variables de la plateforme : tout `$` suivi d'un nom est remplacé par le secret du même nom, ou par une chaîne vide. N'utilisez pas de variables `$` dans les paramètres des destinataires : placez ces modèles dans un fichier de modèles, reportez-vous à la section « [Personnaliser le contenu des notifications](#alert-templates) ».

**Note :** Lorsque la plateforme est surveillée par l'équipe d'astreinte OVHcloud, les alertes continuent d'être envoyées à cette équipe : vos routes sont évaluées en complément de sa route, jamais à sa place.

Pour vérifier la configuration, ouvrez `https://alertmanager.<base_dns_name>`
 : la page `Status
` affiche la configuration chargée par Alertmanager. L'alerte `Watchdog`
, toujours active, sert à contrôler la chaîne d'alerte en interne et n'est jamais envoyée à vos destinataires.

##### Personnaliser le contenu des notifications

Par défaut, chaque destinataire envoie le message intégré d'Alertmanager. La plateforme fournit également des modèles prêts à l'emploi, utilisables par n'importe quel destinataire :

| Modèle       | Contenu                                                                                                                                                            |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `opcp.title` | Résumé sur une ligne : état, nombre d'alertes actives, nom de l'alerte, sévérité et contexte, par exemple `[FIRING:2] KubePodCrashLooping (warning) [compute]`     |
| `opcp.text`  | Liste en texte brut des alertes actives et résolues, avec leur résumé, leur description, leurs dates et leurs labels, suivie de liens vers Alertmanager et Grafana |
| `opcp.html`  | Le même contenu en HTML, pour les e-mails                                                                                                                          |

Référencez-les dans les champs des destinataires qui acceptent un modèle :

```yaml
monitoring:
  alertmanager:
    receivers:
      - name: ops-email
        email_configs:
          - to: ops@example.com
            # ... paramètres SMTP
            headers:
              Subject: '{{ template "opcp.title" . }}'
            html: '{{ template "opcp.html" . }}'
      - name: ops-chat
        slack_configs:
          - api_url: "${alertmanager_slack_url}"
            title: '{{ template "opcp.title" . }}'
            text: '{{ template "opcp.text" . }}'
```

Pour écrire vos propres modèles, ajoutez des fichiers de modèles sous `templates`, dans la [syntaxe des modèles de notification d'Alertmanager](https://prometheus.io/docs/alerting/latest/notifications/) (en anglais). Contrairement aux paramètres des destinataires, ces fichiers ne sont pas modifiés par la substitution de variables : ils peuvent donc utiliser des variables `$` :

```yaml
monitoring:
  alertmanager:
    templates:
      customer.tmpl: |
        {{ define "customer.subject" }}[My Company] {{ range $i, $a := .Alerts }}{{ if $i }}, {{ end }}{{ $a.Labels.alertname }}{{ end }}{{ end }}
    receivers:
      - name: ops-email
        email_configs:
          - to: ops@example.com
            # ... paramètres SMTP
            headers:
              Subject: '{{ template "customer.subject" . }}'
            html: '{{ template "opcp.html" . }}'
```

Appliquez les modifications avec `sudo opcp-cli deploy --system` : Alertmanager recharge les modèles sans redémarrer. Les règles suivantes s'appliquent :

- chaque nom de fichier doit se terminer par `.tmpl`, sans quoi le déploiement est refusé ;
- les noms de modèles `opcp.*` et `opsgenie.*` appartiennent à la plateforme : un de vos modèles portant l'un de ces noms est ignoré. Pour adapter un modèle par défaut, copiez-le sous un nom qui vous est propre, par exemple `customer.html`. Sur une plateforme que vous administrez vous-même, consultez les modèles par défaut avec `kubectl -n monitoring get configmap alertmanager-templates -o yaml`.

**Attention :** Une erreur de modèle n'est détectée qu'à l'envoi d'une notification : celle-ci n'est alors pas délivrée. Après avoir modifié un modèle, consultez les logs d'Alertmanager et la métrique `alertmanager_notifications_failed_total` dans Grafana, idéalement pendant qu'une alerte de test est active.

#### Lire les règles d'alerte depuis un dépôt Git

Les règles d'alerte et d'enregistrement (objets `PrometheusRule`) peuvent être lues depuis un dépôt Git qui vous appartient plutôt que depuis la plateforme, pour que chaque modification suive votre propre processus de validation. Activez cette option avec `sudo opcp-cli config edit` :

```yaml
monitoring:
  prometheus_rules:
    repository:
      enabled: true
      url: ssh://<votre-serveur-git>/<projet>/<depot>.git
      branch: main
```

**Attention :** Ce dépôt **remplace** les règles livrées avec la plateforme : il doit contenir les règles de la plateforme en plus des vôtres, et les règles livrées avec les versions ultérieures doivent y être intégrées à chaque mise à jour.

Avant de l'activer, contactez le support OVHcloud pour connaître les prérequis : accès au dépôt et organisation attendue de son contenu.

### Limitations connues

- **Locataire unique.** Mimir est exploité comme un locataire logique unique : le plan de contrôle et chaque nœud de calcul partagent le même espace de métriques et le même quota d'ingestion. Il n'existe pas d'isolation des métriques par équipe ou par projet. Cette pile est destinée à l'exploitation de la plateforme : pour un usage multi-locataire, le service d'observabilité du Cloud Store est conçu pour la multilocation.
- **Pas de redondance des métriques par défaut.** La chaîne d'ingestion Mimir est déployée sans réplication par défaut. Une plateforme exigeant que la perte d'un composant d'ingestion soit transparente doit être dimensionnée en conséquence lors de la livraison.
- **API de requête externe.** L'API de requête en lecture seule est limitée en débit par adresse IP source pour protéger le Mimir de la plateforme : des tableaux de bord lourds ou des requêtes larges depuis un Grafana externe peuvent recevoir des réponses `429 Too Many Requests`.
- **Alertmanager optionnel.** Sauf si les notifications d'alerte ont été activées sur votre plateforme (reportez-vous à la section « [Envoyer les notifications d'alerte](#alert-notifications) ») ou si la plateforme est surveillée par l'équipe d'astreinte OVHcloud, Alertmanager n'est pas déployé : les règles sont évaluées mais aucune notification n'est émise et aucune interface Alertmanager n'est publiée.

#### Limites par défaut

Les limites à l'origine de ces comportements sont définies dans la section `monitoring.mimir` de la configuration de la plateforme. Leurs valeurs par défaut sont les suivantes :

| Paramètre                                                   | Valeur par défaut  | Signification                                                                                       |
| ----------------------------------------------------------- | ------------------ | --------------------------------------------------------------------------------------------------- |
| `retention.compactor_blocks`                                | `60d`              | Rétention des métriques à long terme                                                                |
| `read_api.rate_limit.average` / `read_api.rate_limit.burst` | `50` / `100`       | Requêtes par seconde, par adresse IP source, acceptées sur l'API de requête externe                 |
| `limits.max_label_names_per_series`                         | `50`               | Nombre maximal de labels sur une série                                                              |
| `limits.ingestion_rate` / `limits.ingestion_burst_size`     | `50000` / `500000` | Échantillons par seconde acceptés par Mimir, et échantillons acceptés en rafale au-delà de ce débit |
| `limits.max_global_series_per_user`                         | `3000000`          | Nombre maximal de séries actives pour l'ensemble de la plateforme (locataire unique)                |

`MimirTenantSeriesApproachingLimit` et `MimirTenantSeriesNearLimit` préviennent en amont, lorsque les séries actives atteignent 70 % puis 85 % de `max_global_series_per_user`. `MimirSamplesDiscardedSeriesLimit` se déclenche lorsque des échantillons sont effectivement rejetés, en raison du plafond de séries, du débit d'ingestion ou du nombre de labels.

Sur une plateforme que vous administrez vous-même, surchargez uniquement les valeurs à modifier avec `sudo opcp-cli config edit`, par exemple pour conserver les métriques plus longtemps et relever les limites d'ingestion :

```yaml
monitoring:
  mimir:
    retention:
      compactor_blocks: 90d
    limits:
      max_global_series_per_user: 5000000
      ingestion_rate: 100000
      ingestion_burst_size: 1000000
    read_api:
      rate_limit:
        average: 100
        burst: 200
```

Appliquez ensuite la configuration avec `sudo opcp-cli deploy --system`. Sur une plateforme infogérée par OVHcloud, demandez la modification via votre canal de support habituel.

**Attention :** Ces valeurs doivent être adaptées en cohérence avec la capacité du plan de contrôle. Relever `max_global_series_per_user` augmente la mémoire utilisée par Mimir : prévoyez environ 4 Gio par million de séries actives (jusqu'à 6 Gio pendant la compaction). Allonger la rétention augmente l'espace occupé dans le bucket de stockage objet.

#### Rétention des logs

La rétention des logs est définie dans la section `monitoring.loki` de la configuration de la plateforme. Ses valeurs par défaut sont les suivantes :

| Paramètre          | Valeur par défaut | Signification                                 |
| ------------------ | ----------------- | --------------------------------------------- |
| `retention_period` | `7d`              | Durée pendant laquelle Loki conserve les logs |
| `storage.size`     | `50Gi`            | Taille du volume qui stocke les logs          |

Sur une plateforme que vous administrez vous-même, surchargez-les avec `sudo opcp-cli config edit`, par exemple pour conserver les logs pendant 14 jours :

```yaml
monitoring:
  loki:
    retention_period: 14d
    storage:
      size: 100Gi
```

Appliquez ensuite la configuration avec `sudo opcp-cli deploy --system`. Sur une plateforme infogérée par OVHcloud, demandez la modification via votre canal de support habituel.

**Attention :** Les logs sont stockés sur un volume du plan de contrôle, et non dans un bucket de stockage objet : lorsqu'il est plein, les nouveaux logs sont perdus. Dimensionnez le volume en cohérence avec la rétention et avec le volume de logs de votre plateforme, qui augmente nettement lorsque les [logs des nœuds de calcul](#compute-logs-loki) sont centralisés dans Loki. L'agrandissement du volume d'une plateforme existante peut nécessiter une intervention manuelle : contactez le support OVHcloud au préalable.

## Aller plus loin

[Gestion des droits IAM](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/iam-rights-management.md)

[Comment mettre à jour les buckets S3 de sauvegarde](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/how-to-update-backup-s3-buckets.md) (exemple de modification de configuration avec `opcp-cli`)

[Comment gérer la configuration d'OPCP avec opcp-cli](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/how-to-manage-configuration.md)

[Mise en route de votre OPCP](https://docs.ovhcloud.com/fr/guides/hosted-private-cloud/opcp/getting-started.md)

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page [Professional Services](https://www.ovhcloud.com/fr/professional-services/) pour obtenir un devis et faire analyser votre projet par nos experts.

Échangez avec notre [communauté d'utilisateurs](https://community.ovhcloud.com/).

1
 : S3 est une marque déposée appartenant à Amazon Technologies, Inc. Les services OVHcloud ne sont pas sponsorisés, approuvés, ou affiliés de quelque manière que ce soit.