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

  1. Ein Server, auf dem CentOS 8 läuft
  2. Ein Nicht-Sudo-Benutzer mit Root-Rechten.
  3. Deaktiviertes SELinux
  4. Ein weiterer Server mit CentOS 8, den du überwachen möchtest.
  5. 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.

PHP-Infoseite

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.

Nagios Homepage

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 [email protected]_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.

Nagios Host-Überwachung

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.

Nagios Host Details

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.

Nagios Dienst überwacht den Status

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 [email protected] 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.

Das könnte dich auch interessieren …