Comment configurer la pile LGTM pour mettre en place une observabilité de bout en bout

La pile LGTM, composée de Loki pour les journaux, Grafana pour la visualisation, Tempo pour le traçage et Mimir pour les métriques, est une suite d’observabilité open source développée par Grafana Labs.

Elle regroupe les métriques, les journaux et les traces au sein d’une plateforme unique, ce qui offre aux équipes une vue d’ensemble des performances du système.

Dans ce guide, vous allez configurer la pile LGTM sur un serveur privé virtuel (VPS). Vous configurerez chaque composant, puis créerez un tableau de bord d’observabilité afin d’obtenir une visibilité complète sur vos applications et votre infrastructure.

Qu’est-ce que l’observabilité de bout en bout ?

L’observabilité de bout en bout consiste à surveiller et à analyser l’ensemble du cycle de vie d’une application, depuis les interactions des utilisateurs sur le front-end jusqu’aux services et composants d’infrastructure du back-end.

Contrairement à la supervision traditionnelle, qui se limite au suivi de métriques prédéfinies pour évaluer l’état d’un système et détecter des problèmes connus, l’observabilité de bout en bout offre une vue unifiée des éléments suivants :

• Interactions utilisateur – suivi des métriques du front-end et du comportement des utilisateurs.
• Performances des applications – surveillance des services back-end et des API internes.
• État de l’infrastructure – évaluation de l’état des serveurs, des bases de données et des réseaux.
• Services tiers – surveillance des dépendances, comme les passerelles de paiement ou les fournisseurs de services cloud.

En corrélant les données provenant de l’ensemble de ces couches, les équipes comprennent plus facilement l’impact des changements apportés à un composant sur les performances globales du système et peuvent détecter rapidement les problèmes, où qu’ils surviennent.

La pile LGTM prend en charge l’observabilité de bout en bout en instrumentant les applications afin de collecter des données de télémétrie : journaux, métriques et traces. Elle agrège ensuite ces données à l’aide de ses différents composants et les affiche dans des tableaux de bord Grafana pour en faciliter l’analyse.

Cette approche présente plusieurs avantages :

• Supervision complète – la pile LGTM offre une vue d’ensemble du comportement du système, ce qui facilite la détection et la résolution proactives des problèmes.
• Dépannage plus efficace – la corrélation des données issues de plusieurs sources aide les équipes à identifier rapidement les causes profondes des incidents, réduisant ainsi le temps moyen de résolution (MTTR).
• Évolutivité – chaque composant de la pile LGTM peut évoluer horizontalement afin de prendre en charge des systèmes distribués et complexes.
• Rentabilité – en tant que solution open source, la pile LGTM élimine les frais de licence associés aux outils d’observabilité propriétaires.

Prérequis

Avant de configurer la pile LGTM, préparez une instance VPS qui l’hébergera. Grafana, qui constitue l’interface principale de visualisation des données d’observabilité, ne nécessite pas de ressources importantes. Vous pouvez exécuter la pile LGTM complète sur un VPS disposant de :

• 1 cœur de processeur
• 512 Mo de RAM

Toutefois, la pile LGTM étant destinée à surveiller les performances du système et le comportement des applications, choisissez une offre VPS adaptée à la taille de votre infrastructure et à votre charge de travail.

Le service VPS de Hostinger constitue une excellente option, avec des offres allant de €5.49/mois.

Nos offres proposent jusqu’à 8 vCPU, 32 Go de RAM et 400 Go de stockage NVMe. Vous pourrez les faire évoluer à tout moment si votre plateforme d’observabilité nécessite davantage de puissance ou d’espace de stockage.

Ensuite, configurez votre pare-feu. Ouvrez les ports suivants sur votre VPS afin de garantir le bon fonctionnement des composants de la pile LGTM :

Si vous venez d’acquérir un VPS ou que vous n’avez pas encore configuré de pare-feu, vous pouvez ignorer cette étape.

Si Uncomplicated Firewall (UFW) est activé sur votre serveur, ouvrez un terminal et exécutez les commandes suivantes :

sudo ufw allow 3000/tcp    # Grafana  
sudo ufw allow 3100/tcp    # Loki  
sudo ufw allow 3200/tcp    # Tempo  
sudo ufw allow 9090/tcp    # Mimir  
sudo ufw allow 4318/tcp    # OpenTelemetry Collector

