So installierst und konfigurierst du Nagios auf Rocky Linux 9
Nagios ist ein beliebtes und eines der leistungsfähigsten Open-Source-Überwachungssysteme. Es überwacht deine IT-Infrastruktur und sorgt dafür, dass deine Netzwerke, Server, Anwendungen und Prozesse reibungslos laufen. Mit einem Überwachungssystem kannst du Probleme erkennen, bevor sie auftreten, und sie schnell beheben, um Kosten und Ausfallzeiten zu sparen.
In diesem Lernprogramm lernst du, wie du Nagios auf einem Rocky Linux 9 Server installierst und konfigurierst. Außerdem werden wir einige grundlegende Konfigurationen vornehmen und den Nagios Remote Plugin Executor (NPRE) installieren, mit dem wir entfernte Hosts überwachen können.
Voraussetzungen
- Ein Server mit Rocky Linux 9.
- Ein Nicht-Sudo-Benutzer mit Root-Rechten.
- SELinux ist deaktiviert. Für dieses Tutorial würde es auch bei aktiviertem SELinux ohne Probleme funktionieren. Aber je nachdem, welche Nagios-Monitore du verwendest, musst du entweder SELinux konfigurieren oder du solltest es lieber deaktiviert lassen.
- Ein weiterer Server mit Rocky Linux 9, den du überwachen willst.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo dnf update
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux Server wird mit der Firewall Firewalld geliefert.
Überprüfe, ob die Firewall läuft.
$ sudo firewall-cmd --state
Du solltest die folgende Ausgabe erhalten.
running
Überprüfe die aktuell erlaubten Dienste/Ports.
$ sudo firewall-cmd --permanent --list-services
Es sollte die folgende Ausgabe erscheinen.
dhcpv6-client mdns ssh
Lasse HTTP- und HTTPS-Ports zu.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --permanent --list-services
Du solltest eine ähnliche Ausgabe sehen.
dhcpv6-client http https mdns ssh
Lade die Firewall neu.
$ sudo firewall-cmd --reload
Schritt 2 – Installiere Apache und PHP
Um Nagios zu betreiben, musst du Apache und PHP installieren.
Installiere und aktiviere den Apache-Dienst.
$ sudo dnf install httpd $ sudo systemctl enable httpd
Um PHP zu installieren, verwenden wir das Remi Repository. Installiere Remi Repo und aktiviere PHP 8.1.
$ sudo dnf install dnf-utils http://rpms.remirepo.net/enterprise/remi-release-9.rpm $ sudo dnf module reset php -y $ sudo dnf module enable php:remi-8.1 -y
Installiere PHP und einige gängige PHP-Module.
$ sudo dnf install -y php php-gd php-curl
Überprüfe die PHP-Installation.
$ php --version
PHP 8.1.16 (cli) (built: Feb 14 2023 18:59:41) (NTS gcc x86_64)
Copyright (c) The PHP Group
Zend Engine v4.1.16, Copyright (c) Zend Technologies
with Zend OPcache v8.1.16, Copyright (c), by Zend Technologies
Aktiviere PHP und starte den Dienst.
$ sudo systemctl enable --now php-fpm
Starte den Apache-Dienst neu, damit die Änderung wirksam wird.
$ sudo systemctl restart httpd
Du kannst die Installation von Apache und PHP überprüfen, indem du eine Datei info.php im Verzeichnis /var/www/html anlegst, das vom Apache-Installationsprogramm erstellt wurde.
$ sudo nano /var/www/html/info.php
Füge den folgenden Code in den Editor ein.
<?php phpinfo();
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die URL http://<yourserverip>/info.php in deinem Browser und du solltest die folgende Seite zu sehen bekommen.
Schritt 3 – Nagios installieren
Für den größten Teil dieses Tutorials musst du deinen Hauptserver installieren und mit ihm arbeiten.
Abhängigkeiten installieren
Für diesen Lehrgang müssen Nagios und seine Plugins aus dem Quellcode erstellt werden. Daher musst du zunächst einige Entwicklungsbibliotheken installieren. Wir brauchen auch das EPEL-Repository, aber das wurde im vorherigen Schritt automatisch mit dem Remi-Repository installiert, so dass wir es hier überspringen können.
$ sudo dnf install gcc glibc glibc-common gd gd-devel make net-snmp openssl-devel unzip wget gettext autoconf net-snmp-utils postfix automake perl-Net-SNMP
Nagios herunterladen
Lade die neueste Version von der GitHub-Releaseseite von Nagios herunter. Zum Zeitpunkt des Tutorials ist die Version 4.4.10 die letzte verfügbare Version. Ändere den Befehl, falls du eine andere Version möchtest.
$ cd ~ $ sudo wget -O nagios.tar.gz https://github.com/NagiosEnterprises/nagioscore/releases/download/nagios-4.4.10/nagios-4.4.10.tar.gz
Entpacke die tar-Datei.
$ sudo tar zxf nagios.tar.gz
Verschiebe das entpackte Verzeichnis in das Verzeichnis /usr/src.
sudo mv nagios-4.4.10 /usr/src/nagios
Wechsle in das Verzeichnis /usr/src/nagios.
$ cd /usr/src/nagios
Nagios kompilieren
Der nächste Schritt besteht darin, Nagios aus den Quelldateien zu kompilieren. Führe das Skript configure aus, um zu prüfen, ob alle Abhängigkeiten vorhanden sind.
$ sudo ./configure
Nach dem erfolgreichen Abschluss des Skripts solltest du eine ähnliche Ausgabe erhalten.
*** Configuration summary for nagios 4.4.10 2023-01-17 ***:
General Options:
-------------------------
Nagios executable: nagios
Nagios user/group: nagios,nagios
Command user/group: nagios,nagios
Event Broker: yes
Install ${prefix}: /usr/local/nagios
Install ${includedir}: /usr/local/nagios/include/nagios
Lock file: /run/nagios.lock
Check result directory: /usr/local/nagios/var/spool/checkresults
Init directory: /lib/systemd/system
Apache conf.d directory: /etc/httpd/conf.d
Mail program: /usr/sbin/sendmail
Host OS: linux-gnu
IOBroker Method: epoll
Web Interface Options:
------------------------
HTML URL: http://localhost/nagios/
CGI URL: http://localhost/nagios/cgi-bin/
Traceroute (used by WAP):
Review the options above for accuracy. If they look okay,
type 'make all' to compile the main program and CGIs.
Starte die Kompilierung.
$ sudo make all
Nagios-Benutzer und -Gruppe erstellen
Erstelle einen neuen Benutzer und eine neue Gruppe, die den Nagios-Prozess ausführen werden.
$ sudo make install-groups-users
Du solltest die folgende Ausgabe sehen.
groupadd -r nagios useradd -g nagios nagios
Füge den Benutzer apache zu der Gruppe nagios hinzu.
$ sudo usermod -a -G nagios apache
Nagios-Binärdateien installieren
Führe den folgenden Befehl aus, um Nagios-Binärdateien, CGIs und HTML-Dateien zu installieren.
$ sudo make install
Externes Befehlsverzeichnis erstellen
Nagios kann Befehle von externen Anwendungen verarbeiten und benötigt dafür ein Verzeichnis.
$ sudo make install-commandmode /bin/install -c -m 775 -o nagios -g nagios -d /usr/local/nagios/var/rw chmod g+s /usr/local/nagios/var/rw *** External command directory configured ***
Nagios-Konfigurationsdateien installieren
Installiere die Beispielkonfigurationsdateien.
$ sudo make install-config
Apache-Konfigurationsdateien installieren
Führe den folgenden Befehl aus, um die Apache-Konfigurationsdateien zu installieren.
$ sudo make install-webconf
Starte den Webserver neu, um die Konfiguration zu aktivieren.
$ sudo systemctl restart httpd
Erstelle eine Systemd-Dienstdatei
Führe den folgenden Befehl aus, um eine systemd-Einheitsdatei zu installieren.
$ sudo make install-daemoninit
Aktiviere die HTTP-Authentifizierung
Du kannst die Nagios-Weboberfläche über HTTP-Authentifizierung sperren. Führe den folgenden Befehl aus, um den Benutzer mit htpasswd zu erstellen. Du wirst zur Eingabe eines Passworts aufgefordert.
$ sudo htpasswd -c /usr/local/nagios/etc/htpasswd.users nagiosadmin New password: Re-type new password: Adding password for user nagiosadmin
Der Standardname für den Benutzer ist nagiosadmin. Du kannst einen anderen Benutzernamen verwenden, indem du alle Instanzen von nagiosadmin in der Datei /usr/local/nagios/etc/cgi.cfg durch den gewünschten Benutzernamen ersetzt. Oder du fügst den Benutzernamen mit einem Komma hinzu, wie im Folgenden beschrieben.
authorized_for_system_information=nagiosadmin, username1 authorized_for_configuration_information=nagiosadmin, username1 authorized_for_system_commands=nagiosadmin, username1 authorized_for_all_services=nagiosadmin, username1 authorized_for_all_hosts=nagiosadmin, username1 authorized_for_all_service_commands=nagiosadmin, username1 authorized_for_all_host_commands=nagiosadmin, username1
Du kannst Benutzer mit Lesezugriff hinzufügen, indem du die folgende Konfiguration in der Datei aktivierst, indem du die vorangestellte Raute (#) entfernst. Führe dann die htpasswd mit dem Benutzernamen aus.
authorized_for_read_only=username2
Starte den Server neu, damit die Konfiguration in Kraft treten kann.
$ sudo systemctl restart httpd
Schritt 4 – Nagios Plugins installieren
Installiere die für die Nagios-Plugins erforderlichen Voraussetzungen.
$ sudo dnf install epel-release $ sudo dnf install -y gcc glibc glibc-common make gettext automake autoconf wget openssl-devel net-snmp net-snmp-utils postgresql-devel openldap-devel bind-utils samba-client fping openssh-clients lm_sensors perl-Net-SNMP
Lade die neueste Version von der GitHub-Seite der Nagios-Plugins herunter. Zum Zeitpunkt des Tutorials ist die Version 2.4.3 die letzte verfügbare Version. Ändere den Befehl, falls du eine andere Version möchtest.
$ cd ~ $ sudo wget -O nagios-plugins.tar.gz https://github.com/nagios-plugins/nagios-plugins/releases/download/release-2.4.3/nagios-plugins-2.4.3.tar.gz
Entpacke die tar-Datei.
$ sudo tar zxf nagios-plugins.tar.gz
Verschiebe das entpackte Verzeichnis in das Verzeichnis /usr/src.
$ sudo mv nagios-plugins-2.4.3 /usr/src/nagios-plugins
Wechsle zurück in das Verzeichnis /usr/src/nagios-plugins.
$ cd /usr/src/nagios-plugins
Führe die folgenden Befehle aus, um die Plugins zu kompilieren und zu installieren.
$ sudo ./configure $ sudo make $ sudo make install
Schritt 5 – Installiere das check_nrpe Plugin
Lade die neueste Version von der NRPE GitHub Release-Seite herunter. Zum Zeitpunkt der Erstellung dieses Tutorials ist die neueste Version 4.1.0 verfügbar. Ändere den folgenden Befehl, falls du eine andere Version möchtest.
$ cd ~ $ wget https://github.com/NagiosEnterprises/nrpe/releases/download/nrpe-4.1.0/nrpe-4.1.0.tar.gz
Entpacke das Archiv.
$ tar zxf nrpe-*.tar.gz
Verschiebe das entpackte Verzeichnis in das Verzeichnis /usr/src.
$ sudo mv nrpe-4.1.0 /usr/src/nrpe
Wechsle in das Verzeichnis /usr/src/nrpe.
$ cd /usr/src/nrpe
Konfiguriere und installiere das Plugin.
$ sudo ./configure $ sudo make check_nrpe $ sudo make install-plugin
Dadurch wird das Plugin check_nrpe in das Verzeichnis /usr/local/nagios/libexec/ verschoben.
Schritt 6 – Starten von Nagios
Nachdem Nagios und die Plugins installiert sind, ist es an der Zeit, den Nagios-Dienst zu starten.
$ sudo systemctl start nagios
Überprüfe den Status des Dienstes, um zu sehen, ob er ordnungsgemäß läuft.
$ sudo systemctl status nagios
Nagios Web Interface
Öffne die URL http://<domain_or_ip_address>/nagios in deinem Browser. Du solltest eine Anmeldeaufforderung sehen.
Gib die Anmeldedaten ein, die du bei der HTTP-Authentifizierung erstellt hast, und du solltest den folgenden Bildschirm sehen.
Schritt 7 – Hosts überwachen
Um einen Host zu überwachen, musst du den NRPE Daemon und die Nagios Plugins auf dem Host installieren. Wir werden einen Rocky Linux 9 Server von unserem Nagios Server aus überwachen.
Melde dich bei deinem Host an.
$ ssh user@monitored_server_ip
Nagios-Plugins installieren
Installiere die Nagios-Plugins, indem du Schritt 4 von vorher wiederholst.
NRPE installieren
Installiere die erforderlichen Voraussetzungen für den NRPE-Daemon.
$ sudo dnf install -y gcc glibc glibc-common openssl openssl-devel perl wget
Lade NRPE herunter.
$ cd ~ $ wget https://github.com/NagiosEnterprises/nrpe/releases/download/nrpe-4.1.0/nrpe-4.1.0.tar.gz
Entpacke das Archiv.
$ tar zxf nrpe-*.tar.gz
Verschiebe das entpackte Verzeichnis in das Verzeichnis /usr/src.
$ sudo mv nrpe-4.1.0 /usr/src/nrpe
Wechsle in das NRPE-Verzeichnis.
$ cd /usr/src/nrpe
Konfiguriere und installiere NRPE.
$ sudo ./configure --enable-command-args $ sudo make all
Erstelle den Benutzer und die Gruppe.
$ sudo make install-groups-users
Installiere die NRPE Binaries, den NRPE Daemon und das check_npre Plugin.
$ sudo make install
Installiere die Konfigurationsdateien.
$ sudo make install-config
Aktualisiere die Servicedatei. Die Datei /etc/services wird verwendet, um Dienstnamen in Portnummern zu übersetzen.
$ sudo sh -c "echo >> /etc/services" $ sudo sh -c "sudo echo '# Nagios services' >> /etc/services" $ sudo sh -c "sudo echo 'nrpe 5666/tcp' >> /etc/services"
Installiere den NPRE Service Daemon.
$ sudo make install-init $ sudo systemctl enable nrpe
Du musst die NPRE-Konfigurationsdatei aktualisieren, die sich unter /usr/local/nagios/etc/nrpe.cfg befindet.
Öffne die Datei zur Bearbeitung.
$ sudo nano /usr/local/nagios/etc/nrpe.cfg
Standardmäßig hört NPRE nur auf Anfragen von Localhost (127.0.0.1). Du musst die IP-Adresse deines Nagios-Servers in die Datei eintragen.
allowed_hosts=127.0.0.1,10.25.5.2
Die folgende Option legt fest, ob der NPRE-Daemon den Clients erlaubt, Befehlsargumente anzugeben oder nicht. Erlaube die Option, indem du den Wert 1 eingibst, um erweiterte NPRE-Konfigurationen zu ermöglichen.
dont_blame_nrpe=1
Wenn du weiter nach unten scrollst, findest du eine Liste mit den NRPE-Befehlen und ihren Definitionen. Sie sind alle auskommentiert. Du musst sie auskommentieren, damit Nagios sie verwenden kann.
Jedem Befehl können Argumente übergeben werden. Einigen Befehlen sind Argumente vorangestellt, andere können Argumente vom Benutzer annehmen. Jeder Befehl kann die folgenden Benachrichtigungsoptionen haben.
- W steht für Warnende Servicezustände
- C steht für kritische Zustände des Dienstes
- R steht für notify on service recovering (OK states)
Du kannst also festlegen, auf welcher Ebene ein Befehl welche Art von Benachrichtigung senden kann. Wir werden hier nicht auf die detaillierte Beschreibung und Funktion der einzelnen Befehle eingehen, da sie den Rahmen dieses Tutorials sprengen würden.
# The following examples use hardcoded command arguments... # This is by far the most secure method of using NRPE command[check_users]=/usr/local/nagios/libexec/check_users -w 5 -c 10 command[check_load]=/usr/local/nagios/libexec/check_load -r -w .15,.10,.05 -c .30,.25,.20 command[check_hda1]=/usr/local/nagios/libexec/check_disk -w 20% -c 10% -p /dev/hda1 command[check_zombie_procs]=/usr/local/nagios/libexec/check_procs -w 5 -c 10 -s Z command[check_total_procs]=/usr/local/nagios/libexec/check_procs -w 150 -c 200 # The following examples allow user-supplied arguments and can # only be used if the NRPE daemon was compiled with support for # command arguments *AND* the dont_blame_nrpe directive in this # config file is set to '1'. This poses a potential security risk, so # make sure you read the SECURITY file before doing this. ### MISC SYSTEM METRICS ### command[check_users]=/usr/local/nagios/libexec/check_users $ARG1$ command[check_load]=/usr/local/nagios/libexec/check_load $ARG1$ command[check_disk]=/usr/local/nagios/libexec/check_disk $ARG1$ command[check_swap]=/usr/local/nagios/libexec/check_swap $ARG1$ command[check_cpu_stats]=/usr/local/nagios/libexec/check_cpu_stats.sh $ARG1$ command[check_mem]=/usr/local/nagios/libexec/custom_check_mem -n $ARG1$ ### GENERIC SERVICES ### command[check_init_service]=sudo /usr/local/nagios/libexec/check_init_service $ARG1$ command[check_services]=/usr/local/nagios/libexec/check_services -p $ARG1$ ### SYSTEM UPDATES ### command[check_yum]=/usr/local/nagios/libexec/check_yum #command[check_apt]=/usr/local/nagios/libexec/check_apt ### PROCESSES ### command[check_all_procs]=/usr/local/nagios/libexec/custom_check_procs command[check_procs]=/usr/local/nagios/libexec/check_procs $ARG1$ ### OPEN FILES ### command[check_open_files]=/usr/local/nagios/libexec/check_open_files.pl $ARG1$ ### NETWORK CONNECTIONS ### command[check_netstat]=/usr/local/nagios/libexec/check_netstat.pl -p $ARG1$ $ARG2$
Hebe die Kommentare zu den obigen Befehlen auf, indem du das Symbol # vor den Befehlen entfernst. Du kannst so viele Befehle auskommentieren, wie du brauchst.
Füge den folgenden Befehl hinzu, um den Speicherplatz im Stammverzeichnis zu überprüfen.
command[check_root]=/usr/lib64/nagios/plugins/check_disk -w 20% -c 10% -p /
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erlaube den Port 5666, der vom NPRE-Plugin verwendet wird.
$ sudo firewall-cmd --permanent --add-port=5666/tcp
Lade die Firewall neu.
$ sudo firewall-cmd --reload
Starte NPRE.
$ sudo systemctl start nrpe
Alle Befehle werden von nun an auf dem Nagios-Hauptserver ausgeführt, sofern nicht anders angegeben.
Überprüfe, ob NRPE funktioniert, indem du den folgenden Befehl auf deinem Haupt-Nagios-Server ausführst.
$ /usr/local/nagios/libexec/check_nrpe -H monitored_server_ip
Du solltest die folgende Ausgabe sehen.
NRPE v4.1.0
Um die Hosts zu überwachen, musst du Konfigurationsdateien für jeden Host erstellen, den du überwachen willst. Diese Hosts werden dann über die Nagios-Weboberfläche zugänglich.
Erstelle das Verzeichnis, in dem die Konfigurationsdateien gespeichert werden sollen, und gib ihm die entsprechenden Berechtigungen.
$ sudo mkdir /usr/local/nagios/etc/servers $ sudo chown -R nagios:nagios /usr/local/nagios/etc/servers $ sudo chmod g+w /usr/local/nagios/etc/servers
Öffne die Nagios-Konfigurationsdatei /usr/local/nagios/etc/nagios.cfg zur Bearbeitung.
$ sudo nano /usr/local/nagios/etc/nagios.cfg
Suche die folgende Datei und entkommentiere sie, indem du das vorangestellte # entfernst.
cfg_dir=/usr/local/nagios/etc/servers
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Im nächsten Schritt fügst du den Befehl check_nrpe zur Datei /usr/local/nagios/etc/objects/commands.cfg hinzu, damit er zur Überwachung von Hosts verwendet werden kann.
Öffne die Datei /usr/local/nagios/etc/objects/commands.cfg zum Bearbeiten.
$ sudo nano /usr/local/nagios/etc/objects/commands.cfg
Füge den folgenden Code am Ende der Datei ein.
define command {
command_name check_nrpe
command_line $USER1$/check_nrpe -H $HOSTADDRESS$ -t 30 -c $ARG1$ $ARG2$
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle eine neue Konfigurationsdatei für den Remote-Host im Verzeichnis /usr/local/nagios/etc/servers/.
$ sudo nano /usr/local/nagios/etc/servers/yourhost.cfg
Füge den folgenden Code hinzu, indem du den Wert host_name durch den Namen deines Remote-Hosts, den Wert alias durch die Beschreibung deines Hosts und den Wert address durch die IP-Adresse deines Remote-Hosts ersetzst.
define host {
use linux-server
host_name monitored_server_host_name
alias My client server
address monitored_server_private_ip
max_check_attempts 5
check_period 24x7
notification_interval 30
notification_period 24x7
}
Mit dieser Konfiguration teilt dir Nagios mit, ob der Host aktiv ist oder nicht. Du wirst weitere Dienste hinzufügen müssen, um zusätzliche Dinge zu überwachen.
Füge den folgenden Block hinzu, um die Verbindungsstatistiken des Hosts zu überprüfen.
define service {
use generic-service
host_name monitored_server_host_name
service_description PING
check_command check_ping!200.0,20%!400.0,90%
}
Füge den folgenden Block hinzu, um die durchschnittliche Auslastung deines Servers zu überwachen.
define service {
use generic-service
host_name monitored_server_host_name
service_description Load average
check_command check_nrpe!check_load!-a '-w 0.7,0.6,0.5 -c 0.9,0.8,0.7'
}
Die Direktive use generic-service weist Nagios an, von einer von Nagios vordefinierten Vorlage namens generic-service zu erben.
Als Nächstes fügst du einen Block hinzu, um die Festplattennutzung zu überwachen. Ändere den Befehl mit den entsprechenden Festplattenbezeichnungen.
define service {
use generic-service
host_name monitored_server_host_name
service_description /dev/vda1 free space
check_command check_nrpe!check_disk!-a '-w 20% -c 10% -p /dev/vda1'
}
Überwache SSH mit dem folgenden Block. Der folgende Block prüft den SSH-Server und erzeugt einen Alarm, wenn der Server nicht innerhalb von 5 Sekunden antwortet.
define service {
use generic-service
host_name monitored_server_host_name
service_description SSH Version Check
check_command check_ssh!-t 5
}
Lass uns die Gesamtzahl der laufenden Prozesse überprüfen.
define service{
use generic-service
host_name monitored_server_host_name
service_description Total Processes
check_command check_nrpe!check_total_procs
}
Überprüfe die aktuell angemeldeten Benutzer.
define service{
use generic-service
host_name monitored_server_host_name
service_description Current Users
check_command check_nrpe!check_users!-a '-w 5 -c 10'
}
Prüfe die Auslastung der SWAP-Festplatte.
define service{
use generic-service
host_name monitored_server_host_name
service_description SWAP Usage
check_command check_nrpe!check_swap!-a '-w 40% -c 20%'
}
Überprüfe die Root-Partition und ihre Festplattenbelegung.
define service{
use generic-service
host_name nagiosclient
service_description Root / Partition
check_command check_nrpe!check_disk!-a '-w 20% -c 10% -p /'
}
Prüfe, ob ein HTTP-Server installiert ist.
define service {
use generic-service
host_name nagiosclient
service_description HTTP
check_command check_http
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte Nagios neu.
$ sudo systemctl restart nagios
Monitore überprüfen
Öffne dein Nagios Dashboard und klicke auf die Option Hosts in der linken Seitenleiste. Du solltest den neu konfigurierten Host zusammen mit localhost auf der Seite sehen.
Klicke auf den neu konfigurierten Host(nagiosclient) und wenn alles richtig konfiguriert ist, solltest du seinen Status sehen. Es kann etwa eine Minute dauern, bis der Status erscheint.
Um die Dienste oder Monitore zu sehen, die wir konfiguriert haben, klicke auf die Option Statusdetails für diesen Host anzeigen und du solltest die folgende Seite sehen.
So bekommst du einen guten Überblick darüber, wie deine Hosts funktionieren.
Schritt 8 – Nginx installieren
Du kannst Nagios entweder direkt über die Server-IP laufen lassen oder es auf deinem Domainnamen hosten lassen. Nagios wird bereits mit Apache-Konfigurationsdateien ausgeliefert, aber wir werden Nginx verwenden, um es zu betreiben. Wir werden Nginx als Reverse Proxy vor dem Apache Webserver verwenden.
Apache läuft bereits auf Port 80. Deshalb müssen wir das zuerst ändern. Dann können wir Nginx als Proxy laufen lassen.
Öffne die Datei /etc/httpd/conf/httpd.conf zum Bearbeiten.
$ sudo nano /etc/httpd/conf/httpd.conf
Ändere die Zeile Listen 80 in Listen 8080. Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Da wir den Domänennamen für den Zugriff auf Nagios verwenden werden, müssen wir den Port 8080 nicht für den öffentlichen Zugriff öffnen.
Starte den Apache-Server neu.
$ sudo systemctl restart httpd
Als nächstes installierst du Nginx.
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zur Erstellung des offiziellen Nginx-Repositorys.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code in die Datei ein.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere den Nginx-Server.
$ sudo dnf install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.22.1
Aktiviere und starte den Nginx-Server.
$ sudo systemctl enable nginx --now
Schritt 9 – SSL installieren und konfigurieren
Bevor wir Nginx konfigurieren, müssen wir ein SSL-Zertifikat für die Domain einrichten und konfigurieren, die wir mit Nagios verwenden wollen. In unserem Fall werden wir http://nagios.example.com verwenden.
Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installiere den Snapd-Installer. Er benötigt das EPEL-Repository, das wir bereits installiert haben, also können wir das überspringen.
Installiere Snapd.
$ sudo dnf install -y snapd
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und stelle sicher, dass deine Snapd-Version auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Gib den folgenden Befehl ein, um Certbot zu installieren.
$ sudo snap install --classic certbot
Stelle mit folgendem Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe die Installation.
$ certbot --version certbot 2.3.0
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m admin@example.com -d nagios.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/nagios.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 10 – Nginx konfigurieren
Bevor wir Nginx konfigurieren, sollten wir noch eine weitere Änderung vornehmen. Standardmäßig stellt der Apache Nagios über http://<serverIP>:8080/nagios bereit. Jetzt können wir einen Proxy direkt für Nagios einrichten, aber es wird über https://nagios.example.com/nagios bedient. Wir können bei Nginx einen Redirect auf die Root-URL einrichten, was die Sache verkompliziert. Aus diesem Grund werden wir eine Änderung direkt bei Apache und Nagios vornehmen.
Öffne zunächst die Datei /usr/local/nagios/etc/cgi.cfg zum Bearbeiten.
$ sudo nano /usr/local/nagios/etc/cgi.cfg
Ändere url_html_path=/nagios in url_html_path=/.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Als Nächstes öffnest du /etc/httpd/conf.d/nagios.conf zur Bearbeitung.
$ sudo nano /etc/httpd/conf.d/nagios.conf
Ändere ScriptAlias /nagios/cgi-bin "/usr/local/nagios/sbin" in ScriptAlias /cgi-bin "/usr/local/nagios/sbin".
Kommentiere die Zeile Alias /nagios "/usr/local/nagios/share" aus, indem du sie in die folgende Zeile änderst.
#Alias /nagios "/usr/local/nagios/share"
Füge die folgende Zeile darunter ein.
DocumentRoot /usr/local/nagios/share
Füge die folgende Zeile am Anfang der Datei ein.
<VirtualHost *:8080>
Füge die folgende Zeile am Ende der Datei ein.
</VirtualHost>
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne zum Schluss die Datei /usr/local/nagios/share/config.inc.php zur Bearbeitung.
$ sudo nano /usr/local/nagios/share/config.inc.php
Ändere $cfg['cgi_base_url']='/nagios/cgi-bin'; in $cfg['cgi_base_url']='/cgi-bin';.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte sowohl Apache als auch Nagios neu.
$ sudo systemctl restart httpd $ sudo systemctl restart nagios
Um zu überprüfen, ob alles richtig funktioniert, öffne die URL http://<serverIP>:1080 in deinem Browser und du solltest sehen, dass Nagios richtig funktioniert. Vergewissere dich auch, dass die Daten der Hosts empfangen werden.
Wenn alles funktioniert, können wir mit der Erstellung unserer Konfigurationsdatei für Nginx fortfahren.
Erstelle eine Konfigurationsdatei für Nagios im Verzeichnis /etc/nginx/conf.d.
$ sudo nano /etc/nginx/conf.d/nagios.conf
Füge den folgenden Code in die Datei ein.
server {
listen 80; listen [::]:80;
server_name nagios.example.com;
return 301 https://$host$request_uri;
}
server {
server_name nagios.example.com;
listen 443 ssl http2;
listen [::]:443 ssl http2;
access_log /var/log/nginx/nagios.access.log;
error_log /var/log/nginx/nagios.error.log;
ssl_certificate /etc/letsencrypt/live/nagios.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/nagios.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/nagios.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Konfigurationsdatei.
$ sudo nginx -t
Wenn du die folgende Fehlermeldung erhältst, musst du die Datei /etc/nginx/nginx.conf bearbeiten, um die Größe der Variable server_names_hash_bucket_size hinzuzufügen/anzupassen.
nginx: [emerg] could not build the server_names_hash, you should increase server_names_hash_bucket_size
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor
server_names_hash_bucket_size 64;
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Überprüfe Nginx erneut.
Wenn du keine Probleme siehst, starte den Nginx-Server neu.
$ sudo systemctl restart nginx
SELinux konfigurieren
Wenn du SELinux aktiviert gelassen hast, führe den folgenden Befehl aus, um Nginx zu erlauben, sich mit dem Netzwerk zu verbinden.
$ sudo setsebool -P httpd_can_network_connect on
Starte die Domain https://nagios.example.com in deinem Browser und du solltest mit der Nagios-Homepage begrüßt werden.
Fazit
Du hast Nagios auf einem Rocky Linux 9 Server installiert und konfiguriert, um verschiedene Dienste wie Auslastung, Festplatten-/Swapnutzung, Benutzer, Gesamtprozesse, HTTP und SSH zu überwachen. Damit ist unser Tutorium abgeschlossen. Um mehr zu erfahren, solltest du die offizielle Nagios-Dokumentation lesen, in der die Überwachung und verschiedene Befehle ausführlich beschrieben werden. Wenn du Fragen hast, schreibe sie unten in die Kommentare.