Monitoring - Überwachung von Geräten und Serverstrukturen

Autor : Gerd Raudenbusch
Stand : 29.12.2024

Inhalt

Linux-Rechner

Bei Cockpit handelt es sich um eine webbasierte Verwaltungsoberfläche für Linux-Server, die es Administratoren ermöglicht, Systeme einfach über einen Webbrowser zu steuern und zu überwachen. Entwickelt von Red Hat, richtet sich Cockpit sowohl an Anfänger als auch an erfahrene Administratoren und unterstützt verschiedene Linux-Distributionen wie Fedora, Red Hat Enterprise Linux, Debian und Ubuntu.

Hauptmerkmale von Cockpit

Einsatzmöglichkeiten

Cockpit eignet sich besonders gut für die Verwaltung von einzelnen Servern oder kleiner Serverfarmen in Unternehmensumgebungen. Es vereinfacht viele administrative Aufgaben und ist darauf ausgelegt, die Effizienz bei der Serververwaltung zu steigern.

Installation von Cockpit

Cockpit kann mit apt install cockpit -y && apt install cockpit-podman -y && systemctl enable cockpit && systemctl start cockpit installiert werden kann. Cockpit läuft auf Port 9090 und kann anschließend im Webbrowser unter der Adresse http://linux-rechner-adresse:9090 erreicht werden.

Raspberry Pi

RPi Monitor ist eine Überwachungssoftware speziell für den Raspberry Pi, die es Nutzern ermöglicht, verschiedene Systemparameter in Echtzeit zu überwachen. Die Anwendung bietet eine benutzerfreundliche webbasierte Oberfläche, auf der wichtige Informationen über den Zustand des Raspberry Pi angezeigt werden.

Hauptmerkmale von RPi Monitor

Einsatzmöglichkeiten

RPi Monitor eignet sich hervorragend für Benutzer, die ihren Raspberry Pi kontinuierlich betreiben und dessen Leistung und Zustand im Blick behalten möchten. Es ist besonders nützlich für Projekte, die eine ständige Überwachung erfordern, wie z.B. Serveranwendungen oder IoT-Projekte.

Installation von RPI Monitor

Die Software lässt sich einrichten mit sudo wget http://goo.gl/vewCLL -O /etc/apt/sources.list.d/rpimonitor.list && sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 2C0D3C0F && gpg --no-default-keyring --keyserver keyserver.ubuntu.com --recv-keys 2C0D3C0F && sudo apt-get update && sudo apt-get install rpimonitor. Der rpimonitor ist auf Port 8888 über die Weboberfläche erreichbar, unter der URL http://raspi-adresse:8888

Monitoring mit Nagios

Während cockpit und rpimonitor für einzelne Geräte erdacht ist, handelt es sich bei Nagios um eine seit Jahrzehnten etablierte eine Open-Source-Monitoring-Software, die zur Überwachung von IT-Infrastrukturen, Netzwerken, Hosts und spezifischen Diensten eingesetzt wird und gut funktioniert, aber nicht unbedingt als leichtgewichtig betrachtet werden kann. Entwickelt wurde Nagios ursprünglich von Ethan Galstad und erschien 1999 unter dem Namen NetSaint, bevor es 2001 in Nagios umbenannt wurde. Der Name ist ein rekursives Akronym und steht für "Nagios Ain't Gonna Insist On Sainthood"

Hauptmerkmale von Nagios

Einsatzgebiete

Nagios wird häufig in Unternehmen eingesetzt, um die IT-Effizienz zu gewährleisten und Probleme frühzeitig zu erkennen. Es ist besonders nützlich für die Überwachung komplexer IT-Infrastrukturen, da es eine umfassende Sicht auf den Zustand aller Komponenten ermöglicht .

Installation von Nagios

Mit folgendem Skript kann die aktuelle Version von Nagios auf Ubuntu installiert werden :

#!/bin/bash
# Nagios Installation Script 

# Update and upgrade system packages
echo "Updating system packages..."
sudo apt update && sudo apt upgrade -y