Vérifiez ensuite qu’UFW est bien actif et que les règles ont été appliquées en exécutant la commande suivante :

sudo ufw status

Comment configurer la pile LGTM sur un VPS

Il existe plusieurs façons de configurer la pile LGTM sur un VPS. Dans ce tutoriel, nous utiliserons Docker Compose, qui permet de déployer et de gérer rapidement tous les composants à partir d’un seul fichier. Cette approche est la plus simple et convient parfaitement pour débuter.

Si vous préférez disposer d’un contrôle plus fin ou ne souhaitez pas utiliser Docker, nous vous montrerons également comment installer chaque composant manuellement.

1. Préparer l’environnement

Commencez par mettre à jour la liste des paquets de votre VPS, puis mettez à niveau les paquets installés vers leur dernière version. Vous vous assurez ainsi que votre serveur bénéficie des derniers correctifs de sécurité et des améliorations logicielles :

sudo apt update && sudo apt upgrade -y

Si vous le souhaitez, supprimez ensuite les paquets et dépendances inutilisés afin de libérer de l’espace disque :

sudo apt autoremove -y

Installez ensuite Docker sur votre serveur afin de déployer les composants dans des conteneurs et d’utiliser Docker Compose.

Les utilisateurs d’un VPS Hostinger peuvent simplifier cette étape en utilisant un modèle Docker préconfiguré en un clic. Sinon, installez Docker manuellement à l’aide des commandes Linux correspondantes.

Si vous ne prévoyez pas d’utiliser Docker, vous pouvez ignorer cette section.

Une fois l’installation terminée, vérifiez que Docker fonctionne correctement en exécutant la commande suivante :

sudo systemctl status docker

Appuyez sur Ctrl + C pour quitter l’affichage de l’état.

Créez ensuite un nouveau répertoire pour les fichiers de la pile LGTM, puis accédez-y. Remplacez grafana-lgtm par le nom de répertoire de votre choix :

mkdir grafana-lgtm

cd grafana-lgtm

2. Configurer Loki pour l’agrégation des journaux

Loki assure l’agrégation des journaux en collectant et en stockant les données provenant de différentes sources.

Il indexe uniquement les métadonnées plutôt que le contenu complet des journaux, ce qui réduit les besoins en stockage et améliore les performances des requêtes, notamment lorsque le volume de journaux est important.

Dans le répertoire grafana-lgtm, créez un fichier nommé loki-local-config.yaml à l’aide de l’éditeur de texte nano :

sudo nano loki-local-config.yaml

Collez la configuration suivante dans le fichier :

auth_enabled: false

server:
  http_listen_port: 3100

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /tmp/loki/boltdb-shipper-active
    cache_location: /tmp/loki/boltdb-shipper-cache
    cache_ttl: 24h
  filesystem:
    directory: /tmp/loki/chunks

limits_config:
  reject_old_samples: true
  reject_old_samples_max_age: 168h
  allow_structured_metadata: false

ingester:
  lifecycler:
    address: 127.0.0.1
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1
    final_sleep: 0s
  chunk_idle_period: 5m
  chunk_retain_period: 30s

common:
  path_prefix: /tmp/loki

compactor:
  working_directory: /tmp/loki/compactor

Une fois l’opération terminée, appuyez sur Ctrl + X → Y → Entrée pour enregistrer le fichier et quitter nano.

3. Configurer Mimir pour le stockage des métriques

Grafana Mimir s’appuie sur Prometheus et étend ses capacités en proposant un stockage évolutif à long terme ainsi qu’un moteur d’interrogation performant pour les grands volumes de données de séries chronologiques.

Dans ce guide, nous utiliserons toutefois uniquement Prometheus, car il s’intègre plus facilement à OpenTelemetry Collector pour collecter les métriques de cette configuration.

Si vous souhaitez également utiliser Mimir pour bénéficier de fonctionnalités avancées de stockage et de mise à l’échelle, vous pouvez le déployer en complément de Prometheus.

Créez un fichier prometheus.yml à l’aide de nano, comme vous l’avez fait pour la configuration de Loki. Collez ensuite la configuration suivante :

