So installieren und konfigurieren Sie NATS unter Ubuntu 16.04

Einführung

NATS ist ein Open-Source-Hochleistungs-Messaging-System, das häufig als "zentrales Nervensystem für die Cloud" bezeichnet wird. Es ist in der Lage, Millionen von Nachrichten pro Sekunde weiterzuleiten, wodurch es sich ideal für die Verbindung von Microservices und Internet of Things-Geräten eignet.

NATS ist ein Pub-Sub-Nachrichtensystem. In dieser Art von System senden ein oder mehrere Verleger Nachrichten mit einem bestimmten Betreff an einen Nachrichtenbroker, und der Nachrichtenbroker liefert diese Nachrichten an beliebige Clients oder Abonnenten des angegebenen Betreffs. Publisher kennen Abonnenten nicht oder interessieren sich nicht für sie und umgekehrt. Durch diese Architektur ist es einfach, das System zu skalieren und neue Funktionen hinzuzufügen, da wir Herausgeber und Abonnenten hinzufügen können, ohne den Rest des Systems zu beeinträchtigen. Diese Art von System eignet sich perfekt zur Überwachung von Servern und Geräten. Geräte können Nachrichten senden und wir können diese Nachrichten abonnieren, um Benachrichtigungen per E-Mail oder auf andere Weise zu senden.

In diesem Tutorial installieren wir + gnatsd +, den offiziellen NATS-Server, als Dienst und machen ihn sicher zugänglich. Wir werden auch ein grundlegendes Warnsystem für Serverüberlastungen erstellen, das E-Mails versendet, wenn die Serverlast zu hoch wird, und dabei "+ gnatsd +" als Nachrichtenbroker verwendet.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie:

Ein neuer Ubuntu 16.04 Server.
Ein Standard-Benutzerkonto mit "+ sudo +" - Berechtigungen. Sie können ein Standardkonto einrichten, indem Sie der Initial Server Setup with Ubuntu 16.04 folgen.

Schritt 1 - Herunterladen des NATS-Servers

Laden Sie zunächst den "+ gnatsd +" - Server herunter und stellen Sie sicher, dass er problemlos auf unserem System ausgeführt wird.

Die neueste stabile + gnatsd + Version ist die Version 0.9.4 zum Zeitpunkt der Erstellung dieses Tutorials. Sie können the NATS download page für eine spätere Version überprüfen und die folgenden Befehle nach Bedarf anpassen, wenn Sie eine neuere Version verwenden möchten.

Melden Sie sich zunächst mit Ihrem Nicht-Root-Konto bei Ihrem Server an:

ssh @

Stellen Sie dann sicher, dass Sie sich im Home-Verzeichnis Ihres Benutzers befinden:

cd

Verwenden Sie anschließend "+ wget ", um " gnatsd +" auf Ihren Server herunterzuladen:

wget https://github.com/nats-io/gnatsd/releases/download/v/gnatsd-v-linux-amd64.zip

Das soeben heruntergeladene Archiv ist ein komprimiertes Archiv. Sie müssen also "+ unzip " installieren, um die Dateien zu extrahieren. Sie können es mit ` apt +` installieren:

sudo apt-get install -y unzip

Dann benutzen Sie "+ unzip ", um " gnatsd +" zu extrahieren:

unzip -p gnatsd-v-linux-amd64.zip gnatsd-v-linux-amd64/gnatsd > gnatsd

Dann machen Sie + gnatsd + ausführbar, damit Sie es ausführen können:

chmod +x gnatsd

Testen wir, dass wir "+ gnatsd " ausführen können, indem wir es aus dem aktuellen Verzeichnis ausführen. Verwenden Sie den folgenden Befehl, um ` gnatsd +` zu starten:

./gnatsd --addr 127.0.0.1 --port 4222

Die angezeigte Ausgabe ähnelt dem folgenden Beispiel:

Output[1851] 2016/09/23 05:20:02.247420 [INF] Starting nats-server version 0.9.4
[1851] 2016/09/23 05:20:02.248182 [INF] Listening for client connections on
[1851] 2016/09/23 05:20:02.248626 [INF] Server is ready

Standardmäßig überwacht "+ gnatsd " den Port " 4222 " an der Adresse " 0.0.0.0 ", die allen Schnittstellen entspricht. Mit dem Argument " - Port " können Sie den Port ändern, und mit " - Addr " können Sie die Adresse ändern, die abgehört wird. Wir haben ` gnatsd ` mit ` - addr 127.0.0.1 ` ausgeführt, damit es nur auf unserem Server verfügbar ist und externen Clients nicht zur Verfügung steht. Später im Tutorial werden wir " gnatsd +" sichern und der Welt öffnen.

Drücken Sie "+ STRG + C ", um " gnatsd +" zu beenden.

Jetzt, da Sie wissen, dass die Dinge funktionieren, lassen Sie uns die Dinge formeller einrichten.

