---
title: "Monitorizar temperaturas con lm-sensors en Ubuntu 24.04"
description: "Instala lm-sensors en Ubuntu 24.04, detecta los chips de la placa, lee temperaturas, ventiladores y voltajes y envía los datos a Prometheus con node_exporter."
category: "Gestión de Hardware y Sistema"
language: es
source: https://cubepath.com/es/docs/gestión-de-hardware-y-sistema/monitorizacion-de-temperatura-con-lm-sensors
updated: 2026-09-25
---

# Monitorizar temperaturas con lm-sensors en Ubuntu 24.04

lm-sensors es el conjunto de herramientas de Linux que lee los sensores de hardware expuestos por el kernel: temperatura de CPU y NVMe, velocidad de ventiladores y voltajes de la placa base. En este tutorial instalarás lm-sensors en Ubuntu 24.04, detectarás los chips de monitorización de tu servidor, ajustarás etiquetas y umbrales, y exportarás las lecturas a Prometheus con node_exporter para poder alertar cuando algo se caliente demasiado. También verás cómo consultar los sensores de la BMC con `ipmitool` en servidores que la tienen.

## Requisitos previos

- Un servidor físico con Ubuntu 24.04 LTS, por ejemplo un servidor dedicado (bare metal) de CubePath.
- Un usuario no root con privilegios `sudo`.
- Opcional: un servidor Prometheus para recoger las métricas del paso 5.

> Nota: en un VPS no hay sensores de hardware accesibles. `sensors` no mostrará nada útil, porque la temperatura del host físico la vigila el proveedor.

## Paso 1: Instalar lm-sensors

Instala el paquete desde los repositorios de Ubuntu:

```bash
sudo apt update
sudo apt install lm-sensors
```

Comprueba que el comando está disponible:

```bash
sensors -v
```

```output
sensors version 3.6.0 with libsensors version 3.6.0
```

## Paso 2: Detectar los chips de sensores

Muchos sensores (temperatura de núcleos de CPU, NVMe) funcionan nada más arrancar gracias a los módulos `coretemp` (Intel) y `k10temp` (AMD). Los chips de la placa base que leen ventiladores y voltajes (Nuvoton, ITE y similares) necesitan cargar un módulo concreto. `sensors-detect` sondea el hardware y te dice cuál.

Ejecútalo en modo automático, que acepta las respuestas por defecto (las seguras):

```bash
sudo sensors-detect --auto
```

Al final muestra un resumen parecido a este:

```output
Now follows a summary of the probes I have just done.

Driver `coretemp':
  * Chip `Intel digital thermal sensor' (confidence: 9)

Driver `nct6775':
  * ISA bus, address 0x290
    Chip `Nuvoton NCT6798D Super IO Sensors' (confidence: 9)
```

Carga el módulo que haya propuesto (en el ejemplo, `nct6775`) sin necesidad de reiniciar:

```bash
sudo modprobe nct6775
```

Para que se cargue en cada arranque, añádelo a un archivo de `/etc/modules-load.d/`:

```bash
echo nct6775 | sudo tee /etc/modules-load.d/sensors.conf
```

Comprueba que los módulos están cargados:

```bash
lsmod | grep -E 'coretemp|k10temp|nct6775|it87'
```

```output
nct6775                36864  0
coretemp               24576  0
```

Si `sensors-detect` no encuentra ningún chip de placa base, es normal en muchos servidores: los ventiladores y voltajes los gestiona la BMC y se leen con IPMI (paso 6).

## Paso 3: Leer temperaturas, ventiladores y voltajes

Ejecuta `sensors` sin argumentos:

```bash
sensors
```

```output
coretemp-isa-0000
Adapter: ISA adapter
Package id 0:  +48.0°C  (high = +80.0°C, crit = +100.0°C)
Core 0:        +45.0°C  (high = +80.0°C, crit = +100.0°C)
Core 1:        +47.0°C  (high = +80.0°C, crit = +100.0°C)

nvme-pci-0100
Adapter: PCI adapter
Composite:     +39.9°C  (low  = -273.1°C, high = +84.8°C)
                        (crit = +84.8°C)

nct6798-isa-0290
Adapter: ISA adapter
Vcore:          1.05 V  (min =  +0.00 V, max =  +1.74 V)
fan1:          1204 RPM  (min =    0 RPM)
SYSTIN:        +34.0°C  (high = +80.0°C, hyst = +75.0°C)
```

Cada bloque es un chip: su nombre (`coretemp-isa-0000`), el bus y las lecturas con sus límites `high` y `crit` cuando el chip los proporciona. En AMD verás `k10temp-pci-00c3` con la lectura `Tctl`.

Para scripts o integraciones, `sensors` puede devolver JSON:

```bash
sensors -j
```

Y si solo te interesa un chip, pásale su nombre con comodines:

```bash
sensors 'coretemp-*'
```

## Paso 4: Ajustar etiquetas y umbrales

La configuración de lm-sensors está en `/etc/sensors3.conf`, que no debes editar directamente. Tus ajustes van en archivos dentro de `/etc/sensors.d/`. Crea uno:

```bash
sudo nano /etc/sensors.d/servidor.conf
```

Añade un bloque por chip. Este ejemplo, para el chip Nuvoton del paso anterior, renombra lecturas, fija un mínimo al ventilador y oculta entradas sin nada conectado:

```text
chip "nct6798-*"
    label temp1 "Placa base"
    label fan1  "Ventilador CPU"
    set fan1_min 400
    ignore fan5
    ignore fan6
```

