Das Dilemma mit Synology

[Homoran]

Ich plage mich ein wenig damit die Vitaldaten aus der Synology zu holen.
ich hatte das zuerst über den SNMP-Adapter gemacht, das lief ganz gut.

Als ich dann feststellte, dass der NFS mount aus der pve dauerhaft bestand, ich aber so gut wie nie komplette VMs gesichert hatte, habe ich den NFS gelöscht - und siehe da der Stromverbrauch ging runter.
Allerdings hatten die Platten auf einmal eine Temperatur von 0°C

Außerdem erhielt ich jetzt auch ERROR Meldungen vom SNMP Adapter im log, dass die Abfrage in ein Timeout gelaufen sei.

Also Timeout erhöht.
Daraufhin kam der Fehler seltener, aber nicht mehr alle Platten fuhren in den Standby

auch die Verteilung der IPs auf beide NICs brachte nichts, auch eine Regelmäßigkeit anhand der angemeckerten IP zu erkennen, ob es bestimmte OIDs waren, die zum timeout führten gab es nicht, oder ich habe sie nicht gesehen.

---

Jetzt habe ich es mit dem Synology-Adapter versucht.
Auf Anraten im Thread direkt die 2.0.1 über die räudige Katze geladen (in latest war nur die 1.xy zu haben) und einen Schreck bekommen.
Das Passwort blieb in Klartext in der Konfig sichtbar. (Habe dazu ein Issue erstellt)
Weiters benötigt es einen User mit admin Rechten auf der Syno.

Beides Dinge, die ich nicht liebe.

Als es dann aber auch hier dazu kam, dass es entweder 0-Werte in der Temperatur gab, oder die Platten nicht mehr in den Ruhezustand gingen, habe ich den Adapter wieder gelöscht.

Trotzdem blieb der Stromverbrauch hoch.
Als ich in der Syno nachgesehen hatte, war der eigens für den Adapter angelegte User noch verbunden. Habe den Mount gekappt und nach 10 Minuten war wieder Ruhe

---

Da ich auch immer wieder gegen Docker auf Syno anführe, dass der Mehrverbrauch der Platten im Dauerbetrieb höher ist, als ein NUC oder gar RasPi braucht, und bei meinen 6 Platten etwa bei 25W 24/7 = 50€p.a. beträgt habe ich das monitoren der Syno erst einmal aufgegeben.

jetzt steigt der Stromverbrauch nachts während der Backups nochmal kurz an, ansonsten ist Ruhe

Gibt es noch irgendwie eine Möglichkeit an Daten der Syno zu kommen
Mir geht es da um die üblichen lebenswichtigen Informationen Temp/RAM/CPU sowei ggf. S.M.A.R.T Informationen

[Jey Cee]

@homoran Deine Versuche waren, soweit das ersichtlich ist, alle die Daten von extern zu holen. Wie wäre es das ganze um zu drehen, also die Daten von der Synology an ioBroker senden zu lassen.
Ich kenn die Möglichkeiten der Synology nicht, aber zumindest Python läuft wohl darauf, damit Liese sich sowas schon realisieren.
Auf ioBroker Seite kann dann der Simple API Adapter die Daten annehmen.

[Homoran]

@jey-cee sagte in Das Dilemma mit Synology:

aber zumindest Python läuft wohl darauf, damit Liese sich sowas schon realisieren.

Wahlweise Bahnhof oder

Die Pythons (Pythonidae; altgr. Πύθων Pythōn; Einzahl der, allgemeinsprachlich auch die Python) sind eine Familie von Schlangen

Klingt zwar brauchbar - aber nicht für mich. Halte ich mal im Hinterkopf - Danke

[Glasfaser]

@Homoran

@jey-cee sagte in Das Dilemma mit Synology:
also die Daten von der Synology an ioBroker senden zu lassen.

vor dem Synology Adapter .....hatte ich das , vielleicht kannst du damit was anfangen

Synology NAS-Systemwerte an ioBroker übertragen

https://forum.iobroker.net/topic/31411/anzeige-status-docker-container/37