Enregistrez le fichier une fois l’opération terminée.

4. Configurer Tempo pour le traçage distribué

Grafana Tempo est un backend de traçage distribué conçu pour collecter, stocker et interroger les données de traçage dans les architectures de microservices.

Il vous permet de visualiser le parcours des requêtes lorsqu’elles traversent différents services, ce qui facilite l’identification rapide des goulets d’étranglement.

Comme pour les composants précédents, créez un fichier nommé tempo-local.yaml, puis collez-y la configuration suivante :

distributor:
  receivers:
    otlp:
      protocols:
        http:
          endpoint: "0.0.0.0:4318"

storage:
  trace:
    backend: local
    local:
      path: /tmp/tempo/blocks
    wal:
      path: /tmp/tempo/wal

ingester:
  trace_idle_period: 30s
  max_block_duration: "5m"
  lifecycler:
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1

compactor:
  compaction:
    block_retention: 1h

querier: {}  # ⭐ Doit être ajouté, sinon Tempo s’arrêtera automatiquement

multitenancy_enabled: false  # ⭐ Recommandé afin d’éviter les erreurs liées à un environnement à locataire unique

5. Installer Grafana pour la visualisation des données d’observabilité

Grafana constitue la couche de visualisation centrale de la pile LGTM. Il regroupe les données de tous les autres composants dans une interface unique, ce qui facilite la détection et la résolution des anomalies du système.

Vous pouvez installer Grafana sur votre VPS, soit manuellement, soit à l’aide de Docker Compose.

Si vous choisissez Docker Compose, commencez par créer un dossier nommé grafana dans le répertoire grafana-lgtm :

mkdir grafana

cd grafana

Créez ensuite un fichier nommé datasources.yml dans grafana-lgtm/grafana afin de configurer les sources de données. Collez-y le contenu suivant :

apiVersion: 1
datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true

  - name: Loki
    type: loki
    access: proxy
    url: http://loki:3100
    isDefault: false

  - name: Tempo
    type: tempo
    access: proxy
    url: http://tempo:3200
    isDefault: false

Créez ensuite un second fichier nommé dashboards.yml dans le même répertoire afin de configurer les fournisseurs de tableaux de bord Grafana :

apiVersion: 1
providers:
  - name: 'Local Dashboards'
    orgId: 1
    folder: ''
    type: file
    disableDeletion: false
    updateIntervalSeconds: 5
    options:
      path: /var/lib/grafana/dashboards

Créez ensuite un dossier nommé dashboards et accédez-y :

mkdir dashboards

cd dashboards

Ajoutez un fichier nommé springboot-observability.json. Il servira d’exemple de tableau de bord :

{
    "uid": "springboot-observability",
    "title": "Spring Boot OTEL Demo Dashboard",
    "time": {
        "from": "now-5m",
        "to": "now"
    },
    "panels": [
        {
            "type": "timeseries",
            "title": "JVM Heap Memory Used",
            "datasource": "Prometheus",
            "targets": [
                {
                    "expr": "process_runtime_jvm_memory_usage{service_name=\"springboot-otel-demo\", type=\"heap\"}"
                }
            ],
            "fieldConfig": {
                "defaults": {
                    "unit": "bytes"
                }
            },
            "gridPos": {
                "x": 0,
                "y": 0,
                "w": 12,
                "h": 8
            }
        },
        {
            "type": "logs",
            "title": "Application Logs (springboot-otel-demo)",
            "datasource": "Loki",
            "targets": [
                {
                    "expr": "{service_name=\"springboot-otel-demo\"}"
                }
            ],
            "gridPos": {
                "x": 0,
                "y": 8,
                "w": 24,
                "h": 8
            }
        }
    ]
}

6. Créer un fichier Docker Compose

Après avoir configuré chaque composant, créez un fichier Docker Compose. Ce fichier permet de définir et de gérer tous les services de la pile LGTM au même endroit, afin de simplifier et d’uniformiser le déploiement.

Vous pouvez ignorer cette étape si vous avez installé tous les composants manuellement, sans Docker.

Revenez d’abord dans le répertoire grafana-lgtm, puis créez un fichier nommé docker-compose.yml :