# Install required dependencies
echo "Installing required dependencies..."
sudo apt install -y autoconf gcc libc6 make wget unzip apache2 php libapache2-mod-php libgd-dev

# Download Nagios Core and Plugins
echo "Downloading Nagios Core and Plugins..."
cd /tmp
wget https://assets.nagios.com/downloads/nagioscore/releases/nagios-4.4.7.tar.gz
wget https://nagios-plugins.org/download/nagios-plugins-2.3.3.tar.gz

# Extract the downloaded files
echo "Extracting downloaded files..."
tar zxvf nagios-4.4.7.tar.gz
tar zxvf nagios-plugins-2.3.3.tar.gz

# Compile and install Nagios Core
echo "Compiling and installing Nagios Core..."
cd nagios-4.4.7
./configure --with-httpd-conf=/etc/apache2/sites-enabled
make all
sudo make install
sudo make install-init
sudo make install-config
sudo make install-commandmode
sudo make install-webconf

# Create a Nagios user and group
echo "Creating Nagios user and group..."
sudo useradd nagios
sudo groupadd nagcmd
sudo usermod -a -G nagcmd nagios
sudo usermod -a -G nagcmd www-data

# Configure contacts for email notifications
echo "Configuring email notifications..."
EMAIL="your_email@example.com"  # Change this to your email address.
sudo sed -i "s/email@domain.com/$EMAIL/g" /etc/nagios4/objects/contacts.cfg

# Install Nagios Plugins
echo "Installing Nagios Plugins..."
cd /tmp/nagios-plugins-2.3.3
./configure --with-nagios-user=nagios --with-nagios-group=nagios
make
sudo make install

# Configure Apache for Nagios web interface
echo "Creating admin user for Nagios web interface..."
sudo htpasswd -c /etc/nagios4/htpasswd.users nagiosadmin

# Restart Apache to apply changes
echo "Restarting Apache..."
sudo systemctl restart apache2

# Verify configuration and start Nagios service
echo "Verifying Nagios configuration..."
sudo /usr/sbin/nagios4 -v /etc/nagios4/nagios.cfg

if [ $? -eq 0 ]; then
    echo "Starting Nagios service..."
    sudo systemctl start nagios
    sudo systemctl enable nagios
    echo "Nagios installation completed successfully!"
    echo "Access the web interface at http://your_server_ip/nagios"
else
    echo "Nagios configuration verification failed!"
fi

Konfiguration der Test-Kommandos

Für den Test, ob ein TCP-Port offen ist, empfiehlt es sich, in /etc/nagios4/objects/commands.cfg die folgenden Zeilen von Kommentar-Zeichen zu befreien :

define command {
    command_name check_tcp_service
    command_line $USER1$/check_tcp -H $HOSTADDRESS$ -p $ARG1$ -t 3
}

Konfiguration der Hosts-Gruppen

in der Datei /etc/nagios4/objects/hostgroups.cfg kann man Host-Gruppen definieren, wobei das Schlüsselwort members für Hosts und das Schlüsselwort hostgroup_members für Untergruppen reserviert ist. Hier ist eine Beispiel-Konfiguration mit Host-Gruppen für Routing-Infrastruktur, IoT-Geräte und externe Server :

define hostgroup {
    hostgroup_name          homenetwork-router
    alias                   homenetwork-router
    members                 AP-Keller,AP-Erdgeschoss,AP-Obergeschoss,RP-Garten,RP-Dachgeschoss
}

define hostgroup {
    hostgroup_name          homenetwork-iot
    alias                   homenetwork-iot
    members                 IoTBridge-Aussen,IoTBridge-Innen,Saugroboter,Drucker
}

define hostgroup {
    hostgroup_name          homenetwork
    alias                   homenetwork
    hostgroup_members       homenetwork-router,homenetwork-iot
}

define hostgroup {
   hostgroup_name           external-server
   alias                    external-server
   members                  external.net
}

define hostgroup {
   hostgroup_name           all
   alias                    all
   hostgroup_members        homenetwork,external-server
}

Konfiguration der Hosts und ihrer Services

