NestDisk: el mini-NAS silencioso que desafía a los servidores tradicionales (y cabe en la palma de la mano) - Página 11 de 12

Índice

Glances, PowerCap/RAPL

Hablando de intersantes utilidades Open Source disponibles en GitHub hasta ahora no habíamos descubierto Glances.

Glances es una herramienta de monitorización ligera y en tiempo real que ofrece una visión completa del estado del sistema: CPU, memoria, red, discos, sensores y procesos. Integrado con Home Assistant mediante su API o a través de contenedores Docker, permite que HA recoja métricas detalladas del NAS o del servidor donde se ejecuta, convirtiéndolas en sensores que pueden usarse en paneles, automatizaciones o alertas. Es una forma muy eficiente de que Home Assistant supervise la salud de la infraestructura sin necesidad de instalar agentes pesados ni configuraciones complejas.

Por ejemplo, en nuestro caso hemos instalado Glances en el NestDisk así como en el NanoPC T6 de FriendlyELEC que revisamos hace un par de años y todavía seguimos usando con Jellyfin.

La cantidad de información en tiempo real a la que se puede acceder es increible lo que junto a la integración que existe con Home Assistant le hacen indispensable.

Con ayuda de una pequeña APP que hemos hecho en Python y montado en un contenedor junto a un cliente de MQTT somos capaces de leer dos veces por minuto los valores de potencia medida mediante POWERCAP de la CPU del NestDisk. También recibimos los valores de frecuencia, carga de la CPU y temperatura mientras que los datos de almacenamiento libre del NVMe y del disco SATA nos llegan vía Glances.

 api@nestdisk:/srv/tera/mydockers/powercap-mqtt$ cat powercap_mqtt.py 
# -*- coding: utf-8 -*-
#!/usr/bin/env python3
import time
import paho.mqtt.client as mqtt

# ---------------------------------------------------------
# NOTAS PARA REINICIAR EL CONTENEDOR (ASCII SAFE COMMENTS)
#
# Reiniciar el contenedor tras cambios en el .py:
#     docker compose restart powercap-mqtt
#
# Recrear el contenedor si hay cambios mayores:
#     docker compose up -d --force-recreate powercap-mqtt
#
# ---------------------------------------------------------

MQTT_HOST = "192.168.1.144"
MQTT_USER = "XXXXXXXXXXXX"
MQTT_PASS = "XXXXXXXXXXXX"
MQTT_BASE = "nestdisk/cpu/"

INTERVAL = 30  # segundos

# -------------------------------
# MQTT
# -------------------------------
print("[powercap] Conectando a MQTT...")
client = mqtt.Client(client_id="nestdisk_powercap", clean_session=True)
client.username_pw_set(MQTT_USER, MQTT_PASS)
client.connect(MQTT_HOST, 1883, 60)
client.loop_start()
print("[powercap] Conectado.")

