So verwenden Sie Docker für die Anwendungsüberwachung und Protokollverwaltung

Docker ist zu einer unverzichtbaren Technologie in modernen Anwendungen geworden, aber die Verwendung von Docker für die Anwendungsüberwachung und Protokollverwaltung ist eine Herausforderung. Mit der kontinuierlichen Verbesserung der Docker-Netzwerkfunktionen wie Service Discovery und Load Balancing benötigen wir zunehmend ein vollständiges, stabiles und effizientes Anwendungsüberwachungssystem.

In diesem Artikel stellen wir kurz die Verwendung von Docker für die Anwendungsüberwachung und Protokollverwaltung vor und geben konkrete Codebeispiele.

Verwenden Sie Prometheus zur Anwendungsüberwachung

Prometheus ist ein von SoundCloud entwickeltes Open-Source-Tool zur Überwachung und Warnung von Diensten auf Pull-Modellbasis. Es ist in der Go-Sprache geschrieben und wird häufig in Microservice-Lösungen und Cloud-Umgebungen verwendet. Als Überwachungstool kann es die CPU, den Speicher, das Netzwerk und die Festplatte usw. von Docker überwachen und unterstützt außerdem mehrdimensionale Datenvermittlung sowie flexible Abfrage-, Alarm- und Visualisierungsfunktionen, sodass Sie schnell reagieren und Entscheidungen treffen können.

Eine weitere zu beachtende Sache ist, dass Prometheus im Pull-Modus Stichproben durchführen muss, d. h. auf die /metrics-Schnittstelle in der überwachten Anwendung zugreifen muss, um Überwachungsdaten zu erhalten. Daher müssen Sie beim Starten des überwachten Anwendungsimages zunächst die IP und den Port konfigurieren, die auf Prometheus zugreifen können, in der /metrics-Schnittstelle. Unten finden Sie eine einfache Node.js-Anwendung.

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!')
})

In diesem Code geben wir einen api_calls_total-Überwachungsindikator über die /metrics-Schnittstelle zurück.

Als nächstes laden Sie das Docker-Image von Prometheus von der offiziellen Website herunter und erstellen eine docker-compose.yml-Datei. In dieser Datei erhalten wir die Daten der Node.js-Anwendung.

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

In der Datei docker-compose.yml definieren wir zwei Dienste, einen ist der Node-Dienst, der die Node.js-Anwendung ausführt, und der andere ist der Prometheus-Dienst zur Überwachung. Unter anderem ist der vom Node-Dienst veröffentlichte Port Port 3000. Durch Portzuordnung kann über die IP-Adresse und den 3000-Port in docker-compose.yml auf die /metrics-Schnittstelle der Node-Anwendung zugegriffen werden. Prometheus kann über Port 9090 auf die entsprechenden Überwachungsindikatordaten zugreifen.

Abschließend müssen wir in der Datei prometheus.yml die abzurufende Datenquelle definieren.

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']

In dieser Datei definieren wir die Indikatoren aller zu erfassenden Node.js-Anwendungen, wobei der Zielparameter die IP-Adresse der Node.js-Anwendung und die entsprechende Portnummer ist. Hier verwenden wir Knoten und Port 3000.

Führen Sie abschließend den Befehl docker-compose up aus, um die gesamte Anwendung und ihren Überwachungsdienst zu starten und die Mitgliedsmetriken in Prometheus anzuzeigen.

Verwenden Sie ElasticSearch und Logstash für die Protokollverwaltung

In Docker werden Anwendungsprotokolldaten in verschiedenen Docker-Containern verteilt. Wenn Sie diese Protokolle an einem zentralen Ort verwalten möchten, können Sie ElasticSearch und Logstash in ELK verwenden, um die Protokolle zentral zu verwalten und so die Überwachung und Analyse von Computerressourcen zu erleichtern.

Bevor Sie beginnen, müssen Sie die Docker-Images von Logstash und ElasticSearch herunterladen und eine docker-compose.yml-Datei erstellen.

In dieser Datei definieren wir drei Dienste, darunter bls, einen API-Dienst zur Simulation von Geschäftsprotokollen. Nach jeder Antwort wird ein Protokoll in Standard- und Protokolldateien aufgezeichnet. Der Logstash-Dienst basiert auf dem offiziell von Logstash bereitgestellten Docker-Image und wird zum Sammeln, Filtern und Übertragen von Protokollen verwendet. Der ElasticSearch-Dienst wird zum Speichern und Abrufen von Protokollen verwendet.

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

In der Konfigurationsdatei ordnen wir den Pfad im Container dem Protokolldateisystem des Hosts zu. Gleichzeitig werden über die Protokollierungsoption die Volumengröße und die Menge des Protokolls definiert, um den vom Protokoll belegten Speicherplatz zu begrenzen.

In der Logstash-Konfigurationsdatei definieren wir eine neue Pipeline mit dem Namen nginx_pipeline.conf, die für die Erfassung, Filterung und Übertragung von Nginx-Protokollen verwendet wird. Ähnlich wie ELK verarbeitet Logstash die empfangenen Protokolle basierend auf unterschiedlichen Bedingungen und sendet sie an den bereits erstellten Elasticsearch-Cluster. In dieser Konfigurationsdatei definieren wir die folgende Verarbeitungslogik: 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

In dieser Konfigurationsdatei definieren wir eine Eingabe namens file, was bedeutet, dass wir Daten aus der lokalen Protokolldatei lesen möchten. Als Nächstes haben wir einen Filter eingeführt, der die Grok-Bibliothek verwendet, um Protokolle zu analysieren, die einer bestimmten Vorlage entsprechen. Schließlich definieren wir die Ausgabe, die Daten an die Adresse des Elasticsearch-Clusters überträgt, während der Abruf und die Meldung an den Container über die Umgebungsvariable ES_HOST übergeben werden.

Am Ende erhalten wir nach Abschluss der gesamten ELK-Konfiguration ein effizientes Protokollverwaltungssystem, das an einen zentralen Ort gesendet und zusammengeführt wird, was einfache Such-, Filter- und Visualisierungsvorgänge ermöglicht. 🎜

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Docker für die Anwendungsüberwachung und Protokollverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!