cd ~/grafana-lgtm
sudo nano docker-compose.yml

Ajoutez ensuite la configuration suivante au fichier :

services:

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

  loki:
    image: grafana/loki:latest
    container_name: loki
    user: "0:0"  # Exécute le conteneur avec l’utilisateur root
    volumes:
      - ./loki-local-config.yaml:/etc/loki/local-config.yaml:ro
      - loki-data:/tmp/loki
    command: -config.file=/etc/loki/local-config.yaml
    ports:
      - "3100:3100"

  tempo:
    image: grafana/tempo:latest
    container_name: tempo
    user: "0:0"  # Exécute le conteneur avec l’utilisateur root
    volumes:
      - ./tempo-local.yaml:/etc/tempo/tempo-local.yaml:ro
      - tempo-data:/tmp/tempo
    command: ["-config.file=/etc/tempo/tempo-local.yaml"]
    ports:
      - "3200:3200"   # Port HTTP utilisé pour les requêtes

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin 
      - GF_SECURITY_ADMIN_PASSWORD=admin 
    volumes:
      - ./grafana/datasources.yml:/etc/grafana/provisioning/datasources/datasources.yml:ro
      - ./grafana/dashboards.yml:/etc/grafana/provisioning/dashboards/dashboards.yml:ro
      - ./grafana/dashboards/:/var/lib/grafana/dashboards:ro
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
      - loki
      - tempo

volumes:
  loki-data: {}
  tempo-data: {}

Portez une attention particulière aux valeurs GF_SECURITY_ADMIN_USER et GF_SECURITY_ADMIN_PASSWORD du service grafana. Elles correspondent aux identifiants de connexion par défaut du tableau de bord Grafana. Modifiez-les afin de renforcer la sécurité.

N’oubliez pas d’enregistrer le fichier après l’avoir modifié.

Déployez ensuite tous les services sur votre serveur à l’aide de la commande suivante :

docker compose up -d

Pour vérifier que tous les services sont en cours d’exécution, exécutez la commande suivante :

docker compose ps

7. Accéder au tableau de bord Grafana

Ouvrez votre navigateur et accédez au tableau de bord Grafana à l’aide de l’URL suivante. Remplacez your_vps_ip par l’adresse IP de votre serveur :

Si vous hébergez votre pile LGTM sur un VPS Hostinger, vous trouverez son adresse IP dans hPanel, sous VPS → Gérer → Aperçu général → Informations du VPS.

Connectez-vous à l’aide du nom d’utilisateur et du mot de passe définis dans votre fichier Docker Compose. Si vous utilisez les identifiants par défaut, Grafana vous demandera de modifier votre mot de passe lors de la connexion.

L’interface de Grafana se compose d’une barre latérale à gauche, qui regroupe les menus de navigation, et d’un espace de travail à droite, dans lequel vous pouvez afficher et gérer vos tableaux de bord.

Si vous avez déployé les composants avec Docker Compose, Grafana ajoute automatiquement toutes les sources de données. Pour le vérifier, accédez à Connexions → Sources de données.

Si vous avez installé les composants manuellement, vous devrez ajouter les sources de données vous-même. Cliquez sur Ajouter une source de données, recherchez le composant souhaité, puis sélectionnez-le.

Renseignez ensuite le champ URL pour chaque composant comme suit :

• Loki – http://loki:3100
• Mimir et Prometheus – http://prometheus:9090
• Tempo – http://tempo:3200

Après avoir configuré chaque source de données, faites défiler la page vers le bas et cliquez sur Enregistrer et tester.

8. Explorer les sources de données

Vous pouvez maintenant visualiser vos données en exécutant des requêtes. Chaque composant utilise son propre langage de requête : LogQL pour Loki, PromQL pour Mimir et Prometheus, et TraceQL pour Tempo.

Dans la barre latérale de Grafana, cliquez sur Explorer, puis sélectionnez la source de données de votre choix dans le menu déroulant situé en haut de la page.

Pour Loki et Prometheus, ouvrez l’onglet Code. Pour Tempo, sélectionnez TraceQL. Saisissez ensuite votre requête et appuyez sur Maj + Entrée pour l’exécuter.

Voici quelques exemples de requêtes de base pour chaque source de données :