Schritt 2 - Verzeichnisstruktur und Konfigurationsdatei erstellen

Unter Linux werden Software-Dienste von Drittanbietern häufig im Verzeichnis "+ / srv " gespeichert. Wir werden diese Konvention befolgen und NATS-bezogene Dateien unter ` / srv / nats ` aufbewahren. Wir werden die ausführbare Datei " gnatsd " in " / srv / nats / bin +" ablegen.

Erstellen Sie zuerst den Ordner "+ / srv / nats / bin +":

sudo mkdir -p /srv/nats/bin

Verschieben Sie dann + gnatsd + in den Ordner + / srv / nats / bin +:

sudo mv ~/gnatsd /srv/nats/bin

Der Server kann seine Konfiguration aus einer Datei laden. Dies ist hilfreich, wenn wir die Servereinstellungen später im Lernprogramm ändern müssen. Erstellen Sie die Datei + / srv / nats / gnatsd.config +:

sudo nano /srv/nats/gnatsd.config

Fügen Sie der Datei den folgenden Inhalt hinzu:

/srv/nats/gnatsd.config

port: 4222
net: '127.0.0.1'

Diese Konfigurationsdatei weist den "+ gnatsd " - Server an, den Port " 4222 " an der Adresse " 127.0.0.1 +" abzuhören, wie zuvor, aber dieses Mal müssen wir diese Optionen nicht in der Befehlszeile angeben.

Führen Sie den Server erneut aus, um sicherzustellen, dass die Einstellungen korrekt sind. Führen Sie den folgenden Befehl aus, um "+ gnatsd +" mit der neuen Konfigurationsdatei zu starten:

/srv/nats/bin/gnatsd -c /srv/nats/gnatsd.config

Die Ausgabe ähnelt der, die Sie zuvor gesehen haben:

Output[1869] 2016/06/18 05:30:55.988856 [INF] Starting nats-server version 0.9.4
[1869] 2016/06/18 05:30:55.989190 [INF] Listening for client connections on
[1869] 2016/06/18 05:30:55.989562 [INF] Server is ready

Drücken Sie erneut die Tastenkombination "+ STRG + C ", um " gnatsd +" zu beenden und zu Ihrer Eingabeaufforderung zurückzukehren. Jetzt erstellen wir einen Benutzer, der diesen Dienst ausführt.

Schritt 3 - Erstellen des Dienstbenutzers

Es ist eine gute Sicherheitspraxis, jeden Dienst mit einem eigenen Benutzerkonto auszuführen, um den Schaden zu begrenzen, falls ein Dienst beeinträchtigt wird. Erstellen wir einen Benutzer und eine Gruppe, die den NATS-Dienst und NATS-bezogene Dateien besitzen.

Zuerst erstellen wir einen Systembenutzer und eine Systemgruppe mit dem Namen "++":

sudo adduser --system --group --no-create-home --shell /bin/false nats

