Ich bastel zur Zeit an einer Webseite um allgemeine System Informationen zu sammeln und über einen Internet Webserver anzuzeigen: http://5.231.51.22/sysinfos/
Fand es interessant eine einfache und zentrale Übersicht, mit Daten wie die aktuelle Uptime, was für ein Rechner genutzt wird oder was für eine Auslastung das System hat, über all meine kleinen Rechner (Futro S400, Igel 564LX, RaspberryPi und ein miniITX) zu haben
Dazu nutze ich ein bash Script welches ein mal täglich die Daten sammelt, an einen Webserver schickt (input.php) und auf dem Webserver wiederum kann man eine output.php aufrufen die diese Daten dann anzeigt..
Wichtig für mich ist das Projekt möglichst transparent zu gestalten - alle Dateien sind für jeden einsehbar, sowohl die SQLite Datenbank als auch die beiden php Dateien.
Dafür hab ich für die PHP Dateien Verknüpfungen (symlinks) angelegt, da sonst der apache2 Webserver die *.php Dateien verarbeiten würde. Das funktioniert für die input.php auch sehr gut, nur für die output.php nicht so super da dort auch html Code enthalten ist wo sich leider nicht verhindern lässt dass apache2 diesen verarbeitet..
Aber um sicherzustellen das ich keine IPs oder derartiges speicher sollte es für euch eigentlich reichen in sowohl input.php (die Datei, die die Informationen vom sysinfos.sh entgegen nimmt) und der SQLite Datenbank (db.sqlite.sysinfos) rein gucken zu können - Ansonsten versuche ich auch immer stets den aktuell verwendeten Source zu packen: http://5.231.51.22/sysinfos/_source_.tar.gz (alternativer download link: > *klick* <)
Falls euch das doch nicht reicht könnt ihr mir auch gerne eine PN schicken und ich geb euch kurzfristig Zugriff auf den Server
Ihr könnt euer eigenes System nur dann erkennen wenn ihr zB eure UUID kennt (oder zumindest die ersten 4 Stellen )
Folgende Daten werden zZt gesammelt:
- system uptime
- cpu model name
- cpu frequence
- cpu cores
- cpu load
- cpu load avg
- kernel
- distribution
- uuid of first harddisc
Die UUID benötige ich um ein System eindeutig zu identifizieren, damit ein Datenbank Eintrag auch aktualisiert werden kann
Das Projekt befindet sich derzeit noch in der Entwicklung, funktioniert bereits aber schon sehr gut..
Würde an dieser Stelle gern Feedback sammeln um ggf noch was zu verbessern und vielleicht steht ja eurerseits auch soviel Interesse daran das man das Projekt hier im Forum oben Anpinnt und als Referenz für Fragen wie zB:
Wie stabil ist ein ThinClient o.ä.?
Dabei spielt aber eben nicht nur die Uptime eine rolle sondern auch wie sehr er genutzt wird (load), um was für ein Modell es sich handelt (cpu) und welcher Kernel genutzt wird.
Eigentlich sogar auch sowas wie Temperatur usw aber leider haben nicht alle Systeme Sensoren die man abfragen könnte
Ihr benötigt nur ein bash Script (sysinfos.sh), was ihr irgendwo speichern könnt (zB im /root/ Verzeichnis)
Ich empfehle aber einen extra Benutzer anzulegen der das Script dann ausführt (es sollten generell keine Prozesse oder Scripte als root laufen!)
Zum anlegen eines Benutzers gebt ihr als root folgenden Befehl ein: useradd -m -s/bin/bash sysinfo
-m bewirkt dass das Homedir für den Benutzer angelegt wird
-s/bin/bash legt die standard shell fest, also bash
sysinfo ist der Benutzer der angelegt wird und folglich wäre sein Homedir: /home/sysinfo
Dann wechselt ihr zu diesem Benutzer mit dem Befehl: su - sysinfo
Dann öffnet ihr am besten einen Linux Editor wie zB nano oder joe oder vi und copy&pastet das folgende Script dort direkt rein:
nano sysinfos.sh
Spoiler anzeigen
#!/bin/bash
#
# Track System Informations to a Website. version: 0.12
#
# Collected Informations:
# - system uptime
# - cpu model name
# - cpu frequence
# - cpu cores
# - cpu loadavg
# - kernel
# - distribution
# - uuid of first harddisc
#
## Enable Script Updates? [0=no , 1=yes]
ScriptUpdater=1
# -------------------------------------------------------------- #
# >>> >> > DO NOT MESS WiTH ANYTHiNG BELOW THiS LiNE! < << <<< #
# -------------------------------------------------------------- #
# required system cmd's:
# basename blkid cat cut date echo grep head ping sed stat uptime wget wc
#get writeable temp dir
if [ -w "/tmp" ]; then
TMP="/tmp/"
elif [ -w "/usr/tmp" ]; then
TMP="/usr/tmp/"
elif [ -w "/usr/local/tmp" ]; then
TMP="/usr/local/tmp/"
elif [ -w "/root" ]; then
TMP="/root/"
else
TMP=""
fi
#- variables
ScriptFileName=$(basename $0)
PiDFILE="${TMP}.pid.$ScriptFileName"
blkid=/sbin/blkid
OnlinePing="5.231.51.22"
OnRetry="120"
Send2URL="http://$OnlinePing/sysinfos/"
## Distro Detection Informations - Defines known linux distros
#(bash v3 doesnt support declare -A)
Distros=(
'Debian::/etc/debian_release;/etc/debian_version'
'Ubuntu::/etc/lsb-release'
'Arch Linux::/etc/arch-release'
'Gentoo::/etc/gentoo-release'
'Fedora::/etc/fedora-release'
'FedoraCore::/etc/fedora-release'
'CentOS::/etc/redhat-release;/etc/redhat_version'
'SUSE LINUX::/etc/SuSE-release;/etc/UnitedLinux-release'
'Mandrake::/etc/mandrake-release'
'MandrivaLinux::/etc/mandrake-release'
'RedHat::/etc/redhat-release;/etc/redhat_version'
'Slackware::/etc/slackware-release;/etc/slackware-version'
'Trustix::/etc/trustix-release;/etc/trustix-version'
'FreeEOS::/etc/eos-version'
'Cobalt::/etc/cobalt-release'
'LinuxFromScratch::/etc/lfs-release'
'Rubix::/etc/rubix-version'
'PLD::/etc/pld-release'
'RedHatEnterpriseES::/etc/redhat-release;/etc/redhat_version'
'RedHatEnterpriseAS::/etc/redhat-release;/etc/redhat_version'
'LFS::/etc/lfs-release;/etc/lfs_version'
'HLFS::/etc/hlfs-release;/etc/hlfs_version'
'IYCC::/etc/lsb-release'
'Synology::/etc/synoinfo.conf'
'Mageia::/etc/mageia-release'
'Alpine::/etc/alpine-release'
'Lucid::/etc/DISTRO_SPECS'
)
#- functions
ltrim() { echo "$1" | sed -e "s/^ *//"; }
rtrim() { echo "$1" | sed -e "s/ *$//"; }
trim() { x="$(ltrim "$1")"; echo "$(rtrim "$x")"; }
detect_Distro() {
#LSB=$(which lsb_release)
#if [ -n "$LSB" ]; then
# DISTRI=$($LSB -d 2>/dev/null | cut -d ':' -f2- | sed 's/^ *//g' | awk {'print(substr($0,2))'})
# if [ -z "$DISTRI" ]; then
# DISTRI=$(trim "$(lsb_release -a 2>/dev/null | grep 'ID:' | awk {'print $3'})")
# [ -n "$DISTRI" ] && DISTRI="$DISTRI $(lsb_release -a 2>/dev/null | grep "Release:" | awk {'print $2'})"
# fi
#else
Found=0
for index in "${Distros[@]}" ; do
NAME="${index%%::*}"
FILES="${index##*::}"
for file in $(echo $FILES | sed 's/\;/ /g'); do
if [ -f "$file" ]; then
NAMEff=$(grep "DISTRIB_DESCRIPTION" $file | sed 's/\"/ /g' | awk {'print $2'})
if [ -n "$NAMEff" ]&&[[ "$NAMEff" =~ "$NAME" ]]; then
DISTRI=$(trim "$(grep 'DISTRIB_DESCRIPTION' $file | sed 's/\"/ /g' | cut -d'=' -f2-)")
fi
[ -z "$DISTRI" ] && DISTRI="$NAME $(cat $file)"
Found=1
fi
[ "$Found" = 1 ] && break
done
[ "$Found" = 1 ] && break
done
#fi
}
_error() {
if [ "$1" -gt 0 ]; then
[ -z "$2" ] && message="" || message="$2"
echo "There was an Error.. $message"
echo "Aborting"
rm -f $PiDFILE
exit 1
fi
}
# URL encoding
proc_url_encode() {
out=${1//%/%25}; out=${out//\{/%7B}; out=${out//\}/%7D}; out=${out//|/%7C};
out=${out//\\/%5C}; out=${out//^/%5E}; out=${out//~/%7E}; out=${out//[/%5B};
out=${out//]/%5D}; out=${out//\`/%60}; out=${out//#/%23}; out=${out//>/%3E};
out=${out//\$/%24}; out=${out//&/%26}; out=${out//+/%2B}; out=${out//,/%2C};
out=${out//\//%2F}; out=${out//:/%3A}; out=${out//;/%3B}; out=${out//=/%3B};
out=${out//\?/%3F}; out=${out// /%20}; out=${out//</%3C};
out=${out//\!/%21}; out=${out//\"/%22}; out=${out//\@/%40}; out=${out//\'/%27};
out=${out//\(/%28}; out=${out//\)/%29}; out=${out//\*/%2A}; out=${out//\-/%2D};
out=${out//\_/%5F}; out=${out//\./%2E}; out=${out//\€/%80};
echo $out
}
#convert spaces to underlines
convert_spaces() { echo "$@" | sed 's/ /_/g'; }
#encode other chars
convert_chars() {
out=""
for input in "$@" ; do
[ -z "$out" ] && out="$(proc_url_encode "$input")" || out="$out $(proc_url_encode "$input")"
done
echo "$out"
}
#get system uptime
get_uptime() {
UPTIME=$(uptime | sed 's/^ *//g');
# Read uptime in seconds
UPTIMESECS=$(cat /proc/uptime | awk -F '.' '{print $1}')
}
#get cpu informations
get_cpuinfos() {
CPU=$(grep "^model name" /proc/cpuinfo | cut -d: -f2 | sed 's/^ *//g' | head -1)
[ -z "$CPU" ] && CPU=$(grep "^Processor" /proc/cpuinfo | cut -d: -f2 | sed 's/^ *//g')
[ -z "$CPU" ] && CPU=$(grep "^cpu model" /proc/cpuinfo | cut -d: -f2 | sed 's/^ *//g')
FREQ=$(grep "^BogoMIPS" /proc/cpuinfo | cut -d: -f2 | head -1 | sed 's/^ *//g')
[ -z "$FREQ" ] && FREQ=$(grep -i "^cpu MHz" /proc/cpuinfo | cut -d: -f2 | head -1 | sed 's/^ *//g')
[ -z "$FREQ" ] && FREQ=$(grep -i "^clock" /proc/cpuinfo | cut -d: -f2 | head -1 | sed 's/^ *//g')
CORES=$(grep "^processor" /proc/cpuinfo | wc -l)
[ -z "$CORES" ] && CORES=1
[ "$CORES" = 0 ] && CORES=1
# CPU Load
read -a CPULOAD < /proc/stat
unset CPULOAD[0]
CPULOAD=("${CPULOAD[@]}")
# CPU AVG Load
CPULOADAVG=$(cat /proc/loadavg | awk {'print $1,$2,$3'})
}
#get unique user id of first harddisc device
get_uuid() {
if [ -f "${TMP}.sysinfo_uuid" ]; then
UUID=$(cat ${TMP}.sysinfo_uuid)
else
[ ! -x "$blkid" ] && blkid=$(whereis blkid | awk {'print $2'})
UUID=$($blkid -o value -s UUID | head -1)
if [ -z "$UUID" ]; then
UUID=$(ls /dev/disk/by-uuid/)
UUID=$(echo $UUID | cut -d' ' -f1)
fi
echo "$UUID" > ${TMP}.sysinfo_uuid
fi
}
#get kernel informations
get_kernel() { KERNEL=$(uname -a | cut -d" " -f3-); }
#get distribution informations
get_distri() {
detect_Distro
#LSB=$(which lsb_release)
#[ -n "$LSB" ] && DISTRI=$($LSB -d | cut -d ":" -f2- | sed 's/^ *//g' | awk {'print $1,$3'})
#[ -z "$DISTRI" ] && [ -f "/etc/debian_version" ] && DISTRI="Debian $(cat /etc/debian_version)"
}
#check if theres a new script available and if replace it
check_4updated_script() {
if [ "$ScriptUpdater" = 1 ]; then
STAT=$(which stat)
if [ -x "$STAT" ]; then
wget -q -O ${TMP}$ScriptFileName "${Send2URL}sysinfos.sh"
NewSize=$($STAT -c%s ${TMP}$ScriptFileName)
OldSize=$($STAT -c%s $0)
#if NewSize and OldSite not equal..
if [ $NewSize -ne $OldSize ]; then
echo -e "\nNEW Script available! Replacing Script..\n\n"
mv -f ${TMP}$ScriptFileName $0
chmod 755 $0
rm -f $PiDFILE
sleep 1
$0
exit 0
fi
fi
fi
}
#- main code
# make sure script is only running once
if [ -f "$PiDFILE" ]; then
PiDs=$(cat $PiDFILE)
if [ -z "$PiDs" ]; then
rm -f $PiDFILE
else
echo "Script seems already to run with PID(s): $PiDs"
echo "Aborting"
exit 0
fi
fi
# put script pid into PiDFILE so its not running multi
PiDs="$$ $!"
echo $PiDs > $PiDFILE
# check if online...
ONLINE=0
[ "$(ping -c1 "$OnlinePing" | grep -c "seq")" -eq 1 ] && ONLINE=1
# if online, get and send data...
if [ "$ONLINE" ]; then
check_4updated_script
_error $?
echo "Getting Required Informations .."
get_uuid
_error $?
get_uptime
_error $?
get_cpuinfos
_error $?
get_kernel
_error $?
get_distri
_error $?
echo " UUID: $UUID"
echo -e " UPTIME: $UPTIME\n UPTIMESECS: $UPTIMESECS"
echo -e " CPU: $CPU\n FREQ: $FREQ\n CORES: $CORES\n LOAD: ${CPULOAD[@]}\n LOAD AVG: ${CPULOADAVG[@]}"
echo " KERNEL: $KERNEL"
echo " DISTRI: $DISTRI"
KERNEL=$(convert_chars $KERNEL)
DATA="UUID=${UUID}&UPTIME=${UPTIME}|${UPTIMESECS}&CPU=${CPU}|${FREQ}|${CORES}|${CPULOAD[@]}|${CPULOADAVG}&DISTRI=${DISTRI}&KERNEL=${KERNEL}"
echo -e "\nDATASTRING: $DATA\n"
echo "Sending Informations to ${Send2URL}input.php .."
wget -q -O- "${Send2URL}input.php?${DATA}"
rm -f $PiDFILE
else
rm -f $PiDFILE
echo "$OnlinePing seems to be offline! Retrying in $OnRetry seconds.."
sleep $OnRetry
$0
fi
exit 0
# EOF
Alles anzeigen
Dann das Script ausführbar machen: chmod 755 sysinfos.sh
Und dann wie folgt in die Benutzer-crontab eintragen.
Dazu am besten vorher einmalig den Befehl export EDITOR=nano ausführen.
Ihr könnt auch einen anderen Editor angeben.
Der Befehl bewirkt dass der Standard Editor zum bearbeiten der crontab gesetzt wird, normalerweise wäre das nämlich " vi " aber der Umgang damit ist wie ich finde komplizierter als mit nano
Also, die crontab des Benutzers bearbeiten: crontab -e
Dort folgendes einfügen:
Damit wird das Script jeden Tag um 19 Uhr ausgeführt
$HOME beinhaltet das Homedir, das ist eine standardtisierte, Systemweite Variable die ihr nicht extra setzen müsst
(zum entwickeln übermitteln meine 2 Systeme jede Stunde ihre Daten)
Changelog:
Spoiler anzeigen
sysinfos.sh
v0.12:
- Distro detection aufgrund von fehlerhaftem erkennen der Version von zB "Ubuntu LTS" verändert..
- UUID wird nun ins TMP Verzeichnis gespeichert damit beim Ausführen über root keine andere UUID ausgelesen wird..
v0.10:
- Distro detection erweitert (27 verschiedene Distro's werden nun erkannt)
- Allgemeine Code-Optimierungen
v0.02:
- Bei jedem ausführen wird das sysinfos.sh Script vom Webserver geladen, die Grösse verglichen und das alte ggf ersetzt (kann über "ScriptUpdater" abgeschaltet werden)
- Errorhandling verbessert
Falls ihr Fragen habt dann würde ich mich freuen euch diese zu beantworten