Für jeden Host legt man im Verzeichnis /etc/nagios4/objects eine Datei hostname.cfg an, welche den Hostnamen und die zu überwachenden Services definiert, hier z.B. ein Mailserver mit Weboberfläche :

define host {
    use                     linux-server
    host_name               external.net
    alias                   external.net
    address                 1.2.3.4
    check_command           check_ping!100.0,20%!500.0,60%
    check_interval 30
    max_check_attempts 2

}

define service {
    use                     generic-service
    host_name               external.net
    service_description     Ping
    check_command           check_ping!100.0,20%!500.0,60%
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     Webserver on Port 443
    ;check_command           check_http!-p 443
    check_command           check_tcp_service!443
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     ssh
    check_command           check_tcp_service!22
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     snmp-relay
    check_command           check_tcp_service!25
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     imap-starttls
    check_command           check_tcp_service!143
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     imap-tls
    check_command           check_tcp_service!993
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     snmp-starttls
    check_command           check_tcp_service!465
}

define service {
    use                     generic-service
    host_name               external.net
    service_description     snmp-tls
    check_command           check_tcp_service!587
}

Abschluss der Konfiguration

Am Ende muss jede neue angelegte Konfigurationsdatei *.cfg in /etc/nagios4/nagios.cfg verlinkt werden, damit sie Beachtung findet :

# You can specify individual object config files as shown below:
cfg_file=/etc/nagios4/objects/commands.cfg
cfg_file=/etc/nagios4/objects/contacts.cfg
cfg_file=/etc/nagios4/objects/timeperiods.cfg
cfg_file=/etc/nagios4/objects/templates.cfg

# Host groups
cfg_file=/etc/nagios4/objects/hostgroups.cfg

# Definitions for monitoring the hosts
cfg_file=/etc/nagios4/objects/host1.cfg
cfg_file=/etc/nagios4/objects/host2.cfg
cfg_file=/etc/nagios4/objects/host3.cfg