OutputAdding system user `nats' (UID 106) ...
Adding new group `nats' (GID 114) ...
Adding new user `nats' (UID 106) with group `nats' ...
Not creating home directory `/home/nats'.

Wir haben dem Systembenutzer "+ nats " die Shell " / bin / false " zugewiesen, um die Anmeldungen für diesen Benutzer zu deaktivieren und die Erstellung des Basisverzeichnisses zu unterdrücken. Wir haben auch eine Gruppe " nats +" erstellt.

Ändern Sie den Besitzer des Verzeichnisses "+ / srv " in den Benutzer " nats +" und die Gruppe:

sudo chown -R nats:nats /srv

Nachdem wir den Benutzer "+ nats +" und die Gruppe erstellt haben, fahren wir mit der Erstellung des NATS-Dienstes fort.

Schritt 4 - Ausführen von gnatsd als Dienst

Wir möchten, dass + gnatsd + beim Booten des Systems startet und bei einem Absturz neu startet. Wir werden systemd verwenden, um dies zu handhaben.

systemd ist ein Service Manager für Linux-Systeme. Es ist dafür verantwortlich, Dienste beim Booten zu starten, bei Bedarf neu zu starten und beim Herunterfahren des Systems kontrolliert zu stoppen.

Wir müssen eine Dienstkonfiguration erstellen, um zu definieren, wie und wann der NATS-Dienst gestartet werden soll. Vom Benutzer erstellte Servicedateien befinden sich in + / etc / systemd / system +. Erstellen Sie daher die Datei + / etc / systemd / system / nats.service +:

sudo nano /etc/systemd/system/nats.service

Fügen Sie dieses Skript in die Datei ein, um zu definieren, wie "+ gnatsd +" gestartet werden soll:

/etc/systemd/system/nats.service

[Unit]
Description=NATS messaging server

[Service]
ExecStart=/srv/nats/bin/gnatsd -c /srv/nats/gnatsd.config
User=nats
Restart=on-failure

[Install]
WantedBy=multi-user.target

Der Abschnitt "+ [Unit] " enthält allgemeine Informationen zum Dienst, z. B. " Description +", das den Dienst beschreibt.
Der Abschnitt "+ [Service] " enthält die service-bezogene Konfiguration. ` ExecStart ` ist der Befehl zum Ausführen des Servers. Wir verwenden hier den absoluten Pfad der ausführbaren Datei " gnatsd ". ` Neustart = On-Failure` bedeutet, dass der Dienst neu gestartet werden muss, wenn er abstürzt oder mit einem Fehler beendet wird. Es wird nicht neu gestartet, wenn es von systemd gestoppt wurde.
Der Abschnitt "+ [Install] " enthält Informationen zur Installation des Dienstes. ` WantedBy = multi-user.target` weist systemd an, den Dienst zu starten, wenn` + multi-user.target` gestartet wird. Dies ist eine allgemeine Methode zum Starten von Diensten beim Systemstart.

Sobald die Servicebeschreibung vorhanden ist, können wir sie mit dem folgenden Befehl starten:

sudo systemctl start

Bestätigen wir, dass "+ gnatsd " ausgeführt wird, indem Sie eine " PING +" - Nachricht senden:

printf "PING\r\n" | nc 127.0.0.1 4222

Wir haben gerade "+ nc " verwendet, um mit " gnatsd " zu kommunizieren. ` nc +` ist ein Befehlszeilenprogramm zur Kommunikation mit TCP- oder UDP-Servern. Der von uns verwendete Befehl gibt eine Ausgabe ähnlich der folgenden aus:

OutputINFO {"server_id":"Os7xI5uGlYFJfLlfo1vHox","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":false,"ssl_required":false,"tls_required":false,"tls_verify":false,"max_payload":1048576}

Die Antwort "+ PONG +" teilt uns mit, dass der Server zuhört und wie erwartet arbeitet. Wir müssen einen letzten Befehl ausführen, damit unser NATS-Server beim Booten startet:

sudo systemctl enable

Sie sehen die folgende Ausgabe, die bestätigt, dass der Dienst installiert wurde:

OutputCreated symlink from /etc/systemd/system/multi-user.target.wants/nats.service to /etc/systemd/system/nats.service.

Wir haben "+ gnatsd +" erfolgreich für die Ausführung als Dienst konfiguriert. Jetzt sichern wir es und machen es für externe Kunden zugänglich.

Schritt 5 - Sichern der Verbindungen zum NATS-Dienst

Wenn alle Verlage und Abonnenten, die wir mit "+ gnatsd " verwenden möchten, auf demselben Server ausgeführt werden, können wir dies als "erledigt" und "weitermachen" bezeichnen, aber dies ist heutzutage selten der Fall. Externe Clients müssen eine sichere Verbindung herstellen und Nachrichten an " gnatsd +" veröffentlichen.

+ gnatsd + unterstützt TLS-Transport, daher werden wir diesen verwenden, um die Kommunikation zwischen + gnatsd + und NATS-Clients zu sichern.

Zuerst brauchen wir ein Zertifikat. Sie können ein kommerzielles Zertifikat kaufen, eines von http://letsencrypt.org [Let’s Encrypt] abrufen oder ein selbstsigniertes Zertifikat erstellen. Wir werden den letzteren Ansatz verwenden, da der Erwerb eines Zertifikats nicht in den Geltungsbereich dieses Artikels fällt.

Erstellen Sie ein Verzeichnis, in dem das Zertifikat vorübergehend gespeichert wird:

mkdir ~/priv

Erstellen Sie dann ein selbstsigniertes Zertifikat mit dem folgenden Befehl:

openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \
   -keyout priv/gnatsd.key -out priv/gnatsd.crt \
   -subj "/C=US/ST=/L=/O=/CN=www."

Dieser Befehl erstellt ein RSA-Zertifikat mit 2048 Bit und 10 Jahren Gültigkeit. Beachten Sie, dass wir einen beliebigen Domainnamen verwendet haben, da wir in diesem Artikel die TLS-Überprüfung für den "+ gnatsd +" - Server nicht aktivieren.

Sie sollten nun die Dateien "+ gnatsd.key " und " gnatsd.crt " im Verzeichnis " ~ / priv " haben. Verschieben wir diese Dateien in unsere Verzeichnisstruktur " / srv / nats / +", damit sich alles an einem Ort befindet. Führen Sie den folgenden Befehl aus:

sudo mv ~/priv /srv/nats

Nun machen Sie + / srv / nats / priv + nur für den + nats + Benutzer und die Gruppe zugänglich:

sudo chmod 440 /srv/nats/priv/*
sudo chmod 550 /srv/nats/priv
sudo chown -R nats:nats /srv/nats/priv

Jetzt aktualisieren wir "+ / srv / nats / gnatsd.config +", um das Zertifikat und den Schlüssel zu enthalten, die wir gerade erstellt haben. Öffnen Sie die Konfigurationsdatei erneut:

sudo nano /srv/nats/gnatsd.config

Fügen Sie den folgenden Abschnitt hinzu, um "+ gnatsd +" anzuweisen, Ihr Zertifikat und Ihren Schlüssel zu verwenden:

/srv/nats/gnatsd.config

. . .

tls {
 cert_file: ""
 key_file: ""
 timeout: 1
}

Speichern Sie die Datei und beenden Sie den Editor. Starten Sie dann den Dienst neu, damit er die Änderungen übernehmen kann.

sudo systemctl restart

Testen wir, ob unsere Zertifikate funktionieren. Führen Sie diesen Befehl aus:

printf "PING\r\n" | nc localhost 4222

Dieses Mal gibt der Befehl die folgende Meldung aus:

OutputINFO {"server_id":"npkIPrCE5Kp8O3v1EfV8dz","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":false,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Der Server hat die Meldung "+ -ERR" Sichere Verbindung - TLS erforderlich "+" zurückgegeben, die bestätigt, dass die neue Konfiguration übernommen wurde und eine sichere Verbindung erforderlich ist.

Um mit unserem NATS-Service kommunizieren zu können, ohne einen vollständigen NATS-Client zu installieren, verwenden wir ein Tool namens catnats. Laden wir es zuerst herunter:

wget https://github.com/yuce/catnats/raw/0.1.2/catnats.py

Und mach es ausführbar:

chmod +x catnats.py

Verschieben Sie abschließend "+ catnats.py " in den Ordner " / srv / nats / bin " und benennen Sie ihn in " catnats +" um:

sudo mv catnats.py /srv/nats/bin/catnats

Überprüfen wir, ob wir mit unserem NATS-Dienst über "+ catnats " kommunizieren können, indem wir die gleiche " PING +" - Nachricht senden, die wir zuvor gesendet haben:

printf "PING\r\n" | /srv/nats/bin/catnats --addr 127.0.0.1:4222

Diese Ausgabe zeigt an, dass Ihre Verbindung sicher ist:

OutputINFO {"server_id":"npkIPrCE5Kp8O3v1EfV8dz","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":false,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Nachdem wir die Kommunikation gesichert haben, aktivieren wir die Authentifizierung, sodass ein Benutzername und ein Kennwort erforderlich sind, um eine Verbindung zu NATS herzustellen.

Schritt 6 - Authentifizierung erforderlich

Für unseren NATS-Dienst ist standardmäßig keine Authentifizierung erforderlich. Dies ist in Ordnung, wenn der Dienst nur in einem privaten Netzwerk verfügbar ist. Wir möchten jedoch, dass unser NATS-Dienst im Internet verfügbar ist, daher sollten wir die Authentifizierung aktivieren. + gnatsd + unterstützt die Authentifizierung mit Benutzernamen und Passwort und ist leicht zu aktivieren.

Öffnen Sie die Datei + / srv / nats / gnatsd.config +:

sudo nano /srv/nats/gnatsd.config

Fügen Sie einen neuen Abschnitt "+ authorisation +" hinzu, der die Anmeldeinformationen angibt. Wir werden "" als Benutzernamen und "" als Passwort für dieses Tutorial verwenden. In einer Produktionsumgebung sollten Sie ein längeres, komplexeres Kennwort verwenden:

/srv/nats/gnatsd.config

. . .

authorization {
 user:
 password:
}

Speichern Sie die Datei und ändern Sie dann den Eigentümer von "+ / srv / nats / gnatsd.config " in " nats +" und machen Sie sie für diesen Benutzer lesbar, um den Benutzernamen und das Kennwort vor anderen Benutzern im System zu schützen:

sudo chown nats /srv/nats/gnatsd.config
sudo chmod 400 /srv/nats/gnatsd.config

Starten Sie dann den Dienst neu, damit die Änderungen wirksam werden:

sudo systemctl restart nats

Senden wir eine "+ PING " - Nachricht an " gnatsd ", um zu überprüfen, ob alles in Ordnung ist. Verwenden Sie erneut " catnats +", um die Nachricht zu senden:

printf "PING\r\n" | /srv/nats/bin/catnats --addr 127.0.0.1:4222

Sie sehen die folgende Ausgabe:

OutputNFO {"server_id":"sY0SSJBNbEw53HxzS9mH1t","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Dies sagt uns, dass die Änderungen erfolgreich angewendet wurden und wir nun den richtigen Benutzernamen und das richtige Passwort senden müssen, um eine Verbindung zum Dienst herzustellen. Versuchen wir es noch einmal, und geben Sie den Benutzernamen "" und das Kennwort "" ein:

printf "PING\r\n" | /srv/nats/bin/catnats --addr 127.0.0.1:4222 --user  --pass

Diesmal hat es geklappt, wie Sie aus der folgenden Ausgabe ersehen können:

OutputINFO {"server_id":"sY0SSJBNbEw53HxzS9mH1t","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Jetzt, da wir diesen Dienst auf Clients beschränkt haben, die den Benutzernamen und das Kennwort kennen, können wir den Dienst neu konfigurieren, damit sich externe Clients verbinden können.

Schritt 7 - Den Dienst für die Welt öffnen

Wir haben unseren NATS-Server so konfiguriert, dass er die lokale Schnittstelle "+ 127.0.0.1 " überwacht. Wenn wir es dazu bringen, auf " 0.0.0.0 " zu hören, wird es der Welt zur Verfügung stehen. Aktualisieren wir ein letztes Mal " / srv / nats / gnatsd.config +":

sudo nano /srv/nats/gnatsd.config

Ändern Sie dann die mit der Einstellung "+ net +" verknüpfte IP-Adresse:

/srv/nats/gnatsd.config

. . .
net: ''
. . .

Speichern Sie die Datei und starten Sie den Dienst neu:

sudo systemctl restart nats

Und jetzt ist unser NATS-Service für externe Client-Verbindungen bereit. Erstellen Sie einen einfachen Überwachungsdienst, der unseren NATS-Server als Nachrichtenbroker verwendet, um zu erfahren, wie er verwendet wird.

Schritt 8 - (Optional) Konfigurieren von Benachrichtigungen bei Serverüberlastung

In diesem Abschnitt erstellen Sie ein einfaches Überlastüberwachungssystem, das Ihren NATS-Dienst nutzt. Das System empfängt Lastdurchschnitte von Servern und sendet eine E-Mail an einen Administrator, wenn einer der Server überlastet ist.

Das Beispielprojekt besteht aus folgenden Komponenten:

Der NATS-Dienst, den Sie gerade konfiguriert haben.
Ein monitor, der den Hostnamen, den Lastdurchschnitt und die Prozessoranzahl des Servers alle 60 Sekunden an das Subjekt + stats.loadaverage + sendet. Sie müssen diese Komponente auf jedem Server ausführen, den Sie auf Auslastung überwachen möchten.
Ein notifier, der das Thema + stats.loadaverage + abonniert und den Hostnamen, den Lastdurchschnitt und die Prozessoranzahl eines Servers empfängt. Wenn der Lastdurchschnitt eines Hosts über einem bestimmten Schwellenwert liegt, sendet der Benachrichtiger eine E-Mail über einen SMTP-Server an eine vordefinierte Adresse.

Der Einfachheit halber werden alle diese Komponenten auf demselben Server ausgeführt. Sie können jedoch versuchen, jede Komponente auf einem anderen Server auszuführen, wenn Sie dieses Lernprogramm abgeschlossen haben.

Einrichten des Monitors

Sie können die durchschnittliche Auslastung eines Linux-Systems aus + / proc / loadavg + ablesen. Für dieses Projekt interessiert uns nur der Lastdurchschnitt der letzten Minute, der das erste Feld der Ausgabe ist. Verwenden Sie diesen Befehl, um diesen Wert abzurufen:

cat /proc/loadavg | cut -f1 -d" "

Sie sehen die folgende Ausgabe:

Output0.11

Der Lastdurchschnitt, den Sie durch Lesen von "+ / proc / loadavg +" erhalten, hängt von der Anzahl der Prozessoren ab. Sie müssen ihn also normalisieren, indem Sie den Lastdurchschnitt durch die Anzahl der Prozessoren dividieren. Mit dem folgenden Befehl können Sie die Prozessoranzahl Ihres Servers ermitteln:

getconf _NPROCESSORS_ONLN

Das Ergebnis wird in Ihrem Terminal angezeigt:

Output1

Da die Standardshell unseres Servers keine Gleitkomma-Arithmetik verarbeiten kann, senden wir sowohl den Lastdurchschnitt als auch die Anzahl der Prozessoren zusammen mit dem Hostnamen als Nutzlast für unsere Nachricht und führen die Aufteilung im Notifier später durch. Hier ist der Befehl, mit dem wir die Nutzlast erstellen:

echo $(hostname) `cat /proc/loadavg | cut -f1 -d" "` `getconf _NPROCESSORS_ONLN`

Der Befehl zeigt den Hostnamen, den Lastdurchschnitt und die Anzahl der Prozessoren an:

Output 0.28 1

Erstellen wir ein Shell-Skript, das den Hostnamen, den Lastdurchschnitt und die Prozessoranzahl mit dem Betreff "+ stats.loadaverage " auf unserem NATS-Server veröffentlicht. Wir werden unser System so konfigurieren, dass dieses Skript regelmäßig ausgeführt wird. Erstellen Sie eine neue Datei mit dem Namen " ~ / publish_load_average.sh +":

nano ~/publish_load_average.sh

Fügen Sie der Datei das folgende Skript hinzu:

~ / publish_load_average.sh

NATS_ADDR=
LOADAVG=
NPROC=
SUBJECT=
PAYLOAD=
MESSAGE=
printf "$MESSAGE" | /srv/nats/bin/catnats -q --raw --addr $NATS_ADDR --user  --pass

Dieses Skript erstellt die Nachricht und leitet sie dann an "+ catnats " weiter, das die Nachricht an den NATS-Dienst veröffentlicht. Wir führen " catnats " mit dem Schalter " -q " aus, um eine Ausgabe zu unterdrücken, und wir verwenden den Schalter " - raw ", damit " catnats " nicht versucht, den Inhalt der Eingabe zu interpretieren. Sie können den Wert der Variablen " $ NATS_ADDR +" ändern, wenn sich der NATS-Dienst auf verschiedenen Servern befindet.

Testen wir, ob das Skript Ladedurchschnittswerte an NATS sendet.

Der folgende Befehl führt "+ ~ / publish_load_average.sh " alle 5 Sekunden aus. Beachten Sie, dass wir das Zeichen " & +" am Ende der Zeile verwenden, um den Befehl im Hintergrund auszuführen:

while true; do sh ~/publish_load_average.sh; sleep 5; done &

Die Ausgabe zeigt, dass der Befehl im Hintergrund mit einer Prozess-ID ausgeführt wird:

Output[1]

Stellen Sie nun eine Verbindung zu NATS her und abonnieren Sie den Betreff "+ stats.loadaverage +", um die Durchschnittswerte für das Laden abzurufen:

printf "SUB stats.loadaverage 0\r\n" | /srv/nats/bin/catnats --raw --no-exit --pong --user  --pass

Wir verwenden das Flag "+ - no-exit ", um die automatische Beendigung zu deaktivieren, und " - pong +", um die Verbindung zu NATS aufrechtzuerhalten. Wenn alles korrekt ist, sollten Sie eine Ausgabe ähnlich der folgenden erhalten, die alle 5 Sekunden aktualisiert wird:

OutputINFO {"server_id":"A8qJc7mdTy8AWBRhPWACzW","version":"0.8.1","go":"go1.6.2","host":"0.0.0.0","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}
+OK
+OK
MSG stats.loadaverage 0 27

Drücken Sie "+ STRG + C ", um " catnats " zu verlassen. Stoppen wir die Schleife mit dem Namen " publish_load_average.sh ", da wir " publish_load_average.sh +" besser ausführen können:

kill

Der Ansatz, den wir gerade gewählt haben, eignet sich hervorragend zum Testen, aber wir möchten ihn nicht permanent anwenden. Wir möchten, dass das System + publish_load_average.sh + jede Minute ausführt. Um dies zu erreichen, können wir einen crontab-Eintrag hinzufügen. Linux-Systeme verwenden "+ cron ", ein System, das Befehle oder "Jobs" nach einem von uns festgelegten Zeitplan ausführen kann. Mit dem Befehl " crontab +" können wir diese Jobs verwalten. Alles über Cron erfahren Sie im Tutorial How To Use Cron To Automate Tasks Auf einem VPS.

Führen Sie den folgenden Befehl aus, um einen neuen Eintrag zu erstellen:

crontab -e

Wenn Sie den obigen Befehl noch nie ausgeführt haben, wird möglicherweise die folgende Eingabeaufforderung angezeigt, in der Sie aufgefordert werden, einen Texteditor zum Verwalten von Einträgen auszuwählen:

Outputno crontab for demo - using an empty one

Select an editor.  To change later, run 'select-editor'.
 1. /bin/ed
 2. /bin/nano        <---- easiest
 3. /usr/bin/vim.basic
 4. /usr/bin/vim.tiny

Choose 1-4 [2]:

Geben Sie die Nummer des Editors ein, mit dem Sie sich am besten auskennen, und drücken Sie "+ ENTER". In dem von Ihnen ausgewählten Editor wird eine Datei angezeigt.

Fügen Sie am Ende der geöffneten Datei die folgende Zeile hinzu, aber ersetzen Sie Ihren Benutzernamen, wenn Sie etwas anderes als "++" verwendet haben:

*/1 * * * * bash /home//publish_load_average.sh

Der obige Eintrag weist + cron + an, unser Skript + publish_load_average.sh + jede Minute auszuführen. Speichern Sie die Datei und schließen Sie den Editor.

Testen wir nun, ob das regelmäßige Veröffentlichen des Lastdurchschnitts funktioniert:

printf "SUB stats.loadaverage 0\r\n" | /srv/nats/bin/catnats --raw --no-exit --pong --user  --pass

Warten Sie einige Minuten, und die angezeigte Ausgabe ähnelt der folgenden:

OutputINFO {"server_id":"A8qJc7mdTy8AWBRhPWACzW","version":"0.8.1","go":"go1.6.2","host":"0.0.0.0","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}
+OK
+OK
MSG stats.loadaverage 0 27

MSG stats.loadaverage 0 27

Drücken Sie "+ STRG + C ", um " catnats +" zu beenden.

Wir haben den Monitor erfolgreich eingerichtet und er sendet Nachrichten an unseren NATS-Server. Als Nächstes richten wir den Notifier ein, der diese Daten verwendet.

Notifier erstellen

Erstellen wir den Notifier, der eine Verbindung zu unserem NATS-Service herstellt und auf "+ stats.loadaverage +" -Nachrichten wartet. Immer wenn unser Programm eine Nachricht erhält, berechnet es den Lastdurchschnitt pro Prozessor. Wenn der Wert 0,6 oder 60% der CPU-Auslastung pro Prozessor übersteigt, wird ein Warnflag für den Host festgelegt, der die Nachricht veröffentlicht hat, und eine E-Mail an eine vordefinierte Adresse gesendet. Wenn der Lastdurchschnitt pro Prozessor unter 0,4 liegt, wird das Warnflag für den Host gelöscht. Um ein Überfluten des Posteingangs zu verhindern, senden wir eine einzelne E-Mail, wenn das Warnflag gesetzt ist.

Wir werden Node.JS verwenden, um den Notifier zu erstellen, da es einen großartigen NATS-Client für Node.js gibt. Installieren Sie also zuerst Node.js:

sudo apt-get install -y npm

Erstellen Sie als Nächstes das Verzeichnis für den Notifier und wechseln Sie dorthin:

mkdir ~/overload_notifier && cd ~/overload_notifier

Node.js-Projekte verwenden eine Datei mit dem Namen "+ package.json +", die Informationen über das Projekt und seine Abhängigkeiten enthält. Führen Sie den folgenden Befehl aus, um diese Datei zu erstellen:

npm init -y

Installieren Sie dann den NATS-Client für Node.js sowie das Modul "+ nodemailer +", das wir in diesem Projekt zum Senden von Warnmeldungen verwenden:

npm install [email protected] [email protected] --save-exact

Jetzt können wir den Notifier erstellen. Erstellen Sie die Datei + notifier.js +:

nano notifier.js

Fügen Sie der Datei dann den folgenden Code hinzu:

notifier.js

var NATS_URL = 'nats://127.0.0.1:4222';
var NATS_USER = '';
var NATS_PASS = '';
var EMAIL_TO = '';

Stellen Sie sicher, dass Sie diese Optionen so ändern, dass sie Ihrem Benutzernamen und Kennwort für den NATS-Dienst sowie Ihrer E-Mail-Adresse entsprechen.

Fügen Sie als Nächstes diesen Code hinzu, um den NATS-Client von Node.js zu importieren und eine Verbindung zum Dienst + gnatsd + herzustellen:

notifier.js

var tlsOptions = {
 rejectUnauthorized: false,
};
var nats = require('nats').connect({url: NATS_URL,
                                   tls: tlsOptions,
                                   user: NATS_USER,
                                   pass: NATS_PASS});

Fügen Sie dann diesen Code hinzu, um den Mailer einzurichten und eine Verbindung zum SMTP-Server herzustellen, der die E-Mails sendet. Wir richten diesen Server in Kürze ein:

notifier.js

var nodemailer = require('nodemailer');
var transport = nodemailer.createTransport('smtp://localhost:2525');

Fügen Sie dann den Rest des Codes hinzu, um den Lastdurchschnitt zu berechnen und festzustellen, ob eine Benachrichtigungs-E-Mail gesendet werden muss:

notifier.js

// keep the state of warnings for each host
var warnings = {};

function sendEmail(subject, text) {
   transport.sendMail({
       to: EMAIL_TO,
       subject: subject,
       text: text
   });
}

function processMessage(message) {
   // message fields: host load processor_count
   var fields = message.split(" ");
   var host = fields[0];
   var loadAverage = parseFloat(fields[1]) / parseInt(fields[2]);
   if (loadAverage > 0.6) {
       if (!warnings[host]) {
           // send warning email if one wasn't already sent
           var res = sendEmail('Warning! Server is Overloaded: ' + host,
                               'Load average: ' + loadAverage);
           // set warning for the host
           warnings[host] = true;
       }
   }
   else if (loadAverage < 0.4) {
       if (warnings[host]) {
           // clear the warning
           warnings[host] = false;
       }
   }
}

nats.subscribe('stats.loadaverage', processMessage);

Wir abonnieren die Nachricht und führen jedes Mal, wenn wir eine Nachricht erhalten, die Funktion "+ processMessage +" aus, die die von uns gesendete Nutzlast analysiert und den Lastdurchschnitt ermittelt. Wenn es zu hoch ist, senden wir die Nachricht und verfolgen, ob wir zuvor eine gesendet haben, indem wir basierend auf dem Hostnamen ein Flag setzen. Auf diese Weise können wir Benachrichtigungen pro Host verfolgen. Wenn der Lastdurchschnitt unter unserer Schwelle liegt, löschen wir dieses Flag.

Wenn der Monitor und der Notifier installiert sind, können Sie unser Beispielprojekt testen.

Testen des Projekts

Machen wir eine Probefahrt. Wir werden eine künstliche Last erzeugen und prüfen, ob der Benachrichtiger die Warn-E-Mail sendet, wenn die Last zu hoch wird.

Installieren wir das Tool "+ stress +", um die CPU-Auslastung auf unserem Server zu generieren:

sudo apt-get install -y stress

Als nächstes müssen wir einen SMTP-Server einrichten, um die Nachrichten von unserem Notifier zu versenden. Die Installation und Konfiguration eines vollwertigen SMTP-Servers wäre für diesen Test ein Übermaß. Daher verwenden wir einen einfachen SMTP-Server, der nur die an ihn gesendeten E-Mails anzeigt, anstatt sie tatsächlich zu senden. Die Programmiersprache Python enthält ein von uns geladenes "+ DebuggingServer +" -Modul, das empfangene E-Mails verwirft, sie jedoch auf dem Bildschirm anzeigt, damit wir sicherstellen können, dass alles funktioniert. Python ist bereits auf unserem Ubuntu-Server installiert, daher ist dies eine perfekte Lösung.

Starten wir den Debugging-SMTP-Server im Hintergrund. Wir werden dafür sorgen, dass + localhost + port + 2525 + abgehört wird, was der SMTP-Adresse entspricht, die wir in unserem + notifier.js + Code konfiguriert haben. Führen Sie diesen Befehl aus, um den SMTP-Server zu starten:

python -m smtpd -n -c DebuggingServer localhost:2525 &

Starten Sie dann den Notifier im Hintergrund mit diesem Befehl:

nodejs ~/overload_notifier/notifier.js &

Lassen Sie uns zum Schluss eine gewisse Auslastung aller Prozessoren unseres Servers generieren. Führen Sie den Befehl + stress + mit den folgenden Optionen aus:

stress --cpu $(getconf _NPROCESSORS_ONLN)

Nach einigen Minuten wird eine Ausgabe ähnlich der folgenden angezeigt, wenn der SMTP-Server die vom Benachrichtiger gesendeten Nachrichten anzeigt:

Output---------- MESSAGE FOLLOWS ----------
Content-Type: text/plain
To:
Subject: Warning! Server is Overloaded:
Message-Id: <1466354822129-04c5d944-0d19670b-780eee12@localhost>
X-Mailer: nodemailer (2.4.2; +http://nodemailer.com/;
SMTP/2.5.0[client:2.5.0])
Content-Transfer-Encoding: 7bit
Date: Sun, 19 Jun 2016 16:47:02 +0000
MIME-Version: 1.0
X-Peer: 127.0.0.1


------------ END MESSAGE ------------

Auf diese Weise wissen Sie, dass Sie erfolgreich E-Mails gesendet haben, wenn die Auslastung des Servers zu hoch ist.

Drücken Sie "+ STRG + C +", um die Lasterzeugung zu stoppen. Sie haben das Beispielprojekt abgeschlossen und sollten nun eine gute Idee haben, wie Sie diese Funktion in Ihrer eigenen Umgebung nutzen können.

Fazit

In diesem Artikel haben Sie das NATS PubSub-Messaging-System kennengelernt, es auf sichere Weise als Dienst installiert und in einem Beispielprojekt getestet. Das Beispielprojekt verwendete den Node.JS-Client, NATS verfügt jedoch über Clients für weitere Sprachen und Frameworks, die auf der NATS-Downloadseite aufgelistet sind. Weitere Informationen zu NATS finden Sie in der official documentation.

TOC

So installieren und konfigurieren Sie NATS unter Ubuntu 16.04

Einführung

Voraussetzungen

Schritt 1 - Herunterladen des NATS-Servers

Schritt 2 - Verzeichnisstruktur und Konfigurationsdatei erstellen

Schritt 3 - Erstellen des Dienstbenutzers

Schritt 4 - Ausführen von gnatsd als Dienst

Schritt 5 - Sichern der Verbindungen zum NATS-Dienst

Schritt 6 - Authentifizierung erforderlich

Schritt 7 - Den Dienst für die Welt öffnen

Schritt 8 - (Optional) Konfigurieren von Benachrichtigungen bei Serverüberlastung

Einrichten des Monitors

Notifier erstellen

Testen des Projekts

Fazit

Related