So installierst du Sensu Monitoring Solution auf Rocky Linux 9

Sensu ist ein Open-Source-Infrastruktur- und Anwendungsüberwachungssystem, das für die Überwachung von Containern und Nicht-Containern sowie Multi-Cloud-Infrastrukturen entwickelt wurde.

Sensu ist eine skalierbare, sichere und integrierte Überwachungslösung für deine Technologie- und Serverinfrastruktur. Mit Sensu kannst du Server, den Zustand von Anwendungen und Diensten überwachen und über die Integration von Drittanbietern Warnmeldungen an mehrere Ziele senden.

In diesem Lernprogramm installierst du Sensu Monitoring Solution auf einem Rocky Linux 9 Server. Außerdem wirst du Sensuctl installieren und einrichten, mit dem du Sensu über das Kommandozeilenterminal verwalten kannst.

Am Ende dieses Tutorials wirst du auch den Sensu Agent auf RHEL-basierten und Debian-basierten Distributionen installieren. Dann richtest du Prüfungen für die Überwachung von Servern über Sensu Agent ein.

Vorraussetzungen

Um diesem Tutorial zu folgen, brauchst du die folgenden Voraussetzungen

• Einen Linux-Server mit Rocky Linux 9.
• Einen Nicht-Root-Benutzer mit sudo/root-Administrator-Rechten.
• Ein SELinux, das im permissiven Modus läuft.

Was den Zielüberwachungsserver angeht, so werden in diesem Beispiel Rocky Linux und Debian Server verwendet. Nachfolgend findest du die Details zu den Servern, die für die Demonstration verwendet werden:

Host          IP Address        Used as
-----------------------------------------------
sensu-rock    192.168.5.45    Sensu Go Backend
RPM-OS        192.168.5.80    Sensu Go Agent
DEB-OS        192.168.5.85    Sensu Go Agent

Das war’s. Du kannst mit der Installation von Sensu beginnen.

Repository einrichten

Als erstes aktivierst du das CRB (Code Ready Builder) Repository, fügst das EPEL (Extra Package for Enterprise Linux) Repository hinzu und dann das Sensu Repository über packagecloud.io.

Unter Rocky Linux 9 entspricht das crb-Repository dem PowerTools-Repository, das unter CentOS verfügbar ist. Führe den folgenden dnf-Befehl aus, um das crb-Repository zu aktivieren und das EPEL-Repository zu installieren.

sudo dnf config-manager --set-enabled crb
sudo dnf install epel-release

Sobald crb aktiviert und das EPEL-Repository installiert ist, führe den folgenden Befehl aus, um das Sensu-Repository zu deinem Rocky Linux-Server hinzuzufügen. Dadurch wird das Sensu-Repository automatisch auf deinem System eingerichtet und du verwendest das Sensu-Repository aus dem stabilen Zweig.

curl -s https://packagecloud.io/install/repositories/sensu/stable/script.rpm.sh | sudo bash

Überprüfe die Liste der aktivierten Repositories auf deinem System, indem du den folgenden dnf-Befehl eingibst. Du solltest eine Meldung erhalten, dass die Repositories crb, epel und sensu_stable zu deinem Rocky Linux System hinzugefügt wurden.

sudo dnf repolist

Jetzt, wo du die notwendigen Repositories hinzugefügt hast, kannst du mit der Installation von Sensu beginnen.

Installation von Sensu Go Backend

Sensu ist eine Komplettlösung für das Monitoring im großen Maßstab, mit der du traditionelle Server, Container, Anwendungen und/oder Cloud-Anwendungen überwachen kannst. Bevor du Sensu installierst, musst du wissen, dass Sensu aus drei Komponenten besteht, die im Folgenden aufgelistet sind:

• Sensu Backend – die Hauptkomponente von Sensu, die von einem eingebetteten Transport und einem etcd-Datenspeicher unterstützt wird. Sensu Backend stellt den WebSocket für die Kommunikation mit dem Sensu Agent und die HTTP-API für die Kommunikation mit sensuctl bereit. Außerdem bietet es ein Web-UI-Dashboard, auf das du über einen Browser zugreifen kannst.
• Sensu Agent – dies ist ein leichtgewichtiger Client, der auf den Zielservern installiert und ausgeführt wird. Der Agent generiert Status und Metriken auf dem Zielserver und sendet die Ergebnisse per WebSocket an das Sensu Backend.
• Sensu Workstation – das ist der lokale Computer, auf dem du Sensuctl installierst oder über deinen Browser auf das Sensu Dashboard zugreifen kannst.