# -------------------------------
# Abrimos ficheros una sola vez
# -------------------------------
f_energy = open("/sys/class/powercap/intel-rapl:0/energy_uj", "r")
f_range = open("/sys/class/powercap/intel-rapl:0/max_energy_range_uj", "r")
f_pl1 = open("/sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw", "r")
f_pl2 = open("/sys/class/powercap/intel-rapl:0/constraint_1_power_limit_uw", "r")
f_freq = open("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "r")
f_load = open("/proc/loadavg", "r")

# Temperatura REAL de la CPU (x86_pkg_temp)
f_temp = open("/sys/class/thermal/thermal_zone2/temp", "r")

# Leemos el rango máximo una vez
f_range.seek(0)
max_range = int(f_range.read().strip())

prev_energy = None
prev_time = None

print("[powercap] Iniciando bucle principal...")

# -------------------------------
# Bucle principal
# -------------------------------
while True:
    now = time.time()

    # Leer energía
    f_energy.seek(0)
    energy = int(f_energy.read().strip())

    if prev_energy is not None:
        delta_e = energy - prev_energy
        if delta_e &lt; 0:
            delta_e += max_range

        delta_t = now - prev_time
        power_cpu = delta_e / 1_000_000 / delta_t  # W
    else:
        power_cpu = 0.0

    prev_energy = energy
    prev_time = now

    # Potencia corregida (offset real del N150)
    power_total = power_cpu + 9.5

    # Leer PL1 / PL2
    f_pl1.seek(0)
    pl1 = int(f_pl1.read().strip()) // 1_000_000

    f_pl2.seek(0)
    pl2 = int(f_pl2.read().strip()) // 1_000_000

    # Leer frecuencia
    f_freq.seek(0)
    freq = int(f_freq.read().strip()) // 1000  # MHz

    # Leer carga CPU
    f_load.seek(0)
    load = float(f_load.read().split()[0]) * 100

    # Leer temperatura CPU REAL
    f_temp.seek(0)
    temp = int(f_temp.read().strip()) / 1000

    # LOGS
    print(f"[powercap] CPU={power_cpu:.1f}W  TOTAL={power_total:.1f}W  "
          f"FREQ={freq}MHz  TEMP={temp:.1f}°C")

    # Publicar
    client.publish(MQTT_BASE + "power_cpu", f"{power_cpu:.1f}")
    client.publish(MQTT_BASE + "power_total", f"{power_total:.1f}")
    client.publish(MQTT_BASE + "pl1", str(pl1))
    client.publish(MQTT_BASE + "pl2", str(pl2))
    client.publish(MQTT_BASE + "freq", str(freq))
    client.publish(MQTT_BASE + "load", f"{load:.1f}")
    client.publish(MQTT_BASE + "temp", f"{temp:.1f}")

    time.sleep(INTERVAL)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

api@nestdisk:/srv/tera/mydockers/powercap-mqtt$ cat powercap_mqtt.py

# -*- coding: utf-8 -*-

#!/usr/bin/env python3

import time

import paho.mqtt.client as mqtt

# ---------------------------------------------------------

# NOTAS PARA REINICIAR EL CONTENEDOR (ASCII SAFE COMMENTS)

# Reiniciar el contenedor tras cambios en el .py:

# docker compose restart powercap-mqtt

# Recrear el contenedor si hay cambios mayores:

# docker compose up -d --force-recreate powercap-mqtt

# ---------------------------------------------------------

MQTT_HOST = "192.168.1.144"

MQTT_USER = "XXXXXXXXXXXX"

MQTT_PASS = "XXXXXXXXXXXX"

MQTT_BASE = "nestdisk/cpu/"

INTERVAL = 30 # segundos

# -------------------------------

# MQTT

# -------------------------------

print("[powercap] Conectando a MQTT...")

client = mqtt.Client(client_id="nestdisk_powercap", clean_session=True)

client.username_pw_set(MQTT_USER, MQTT_PASS)

client.connect(MQTT_HOST, 1883, 60)

client.loop_start()

print("[powercap] Conectado.")

# -------------------------------

# Abrimos ficheros una sola vez

# -------------------------------

f_energy = open("/sys/class/powercap/intel-rapl:0/energy_uj", "r")

f_range = open("/sys/class/powercap/intel-rapl:0/max_energy_range_uj", "r")

f_pl1 = open("/sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw", "r")

f_pl2 = open("/sys/class/powercap/intel-rapl:0/constraint_1_power_limit_uw", "r")

f_freq = open("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "r")

f_load = open("/proc/loadavg", "r")

# Temperatura REAL de la CPU (x86_pkg_temp)

f_temp = open("/sys/class/thermal/thermal_zone2/temp", "r")

# Leemos el rango máximo una vez

f_range.seek(0)

max_range = int(f_range.read().strip())

prev_energy = None

prev_time = None

print("[powercap] Iniciando bucle principal...")

# -------------------------------

# Bucle principal

# -------------------------------

while True:

now = time.time()

# Leer energía

f_energy.seek(0)

energy = int(f_energy.read().strip())

if prev_energy is not None:

delta_e = energy - prev_energy

if delta_e < 0:

delta_e += max_range

delta_t = now - prev_time

power_cpu = delta_e / 1_000_000 / delta_t # W

else:

power_cpu = 0.0

prev_energy = energy

prev_time = now

# Potencia corregida (offset real del N150)

power_total = power_cpu + 9.5

# Leer PL1 / PL2

f_pl1.seek(0)

pl1 = int(f_pl1.read().strip()) // 1_000_000

f_pl2.seek(0)

pl2 = int(f_pl2.read().strip()) // 1_000_000

# Leer frecuencia

f_freq.seek(0)

freq = int(f_freq.read().strip()) // 1000 # MHz

# Leer carga CPU

f_load.seek(0)

load = float(f_load.read().split()[0]) * 100

# Leer temperatura CPU REAL

f_temp.seek(0)

temp = int(f_temp.read().strip()) / 1000

# LOGS

print(f"[powercap] CPU={power_cpu:.1f}W TOTAL={power_total:.1f}W "

f"FREQ={freq}MHz TEMP={temp:.1f}°C")

# Publicar

client.publish(MQTT_BASE + "power_cpu", f"{power_cpu:.1f}")

client.publish(MQTT_BASE + "power_total", f"{power_total:.1f}")

client.publish(MQTT_BASE + "pl1", str(pl1))

client.publish(MQTT_BASE + "pl2", str(pl2))

client.publish(MQTT_BASE + "freq", str(freq))

client.publish(MQTT_BASE + "load", f"{load:.1f}")

client.publish(MQTT_BASE + "temp", f"{temp:.1f}")

time.sleep(INTERVAL)

Otra ventaja del NestDisk frente al NanoPC-T6 es que el primero dispone de WOL por lo que podemos «arrancarlo/despertarlo» vía HA así como resetearlo o apagarlo.

Cambiando simplemente el valor de PL1 tal y como hemos comentado anteriormente «limitamos» la frecuencia máxima de la CPU a través de la potencia consumida en la CPU. Haciendo pruebas con diferentes valores de PL1 hemos conseguido calibrar una linea recta que relaciona la potencia de la CPU con la total, como era de esperar.

Y con esto creemos que lo mejor es acabar aquí aunque podríamos seguir hablando de las pruebas que hemos hecho con SnapRAID que, como seguro sabréis, ofrece una aproximación muy distinta a la de OMV: mientras OMV actúa como una plataforma completa de gestión NAS con servicios, plugins y una capa de administración web, SnapRAID se centra exclusivamente en la protección de datos mediante paridad, pensado para grandes colecciones de archivos estáticos. No requiere discos idénticos, no fuerza un RAID tradicional y permite recuperar datos incluso si varias unidades fallan, pero no es adecuado para datos que cambian constantemente. En conjunto, SnapRAID es una solución flexible y segura para almacenamiento “frío”, mientras que OMV es un ecosistema más amplio orientado a gestionar todo el servidor.

922

2 Comments

Inline Feedbacks

Ver todos los comentarios

Admin

Pharizna

23 horas antes

El lanzamiento del Lockerstor 24R Pro Gen2 de nuestros amigos de ASUSTOR refuerza claramente su apuesta por el almacenamiento empresarial de alto rendimiento.

Con 24 bahías y la posibilidad de expansión mediante el Xpanstor 12R, la capacidad potencial que supera el petabyte convierte a este NAS en una opción muy atractiva para centros de datos, virtualización o entornos con múltiples usuarios. La incorporación de RAID 50 y RAID 60 también apunta directamente a cargas de trabajo intensivas, donde el equilibrio entre redundancia y velocidad resulta crítico.

Este movimiento contrasta con soluciones más compactas como el NestDisk miniNAS de Youyeetoo que acabamos de revisar, orientado a oficinas pequeñas o laboratorios domésticos. Mientras aquel prioriza eficiencia y tamaño reducido, la serie Lockerstor R Pro Gen2 apuesta claramente por la escalabilidad y la alta disponibilidad.

21 horas antes

Hasta el NestDisk no me había dado cuenta de lo interesante que es WOL. Por ejemplo, he creado una automatización en Home Assistant que «despierta» mi NAS para realizar los correspondientes Backups de HA … depués se apaga y todo sin hacer ni un «ruidito»

NestDisk: el mini-NAS silencioso que desafía a los servidores tradicionales (y cabe en la palma ...

Glances, PowerCap/RAPL