So installierst und konfigurierst du Nagios unter CentOS 8
Nagios ist ein beliebtes und eines der leistungsfähigsten Open-Source-Computerüberwachungssysteme. Es überwacht deine IT-Infrastruktur und stellt sicher, dass deine Netzwerke, Server, Anwendungen und Prozesse reibungslos funktionieren. 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 CentOS 8 basierten 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, auf dem CentOS 8 läuft
- Ein Nicht-Sudo-Benutzer mit Root-Rechten.
- Deaktiviertes SELinux
- Ein weiterer Server mit CentOS 8, den du überwachen möchtest.
- 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. Fedora Server wird mit der Firewall Firewalld ausgeliefert.
Ü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 systemctl reload firewalld
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 --now httpd
Um PHP zu installieren, verwenden wir das Remi Repository. Installiere Remi Repo und aktiviere PHP 7.4.
$ sudo dnf install dnf-utils http://rpms.remirepo.net/enterprise/remi-release-8.rpm
$ sudo dnf module reset php
$ sudo dnf module enable php:remi-7.4
Installiere PHP und einige gängige PHP-Module.
$ sudo dnf install php php-gd php-curl
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 Nagios auf deinem Hauptserver installieren und arbeiten.
Abhängigkeiten installieren
Für diesen Lehrgang müssen Nagios und seine Plugins aus dem Quellcode erstellt werden. Daher musst du zuerst einige Entwicklungsbibliotheken installieren.
$ sudo dnf install gcc glibc glibc-common gd gd-devel make net-snmp openssl-devel xinetd unzip wget gettext autoconf net-snmp-utils epel-release postfix automake
$ sudo dnf config-manager --enable powertools
$ sudo dnf install perl-Net-SNMP
Nagios herunterladen
Wechsle in das Verzeichnis /usr/src, wo wir die heruntergeladenen Nagios-Quelldateien ablegen werden.
$ cd /usr/src
Lade die neueste Version von Nagios von der Github-Seite herunter. Zum Zeitpunkt des Tutorials ist die Version 4.4.6 die letzte verfügbare Version. Ändere den Befehl, falls du eine andere Version möchtest.
$ sudo wget https://github.com/NagiosEnterprises/nagioscore/archive/nagios-4.4.6.tar.gz
Entpacke die tar-Datei.
$ sudo tar zxf nagios-*.tar.gz
Wechsle in das Nagios-Quellverzeichnis.
$ cd nagioscore-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.6 2020-04-28 ***:
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: /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 braucht 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. Erstelle dazu einen Admin-Benutzer namens nagiosadmin.
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
Starte den Server neu, damit die Konfiguration wirksam wird.
$ sudo systemctl restart httpd
Schritt 4 – Nagios Plugins installieren
Installiere die für die Nagios-Plugins erforderlichen Voraussetzungen.
$ sudo dnf install -y gcc glibc glibc-common make gettext automake autoconf wget openssl-devel net-snmp net-snmp-utils epel-release postgresql-devel libdbi-devel openldap-devel mysql-devel mysql-libs bind-utils samba-client fping openssh-clients lm_sensors
$ sudo dnf config-manager --enable powertools
$ sudo dnf install -y perl-Net-SNMP
Wechsle zurück in das Verzeichnis /usr/src.
$ cd /usr/src
Lade die neueste Version von Nagios von der Github-Seite herunter. Zum Zeitpunkt des Tutorials ist die Version 2.3.3 die letzte verfügbare Version. Ändere den Befehl, falls du eine andere Version möchtest.
$ sudo wget -O nagios-plugins.tar.gz https://github.com/nagios-plugins/nagios-plugins/releases/download/release-2.3.3/nagios-plugins-2.3.3.tar.gz
Entpacke die tar-Datei.
$ sudo tar zxf nagios-plugins.tar.gz
Wechsle in das Plugins-Verzeichnis.
$ cd 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
Wechsle in das Verzeichnis /usr/src.
$ cd /usr/src
Lade die neueste Version von NPRE von der Github-Seite herunter. Zum Zeitpunkt der Erstellung dieses Tutorials ist die neueste Version 4.0.3 verfügbar. Ändere den folgenden Befehl ab, falls du eine andere Version möchtest.
$ sudo wget https://github.com/NagiosEnterprises/nrpe/releases/download/nrpe-4.0.3/nrpe-4.0.3.tar.gz
Entpacke das Archiv.
$ sudo tar zxf nrpe-*.tar.gz
Wechsle in das NPRE-Verzeichnis.
$ cd nrpe-4.0.3
Konfiguriere und installiere das Plugin.
$ sudo ./configure
$ sudo make check_nrpe
$ sudo make install-plugin
Dadurch wird das Plugin check_nrpe im Verzeichnis /usr/local/nagios/libexec/ abgelegt.
Schritt 6 – Nagios starten
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 CentOS 8 basierten 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 Voraussetzungen, die für den NRPE-Daemon erforderlich sind.
$ sudo dnf install -y gcc glibc glibc-common openssl openssl-devel perl wget
Wechsle in das Verzeichnis /usr/src.
$ cd /usr/src
Lade NRPE herunter.
$ sudo wget https://github.com/NagiosEnterprises/nrpe/releases/download/nrpe-4.0.3/nrpe-4.0.3.tar.gz
Entpacke das Archiv.
$ sudo tar zxf nrpe-*.tar.gz
Wechsle in das NPRE-Verzeichnis.
$ cd nrpe-4.0.3
Konfiguriere und installiere NPRE.
$ sudo ./configure --enable-command-args
$ sudo make all
Erstelle den Benutzer und die Gruppe.
$ sudo make install-groups-users
Installiere die NPRE Binaries, den NPRE 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 Warnung
- C = steht für kritische Servicezustände
- 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 dies den Rahmen dieses Tutorials sprengen würde.
# 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 oben genannten Befehlen auf, indem du das Symbol # vor den Befehlen entfernst. Du kannst so viele Befehle auskommentieren, wie du möchtest.
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Lasse den Port 5666 zu, der vom NPRE-Plugin verwendet wird.
$ sudo firewall-cmd --permanent --add-port=5666/tcp
Lade die Firewall neu.
$ sudo systemctl reload firewalld
Starte NPRE.
$ sudo systemctl start nrpe
Alle Befehle werden ab jetzt 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.0.3
Um die Hosts zu überwachen, musst du für jeden Host, den du überwachen willst, eine Konfigurationsdatei erstellen. 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 zum Bearbeiten. 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, wann der Host hoch- oder heruntergefahren ist. 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 client01
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-servicezu erben.
Als Nächstes fügst du einen Block hinzu, um die Festplattenauslastung zu überwachen.
define service {
use generic-service
host_name monitored_server_host_name
service_description /dev/sda1 free space
check_command check_nrpe!check_disk!-a '-w 20% -c 10% -p /dev/sda1'
}
Als nächstes können wir den HTTP-Dienst mit dem folgenden Codeblock überwachen.
define service {
use generic-service
host_name monitored_server_host_name
service_description HTTP
check_command check_http
}
Überwache SSH mit dem folgenden Block. Der folgende Block überprüft den SSH-Server und erzeugt eine Warnung, wenn der Server nicht innerhalb von 5 Sekunden antwortet.
define service {
use generic-service
host_name nagiosclient
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'
}
Überprüfe die Root-Partition und ihre Festplattenauslastung.
define service{
use generic-service
host_name monitored_server_host_name
service_description Root / Partition
check_command check_nrpe!check_root
}
Überprü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%'
}
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.
In unserem Fall haben wir keinen Swap-Speicher konfiguriert und erhalten daher den kritischen Status für den Service, da der Swap-Speicherplatz auf 0 steht. Das sollte dir einen guten Überblick darüber verschaffen, wie deine Hosts funktionieren.
Schritt 8 – Nginx installieren und konfigurieren
Du kannst Nagios entweder direkt über die Server-IP laufen lassen oder es auf deiner eigenen Domain 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.
Füge die neue IP-Adresse zu deiner Firewall hinzu.
$ sudo firewall-cmd --permanent --add-port=8080/tcp
$ sudo systemctl reload firewalld
Starte den Apache-Server neu.
$ sudo systemctl restart httpd
Als nächstes installierst du Nginx.
CentOS 8 wird standardmäßig mit Nginx 1.14 ausgeliefert, aber das ist eine alte Version. Wir können auch die neueste Version aktivieren.
$ sudo dnf module enable nginx:1.20
$ sudo dnf install nginx
Aktiviere den Nginx-Server.
$ sudo systemctl enable nginx
Schritt 8a – 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.
Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot herunterladen. Certbot ist im EPEL-Repository von CentOS verfügbar, das wir bereits zu Beginn des Lehrgangs hinzugefügt haben.
$ sudo dnf install certbot python3-certbot-nginx
Beende den Nginx-Dienst.
$ sudo systemctl stop nginx
Erstelle ein SSL-Zertifikat.
$ sudo certbot certonly --standalone --preferred-challenges --agree-tos --email admin@example.com http -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 einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.
$ sudo nano /etc/cron.daily/certbot-renew
Füge den folgenden Code ein.
#!/bin/sh
certbot renew --cert-name nagios.example.com --pre-hook "systemctl stop nginx" --post-hook "systemctl start nginx"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.
$ sudo chmod +x /etc/cron.daily/certbot-renew
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Bevor wir Nginx konfigurieren, sollten wir noch eine weitere Änderung vornehmen. Standardmäßig stellt der Apache Nagios über http://<serverIP>:8080/nagios bereit. Wir können nun einen Proxy einrichten, der Nagios direkt ansteuert, 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 *:1080>
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 X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
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.
$ sudo systemctl start nginx
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 CentOS 8 basierten Server installiert und konfiguriert, um verschiedene Dienste wie Auslastung, Festplatten-/Swapnutzung, Benutzer, Gesamtprozesse, HTTP und SSH zu überwachen. Damit ist unser Tutorium abgeschlossen. Wenn du mehr erfahren willst, 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.