server {
    listen 443 ssl;
    server_name external.net;

    ssl_certificate /path/to/your/certificate.pem;
    ssl_certificate_key /path/to/your/private_key.pem;

    location / {
        proxy_pass http://localhost:1234;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Monitoring mit MQTT

MQTT (Message Queuing Telemetry Transport) ist ein leichtgewichtiges Kommunikationsprotokoll, das speziell für die effiziente Übertragung von Nachrichten zwischen Geräten im Internet der Dinge (IoT) entwickelt wurde. Es basiert auf dem Publish/Subscribe-Modell, bei dem Geräte (Clients) Nachrichten an einen zentralen Broker senden, der diese Nachrichten an die entsprechenden Empfänger verteilt. Diese Architektur ermöglicht eine Entkopplung von Sendern und Empfängern, was die Kommunikation vereinfacht und flexibler gestaltet.

Hauptmerkmale von MQTT

Anwendungsgebiete

MQTT findet breite Anwendung in der Automatisierungstechnik, industriellen Kommunikation und in drahtlosen Sensornetzwerken. Typische Einsatzszenarien umfassen die Übertragung von Sensordaten wie Temperatur oder Füllstände sowie die Kommunikation zwischen verschiedenen IoT-Geräten.

MQTT-Bridge

Eine MQTT-Bridge ist eine Komponente in der Kommunikation zwischen verschiedenen MQTT-Brokern, die es ermöglicht, Nachrichten und Daten zwischen diesen Brokern auszutauschen. Sie fungiert als Vermittler, der es ermöglicht, dass Nachrichten von einem Broker an einen anderen weitergeleitet werden. Dies ist besonders nützlich in Szenarien, in denen mehrere Systeme oder Standorte miteinander kommunizieren müssen. Mit einer MQTT-Bridge lässt sich erreichen, dass zwei Server sich gegenseitig überwachen können, indem sie gegenseitig ihre Lebenszeichen abonnieren.

Installation der MQTT-Broker

Eclipse Mosquitto ist ein Open-Source-MQTT-Broker, der für die Kommunikation im Internet der Dinge (IoT) entwickelt wurde. Mosquitto fungiert hauptsächlich als MQTT-Broker, der Nachrichten zwischen MQTT-Clients verwaltet. Er empfängt Nachrichten von einem Client und leitet sie an andere Clients weiter, die an den entsprechenden Themen interessiert sind. Ursprünglich von Roger Light in C programmiert, ist Mosquitto Teil des Eclipse-Projekts und hat sich zu einer der beliebtesten MQTT-Broker-Lösungen entwickelt.

Mosquitto kann mit dem Befehl sudo apt update && sudo apt install -y mosquitto mosquitto-clients installiert werden.

Interner MQTT-Server

In einem abgeschotteten Heimnetzwerk ist es nicht notwendig, den Broker mit TLS zu betreiben. Die Konfigurationsdatei /etc/mosquitto/conf.d/myconfig.cfg zu einem externen Server inclusive Bridge zu einem weiteren externen Broker könnte so aussehen :

#
# Mosquitto configuration for home network
#
listener 8383
log_type all

# Connection credential file; Create the credentials with :
# sudo mosquitto_passwd -c /etc/mosquitto/credentials <username>
#
password_file /etc/mosquitto/credentials

#
# Bridge to public extrrnal broker
#
connection bridge-public
address external.net:8383
try_private false
cleansession true

#
# This imports the external root topic to the local broker
#
topic # in 0

#
# This export the local root topic to external broker
#
topic # out 0

#
# This is the CA for letsencrypt, maybe you'll need another one
#
bridge_cafile /etc/ssl/certs/ISRG_Root_X1.pem

#
# Connection credentials for remote server
#
remote_username my-own-remoteuser123
remote_password my-own-remotepassword123

Externer MQTT-Server

Bei einem externen Server sollte zusätzlich für eine TLS-gesicherte Verbindung gesorgt sein, indem z.B. die Domänen-Zertifikate dafür eingesetzt werden.

#
# Mosquitto configuration for external server
#

listener 8383
log_type all

#
# Certificates
#
certfile /etc/mosquitto/certs/fullchain.pem
keyfile /etc/mosquitto/certs/privkey.pem
cafile /etc/ssl/certs/ISRG_Root_X1.pem
tls_version tlsv1.3

# Without client certificate 
require_certificate false

# Connection credential file; Create the credentials with :
# sudo mosquitto_passwd -c /etc/mosquitto/credentials <username>
#
password_file /etc/mosquitto/credentials

Ein MQTT-Topic abonnieren

Die MQTT-Topics sind wie Ordnerstrukturen hierarchisch aufgebaut, wobei das Doppelkreuz # als Wildcard fungiert. Mit dem Befehl mosquitto_sub -L "mqtt://mqttusername:mqttpassword@localhost:8383/#" abonniert man sämtliche Nachrichten im lokalen Netz. Für das externe Netz verwendet man statt mqtt:// eine TLS-Verbindung mit mqtts:// als Präfix in der URL.

Eine MQTT-Nachricht veröffentlichen

Ensprechend sendet man mit dem Befehl mosquitto_pub -L "mqtt://mqttusername:mqttpassword@external.net:8383/testtopic" -m "Testmessage" eine Nachricht in das Topic testtopic.

MQTT-Client für Server-Lebenszeichen

Um auf Linux-basierten Systemen die Eckdaten zu sammeln, werden eigentlich keine Zusatzprogramme benötigt. Es gibt in den Paketquellen bereits enthaltene Hilfsprogramme, wie inxi und neofetch, die sich mit dem Paketmanager installieren lassen. Das folgende Skript sammelt alle 60 Sekunden die Eckdaten des Servers und veröffentlicht sie auf dem MQTT-Topic sysinfo. Nach einer kleinen Anpassung der Konfiguration kann es auf jeden Linux-Client installieren, den man überwachen möchte.

#!/bin/bash

#
#### Configuration
#
MYPID="$$"                       # Leave as it is
MQTTUSER="mymqttuser"            # Fill in your MQTT user
MQTTPASS="mymqttpassword"        # Fill in your MQTT user password
MQTTHOST="mymqttbroker-address"  # Fill in your MQTT broker URL
MQTTPORT="8383"                  # Fill in your MQTT broker port
MQTTTOPIC="sysinfo"              # Leave as it is to provide parameter under topic /<hostname>/sysinfo/
INTERVALL="${2:-60}"

local-ports () {
        ports=(22 8080)
        portnames=("ssh" "http-alt")
        checkalive localhost ${ports} ${portnames}
}


#
# General functions
#
usage () {
	echo "MQTT health client"
	echo ""
	echo "Usage :"
	echo "$(basename ${0}) start   : Start the client in background"
	echo "$(basename ${0}) stop    : Stop the client background processes"
	echo "$(basename ${0}) restart : Stop and start the client"
	echo "$(basename ${0}) service : Install systemd script (for current script location) to be autostarted on boot (run this as root!)"	
}

remove-systemd () {
        if [ $(id -u) -ne 0 ]; then
                echo "Please run as root!"
                exit 1
        fi
	systemctl stop mqtt-healthclient.service
	systemctl disable mqtt-healthclient.service
	rm -f /etc/systemd/system/multi-user.target.wants/mqtt-healthclient.service >/dev/null
	rm -f /lib/systemd/system/mqtt-healthclient.service 
	systemctl daemon-reload
}

install-systemd () {
	if [ $(id -u) -ne 0 ]; then
		echo "Please run as root!"
		exit 1
	fi
	rm -f /etc/systemd/system/multi-user.target.wants/mqtt-healthclient.service >/dev/null 2>&1
	echo "
[Unit]
Description=MQTT health client
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=$(realpath ${0}) start
ExecStop=$(realpath ${0}) stop

[Install]
WantedBy=multi-user.target
" >/lib/systemd/system/mqtt-healthclient.service && ln -s /lib/systemd/system/mqtt-healthclient.service /etc/systemd/system/multi-user.target.wants/mqtt-healthclient.service && \
	systemctl daemon-reload && \
	systemctl enable mqtt-healthclient.service
	if [ "${?}" == "0" ]; then
		echo "Service mqtt-healthclient.service was installed. Start with 'systemctl start mqtt-healthclient'"
	else
		echo "Could not install mqtt-healthclient.service"
	fi

}

assure-tools () {
        column --version >/dev/null 2>&1
        if [ "$?" == "127" ]; then
                echo "Must install column"
                sudo apt update && sudo apt -y upgrade && sudo apt install -y column
        fi

	neofetch --version >/dev/null 2>&1
	if [ "$?" == "127" ]; then
		echo "Must install neofetch"
        	sudo apt update && sudo apt -y upgrade && sudo apt install -y neofetch
	fi
	mosquitto_pub --help >/dev/null 2>&1
        if [ "$?" == "127" ]; then
                echo "Must install MQTT client"
                sudo apt update && sudo apt -y upgrade && sudo apt install -y mosquitto-clients
        fi
        netstat --verson >/dev/null 2>&1
        if [ "$?" == "127" ]; then 
                echo "Must install netstat"
                sudo apt update && sudo apt -y upgrade && sudo apt install -y netstat
        fi
}

#
# System parameter collector functions
#

dspace () {
        df -h | grep -E "/$" | sed -E "s/[ ]+/|/g" | sed -En "s/(.*)\|(.*)\|(.*)\|(.*)\|(.*)\|(.*)/\3 HDD used of \2/p"
}

mspace () {
        free -h | grep -E "Mem|Speicher" | sed -E "s/[ ]+/|/g" | sed -En "s/.*\|(.*)\|(.*)\|(.*)\|(.*)\|(.*)\|(.*)/\2 RAM used of \1/p"
}

cpu () { 
        echo "$(top -n 1 -b | grep -i '%Cpu(s)' | sed -E 's/[ ]+/|/g' | cut -d '|' -f8) idle"
}

portalive () {
        nc -vz -w 1 ${1} ${2} >/dev/null 2>&1;
        echo $?
}

checkalive () {
        ip="${1}"
        ports=${2}
        portnames=${3}
        count=0
	for p in ${ports[@]}; do
		reachable=$(portalive ${ip} ${p})
		status="UNKNOWN"
		if [ "${reachable}" == "0" ]; then
			status="OPEN"
		elif [ "${reachable}" == "1" ]; then
			status="CLOSED"
                fi
                echo "Net-Connection ${ip}:${portnames[${count}]}|${p} is ${status}"
		count=$((count + 1))
	done
}

sysinfo () {
        neofetch --stdout | sed "s/: /|/g" | grep "|" | cat	
        echo "apt-Upgradable|$(apt list --upgradable 2>/dev/null | grep -v "Listing..." | wc -l)"
        echo "apt-Installed|$(apt list --installed 2>/dev/null | grep -v "Listing..." | wc -l)"
        echo "Disk-Usage|$(dspace)"
        echo "Memory-Usage|$(mspace)"
        echo "CPU-Usage|$(cpu)"
        echo "CPU-Processes|$(ps aux | wc -l)"
        echo "Net-Servers|$(netstat -tauln | grep "LISTEN" -c)"
        echo "Net-Connections|$(netstat -tauln | grep -E "ESTABLISHED|VERBUNDEN" -c)"
	echo "$(local-ports)"	
}

startbg () {
	echo "Starting MQTT health client"
	eval "$(realpath ${0}) >/dev/null 2>&1 &"
	name=$(basename ${0})
        ALLPIDS=$(pgrep -f ${name})
        PIDS=$(echo "${ALLPIDS}" | grep -v "${MYPID}" | tr '\n' ' ')
	echo "Started ${PIDS}with interval ${INTERVALL}"
	sleep 1
}

stopbg () {
	echo "Stopping MQTT health client"
	name=$(basename ${0})
	ALLPIDS=$(pgrep -f ${name})
	PIDS=$(echo "${ALLPIDS}" | grep -v "${MYPID}" | tr '\n' ' ')
	for pid in ${PIDS}; do 
		echo "Killing ${pid}"
		kill -s SIGKILL ${pid}
	done
	sleep 1
}

assure-tools
if [ "${1}" == "start" ]; then
	startbg
	exit $?
elif [ "${1}" == "stop" ]; then
	stopbg
	exit $?
elif [ "${1}" == "restart" ]; then
	stopbg
	sleep 1
	startbg
	sleep 1
	exit $?
elif [ "${1}" == "service" ]; then
	if [ "${2}" == "install" ]; then
		install-systemd
	elif [ "${2}" == "remove" ]; then
		remove-systemd
	else
		echo "Give 'install' or 'remove' as parameter"
	fi
	exit $?
else
	usage
	echo ""
	echo "You haven't specified arguments; running in foreground"
fi

echo "Starting MQTT health client"
while true; do
	(
	sysinfo | while read -r line; do 
		key=$(echo "${line}" | cut -d "|" -f1); 
		val=$(echo "${line}" | cut -d "|" -f2-); 
		if [ "${key}" == "" ]; then
			continue
		fi
		echo "${key}|${val}"
		echo "${val}" | mosquitto_pub -l -L "mqtt://${MQTTUSER}:${MQTTPASS}@${MQTTHOST}:${MQTTPORT}/$(hostname)/${MQTTTOPIC}/${key}" && sleep 1
	done
	) | column -ts "|"
	sleep ${INTERVALL} 
done

Neben der Möglichkeit, das Topic zu abonnieren und beim Ausbleiben von Lebenszeichen eine Email zu senden, gibt es inzwischen auch für MQTT Apps für die Mobilgeräte, mit denen man sich mit dem MQTT-Broker verbinden kann, um die Topics zu abonnieren. Viele Apps lassen dabei die Gestaltung einer eigenen GUI zu, da MQTT bei Bastlern auch gerne zur Steuerung von Haustechnik (Schalter, Licht, usw.) Anwendung findet.

Quellen

Zurück zur Hauptseite