Spoiler

#!/bin/bash

ioBrokerSetURL="http://192.168.178.11:8087/set/javascript.0.synology."		# URL zum Setzen der Werte in ioBroker


URL_set_CPUTemp1="${ioBrokerSetURL}CPUTemp1?value="
URL_set_CPUTemp2="${ioBrokerSetURL}CPUTemp2?value="
URL_set_CPUTemp3="${ioBrokerSetURL}CPUTemp3?value="
URL_set_CPUTemp4="${ioBrokerSetURL}CPUTemp4?value="


URL_set_CPUUsage="${ioBrokerSetURL}CPUUsage?value="
URL_set_CPULoad="${ioBrokerSetURL}CPULoad?value="


URL_set_MemTotalGB="${ioBrokerSetURL}MemTotalGB?value="
URL_set_MemFreeGB="${ioBrokerSetURL}MemFreeGB?value="
URL_set_MemUsedGB="${ioBrokerSetURL}MemUsedGB?value="
URL_set_MemFreePercent="${ioBrokerSetURL}MemFreePercent?value="
URL_set_MemUsedPercent="${ioBrokerSetURL}MemUsedPercent?value="
URL_set_MemFreecacheGB="${ioBrokerSetURL}MemFreecacheGB?value="
URL_set_MembuffercacheGB="${ioBrokerSetURL}MembuffercacheGB?value="


URL_set_HDDTemp1="${ioBrokerSetURL}HDDTemp1?value="
URL_set_HDDTemp2="${ioBrokerSetURL}HDDTemp2?value="
URL_set_HDDTemp3="${ioBrokerSetURL}HDDTemp3?value="



URL_set_StorageTotalTB="${ioBrokerSetURL}StorageTotalTB?value="
URL_set_StorageFreeTB="${ioBrokerSetURL}StorageFreeTB?value="
URL_set_StorageUsedTB="${ioBrokerSetURL}StorageUsedTB?value="
URL_set_StorageFreePercent="${ioBrokerSetURL}StorageFreePercent?value="
URL_set_StorageUsedPercent="${ioBrokerSetURL}StorageUsedPercent?value="


URL_set_UptimeDays="${ioBrokerSetURL}UptimeDays?value="
URL_set_UptimeHours="${ioBrokerSetURL}UptimeHours?value="
URL_set_UptimeMinutes="${ioBrokerSetURL}UptimeMinutes?value="


URL_set_DSMVersion="${ioBrokerSetURL}DSMVersion?value="

URL_set_Timestamp="${ioBrokerSetURL}Timestamp?value="

# Ermitteln und Setzen der Werte ##

# CPU-Temperatur
CPUTemp1=$(cat /sys/class/hwmon/hwmon0/temp2_input | awk '{print $1/1000}')
CPUTemp2=$(cat /sys/class/hwmon/hwmon0/temp3_input | awk '{print $1/1000}')
CPUTemp3=$(cat /sys/class/hwmon/hwmon0/temp4_input | awk '{print $1/1000}')
CPUTemp4=$(cat /sys/class/hwmon/hwmon0/temp5_input | awk '{print $1/1000}')

url_CPUTemp1=$URL_set_CPUTemp1$CPUTemp1
echo "$url_CPUTemp1"
curl -s $url_CPUTemp1 > /dev/null 2>&1

url_CPUTemp2=$URL_set_CPUTemp2$CPUTemp2
echo "$url_CPUTemp2"
curl -s $url_CPUTemp2 > /dev/null 2>&1

url_CPUTemp3=$URL_set_CPUTemp3$CPUTemp3
echo "$url_CPUTemp3"
curl -s $url_CPUTemp3 > /dev/null 2>&1

url_CPUTemp4=$URL_set_CPUTemp4$CPUTemp4
echo "$url_CPUTemp4"
curl -s $url_CPUTemp4 > /dev/null 2>&1


# CPU-Usage

