Comment utiliser Docker pour la surveillance des applications et la gestion des journaux

Docker est devenu une technologie essentielle dans les applications modernes, mais utiliser Docker pour la surveillance des applications et la gestion des journaux est un défi. Avec l'amélioration continue des fonctions réseau de Docker, telles que la découverte de services et l'équilibrage de charge, nous avons de plus en plus besoin d'un système de surveillance des applications complet, stable et efficace.

Dans cet article, nous présenterons brièvement l'utilisation de Docker pour la surveillance des applications et la gestion des journaux et donnerons des exemples de code spécifiques.

Utilisez Prometheus pour la surveillance des applications

Prometheus est un outil open source de surveillance et d'avertissement de service basé sur un modèle Pull développé par SoundCloud. Il est écrit en langage Go et est largement utilisé dans les solutions de microservices et les environnements cloud. En tant qu'outil de surveillance, il peut surveiller le processeur, la mémoire, le réseau et le disque de Docker, etc., et prend également en charge la commutation de données multidimensionnelle, les fonctions flexibles de requête, d'alarme et de visualisation, vous permettant de réagir rapidement et de prendre des décisions rapidement.

Une autre chose à noter est que Prometheus doit échantillonner via le mode Pull, c'est-à-dire accéder à l'interface /metrics dans l'application surveillée pour obtenir des données de surveillance. Par conséquent, lors du démarrage de l'image de l'application surveillée, vous devez d'abord configurer l'adresse IP et le port pouvant accéder à Prometheus dans l'interface /metrics. Vous trouverez ci-dessous une simple application Node.js.

const express = require('express')
const app = express()

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.get('/metrics', (req, res) => {
  res.send(`
    # HELP api_calls_total Total API calls
    # TYPE api_calls_total counter
    api_calls_total 100
  `)
})

app.listen(3000, () => {
  console.log('Example app listening on port 3000!')
})

Dans ce code, nous renvoyons un indicateur de surveillance api_calls_total via l'interface /metrics.

Ensuite, téléchargez l'image Docker de Prometheus depuis le site officiel et créez un fichier docker-compose.yml, et dans ce fichier, nous obtenons les données de l'application Node.js.

version: '3'
services:
  node:
    image: node:lts
    command: node index.js
    ports:
      - 3000:3000

  prometheus:
    image: prom/prometheus:v2.25.2
    volumes:
      - ./prometheus:/etc/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=15d'
    ports:
      - 9090:9090

Dans le fichier docker-compose.yml, nous définissons deux services, l'un est le service Node qui exécute l'application Node.js et l'autre est le service Prometheus pour la surveillance. Parmi eux, le port publié par le service Node est le port 3000. Grâce au mappage de ports, l'interface /metrics de l'application Node est accessible via l'IP et le port 3000 dans docker-compose.yml. Prometheus peut accéder aux données de l'indicateur de surveillance correspondant via le port 9090.

Enfin, dans le fichier prometheus.yml, nous devons définir la source de données à obtenir.

global:
  scrape_interval:     15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'node-exporter'
    static_configs:
    - targets: ['node:9100']

  - job_name: 'node-js-app'
    static_configs:
    - targets: ['node:3000']

Dans ce fichier, nous définissons les indicateurs de toutes les applications Node.js à collecter, où le paramètre cibles est l'adresse IP de l'application Node.js et son numéro de port correspondant. Ici, nous utilisons le nœud et le port 3000.

Enfin, exécutez la commande docker-compose up pour démarrer l'ensemble de l'application et son service de surveillance, et affichez les métriques des membres dans Prometheus.

Utilisez ElasticSearch et Logstash pour la gestion des journaux

Dans Docker, les données des journaux d'application sont distribuées dans différents conteneurs Docker. Si vous souhaitez gérer ces journaux dans un endroit centralisé, vous pouvez utiliser ElasticSearch et Logstash dans ELK pour gérer les journaux de manière centralisée afin de faciliter la surveillance et l'analyse des ressources informatiques.

Avant de commencer, vous devez télécharger les images Docker de Logstash et ElasticSearch et créer un fichier docker-compose.yml.

Dans ce fichier, nous définissons trois services, parmi lesquels bls est un service API utilisé pour simuler les journaux d'entreprise. Après chaque réponse, un journal sera enregistré sur la sortie standard et les fichiers journaux. Le service logstash est construit à partir de l'image Docker officiellement fournie par Logstash et est utilisé pour collecter, filtrer et transmettre des journaux. Le service ElasticSearch est utilisé pour stocker et récupérer les journaux.

version: '3'
services:
  bls:
    image: nginx:alpine
    volumes:
      - ./log:/var/log/nginx
      - ./public:/usr/share/nginx/html:ro
    ports:
      - "8000:80"
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "10"

  logstash:
    image: logstash:7.10.1
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline
    environment:
      - "ES_HOST=elasticsearch"
    depends_on:
      - elasticsearch

  elasticsearch:
    image: elasticsearch:7.10.1
    environment:
      - "http.host=0.0.0.0"
      - "discovery.type=single-node"
    volumes:
      - ./elasticsearch:/usr/share/elasticsearch/data

Dans le fichier de configuration, nous mappons le chemin dans le conteneur vers le système de fichiers journaux de l'hôte. Dans le même temps, grâce à l'option de journalisation, la taille du volume et la quantité du journal sont définies pour limiter le stockage occupé par le journal.

Dans le fichier de configuration logstash, nous définissons un nouveau pipeline nommé nginx_pipeline.conf, qui est utilisé pour gérer la collecte, le filtrage et la transmission des journaux nginx. De la même manière que fonctionne ELK, logstash traitera les journaux reçus en fonction de différentes conditions et les enverra au cluster Elasticsearch déjà créé. Dans ce fichier de configuration, nous définissons la logique de traitement suivante : nginx_pipeline.conf，该文件用于处理nginx日志的收集、过滤和传输。与ELK的工作原理相同，logstash将根据不同的条件，对接收到的日志进行处理，并将其发送到已经创建的 Elasticsearch 集群中。在该配置文件中，我们定义了如下处理逻辑：

input {
  file {
    path => "/var/log/nginx/access.log"
  }
}

filter {
  grok {
    match => { "message" => "%{COMBINEDAPACHELOG}" }
  }
}

output {
  elasticsearch {
    hosts => [ "${ES_HOST}:9200" ]
    index => "nginx_log_index"
  }
}

在该配置文件中，我们定义了一个name为file的输入，表示要从本地Log文件中读取数据。接着，我们引入了使用grok库来解析符合特定模板的日志的filter。最后，我们定义了输出，其将数据传输到 Elasticsearch 集群的地址，同时将检索和报告通过环境变量ES_HOSTrrreee

Dans ce fichier de configuration, nous définissons une entrée nommée file, ce qui signifie que nous voulons lire les données du fichier Log local. Ensuite, nous avons introduit un filtre qui utilise la bibliothèque grok pour analyser les journaux correspondant à un modèle spécifique. Enfin, nous définissons la sortie, qui transfère les données à l'adresse du cluster Elasticsearch, tout en transmettant la récupération et le reporting dans le conteneur via la variable d'environnement ES_HOST.

En fin de compte, après avoir terminé toute la configuration ELK comme ci-dessus, nous obtiendrons un système de gestion des journaux efficace. Chaque journal sera envoyé à un endroit centralisé et intégré, permettant des opérations de recherche, de filtrage et de visualisation faciles. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!