In diesem Abschnitt wirst du Sensu Backend auf dem Rocky Linux Server installieren und konfigurieren.

Gib den folgenden dnf-Befehl ein, um das Paket„sensu-go-backend“ auf deinem System zu installieren. Wenn du dazu aufgefordert wirst, gib y zur Bestätigung ein und drücke ENTER, um fortzufahren.

sudo dnf install sensu-go-backend

Sobald Sensu Backend installiert ist, lädst du die Beispielkonfiguration von Sensu Backend über curl nach„/etc/sensu/backend.yml“ herunter. Öffne dann die heruntergeladene Datei mit dem folgenden nano-Editor-Befehl.

sudo curl -L https://docs.sensu.io/sensu-go/latest/files/backend.yml -o /etc/sensu/backend.yml
sudo nano /etc/sensu/backend.yml

Hebe die Kommentare in den folgenden Zeilen auf.

cache-dir: "/var/cache/sensu/sensu-backend"
config-file: "/etc/sensu/backend.yml"

log-level: „debug“
state-dir: „/var/lib/sensu/sensu-backend“

Speichere und schließe die Datei „/etc/sensu/backend.yml“, wenn du fertig bist.

Als nächstes führst du den folgenden systemctl-Befehl aus, um den Dienst„sensu-backend“ zu starten und zu aktivieren. Damit sollte das Sensu Backend laufen und wird beim Systemstart automatisch gestartet.

sudo systemctl start sensu-backend
sudo systemctl enable sensu-backend

Führe den folgenden systemctl-Befehl aus, um den Dienst „sensu-backend“ zu überprüfen und sicherzustellen, dass der Dienst läuft und aktiviert ist.

sudo systemctl is-enabled sensu-backend
sudo systemctl status sensu-backend

Die Ausgabe„enabled“ bestätigt, dass das Sensu Backend beim Systemstart automatisch gestartet wird. Und die Ausgabe„active (running)“ bestätigt, dass das Sensu Backend gerade läuft.

Jetzt, wo du das Sensu Backend installiert hast und es läuft und aktiviert ist. Als Nächstes wirst du den Sensu-Admin-Benutzer initialisieren und die Installation überprüfen.

Sensu Go Backend konfigurieren

In diesem Abschnitt legst du den Administrator-Benutzernamen und das Passwort für das Sensu Backend fest, überprüfst die Installation mit curl und dem Webbrowser und öffnest einige Ports mit firewalld.

Führe den folgenden Befehl aus, um die Umgebungsvariablen„SENSU_BACKEND_CLUSTER_ADMIN_USERNAME“ und„SENSU_BACKEND_CLUSTER_ADMIN_PASSWORD“ einzurichten. Achte darauf, dass du die Werte mit deinem Benutzernamen und Passwort änderst.

export SENSU_BACKEND_CLUSTER_ADMIN_USERNAME=adminsensu
export SENSU_BACKEND_CLUSTER_ADMIN_PASSWORD=SensuRocks

Führe nun den folgenden Befehl„sensu-backend init“ aus, um deine Sensu-Installation zu initialisieren. Damit wird dein Sensu-Backend-Admin-Benutzer erstellt.

sensu-backend init

Als Nächstes führst du den folgenden Befehl aus, um das Paket „jq“ zu installieren, das die Ausgabe in json parst. Führe dann den Befehl curl aus, um den Status des Sensu-Backends zu überprüfen. Die HTTP-API des Sensu-Backends läuft über den Standardport 8080.

sudo dnf install jq
curl -s http://127.0.0.1:8080/health | jq .

Die Ausgabe „Healthy: true“ bestätigt, dass das Sensu Backend ohne Fehler läuft.

Bevor du auf das Sensu Dashboard zugreifen kannst, musst du die Ports in der Firewalld öffnen.