CPUUsage=$(top -b -n3 -p 1 | fgrep "Cpu(s)" | tail -1 | awk -F'id,' -v prefix="$prefix" '{ split($1, vs, ","); v=vs[length(vs)]; sub("%", "", v); printf "%s%.1f\n", prefix, 100 - v }')
url_CPUUsage=$URL_set_CPUUsage$CPUUsage
echo "$url_CPUUsage"
curl -s $url_CPUUsage > /dev/null 2>&1

# CPU-Load-Average

CPULoad=$(uptime | awk -F'[a-z]:' '{ print $2}' | sed 's/ /%20/g')
url_CPULoad=$URL_set_CPULoad$CPULoad
echo "$url_CPULoad"
curl -s $url_CPULoad > /dev/null 2>&1

# Memory Total in Gigabyte

MemTotalGB=$(free | grep Mem | awk '{printf "%.1f\n", $2/1024/1024}')
url_MemTotalGB=$URL_set_MemTotalGB$MemTotalGB
echo "$url_MemTotalGB"
curl -s $url_MemTotalGB > /dev/null 2>&1

# Memory Free in Gigabyte

MemFreeGB=$(free | grep Mem | awk '{printf "%.1f\n", ($4+$6)/1024/1024}')
url_MemFreeGB=$URL_set_MemFreeGB$MemFreeGB
echo "$url_MemFreeGB"
curl -s $url_MemFreeGB > /dev/null 2>&1

# Memory Used in Gigabyte

MemUsedGB=$(free | grep Mem | awk '{printf "%.1f\n", $3/1024/1024}')
url_MemUsedGB=$URL_set_MemUsedGB$MemUsedGB
echo "$url_MemUsedGB"
curl -s $url_MemUsedGB > /dev/null 2>&1

# Memory Free in Prozent

MemFreePercent=$(free | grep Mem | awk '{printf "%.1f\n", ($4+$6)/$2 * 100.0}')
url_MemFreePercent=$URL_set_MemFreePercent$MemFreePercent
echo "$url_MemFreePercent"
curl -s $url_MemFreePercent > /dev/null 2>&1

# Memory Used in Prozent

MemUsedPercent=$(free | grep Mem | awk '{printf "%.1f\n", $3/$2 * 100.0}')
url_MemUsedPercent=$URL_set_MemUsedPercent$MemUsedPercent
echo "$url_MemUsedPercent"
curl -s $url_MemUsedPercent > /dev/null 2>&1

# HDD-Temperaturen in Celsius

HDDTemp1=$(smartctl -A /dev/sda -d ata | grep Temperature_Celsius | awk '{print $10}')
url_HDDTemp1=$URL_set_HDDTemp1$HDDTemp1
echo "$url_HDDTemp1"
curl -s $url_HDDTemp1 > /dev/null 2>&1
HDDTemp2=$(smartctl -A /dev/sdb -d ata | grep Temperature_Celsius | awk '{print $10}')
url_HDDTemp2=$URL_set_HDDTemp2$HDDTemp2
echo "$url_HDDTemp2"
curl -s $url_HDDTemp2 > /dev/null 2>&1

#Temp3 

HDDTemp3=$(smartctl -A /dev/sdb -d ata | grep Temperature_Celsius | awk '{print $10}')
url_HDDTemp3=$URL_set_HDDTemp3$HDDTemp3
echo "$url_HDDTemp3"
curl -s $url_HDDTemp3 > /dev/null 2>&1

###

# Storage-Total Volume 1 in TB

StorageTotalTB=$(df|awk '/volume1$/{printf "%.2f\n", ($2/1024/1024/1024)}')
url_StorageTotalTB=$URL_set_StorageTotalTB$StorageTotalTB
echo "$url_StorageTotalTB"
curl -s $url_StorageTotalTB > /dev/null 2>&1

# Storage-Free Volume 1 in TB

StorageFreeTB=$(df|awk '/volume1$/{printf "%.2f\n", ($4/1024/1024/1024)}')
url_StorageFreeTB=$URL_set_StorageFreeTB$StorageFreeTB
echo "$url_StorageFreeTB"
curl -s $url_StorageFreeTB > /dev/null 2>&1