Loki

{service_name= "my-app"}       # Show all logs for a specific service  
{service_name="my-app"} |= "debug"  # Show only debug logs

Pour découvrir d’autres exemples de requêtes, consultez la documentation officielle de LogQL.

Mimir et Prometheus

Vous trouverez des exemples de requêtes avancées dans la documentation de PromQL.

Tempo

Pour en savoir plus sur les requêtes TraceQL, consultez la documentation officielle, qui présente des exemples de requêtes simples et avancées.

9. Créer un tableau de bord d’observabilité unifié

Dans la barre latérale gauche, ouvrez le menu Tableaux de bord pour afficher vos métriques, vos journaux et vos traces au sein d’une vue unifiée.

Si vous utilisez Docker Compose pour déployer la pile LGTM, un tableau de bord d’exemple est déjà disponible. Il offre un aperçu rapide de l’utilisation de la mémoire et des journaux des applications instrumentées avec OpenTelemetry.

Vous pouvez également créer un nouveau tableau de bord en cliquant sur Nouveau → Nouveau tableau de bord → Ajouter une visualisation.

Sélectionnez ensuite l’une des sources de données configurées. Dans l’éditeur de panneau, donnez un nom au panneau afin d’identifier le composant correspondant, puis saisissez votre requête dans le champ prévu à cet effet pour afficher les données souhaitées.

Une fois le panneau créé, cliquez sur Retour au tableau de bord → Ajouter → Visualisation, puis répétez cette opération pour chacun des autres composants.

Après avoir ajouté tous les panneaux, utilisez la poignée de redimensionnement située dans l’angle inférieur droit de chacun d’eux afin d’ajuster leur largeur et leur hauteur. Une fois la personnalisation terminée, cliquez sur Enregistrer le tableau de bord, attribuez-lui un nom, puis enregistrez vos modifications.

10. Ajouter des applications à votre plateforme d’observabilité

À l’étape précédente, vous avez constaté que le tableau de bord était vide, car aucune application n’avait encore été ajoutée à des fins de surveillance.

Il existe plusieurs façons d’ajouter des applications. Dans ce tutoriel, puisque vous utilisez Docker Compose pour déployer la pile LGTM, nous allons configurer OpenTelemetry Collector.

Il s’agit d’un agent indépendant de tout fournisseur qui collecte les données de télémétrie de vos applications, puis les transmet aux composants appropriés dans un format standardisé.

Pour configurer OpenTelemetry Collector, ouvrez un terminal, accédez au répertoire grafana-lgtm, puis créez un fichier nommé otel-collector-config.yaml à l’aide de nano :

cd grafana-lgtm
sudo nano otel-collector-config.yaml

Ajoutez la configuration suivante au fichier. Elle reçoit les données de télémétrie de vos applications, puis les achemine vers les composants appropriés :

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318    # Écoute sur OTLP/HTTP ; le port doit correspondre à celui défini dans Docker Compose
      grpc:
        endpoint: 0.0.0.0:4317    # Écoute sur OTLP/gRPC (facultatif)

processors:
  batch: {}  # Processeur de traitement par lots ; envoie les données de télémétrie par lots afin d’améliorer les performances

exporters:
  # Exporte les métriques sous forme de point de terminaison de collecte Prometheus
  prometheus:
    endpoint: "0.0.0.0:9464"
    # Active la conversion des attributs de ressource en libellés de métriques afin que service.name et les autres attributs apparaissent dans les libellés Prometheus
    resource_to_telemetry_conversion:
      enabled: true

  # Exporte les journaux vers Loki via OTLP HTTP (à l’aide du récepteur OTLP natif de Loki)
  otlphttp/loki:
    endpoint: "http://loki:3100/loki/api/v1/push"  # Loki's OTLP log receiver HTTP API
    # Loki reçoit les journaux OTLP via l’exportateur otlphttp

  # Exporte les traces vers Tempo via OTLP HTTP
  otlphttp/tempo:
    endpoint: "http://tempo:3200/v1/traces"

# Définit les pipelines de traitement pour chaque type de données de télémétrie
service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]        # Les métriques sont traitées et exposées au format Prometheus
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/loki]     # Les journaux sont traités et envoyés vers Loki (OTLP HTTP)
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/tempo]     # Les traces sont traitées et envoyées vers Tempo (OTLP HTTP)