Las etiquetas (`label`) e `ignore` se aplican solo al mostrar datos. Las líneas `set` escriben el límite en el chip y hay que aplicarlas explícitamente:

```bash
sudo sensors -s
```

Ubuntu aplica estos valores en cada arranque con el servicio `lm-sensors`. Comprueba que el cambio se ve:

```bash
sensors 'nct6798-*'
```

```output
nct6798-isa-0290
Adapter: ISA adapter
Ventilador CPU: 1204 RPM  (min =  400 RPM)
Placa base:    +34.0°C  (high = +80.0°C, hyst = +75.0°C)
```

> Nota: los nombres de las entradas (`temp1`, `fan1`...) dependen del chip. Consulta los reales con `sensors -u`, que muestra cada entrada con su nombre interno. Los límites de temperatura de la CPU (`high`, `crit`) los fija el procesador y no se pueden cambiar.

## Paso 5: Exportar las métricas a Prometheus

Consultar `sensors` a mano no sirve para detectar un ventilador que se para de madrugada. Prometheus node_exporter lee los mismos datos del kernel (`/sys/class/hwmon`) y los publica como métricas. Instálalo desde los repositorios de Ubuntu:

```bash
sudo apt install prometheus-node-exporter
```

El servicio arranca solo y escucha en el puerto 9100. Comprueba que publica las temperaturas:

```bash
curl -s http://localhost:9100/metrics | grep '^node_hwmon_temp_celsius'
```

```output
node_hwmon_temp_celsius{chip="platform_coretemp_0",sensor="temp1"} 48
node_hwmon_temp_celsius{chip="platform_coretemp_0",sensor="temp2"} 45
node_hwmon_temp_celsius{chip="nvme_nvme0",sensor="temp1"} 39.85
```

Las métricas `node_hwmon_temp_max_celsius` y `node_hwmon_temp_crit_celsius` contienen los límites del chip, y `node_hwmon_fan_rpm` la velocidad de los ventiladores. Si tu Prometheus está en otra máquina, abre el puerto solo para su IP (sustituye `ip_de_prometheus`):

```bash
sudo ufw allow from ip_de_prometheus to any port 9100 proto tcp
```

En Prometheus, esta regla de alerta salta cuando cualquier sensor supera su propio límite `high` durante cinco minutos:

```yaml
groups:
  - name: hardware
    rules:
      - alert: TemperaturaAlta
        expr: node_hwmon_temp_celsius >= node_hwmon_temp_max_celsius
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.chip }} {{ $labels.sensor }} a {{ $value }} °C en {{ $labels.instance }}"
```

Comparar con el límite del propio chip evita fijar un número único que no vale igual para una CPU que para un NVMe. Los sensores que no publican límite simplemente no generan alerta.

## Paso 6: Leer los sensores de la BMC con IPMI

En servidores con BMC (iDRAC, iLO, Supermicro IPMI), muchos sensores de la placa, las fuentes de alimentación y los ventiladores solo son visibles a través de IPMI. Instala `ipmitool` y carga los módulos del kernel:

```bash
sudo apt install ipmitool
sudo modprobe ipmi_si
sudo modprobe ipmi_devintf
```

Consulta las temperaturas registradas por la BMC:

```bash
sudo ipmitool sdr type Temperature
```

```output
CPU1 Temp        | 01h | ok  |  3.1 | 49 degrees C
System Temp      | 0Bh | ok  |  7.1 | 31 degrees C
Peripheral Temp  | 0Ch | ok  |  7.1 | 38 degrees C
```

Y los ventiladores con `sudo ipmitool sdr type Fan`. Si `ipmitool` responde `Could not open device`, el servidor no tiene BMC o el módulo `ipmi_si` no la ha encontrado; revisa `sudo dmesg | grep -i ipmi`.

## Solución de problemas

**`sensors` dice `No sensors found!`.** O estás en una máquina virtual (compruébalo con `systemd-detect-virt`, que devuelve `kvm` o similar) o no hay ningún módulo de sensores cargado. En hardware físico, vuelve a ejecutar `sudo sensors-detect --auto` y carga con `modprobe` los módulos que proponga.

**`sensors-detect` detecta un chip pero el módulo no carga.** Algunos chips ITE recientes no están soportados por el módulo `it87` del kernel de Ubuntu. Comprueba el error con `sudo dmesg | tail`. En estos casos, lee los datos por IPMI.

**Lecturas absurdas (por ejemplo +127 °C o -128 °C).** Suelen ser entradas del chip sin nada conectado. Ocúltalas con `ignore tempN` en tu archivo de `/etc/sensors.d/`.

**`sensors -s` da `Error: File ..., line N: Undeclared bus id referenced`.** El nombre del chip del bloque `chip "..."` no coincide con ninguno detectado. Usa el prefijo exacto que muestra `sensors`, con `-*` al final.

## Conclusión

Ahora puedes leer las temperaturas, ventiladores y voltajes de tu servidor con `sensors`, tienes etiquetas y límites adaptados a tu placa y las métricas se exportan a Prometheus con una alerta basada en los límites de cada chip. Como siguientes pasos puedes:

- Crear un panel en Grafana con `node_hwmon_temp_celsius` y `node_hwmon_fan_rpm`.
- Vigilar la salud de los discos con smartmontools.
- Añadir alertas para ventiladores parados con `node_hwmon_fan_rpm == 0`.