Gib den folgenden firewall-cmd-Befehl ein und öffne einige Ports für das Sensu Backend. Lade dann die Firewalld neu, um die Änderungen zu übernehmen.

sudo firewall-cmd --add-port={2379/tcp,2380/tcp,3000/tcp,6060/tcp,8080/tcp,8081/tcp} --permanent
sudo firewall-cmd --reload

Überprüfe die Liste der offenen Ports in der Firewalld mit dem folgenden Befehl.

sudo firewall-cmd --list-all

Öffne nun deinen Webbrowser und rufe die IP-Adresse des Servers gefolgt von Port 3000 (d.h.: http://192.168.5.45:3000/) auf. Du solltest die Login-Seite des Sensu-Backends erhalten.

Melde dich mit deinem Benutzernamen und Passwort an und klicke dann auf„ANMELDEN„.

Wenn du erfolgreich warst, solltest du das Sensu-Administrations-Dashboard erhalten.

Damit hast du Sensu Backend installiert, den Admin-Benutzer und das Passwort konfiguriert und dich erfolgreich im Sensu Dashboard über den Browser angemeldet. Im nächsten Schritt installierst du Sensuctl und verbindest dich dann über Sensuctl mit dem Sensu Backend.

Sensuctl über die Kommandozeile installieren

Führe den folgenden dnf-Befehl aus, um den Sensuctl-Befehl zu installieren. Wenn du dazu aufgefordert wirst, gib zur Bestätigung y ein und drücke ENTER, um fortzufahren.

sudo dnf install sensu-go-cli

Sobald Sensuctl installiert ist, führe den folgenden Befehl aus, um den Binärpfad und die Version von Sensuctl zu überprüfen.

which sensuctl
sensuctl --version

Der Binärpfad von Sensuctl ist unter „/bin/sensuctl“ zu finden, und die installierte Version ist v6.9.1.

Als Nächstes führst du den folgenden„sensuctl„-Befehl aus, um die Verbindung zu deinem Sensu Backend Server zu konfigurieren.

sensuctl configure

Du wirst nun nach einigen Konfigurationen gefragt:

• Authentifizierungsmethode? username/password
• Sensu Backend API URL? Sensu API läuft standardmäßig auf http://127.0.0.1:8080
• Namespace? Standard
• Bevorzugtes Ausgabeformat? Wähle das gewünschte Ausgabeformat aus – dieses Beispiel ist json.
• Benutzername? admin user für sensu
• Passwort? Passwort für den sensu-Admin-Benutzer

Wenn du fertig bist, führe den folgenden Befehl aus, um die Verbindung zu überprüfen.

sensuctl config view

Du erhältst eine ähnliche Ausgabe wie diese – Sensuctl ist mit dem Sensu Backend über die HTTP-API verbunden, die standardmäßig auf „http://127.0.0.1:8080“ läuft.

Nachdem du Sensuctl konfiguriert hast, aktivierst du nun die Autovervollständigung für die Sensuctl-Befehlszeile.

Führe den folgenden dnf-Befehl aus, um das Paket„bash-completion“ zu installieren.

sudo dnf install bash-completion -y

Wenn „bash-completion“ installiert ist, öffne die Datei „~/.bashrc“ mit dem folgenden Editorbefehl nano.

sudo nano ~/.bashrc

Füge die folgenden Zeilen in die Datei ein. Dadurch wird die„bash-completion“ für den Root-Benutzer aktiviert.

if [ -f /usr/share/bash-completion/bash_completion ]; then
. /usr/share/bash-completion/bash_completion
elif [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi

source <(sensuctl completion bash)

Speichere und beende die Datei, wenn du fertig bist.

Als Nächstes führst du den folgenden Befehl aus, um die Datei „~/.bashrc“ in deiner aktuellen Sitzung neu zu laden.

source ~/.bashrc

Überprüfe die automatische Vervollständigung, indem du den Befehl„sensuctl“ eingibst und TAB drückst.

sensuctl TAB

Wenn du erfolgreich warst, solltest du die Liste der Optionen erhalten, die für den Befehl„sensuctl“ zur Verfügung stehen.

Damit hast du Sensuctl installiert, dich über Sensuctl mit dem Sensu Backend Server verbunden und auch die automatische Vervollständigung konfiguriert. Als Nächstes wirst du den Sensu Agent auf den Servern von Rocky Linux und Debian einrichten.

Installation von Sensu Agent

In diesem Abschnitt wirst du Sensu Agent auf zwei verschiedenen Nodes installieren und einrichten. Du installierst Sensu Agent auf RHEL-basierten Distributionen und Debian-basierten Distributionen. Dann richtest du den Sensu Agent so ein, dass er sich über WebSocket mit dem Sensu Backend Server verbindet, den du installiert hast.

Jetzt können wir loslegen.

Sensu Agent auf RHEL-basierten Distributionen

In diesem Beispiel wird ein Rocky Linux 9 Rechner verwendet, der auf RHEL oder CentOS 9 basiert. Um Sensu Agent zu installieren, musst du das Sensu Repository hinzufügen und einige Ports in der Firewalld öffnen.

Führe den folgenden Befehl firewall-cmd aus, um einige Ports zu öffnen. Lade dann die Firewalld neu, um die Änderungen zu übernehmen.

sudo firewall-cmd --add-port={3030/tcp,3030/udp,3031/tcp,8125/udp} --permanent
sudo firewall-cmd --reload

Überprüfe die Liste der freigegebenen Ports in der Firewalld mit dem folgenden Befehl.

sudo firewall-cmd --list-all

Du solltest eine Ausgabe wie diese erhalten:

Als nächstes gibst du den folgenden dnf-Befehl ein, um das crb-Repository zu aktivieren und das EPEL-Repository zu installieren.

sudo dnf config-manager --set-enabled crb
sudo dnf install epel-release

Füge nun das Sensu-Repository hinzu, indem du den folgenden Befehl eingibst. Dadurch wird das Bash-Installer-Skript heruntergeladen und ausgeführt, das die Konfiguration des Repositorys automatisiert.

curl -s https://packagecloud.io/install/repositories/sensu/stable/script.rpm.sh | sudo bash

Ausgabe:

Sobald das Sensu-Repository hinzugefügt wurde, führst du den folgenden dnf-Befehl aus, um das Paket „sens-go-agent“ auf deinem System zu installieren. Wenn du dazu aufgefordert wirst, bestätige mit y und drücke ENTER, um fortzufahren.

sudo dnf install sensu-go-agent

Ausgabe:

Als Nächstes führst du den folgenden Befehl aus, um die Konfigurationsdatei des Sensu-Agenten nach „/etc/sensu/agent.yml“ herunterzuladen. Öffne dann die Konfigurationsdatei „/etc/sensu/agent.yml“ mit dem unten stehenden nano-Editor.

sudo curl -L https://docs.sensu.io/sensu-go/latest/files/agent.yml -o /etc/sensu/agent.yml
sudo nano /etc/sensu/agent.yml

Hebe die Kommentare in den folgenden Zeilen auf und stelle sicher, dass du den standardmäßigen„name“ durch den System-Hostnamen und die„backend-url“ durch die WebSockt IP-Adresse des Sensu Backend Servers ersetzt.

In diesem Beispiel ist der System-Hostname„RPM-OS“ und die IP-Adresse des Sensu Backend-Servers ist„192.168.5.45„.

name: "RPM-OS"
namespace: "default"
...
backend-url:
  - "ws://192.168.5.45:8081"
cache-dir: "/var/cache/sensu/sensu-agent"
config-file: "/etc/sensu/agent.yml"

Speichere die Datei„/etc/sensu/agent.yml“ und beende den Editor, wenn du fertig bist.

Führe nun den folgenden systemctl-Befehl aus, um den Dienst„sensu-agent“ zu starten und zu aktivieren.

sudo systemctl start sensu-agent
sudo systemctl enable sensu-agent

Die Ausgabe„Symlink erstellen … => ...“ bestätigt, dass der Sensu-Agent aktiviert ist.

Als Nächstes überprüfst du den Dienst„sensu-agent“ mit dem folgenden systemctl-Befehl, um sicherzustellen, dass der Dienst läuft und aktiviert ist.

sudo systemctl is-enabled sensu-agent
sudo systemctl status sensu-agent

Die Ausgabe„enabled“ bestätigt, dass der Sensu Agent aktiviert ist und beim Systemstart automatisch gestartet wird. Und der Status von Sensu Agent ist „active (running)„.

Wenn der Sensu Agent auf dem„RPM-OS„-Rechner läuft, wird der Agent über den WebSocket auf Port 8081 mit dem Sensu Backend verbunden.

Sensu Agent auf Debian-basierten Distributionen

Jetzt installierst du den Sensu Agent auf einer Debian-basierten Distribution, richtest die UFW-Firewall ein und konfigurierst den Sensu Agent für die Verbindung mit dem Sensu Backend Server.

Zuerst musst du einige Ports auf deinem System öffnen. Bei Debian-basierten Distributionen kannst du ufw verwenden, um die Firewall einzurichten.

Führe den folgenden apt-Befehl aus, um die ufw-Firewall zu installieren.

sudo apt install ufw -y

Nach der Installation führst du den folgenden ufw-Befehl aus, um den OpenSSH-Dienst und einige Ports hinzuzufügen, die von Sensu Agent verwendet werden sollen.

sudo ufw allow OpenSSH
sudo ufw allow 3030/tcp
sudo ufw allow 3030/udp
sudo ufw allow 3031/tcp
sudo ufw allow 8125/udp

Die Ausgabe„Rules updated“ bestätigt, dass die neue Regel zur Firewall hinzugefügt wurde.

Als Nächstes führst du den folgenden Befehl aus, um die ufw-Firewall zu starten und zu aktivieren. Wenn du dazu aufgefordert wirst, gib zur Bestätigung y ein und drücke ENTER, um fortzufahren.

sudo ufw enable

Überprüfe die Liste der aktivierten Ports und Anwendungen der ufw, indem du den folgenden Befehl eingibst.

sudo ufw status

Du solltest eine Ausgabe wie diese erhalten:

Jetzt kannst du das Paket Sensu Agent installieren.

Führe den folgenden apt-Befehl aus, um grundlegende Abhängigkeiten auf deinem System zu installieren. Gib zur Bestätigung y ein und drücke ENTER, um mit der Installation fortzufahren.

sudo apt install debian-archive-keyring curl gnupg apt-transport-https

Als nächstes fügst du das Sensu-Repository für Debian-basierte Distributionen hinzu, indem du den folgenden Befehl eingibst. Dadurch wird das Bash-Installer-Skript heruntergeladen und ausgeführt, das die Konfiguration des Repositorys automatisiert.

curl -s https://packagecloud.io/install/repositories/sensu/stable/script.deb.sh | sudo bash

Sobald das Repository hinzugefügt ist, installierst du „sensu-go-agent“ mit dem unten stehenden Befehl „apt install“. Wenn du dazu aufgefordert wirst, gib y ein und drücke ENTER.

sudo apt install sensu-go-agent

Als Nächstes führst du den folgenden Befehl aus, um die Konfigurationsdatei des Sensu-Agenten nach „/etc/sensu/agent.yml“ herunterzuladen. Öffne dann die Konfigurationsdatei „/etc/sensu/agent.yml“ mit dem unten stehenden nano-Editor.

sudo curl -L https://docs.sensu.io/sensu-go/latest/files/agent.yml -o /etc/sensu/agent.yml
sudo nano /etc/sensu/agent.yml

Hebe die Kommentare in den folgenden Zeilen auf und stelle sicher, dass du den standardmäßigen„name“ durch den System-Hostnamen und die„backend-url“ durch die WebSockt IP-Adresse des Sensu Backend Servers ersetzt.

In diesem Beispiel ist der System-Hostname„DEB-OS“ und die IP-Adresse des Sensu Backend-Servers ist„192.168.5.45„.

name: "DEB-OS"
namespace: "default"
...
backend-url:
  - "ws://192.168.5.45:8081"
cache-dir: "/var/cache/sensu/sensu-agent"
config-file: "/etc/sensu/agent.yml"

Speichere die Datei „/etc/sensu/agent.yml“ und beende den Editor, wenn du fertig bist.

Führe nun den folgenden systemctl-Befehl aus, um den Dienst „sensu-agent“ zu starten und zu aktivieren.

sudo systemctl start sensu-agent
sudo systemctl enable sensu-agent

Die Ausgabe„Symlink erstellen … => ...“ bestätigt, dass der Sensu-Agent aktiviert ist.

Als Nächstes überprüfst du den Dienst„sensu-agent“ mit dem folgenden systemctl-Befehl, um sicherzustellen, dass der Dienst läuft und aktiviert ist.

sudo systemctl is-enabled sensu-agent
sudo systemctl status sensu-agent

Die Ausgabe„enabled“ bestätigt, dass der Sensu Agent aktiviert ist und beim Systemstart automatisch gestartet wird. Und der Status von Sensu Agent ist„active (running)„.

Wenn der Sensu Agent auf dem „DEB-OS“-Rechner läuft, wird der Agent über den WebSocket an Port 8081 mit dem Sensu Backend verbunden.

Überprüfen des Agenten über Sensu Go Backend und Sensuctl

An dieser Stelle hast du die beiden Server„RPM-OS“ und„DEB-OS“ über den Sensu Agent zu den Sensu Monitoring-Lösungen hinzugefügt. In diesem Abschnitt überprüfst du beide Server über das Sensu Backend Dashboard und über den Sensuctl-Befehl im Terminal.

Wenn du zum Sensu Dashboard zurückkehrst, solltest du drei auf Sensu verfügbare Entitäten sehen.

Klicke auf den Namensraum„default“ und du solltest sehen, dass„RPM-OS“ und„DEB-OS“ zu Sensu hinzugefügt wurden.

Gehe zurück zum Sensu Backend Terminal Server und führe den folgenden sensuctl-Befehl aus, um die Liste der Entitäten zu überprüfen, die in Sensu verfügbar sind.

sensuctl entity list --format tabular

Du solltest sehen, dass die beiden Entitäten„RPM-OS“ und„DEB-OS“ hinzugefügt wurden und in Sensu verfügbar sind.

Checks für die Systemüberwachung erstellen

In Sensu legst du mit Checks fest, welche Dinge du überwachen willst. Beispiele für Checks sind die Überwachung der CPU-Auslastung, der Speichernutzung, der Festplattennutzung und vieles mehr. Checks sind Teil der Assets, also der dynamischen Laufzeiten, die gemeinsam genutzt und wiederverwendet werden können.

In diesem Abschnitt erstellst du neue Checks zur Überwachung der CPU-, Speicher- und Festplattenauslastung. Diese Checks werden zur Überwachung der Server„RPM-OS“ und„DEB-OS“ verwendet.

Um einen Check in Sensu zu erstellen, fügst du Sensu-Assets hinzu und definierst dann Checks, die von deinen Bedürfnissen abhängen. All diese Vorgänge können mit dem Befehl Sensuctl durchgeführt werden.

Führe den folgenden Befehl aus, um ein Asset zur Überprüfung der CPU-Auslastung hinzuzufügen.

sensuctl asset add sensu/check-cpu-usage

Führe nun den folgenden Befehl aus, um eine Prüfung„check_cpu“ mit dem Abonnement„system“ zu erstellen und verwende den Runtime-Assent„sensu/check-cpu-usage„. Du kannst die Einstellungen unter der Option„command“ anpassen.

sensuctl check create check_cpu \
--command 'check-cpu-usage -w 75 -c 90' \
--interval 60 \
--subscriptions system \
--runtime-assets sensu/check-cpu-usage

Als Nächstes fügst du mit dem folgenden Befehl ein neues Asset zur Überprüfung der Speichernutzung hinzu.

sensuctl asset add sensu/check-memory-usage

Führe den folgenden Befehl aus, um eine Prüfung„check_mem“ mit dem Abonnement„system“ zu erstellen und verwende das Laufzeit-Assent„sensu/check-memory-usage„. Du kannst die Einstellungen unter der Option „command“ anpassen.

sensuctl check create check_mem \
--command 'check-memory-usage -w 80 -c 90' \
--interval 60 \
--subscriptions system \
--runtime-assets sensu/check-memory-usage

Führe den folgenden Befehl aus, um das neue Asset zur Überprüfung der Speichernutzung hinzuzufügen.

sensuctl asset add sensu/check-disk-usage

Erstelle dann mit dem folgenden Befehl eine neue Prüfung zur Überprüfung der Speichernutzung. Dadurch wird eine Prüfung„check_disk“ mit dem Abonnement„system“ erstellt und das Laufzeit-Assent„sensu/check-disk-usage“ verwendet. Du kannst die Einstellungen unter der Option„command“ anpassen.

sensuctl check create check_disk \
--command 'check-disk-usage --include-fs-type "xfs,ext4" --exclude-fs-path "/boot" --warning 90 --critical 95' \
--interval 60 \
--subscriptions system \
--runtime-assets sensu/check-disk-usage

Führe schließlich den folgenden Befehl aus, um die Liste der in deinem Sensu Backend verfügbaren Assets zu überprüfen. Du solltest mehrere Assets sehen, mit denen du Checks für verschiedene Systemarchitekturen erstellen kannst.

sensuctl asset list --format tabular

Überprüfe nun die Liste der Checks, die du erstellt hast, indem du den folgenden Befehl eingibst. Du solltest drei Checks sehen : „check_cpu“, „check_mem“ und„check_disk„.

sensuctl check list --format tabular

Systemchecks auf Monitor-Agenten/Hosts anwenden

Nachdem du die Checks in Sensu hinzugefügt hast, wendest du als Nächstes die Checks auf die Entitäten/Hosts„RPM-OS“ und„DEB-OS“ an, indem du jede Entität modifizierst und ihre Abonnements änderst.

Alle deine Checks „check_cpu“, „check_mem“ und„check_disk“ sind für das Abonnement„system“ konfiguriert.

Überprüfe zunächst die Liste der Entitäten mit dem unten stehenden Befehl sensuctl. Du solltest die Server „RPM-OS“ und„DEB-OS“ in der Liste sehen.

sensuctl entity list --format tabular

Als Nächstes führst du den folgenden Befehl aus, um die Entitäten „RPM-OS“ und „DEB-OS“ zu ändern. Die Entitätsklasse sollte„agent“ lauten, dann füge das Abonnement„system“ hinzu. Eine Ausgabe„Updated“ bestätigt, dass die Entität geändert wurde.

sensuctl entity update RPM-OS
sensuctl entity update DEB-OS

Ausgabe:

Gehe zurück zum Sensu Dashboard und wähle den „Standard“-Namensraum. Klicke auf das Menü “ Entitäten “ und du solltest sehen, dass das Abonnement„system“ sowohl zu DEB-OS als auch zu RPM-OS hinzugefügt wurde.

Klicke auf„DEB-OS„, um die Detailüberwachung zu erhalten. Du solltest sehen, dass alle Prüfungen für das„System„-Abonnement durchgeführt wurden.

Klicke auf„RPM-OS„, um eine detaillierte Überwachung zu erhalten. Du solltest sehen, dass alle Checks auf das„System„-Abonnement angewendet werden.

Damit hast du die Checks auf beide Server, RPM-OS und DEB-OS, angewendet.

Fazit

In diesem Lernprogramm hast du die Sensu Monitoring Solution auf einem Rocky Linux 9 Server installiert. Du hast den Sensu-Backend-Administrator-Benutzer installiert und initialisiert und die Sensuctl-Befehlszeile zur Verwaltung des Sensu-Backends installiert und konfiguriert.

Außerdem hast du zwei Hosts (Rocky Linux und Debian Server) über den Sensu Agent zu Sensu hinzugefügt. Außerdem hast du Assets für das Überwachungssystem hinzugefügt, Sensu Checks erstellt und auch Checks für die Überwachung der Zielhosts angewendet.

Jetzt kannst du weitere Hosts über den Sensu Agent hinzufügen. Außerdem kannst du neue Checks definieren und erstellen, neue Sensu-Assets hinzufügen und dann Checks auf deine Hosts und Anwendungen anwenden. Mehr über Sensi erfährst du jetzt in der offiziellen Sensu-Dokumentation.