So installierst und konfigurierst du Zabbix Server und Client auf Rocky Linux 9
Zabbix ist eine kostenlose und quelloffene Überwachungslösung für IT-Infrastrukturen wie Netzwerke, Server, virtuelle Maschinen und Cloud-Dienste. Ihr Kern ist in C und Java geschrieben, das Frontend in PHP. Das Frontend bietet eine webbasierte Oberfläche, mit der du Kennzahlen wie Netzwerkauslastung, CPU-Last, Festplattenspeicherplatz usw. verfolgen und überwachen und auf der Grundlage von benutzerdefinierten Auslösern Benachrichtigungen senden kannst.
Zabbix arbeitet nach dem Client/Server-Modell. Die für verschiedene Betriebssysteme verfügbaren Clients oder Agenten kontaktieren den Server, um die Daten zu senden. Für Systeme ohne Agenten bietet Zabbix die Möglichkeit, allgemeine Überwachungsprotokolle wie das Simple Network Management Protocol (SNMP) oder das Intelligent Platform Management Interface (IPMI) zu verwenden.
In diesem Tutorial lernst du, wie du den Zabbix Server und den Client auf einem Rocky Linux 9 Server installierst.
Voraussetzungen
- Zwei Server mit Rocky Linux 9, von denen einer als Server und der andere als Client fungiert, den wir über den Server überwachen werden.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Fully Qualified Domain Name (FQDN) wie
zabbix.example.com, der auf deinen Server zeigt. - Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun.
- Alles ist auf dem neuesten Stand.
$ sudo dnf update
- Damit das Tutorial und der Zabbix Server laufen, sind einige wichtige Pakete erforderlich. Einige davon befinden sich bereits auf deinem Server.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --permanent --list-services
Es sollte die folgende Ausgabe angezeigt werden.
cockpit dhcpv6-client ssh
Die offenen Ports 10050 und 10051 werden vom Zabbix-Server benötigt, um sich mit dem Agenten zu verbinden.
$ sudo firewall-cmd --add-port={10051/tcp,10050/tcp} --permanent
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-all
Du solltest eine ähnliche Ausgabe sehen.
public target: default icmp-block-inversion: no interfaces: sources: services: cockpit dhcpv6-client http https ssh ports: 10051/tcp 10050/tcp protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
Schritt 2 – SELinux auf permissiven Modus einstellen
Konfiguriere SELinux so, dass es im permissiven Modus arbeitet. In diesem Modus blockiert SELinux keinen Prozess, sondern protokolliert alles in der Audit-Log-Datei. Dies werden wir später nutzen, um SELinux-Regeln einzurichten.
$ sudo setenforce 0 && sudo sed -i 's/^SELINUX=.*/SELINUX=permissive/g' /etc/selinux/config
Überprüfe den SELinux-Status.
$ sestatus SELinux status: enabled SELinuxfs mount: /sys/fs/selinux SELinux root directory: /etc/selinux Loaded policy name: targeted Current mode: permissive Mode from config file: permissive Policy MLS status: enabled Policy deny_unknown status: allowed Memory protection checking: actual (secure) Max kernel policy version: 33
Schritt 3 – Nginx und PHP-Repository konfigurieren
Das Zabbix-Paket installiert automatisch PHP und Nginx. Allerdings greift es auf ältere Versionen zurück. Deshalb müssen wir sicherstellen, dass der Prozess die neueste verfügbare Version installiert.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.
$ 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
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Aktiviere das Nginx Mainline Repository.
$ sudo dnf config-manager --enable nginx-mainline
Als nächstes müssen wir das PHP-Repository konfigurieren.
Der erste Schritt besteht darin, das Epel-Repository zu übernehmen.
$ sudo dnf install epel-release -y
Als nächstes installierst du das Remi-Repository.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Prüfe, ob PHP-Streams verfügbar sind.
$ dnf module list php -y Name Stream Profiles Summary php 8.1 common [d], devel, minimal PHP scripting language Remi's Modular repository for Enterprise Linux 9 - x86_64 Name Stream Profiles Summary php remi-7.4 common [d], devel, minimal PHP scripting language php remi-8.0 common [d], devel, minimal PHP scripting language php remi-8.1 common [d], devel, minimal PHP scripting language php remi-8.2 common [d], devel, minimal PHP scripting language php remi-8.3 common [d], devel, minimal PHP scripting language Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
Die Standardversion ist 8.1. Zum Zeitpunkt der Erstellung dieses Tutorials ist Zabbix mit PHP 8.2 kompatibel. Aktiviere daher das PHP 8.2 Repository von Remi. Die nächste Version von Zabbix wird PHP 8.3 unterstützen, also kannst du es aktivieren, wenn deine Zabbix-Version 6.0.26 oder höher ist.
$ sudo dnf module reset php -y $ sudo dnf module enable php:remi-8.2
Jetzt können wir mit der Installation von Zabbix fortfahren.
Schritt 4 – Zabbix Server installieren
Die Zabbix-Pakete werden standardmäßig im EPEL-Repository bereitgestellt. Bevor wir mit der Installation fortfahren, müssen wir sie deaktivieren. Öffne die /etc/yum.repos.d/epel.repo zur Bearbeitung und füge die folgende Zeile unter dem Abschnitt [epel] hinzu.
[epel] ... excludepkgs=zabbix*
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Die neueste Version von Zabbix ist 6.4.x, aber wir werden die LTS-Version (Long-term support) verwenden, die für eine Produktionsumgebung viel stabiler ist.
Installiere das Repository von Zabbix.
$ sudo rpm -Uvh https://repo.zabbix.com/zabbix/6.0/rhel/9/x86_64/zabbix-release-6.0-4.el9.noarch.rpm
Entferne den gesamten RPM-Cache.
$ sudo dnf clean all
Installiere Zabbix Server, Frontend und Agent. Wir werden den PostgreSQL-Server für unsere Zwecke verwenden und benötigen daher das Paket zabbix-web-pgsql. Wenn du einen MySQL/MariaDB/Percona-Server verwendest, musst du das Paket zabbix-web-mysql installieren.
$ sudo dnf install zabbix-server-pgsql zabbix-web-pgsql zabbix-nginx-conf zabbix-sql-scripts zabbix-selinux-policy zabbix-agent
Schritt 5 – PostgreSQL installieren und konfigurieren
Zabbi funktioniert mit PostgreSQL 13 und höher. Rocky Linux 9 wird standardmäßig mit PostgreSQL 13 ausgeliefert. Für unser Tutorial werden wir jedoch PostgreSQL 16 verwenden.
Installiere die RPM-Datei des PostgreSQL-Repositorys.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Deaktiviere das integrierte PostgreSQL-Modul.
$ sudo dnf -qy module disable postgresql
Jetzt kannst du PostgreSQL mit dem unten stehenden Befehl installieren.
$ sudo dnf install -y postgresql16-server postgresql16-contrib
Initialisiere die Datenbank.
$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb
Aktiviere den PostgreSQL-Dienst.
$ sudo systemctl enable postgresql-16
Starte den PostgreSQL-Dienst.
$ sudo systemctl start postgresql-16
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql-16
? postgresql-16.service - PostgreSQL 16 database server
Loaded: loaded (/usr/lib/systemd/system/postgresql-16.service; enabled; preset: disabled)
Active: active (running) since Thu 2024-01-18 14:54:46 UTC; 10s ago
Docs: https://www.postgresql.org/docs/16/static/
Process: 3407 ExecStartPre=/usr/pgsql-16/bin/postgresql-16-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
Main PID: 3412 (postgres)
Tasks: 7 (limit: 24694)
Memory: 17.4M
CPU: 117ms
CGroup: /system.slice/postgresql-16.service
??3412 /usr/pgsql-16/bin/postgres -D /var/lib/pgsql/16/data/
??3413 "postgres: logger "
??3414 "postgres: checkpointer "
??3415 "postgres: background writer "
??3417 "postgres: walwriter "
??3418 "postgres: autovacuum launcher "
??3419 "postgres: logical replication launcher "
Erstelle den Zabbix-Datenbankbenutzer.
$ sudo -u postgres createuser --pwprompt zabbix
Du wirst zur Eingabe des Passworts aufgefordert.
Enter password for new role: Enter it again:
Erstelle die Zabbix-Datenbank.
$ sudo -u postgres createdb -O zabbix zabbix
Importiere das Anfangsschema und die Datenbankdaten. Du wirst erneut nach deinem Passwort gefragt.
$ zcat /usr/share/zabbix-sql-scripts/postgresql/server.sql.gz | sudo -u zabbix psql zabbix
Dieser Vorgang kann ein paar Minuten dauern.
Öffne die Datei /etc/zabbix/zabbix_server.conf zum Bearbeiten.
$ sudo nano /etc/zabbix/zabbix_server.conf
Suche die Variable DBPassword, entferne das Rautezeichen (#) davor und setze den Wert auf das im vorherigen Schritt gewählte Passwort.
DBPassword=psqlpassword
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starten und aktivieren Sie den Zabbix-Server und die Agentendienste.
$ sudo systemctl enable zabbix-server zabbix-agent --now
Schritt 6 – PHP konfigurieren
Zabbix installiert die PHP- und Nginx-Konfigurationsdateien, die wir verwenden werden. Bevor wir sie verwenden können, müssen wir jedoch noch einige Änderungen vornehmen.
Zuerst müssen wir /etc/php-fpm.d/zabbix.conf zum Bearbeiten öffnen.
$ sudo nano /etc/php-fpm.d/zabbix.conf
Ändere die Werte von user = apache und group = apache in nginx, wie unten gezeigt.
user = nginx group = nginx
Da wir Nginx aus dem offiziellen Repository verwenden, läuft es unter dem Benutzer nginx und nicht unter apache, dem Benutzer, unter dem die Distributionskopie von Nginx läuft.
Du kannst hier auch alle anderen PHP-bezogenen Werte bearbeiten oder eigene Definitionen hinzufügen. Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte und aktiviere den PHP-FPM-Dienst.
$ sudo systemctl enable php-fpm --now
Schritt 7 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installierst du den Snapd-Installer. Er benötigt das EPEL (Extra Packages for Enterprise Linux) Repository, um zu funktionieren. Da wir es aber bereits in Schritt 3 installiert haben, können wir direkt fortfahren.
Installiere Snapd.
$ sudo dnf install -y snapd
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und vergewissere dich, dass deine Version von Snapd 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
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden 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, ob Certbot richtig funktioniert.
$ certbot --version certbot 2.8.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 name@example.com -d zabbix.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/zabbix.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungszeitplanungsdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ------------------------------------------------------------------------------------------------------------------------------------- Sat 2024-01-20 10:04:02 UTC 1min 32s left Sat 2024-01-20 08:52:11 UTC 1h 10min ago dnf-makecache.timer dnf-makecache.service Sun 2024-01-21 00:00:00 UTC 13h left Sat 2024-01-20 00:00:10 UTC 10h ago logrotate.timer logrotate.service Sat 2024-01-20 21:13:00 UTC 11h left Sat 2024-01-20 08:19:11 UTC 1h 43min ago snap.certbot.renew.timer snap.certbot.renew.service
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 8 – Nginx konfigurieren
Zabbix installiert eine Standardkonfigurationsdatei für Nginx. Wir müssen sie bearbeiten, um den Code für die Aktivierung von SSL-Zertifikaten hinzuzufügen. Außerdem müssen wir den Port listen ändern und den Code für die Umleitung von HTTP-Links auf HTTPS hinzufügen.
Öffne die Datei /etc/nginx/conf.d/zabbix.conf, um sie zu bearbeiten.
$ sudo nano /etc/nginx/conf.d/zabbix.conf
Bearbeite den Code so, dass die Datei wie folgt aussieht.
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
root /usr/share/zabbix;
index index.php;
access_log /var/log/nginx/zabbix.access.log;
error_log /var/log/nginx/zabbix.error.log;
ssl_certificate /etc/letsencrypt/live/zabbix.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/zabbix.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/zabbix.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
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_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location = /favicon.ico {
log_not_found off;
}
location / {
try_files $uri $uri/ =404;
}
location /assets {
access_log off;
expires 10d;
}
location ~ /\.ht {
deny all;
}
location ~ /(api\/|conf[^\.]|include|locale) {
deny all;
return 404;
}
location /vendor {
deny all;
return 404;
}
location ~ [^/]\.php(/|$) {
fastcgi_pass unix:/run/php-fpm/zabbix.sock;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_index index.php;
fastcgi_param DOCUMENT_ROOT /usr/share/zabbix;
fastcgi_param SCRIPT_FILENAME /usr/share/zabbix$fastcgi_script_name;
fastcgi_param PATH_TRANSLATED /usr/share/zabbix$fastcgi_script_name;
include fastcgi_params;
fastcgi_param QUERY_STRING $query_string;
fastcgi_param REQUEST_METHOD $request_method;
fastcgi_param CONTENT_TYPE $content_type;
fastcgi_param CONTENT_LENGTH $content_length;
fastcgi_intercept_errors on;
fastcgi_ignore_client_abort off;
fastcgi_connect_timeout 60;
fastcgi_send_timeout 180;
fastcgi_read_timeout 180;
fastcgi_buffer_size 128k;
fastcgi_buffers 4 256k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name zabbix.example.com;
return 301 https://$host$request_uri;
}
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf, um sie zu bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe deine Nginx-Konfiguration.
$ sudo nginx -t
Starte und aktiviere den Nginx-Dienst.
$ sudo systemctl enable nginx --now
Schritt 9 – Zugriff auf das Zabbix-Frontend
Bevor du das Zabbix-Frontend installierst, musst du die Rechte für das Verzeichnis /etc/zabbix/web so einstellen, dass Nginx darauf zugreifen kann.
$ sudo chown -R nginx:nginx /etc/zabbix/web
Öffne die URL https://zabbix.example.com in deinem Browser und du erhältst den folgenden Bildschirm.
Klicke auf die Schaltfläche Nächster Schritt, um die Installation von Zabbix abzuschließen. Auf der nächsten Seite wird geprüft, ob die Systemanforderungen erfüllt sind.
Wenn es keine Probleme gibt, klicke auf die Schaltfläche Nächster Schritt, um fortzufahren. Als Nächstes wirst du aufgefordert, deine Datenbank-Anmeldedaten einzugeben. Entferne das Häkchen bei der Option Datenbank-TLS-Verschlüsselung, da wir sie nicht konfiguriert haben.
Klicke auf die Schaltfläche “ Nächster Schritt „, um fortzufahren. Gib den Namen deines Zabbix-Servers ein. Er ist zwar optional, aber wenn er konfiguriert ist, wird er in der Menüleiste und den Seitentiteln angezeigt.
Klicke auf die Schaltfläche Nächster Schritt, um fortzufahren. Du wirst aufgefordert, alle Einstellungen zu bestätigen.
Wenn alles in Ordnung ist, klicke auf die Schaltfläche Nächster Schritt, um fortzufahren. Du solltest eine Meldung sehen, die dir mitteilt, dass die Installation erfolgreich war.
Klicke auf die Schaltfläche Fertig stellen, um den Vorgang abzuschließen. Du wirst zur Anmeldeseite weitergeleitet.
Der Standardbenutzername ist Admin und das Passwort lautet zabbix. Gib die Anmeldedaten ein und klicke auf die Schaltfläche Anmelden, um auf das Zabbix-Dashboard zuzugreifen.
Schritt 10 – SELinux konfigurieren
Aktiviere den HTTP-Daemon für die Verbindung mit Zabbix.
$ sudo setsebool -P httpd_can_connect_zabbix 1
Erlaube Zabbix, sich mit allen TCP-Ports zu verbinden.
$ sudo setsebool -P zabbix_can_network on
Aktiviere die daemons_enable_cluster_mode, um Fehler des HA-Managers zu vermeiden.
$ sudo setsebool -P daemons_enable_cluster_mode on
Erstelle ein benutzerdefiniertes SELinux-Richtlinienpaket unter Verwendung des Audit-Logs.
$ sudo grep "denied.*zabbix" /var/log/audit/audit.log | audit2allow -M zabbix_policy ******************** IMPORTANT *********************** To make this policy package active, execute: semodule -i zabbix_policy.pp
Installiere das erstellte benutzerdefinierte SELinux-Richtlinienpaket.
$ sudo semodule -i zabbix_policy.pp
Führe den Befehl zur Überprüfung auf Datenbankfehler aus.
$ sudo sealert -a /var/log/audit/audit.log
Es wird dir eine Reihe von Regeln vorschlagen, die du anwenden kannst.
Führe die folgenden Befehle aus.
$ sudo ausearch -c 'php-fpm' --raw | audit2allow -M my-phpfpm $ sudo semodule -X 300 -i my-phpfpm.pp $ sudo ausearch -c 'zabbix_agentd' --raw | audit2allow -M my-zabbixagentd $ sudo semodule -X 300 -i my-zabbixagentd.pp
Wende die Richtlinie an, um Nginx den Zugriff auf PostgreSQL zu ermöglichen.
$ sudo setsebool -P httpd_can_network_connect_db 1
Wende die Richtlinie an, um Verbindungen zu externen Hosts zuzulassen.
$ sudo setsebool -P httpd_can_network_connect 1
Setze SELinux in den erzwingenden Modus.
$ sudo setenforce 1 && sudo sed -i 's/^SELINUX=.*/SELINUX=enforcing/g' /etc/selinux/config
Schritt 11 – Zabbix Agent auf einem entfernten System installieren
Die Hauptaufgabe des Zabbix-Agenten ist es, Informationen aus dem System zu sammeln und sie zur Analyse an den zentralen Zabbix-Server zu senden. Wir werden den Agenten auf einem Rocky Linux 9 System installieren, aber du kannst das auf jeder Distribution tun.
Schritt 11.1 – Firewall auf dem entfernten System konfigurieren
Öffne Port 10050, damit sich der Zabbix-Agent mit dem Server verbinden kann.
$ sudo firewall-cmd --add-port=10050/tcp --permanent --zone=public $ sudo firewall-cmd --reload
Schritt 11.2 – Zabbix-Agent installieren
Du musst Schritt 4 bis auf die letzte Installationsanweisung wiederholen. Das heißt, du bearbeitest die Datei /etc/yum.repos.d/epel.repo und fügst die folgende Zeile in den Abschnitt [epel] ein.
[epel] ... excludepkgs=zabbix*
Als Nächstes installierst du das Zabbix-Repository und leerst den RPM-Cache.
$ sudo rpm -Uvh https://repo.zabbix.com/zabbix/6.0/rhel/9/x86_64/zabbix-release-6.0-4.el9.noarch.rpm $ sudo dnf clean all
Installiere den Zabbix-Agenten.
$ sudo dnf install zabbix-agent
Schritt 11.3 Zabbix-Agent konfigurieren
Zabbix unterstützt zertifikatsbasierte Verschlüsselung, aber der Einfachheit halber werden wir in diesem Tutorial Pre-Shared Keys (PSK) verwenden, um die Verbindung zwischen Server und Agent zu sichern.
Erstelle eine PSK-Datei.
$ sudo sh -c "openssl rand -hex 32 > /etc/zabbix/zabbix_agentd.psk"
Zeige den Schlüssel zum Kopieren an.
$ cat /etc/zabbix/zabbix_agentd.psk 797c84746dfe86f71b0f207785906d2bb886be27149b296d86df6b1ec9de6bbe
Kopiere diesen Schlüssel, denn wir werden ihn später brauchen.
Der Zabbix-Agent speichert seine Konfiguration in der Datei /etc/zabbix/zabbix-agentd.conf. Öffne sie zum Bearbeiten.
$ sudo nano /etc/zabbix/zabbix_agentd.conf
Hebe die Kommentare zu den folgenden Variablen auf und aktualisiere ihre Werte wie unten gezeigt.
Server=<zabbix_server_IP> ServerActive=<zabbix_server_IP> HostMetadata=ZabbixLinuxClient Hostname=zabbixclient.example.com
Setze die IP-Adresse deines Zabbix-Servers als Wert für die Variablen Server und ServerActive ein. Die Variable HostMetadata kann alles sein, was du zur Identifizierung des Systems verwenden kannst. Sie wird auch für die automatische Registrierung im Zabbix-Frontend verwendet, auf die wir später noch eingehen werden. Das Element Hostname bezieht sich auf den System-Hostnamen des Zabbix-Agentenknotens.
Du kannst den Hostnamen mit dem folgenden Befehl herausfinden.
$ cat /etc/hostname
Als Nächstes suchst du den Abschnitt, der eine sichere Verbindung zwischen dem Server und dem Agenten konfiguriert. Suche die Variable TLSConnect und ändere ihren Wert von unencrypted in psk, wie unten gezeigt.
... ### Option: TLSConnect # How the agent should connect to server or proxy. Used for active checks. # Only one value can be specified: # unencrypted - connect without encryption # psk - connect using TLS and a pre-shared key # cert - connect using TLS and a certificate # # Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection) # Default: # TLSConnect=psk ...
Als Nächstes suchst du den Abschnitt TLSAccept und änderst seinen Wert in psk (siehe unten).
... ### Option: TLSAccept # What incoming connections to accept. # Multiple values can be specified, separated by comma: # unencrypted - accept connections without encryption # psk - accept connections secured with TLS and a pre-shared key # cert - accept connections secured with TLS and a certificate # # Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection) # Default: # TLSAccept=psk ...
Als Nächstes suchst du den Abschnitt TLSPSKIdentity und änderst seinen Wert in PSK 001 (siehe Abbildung).
... ### Option: TLSPSKIdentity # Unique, case sensitive string used to identify the pre-shared key. # # Mandatory: no # Default: # TLSPSKIdentity=PSK 001 ...
Dies ist die PSK-ID, die du verwenden wirst, um den Host über das Zabbix-Webfrontend hinzuzufügen.
Schließlich suchst du den Abschnitt TLSPSKFile und änderst den Wert in den Speicherort der PSK-Datei (siehe Abbildung).
... ### Option: TLSPSKFile # Full pathname of a file containing the pre-shared key. # # Mandatory: no # Default: # TLSPSKFile=/etc/zabbix/zabbix_agentd.psk ...
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 11.4 – Zabbix-Agent starten
Starte und aktiviere den Zabbix-Agentendienst.
$ sudo systemctl enable zabbix-agent --now
Schritt 12 – Hinzufügen des Zabbix-Clients zum Zabbix-Frontend für die Überwachung
Wir können einen neuen Host zu den bestehenden definierten Hostgruppen hinzufügen oder eine neue Hostgruppe erstellen. Mit Hostgruppen kannst du die Arten von Knoten, die du überwachen willst, kategorisieren. Um eine neue Hostgruppe zu erstellen, öffnest du die Option Hostgruppen im Menü Konfiguration.
Gib den Namen der Gruppe in das Feld ein und klicke auf die Schaltfläche Übernehmen, um die Gruppe zu erstellen.
Um einen neuen Host zu erstellen, klicke auf die Option Hosts im Menü Konfiguration und dann auf die Schaltfläche Host erstellen oben rechts.
Füge den Hostnamen des Zabbix-Knotens hinzu.
Gib Linux by Zabbix agent im Abschnitt Vorlagen ein und wähle die Vorlage aus dem Dropdown-Menü.
Gib im Abschnitt Gruppen den Eintrag Linux Server ein und wähle ihn aus.
Klicke auf die Schaltfläche Hinzufügen im Abschnitt Schnittstellen und wähle Agent.
Füge dann die IP-Adresse des Zabbix-Client-Knotens hinzu. Wenn du fertig bist, sollte das vollständige Popup “ Neuer Host “ wie folgt aussehen.
Als Nächstes wechselst du zur Registerkarte Verschlüsselung. Wähle PSK für die Optionen “ Verbindungen zum Host “ und “ Verbindungen vom Host „. Setze die PSK-Identität auf PSK 001. Das ist der Wert, den wir in Schritt 11.3 für die Variable TLSPSKIdentity festgelegt haben. Lege dann als PSK-Wert den Schlüssel fest, den du zuvor auf dem Agentenrechner erzeugt hast.
Wenn du fertig bist, klicke auf die Schaltfläche Hinzufügen, um das Hinzufügen des Hosts abzuschließen.
Du solltest den neuen Host in der Liste mit einer grünen Markierung sehen, die anzeigt, dass der Agent mit dem Server verbunden ist und wie erwartet funktioniert.
Schritt 13 – E-Mail-Benachrichtigungen konfigurieren
Zabbix unterstützt viele Arten von Benachrichtigungen wie E-Mail, Slack, Telegram, SMS, etc. Für unser Tutorial werden wir E-Mail-Benachrichtigungen konfigurieren. Besuche das Zabbix-Front-End, klicke auf Verwaltung und dann auf Medientypen im linken Menü. Du siehst zwei E-Mail-Typen, einen für Klartext-E-Mails und einen für HTML-E-Mails.
Klicke auf die Option E-Mail (HTML) und du wirst die folgende Seite sehen.
Gib die Daten deines SMTP-Servers ein. Für unseren Lehrgang verwenden wir den Amazon SES-Dienst. Klicke auf die Schaltfläche Aktualisieren, wenn du fertig bist, um die Angaben zu speichern. Du kommst zurück zur Seite Medientypen. Klicke auf der Seite auf die Schaltfläche Testen, um die E-Mail-Einstellungen zu testen. Es wird ein Popup-Fenster geöffnet. Gib deine E-Mail-Adresse ein und klicke auf die Schaltfläche Testen, um eine Test-E-Mail zu versenden.
Du solltest eine Erfolgsmeldung auf dem Popup sehen, die dir mitteilt, dass es geklappt hat, und du solltest die folgende E-Mail in deinem Posteingang erhalten. Schließe das Popup-Fenster, indem du auf die Schaltfläche Abbrechen klickst.
Schritt 14 – Einen neuen Benutzer anlegen
Der Standardbenutzer von Zabbix ist nicht so konfiguriert, dass er irgendwelche Benachrichtigungen erhält. Das können wir zwar tun, aber der Standardbenutzer ist auch unsicher in der Benutzung. Am besten legst du einen neuen Benutzer an und deaktivierst dann den Standardbenutzer.
Besuche den Abschnitt Verwaltung >> Benutzer im Menü und klicke oben rechts auf die Schaltfläche Benutzer erstellen, um die folgende Seite zu öffnen.
Fülle die Benutzerdetails aus. Wähle Zabbix-Administratoren als Benutzergruppe aus. Wenn du fertig bist, klicke auf die Registerkarte Medien. Klicke auf die Schaltfläche Hinzufügen und wähle als Typ E-Mail (HTML).
Gib deine E-Mail-Adresse in das Feld Senden an ein und klicke auf die Schaltfläche Hinzufügen, um die E-Mail-Option hinzuzufügen. Wechsle dann zur Registerkarte Berechtigungen und klicke auf die Schaltfläche Auswählen, um die Rolle Superadmin hinzuzufügen.
Klicke auf die Schaltfläche Hinzufügen, um das Hinzufügen des Benutzers abzuschließen. Als Nächstes musst du dich vom Frontend abmelden, dich als neuer Benutzer wieder anmelden und zur Benutzerseite zurückkehren. Klicke auf den Benutzer Admin, wähle die Gruppe Deaktiviert und aktualisiere den Benutzer. Dadurch wird die Verwendung des Standardbenutzers deaktiviert.
Schritt 15 – Sende eine Testmeldung
Standardmäßig überwacht Zabbix den freien Speicherplatz auf dem Server. Es erkennt alle Festplatteneinhängungen und führt regelmäßig Überprüfungen durch.
Der erste Schritt besteht darin, den Benachrichtigungs-Trigger zu aktivieren, der es Zabbix ermöglicht, Benachrichtigungen an alle Administratoren zu senden. Zabbix hat den Standard-Trigger bereits konfiguriert. Wir müssen ihn aktivieren, damit er funktioniert. Gehe zu Konfiguration >> Aktionen >> Trigger-Aktionen und ändere den Status von Deaktiviert in Aktiviert (siehe Abbildung).
Als Nächstes meldest du dich am Zabbix-Knoten an und erstellst eine temporäre Datei, die groß genug ist, um eine Warnung zur Festplattennutzung auszulösen.
Ermitteln Sie zunächst den freien Speicherplatz auf dem Server.
$ df -h Filesystem Size Used Avail Use% Mounted on devtmpfs 4.0M 0 4.0M 0% /dev tmpfs 2.0G 0 2.0G 0% /dev/shm tmpfs 780M 51M 730M 7% /run /dev/vda2 94G 12G 78G 13% / /dev/vda1 260M 7.0M 253M 3% /boot/efi tmpfs 390M 4.0K 390M 1% /run/user/1001
Dies zeigt, dass wir etwa 78 GB freien Speicherplatz haben. Als Nächstes verwendest du den Befehl fallocate, um mehr als 80 % des Speicherplatzes vorab zuzuweisen. Das ist groß genug, um den Alarm auszulösen.
$ fallocate -l 74G /tmp/temp.img
Überprüfe die Festplattennutzung erneut.
$ df -h Filesystem Size Used Avail Use% Mounted on devtmpfs 4.0M 0 4.0M 0% /dev tmpfs 2.0G 0 2.0G 0% /dev/shm tmpfs 780M 54M 726M 7% /run /dev/vda2 94G 86G 3.9G 96% / /dev/vda1 260M 7.0M 253M 3% /boot/efi tmpfs 390M 4.0K 390M 1% /run/user/1001
Zabbix löst einen Alarm über den Speicherplatz aus und sendet eine E-Mail-Benachrichtigung darüber. Die E-Mail sieht wie die folgende aus.
Du kannst auch im Dashboard nach der Warnung suchen, die innerhalb weniger Sekunden erscheinen sollte.
Lösche die temporäre Datei, wenn du fertig bist.
$ rm -f /tmp/temp.img
Du solltest eine weitere E-Mail erhalten, die dich darüber informiert, dass das Problem behoben wurde.
Schritt 16 – Automatische Registrierung für Linux-Knoten konfigurieren
Wenn du mehrere Knoten zum Zabbix-Server hinzufügen musst, kann der Prozess etwas mühsam werden. Zum Glück kannst du den Prozess mit dem Zabbix-Frontend automatisieren, indem du die automatische Registrierung nutzt.
Gehe zu Aktionen >> Autoregistrierungsaktionen und klicke oben rechts auf die Schaltfläche Aktion erstellen.
In der neuen Maske gibst du der Aktion einen Namen(Automatische Registrierung von Linux-Servern).
Klicke auf die Schaltfläche Hinzufügen unter Bedingungen, um eine Bedingung hinzuzufügen und wähle Host-Metadaten als Typ, enthält als Operator und Linux als Wert.
Klicke auf Hinzufügen, um fortzufahren und die Seite zum Erstellen der Aktion sollte wie folgt aussehen.
Klicke auf die Registerkarte Vorgänge, wähle als Vorgang Zu Hostgruppe hinzufügen und wähle Linux-Server als Hostgruppen. Klicke auf die Schaltfläche Hinzufügen, um den Vorgang abzuschließen.
Wenn du die PSK-Verschlüsselung verwenden möchtest, kannst du auch das konfigurieren. Gehe in das Menü Verwaltung >> Allgemein >> Autoregistrierung und aktiviere beide Verschlüsselungsoptionen. Gib eine PSK-ID und einen PSK-Schlüssel ein, die auf dem Zabbix-Server erstellt wurden. Du kannst diese PSK-ID und diesen Schlüssel auf jedem Knoten verwenden und sie werden mit diesen Werten verschlüsselt.
Von nun an wird der Zabbix-Agent jedes Mal, wenn du ihn auf einem Linux-Server installierst und konfigurierst, automatisch zum Zabbix-Frontend hinzugefügt.
Fazit
Damit ist unser Tutorial zur Installation und Konfiguration eines Zabbix-Servers auf einem Rocky Linux 9-System abgeschlossen. Wir haben auch einen Zabbix-Agenten auf einem entfernten Server installiert, um eine Verbindung mit dem Server herzustellen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.