Einführung

Das Sammeln von Metriken zu Servern, Anwendungen und Datenverkehr ist ein wichtiger Bestandteil eines Anwendungsentwicklungsprojekts. In Produktionssystemen können viele Probleme auftreten, und die Datenerfassung und -organisation kann dazu beitragen, Infrastrukturengpässe und -probleme zu identifizieren.

In diesem Artikel werden Graphite und StatsD erläutert und wie sie die Grundlage Ihrer Überwachungsinfrastruktur bilden können. Buchen Sie die kostenlose Demo von MetricFire (https://www.metricfire.com/demo/?utm_source=blog&utm_medium=Qiita&utm_campaign=Japan&utm_content=Monitoring%20your%20infrastructure%20with%20StatsD%20and%20Graphite), um Ihre Anforderungen zu sehen Melden Sie sich dann für eine kostenlose Testversion von Hosted Graphite an, einem verwalteten Graphite-Dienst.

Graphit ist eine Bibliothek, die aus mehreren Komponenten besteht. Hier finden Sie eine kurze Beschreibung der einzelnen Komponenten.

Graphit-Webanwendung

In der Graphite-Webanwendung können Sie Diagramme erstellen und Daten zeichnen. Webanwendungen können Diagrammeigenschaften und Layouts speichern.

Carbon Carbon ist das Speicher-Backend von Graphite. Carbon ist im Grunde ein Daemon, der für die Ausführung auf TCP / UDP-Ports konfiguriert werden kann. Um die zunehmende Last zu bewältigen und Replikation und Sharding zu konfigurieren, können Sie mehrere Carbon-Daemons auf demselben oder mehreren Hosts ausführen und Carbon-Relays verwenden, um die Last zu verteilen.

Whisper Whisper ist das Datenbankformat, in dem Graphite Daten speichert.

Whisper reduziert die neuesten Daten mit hoher Auflösung (Sekunden pro Sekunde) auf niedrigere Auflösungen, sodass historische Daten über einen längeren Zeitraum aufbewahrt werden können.

Nachdem wir über Graphite gesprochen haben, sprechen wir über StatsD.

StatsD StatsD ist eine Anwendung von node.js. Es wurde erstellt, um Datenpunkte über Netzwerke, Server und Anwendungen zu senden, und kann in Grafiken gerendert werden.

installieren

https://hub.docker.com/r/graphiteapp/docker-graphite-statsd/ Verwenden Sie das Docker-Image unter

Dies ist eine sehr einfache docker-compose.yml:

version: "3"
services:
  graphite-statsd:
    image: graphiteapp/docker-graphite-statsd
    ports:
      - 2003-2004:2003-2004
      - 2023-2024:2023-2024
      - 8125:8125/udp
      - 8126:8126
      - 80:80

Wenn Sie nach dem Ausführen dieses Docker-Images auf http: // localhost zugreifen, lädt der Browser die Graphite-Webanwendung wie folgt:

Zu diesem Zeitpunkt sollte die Graphitmetrik leer sein. Lassen Sie uns die Bereitstellung testen. Senden Sie eine einfache Metrik mit dem folgenden Befehl an den StatsD-Daemon:

&nbsp;echo "deploys.test.myservice:1|c" | nc -w 1 -u localhost&nbsp; 8125

Die Syntax hier ist:

bucket:value|type

Eimer

Der Bucket ist die Kennung der Metrik. Metrische Datagramme desselben Buckets und desselben Typs werden vom Server als mit demselben Ereignis betrachtet. Im obigen Beispiel haben wir "deploy.test.myservice" als Bucket verwendet.

Wert

Wert ist die der Metrik zugeordnete Zahl. Die Bedeutung des Werts hängt von der Art der Metrik ab.

Art

Typ bestimmt den Typ der Metrik. Es gibt verschiedene Metriktypen wie Timer, Zähler, Messgeräte und Histogramme.

Timer

Timer unterscheiden sich von Zählern, weil sie Zeitintervalle messen. Wenn Sie beispielsweise die Zeit messen möchten, die die REST-API benötigt, um zu antworten, verwenden Sie einen Timer. Eine einzelne Metrik für den Timer, beispielsweise 100 ms, ist nicht sehr nützlich. Es ist bequemer, in Zeitintervallen wie 6 Stunden zu kombinieren. Für jede Metrik werden automatisch verschiedene Submetriken wie Mittelwert, Standardabweichung, 50. Perzentil, 90. Perzentil, 95. Perzentil usw. berechnet.

echo "deploys.test.myservice.time:55|ms" | nc -w 1 -u localhost 8125‍

Spur

Messgeräte werden für feste Werte verwendet, die erhöht oder verringert werden können. Beispielsweise können Messgeräte verwendet werden, um die Anzahl der Threads in einer Anwendung oder die Anzahl der Jobs in einer Warteschlange darzustellen.

Dies ist eine Carbon-Webanwendung, die sowohl Zähler- als auch Timerwerte in einem Diagramm anzeigt.

Integration mit Node.js.

Wir haben gerade gesehen, wie Metriken über die Befehlszeile gesendet werden. In der Realität generieren einige Anwendungen, wie z. B. Node.js und Anwendungen, auf denen Java-basierte Server ausgeführt werden, Metriken, sodass diese Beispiele nicht zutreffen.

Nun wollen wir sehen, wie eine in node.js geschriebene Anwendung Metriken sendet. Stellen Sie sich einen schnellen Server vor, der auf Port 3000 ausgeführt wird (siehe unten).

const express = require("express");
const app = express();
 
app.get("/", (req, res) =&gt; {
    res.send("Response from a simple GET API");
});
 
app.listen(3000, () =&gt; {
    console.log("Node server started on port 3000");
});

Zuerst müssen Sie node-statsd mit npm installieren.

npm i node-statsd --save

Erstellen Sie dann eine Instanz des StatsD-Clients wie folgt:

const StatsD = require("node-statsd"), client = new StatsD();

Der StatsD-Konstruktor akzeptiert mehrere optionale Argumente, z. B. den Host und den Port des Computers, auf dem der StatsD-Server ausgeführt wird. Die vollständige Dokumentation https://github.com/sivy/node-statsd Es ist in.

In meinem Fall habe ich StatsD mit den Standardoptionen [http: // localhost](http: // localhost) und port8125 ausgeführt.

Nachdem Sie eine Instanz des Clients erstellt haben, können Sie verschiedene Methoden aufrufen, um Metriken an Ihre Anwendung zu senden. Beispielsweise können Sie die Anzahl und das Timing von API-Aufrufen wie folgt verfolgen:

app.get("/", (req, res) =&gt; {
    res.send("Response from a simple GET API");
    client.increment("api_counter");
    client.timing("api_response_time", 110);
});

Sobald Sie in Ihrem Browser [http: // localhost: 3000](http: // localhost: 3000) eingeben, wird die API aufgerufen und der StatsD-Client ausgeführt. Sie können die aktualisierten Metriken in der Graphite-Webanwendung sehen.

In der Dokumentation unter [https: //github.com/sivy/node-statsd](https: //github.com/sivy/node-statsd) finden Sie alle für Clientinstanzen verfügbaren Methoden.

Integration mit Java

Die Integration mit Java-basierten Clients ist Node.js sehr ähnlich. Wenn Sie ein Build-System (dringend empfohlen) wie Maven oder Gradle verwenden, erleichtert ein Utility-JAR (https://mvnrepository.com/artifact/com.timgroup/java-statsd-) diese Integration. client / 3.1.0) ist verfügbar. Fügen Sie Ihrer Build-Konfiguration Folgendes hinzu, um sie automatisch einzuschließen.

Für Maven:

&lt;dependency&gt;

      &lt;groupId&gt;com.timgroup&lt;/groupId&gt;

      &lt;artifactId&gt;java-statsd-client&lt;/artifactId&gt;

      &lt;version&gt;3.1.0&lt;/version&gt;

&lt;/dependency&gt;

Für Gradle:

compile group: 'com.timgroup', name: 'java-statsd-client', version: '3.1.0'

Erstellen Sie nach dem Importieren der Clientbibliothek eine Instanz der StatsDClient-Schnittstelle mit der Implementierungsklasse NonBlockingStatsDclient, die das gewünschte Präfix, den Hostnamen und den Port bereitstellt, auf dem der StatsD-Server ausgeführt wird.

Wie unten gezeigt, können Sie über diese Schnittstelle einfache Methoden wie time () und incrementCounter () verwenden, um Graphite an den StatsD-Server zu senden. Eine vollständige Dokumentation finden Sie unter [https: //github.com/tim-group/java-statsd-client](https: //github.com/tim-group/java-statsd-client).

package example.statsd;

import com.timgroup.statsd.NonBlockingStatsDClient;
import com.timgroup.statsd.StatsDClient;

public class App {

   private static final StatsDClient statsd = new NonBlockingStatsDClient("java.statsd.example.prefix", "localhost", 8125);

   public static void main(String[] args) {
       statsd.incrementCounter("java_main_method_counter");
       statsd.time("java_method_time", 125L);

       statsd.stop();
   }
}

Statistik D horizontale Skalierung

In Bezug auf die Infrastruktur kann ein einzelner StatsD-Server nicht alle Lasten bewältigen und erfordert letztendlich eine horizontale Skalierung. Die horizontale Skalierung mit StatsD ist kein einfacher Round-Robin-Lastausgleich, da Sie auch Aggregationen mit StatsD durchführen können. Wenn eine Metrik mit demselben Schlüssel auf mehrere Knoten verteilt ist, kann ein einzelnes StatsD die gesamte Metrik nicht genau aggregieren.

Daher hat der Autor von SatsD einen StatsD-Cluster-Proxy veröffentlicht, der konsistente Hashes verwendet, um sicherzustellen, dass immer dieselben Metriken an dieselbe Instanz gesendet werden.

Im Folgenden finden Sie eine sehr einfache Konfiguration des StatsD-Cluster-Proxys.

{
    nodes: [
    {host: 'host1', port: 8125, adminport: 8128},
    {host: 'host2', port: 8125, adminport: 8130},
    {host: 'host3', port: 8125, adminport: 8132}
    ],
    server: './servers/udp',
    host:  '0.0.0.0',
    port: 8125,
    mgmt_port: 8126,
    forkCount: 4,
    checkInterval: 1000,
    cacheSize: 10000
    }

Sobald die Konfigurationsdatei eingerichtet ist, führen Sie einfach Folgendes aus:

node proxy.js proxyConfig.js

Proxy.js befindet sich im Stammverzeichnis des StatsD-Installationsverzeichnisses.

Einige der Konfigurationsschlüssel sind erklärungswürdig:

** CheckInterval **: Bestimmt das Integritätsprüfungsintervall. Wenn der Knoten offline ist, wird er vom Cluster-Proxy aus der Konfiguration entfernt.
** Server **: Die Server-Binärdatei wird aus der in der Konfiguration "Knoten" angegebenen Knotenkonfiguration gelesen.

Zusammenfassung

StatsD und Graphite eignen sich hervorragend zur Überwachung Ihrer Infrastruktur. Der gesamte oben genannte Code und die Konfiguration sind im Github-Repository verfügbar.

Die Hauptvorteile sind:

** Geringer Speicherbedarf **: StatsD ist ein sehr einfacher node.js-basierter Server, was zu einem sehr geringen Speicherbedarf führt. Dies bedeutet, dass Ihre Infrastruktur problemlos mit diesem Setup beginnen kann.
** Effizientes Netzwerk **: StatsD kann über UDP, ein Protokoll mit geringer Verbindung, betrieben werden, sodass große Datenmengen in sehr kurzer Zeit übertragen werden können.

Wenn Sie diese Prozesse ausprobieren möchten, reservieren Sie bitte eine Demo für MetricFire auf Japanisch (https://www.metricfire.com/demo/?utm_source=blog&utm_medium=Qiita&utm_campaign=Japan&utm_content=Monitoring%20your%20infrastructure%20with] % 20StatsD% 20und% 20Graphite) Bitte. Sie können auch über die beste Überwachungslösung sprechen.

Wir sehen uns in einem anderen Artikel!

[JAVA] Infrastrukturüberwachung mit Graphite und StatsD