# Storage-Used Volume 1 in TB ($3/1024/1024/1024)

StorageUsedTB=$(df|awk '/volume1$/{printf "%.2f\n", ($3/1024/1024)}')
url_StorageUsedTB=$URL_set_StorageUsedTB$StorageUsedTB
echo "$url_StorageUsedTB"
curl -s $url_StorageUsedTB > /dev/null 2>&1

# Storage-Free Volume 1 in Prozent

StorageFreePercent=$(df|awk '/volume1$/{printf "%.1f\n", ($4/$2*100)}')
url_StorageFreePercent=$URL_set_StorageFreePercent$StorageFreePercent
echo "$url_StorageFreePercent"
curl -s $url_StorageFreePercent > /dev/null 2>&1

# Storage-Used Volume 1 in Prozent

StorageUsedPercent=$(df|awk '/volume1$/{printf "%.1f\n", ($3/$2*100)}')
url_StorageUsedPercent=$URL_set_StorageUsedPercent$StorageUsedPercent
echo "$url_StorageUsedPercent"
curl -s $url_StorageUsedPercent > /dev/null 2>&1

# Uptime unterteilt in "volle Tage und Stunden"

UptimeSecs=$(cat /proc/uptime | awk '{printf"%.0f\n", $1}')

UptimeDays=$(($UptimeSecs/86400))

UptimeHours=$((($UptimeSecs/3600)-($UptimeDays*24)))

UptimeMinutes=$((($UptimeSecs/60)-($UptimeDays*24*60)-($UptimeHours*60)))

url_UptimeDays=$URL_set_UptimeDays$UptimeDays

echo "$url_UptimeDays"

curl -s $url_UptimeDays > /dev/null 2>&1

url_UptimeHours=$URL_set_UptimeHours$UptimeHours

echo "$url_UptimeHours"

curl -s $url_UptimeHours > /dev/null 2>&1

url_UptimeMinutes=$URL_set_UptimeMinutes$UptimeMinutes

echo "$url_UptimeMinutes"

curl -s $url_UptimeMinutes > /dev/null 2>&1

# DSM-Version


Version=$(more /etc.defaults/VERSION | grep productversion | awk -F '=' '{print $2}' | sed 's/"//g')

BuildNumber=$(more /etc.defaults/VERSION | grep buildnumber | awk -F '=' '{print $2}' | sed 's/"//g')

FixNumber=$(more /etc.defaults/VERSION | grep smallfixnumber | awk -F '=' '{print $2}' | sed 's/"//g')

DSMVersion=$Version"-"$BuildNumber"%20Update%20"$FixNumber

url_DSMVersion=$URL_set_DSMVersion$DSMVersion

echo "$url_DSMVersion"

curl -s $url_DSMVersion > /dev/null 2>&1

#Timestamp für letztes Update der Werte


TimestampDay=$(date +%Y-%m-%d)

TimestampTime=$(date +%H:%M:%S)

Timestamp=$TimestampDay"%20"$TimestampTime

url_Timestamp=$URL_set_Timestamp$Timestamp

echo "$url_Timestamp"

curl -s $url_Timestamp > /dev/null 2>&1

#bufcache#
MemFreecacheGB=$(free | grep Mem | awk '{printf "%.1f\n", $4/1024/1024}')
url_MemFreecacheGB=$URL_set_MemFreecacheGB$MemFreecacheGB
echo "$url_MemFreecacheGB"
curl -s $url_MemFreecacheGB > /dev/null 2>&1

MembuffercacheGB=$(free | grep Mem | awk '{printf "%.1f\n", $6/1024/1024}')
url_MembuffercacheGB=$URL_set_MembuffercacheGB$MembuffercacheGB
echo "$url_MembuffercacheGB"
curl -s $url_MembuffercacheGB > /dev/null 2>&1

exit 0

[crunchip]

@homoran sagte in Das Dilemma mit Synology:

Gibt es noch irgendwie eine Möglichkeit

Weiss nicht ob das was wäre
https://www.modius-techblog.de/monitoring/synology-nas-mit-prometheus-ueberwachen/