Modifiez ensuite le fichier docker-compose.yml et ajoutez le service otel-collector à la section services :

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    container_name: otel-collector
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml:ro
    command: ["--config", "/etc/otel-collector-config.yaml"]
    ports:
      - "4318:4318"                   # OTLP HTTP
      - "9464:9464"                   # Métriques Prometheus
    depends_on:
      - prometheus
      - loki
      - tempo

Une fois le fichier Docker Compose mis à jour, redémarrez tous les services afin d’appliquer les modifications :

docker compose down -v
docker compose up -d

Configurez ensuite votre application pour envoyer ses données de télémétrie à OpenTelemetry Collector. La procédure dépend du langage et du framework utilisés. Voici deux exemples :

Applications Node.js

Installez les paquets OpenTelemetry requis :

npm install @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http @opentelemetry/exporter-metrics-otlp-http @opentelemetry/exporter-logs-otlp-http

Ajoutez ensuite ce code d’initialisation à votre application :

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { OTLPMetricExporter } = require('@opentelemetry/exporter-metrics-otlp-http');
const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http');
const sdk = new NodeSDK({
traceExporter: new OTLPTraceExporter({
url: 'http://localhost:4318/v1/traces'
}),
metricExporter: new OTLPMetricExporter({
url: 'http://localhost:4318/v1/metrics'
}),
logExporter: new OTLPLogExporter({
url: 'http://localhost:4318/v1/logs'
}),
serviceName: 'my-nodejs-app'
});
sdk.start();

Applications Java

Téléchargez l’agent Java OpenTelemetry :

curl -L -o opentelemetry-javaagent.jar https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar

Lancez ensuite votre application avec l’agent, en remplaçant my-app par le nom de votre service :

java -javaagent:opentelemetry-javaagent.jar \

-Dotel.exporter.otlp.endpoint=http://localhost:4318 \

-Dotel.resource.attributes=service.name=my-app \

-jar your-application.jar

Retournez ensuite sur votre tableau de bord Grafana pour vérifier que les données de télémétrie de votre application sont bien collectées. Vous pourrez alors suivre en temps réel ses performances, ses journaux et ses traces.

Conclusion

La pile LGTM regroupe les journaux, les métriques, les traces et leur visualisation au sein d’une même plateforme. Elle vous aide à superviser plus efficacement les systèmes complexes, à accélérer le dépannage et à obtenir des informations exploitables pour optimiser les performances.

Dans ce guide, vous avez appris à :

1. préparer votre environnement serveur ;
2. installer et configurer Loki pour collecter les journaux ;
3. configurer Prometheus pour collecter les métriques ;
4. configurer Tempo pour le traçage distribué ;
5. installer Grafana pour centraliser la visualisation ;
6. définir les services avec Docker Compose ;
7. accéder au tableau de bord Grafana ;
8. interroger les différentes sources de données ;
9. créer un tableau de bord d’observabilité unifié ;
10. ajouter vos applications à l’aide d’OpenTelemetry Collector.

Pour aller plus loin, explorez les possibilités offertes par LogQL, TraceQL et PromQL afin de créer des requêtes plus avancées. Vous pouvez également configurer des règles d’alerte dans Grafana pour être averti lorsque certaines métriques ou certains journaux atteignent des seuils critiques.

FAQ sur la pile LGTM

Tout le contenu des tutoriels de ce site est soumis aux normes éditoriales et aux valeurs rigoureuses de Hostinger.

L'auteur

Faradilla Ayunindya

Faradilla, plus connue sous le nom de Ninda, possède 10 ans d’expérience en tant que linguiste et 5 ans en tant que spécialiste du marketing de contenu chez Hostinger. Elle aime suivre les tendances technologiques et aider les autres à résoudre leurs problèmes. Pendant son temps libre, Ninda aime apprendre de nouvelles langues et s’intéresser aux sciences de la vie, ainsi que regarder des vidéos d’animaux. Pour en savoir plus sur Ninda, retrouvez-la sur LinkedIn.

Plus d'informations sur Faradilla Ayunindya