Crea un servidor autorreparable con OpenClaw

¿Y si tu servidor pudiera repararse a sí mismo? No solo alertarte cuando algo va mal, sino diagnosticar realmente el problema, aplicar la corrección adecuada y avisarte después. Con OpenClaw puedes construir exactamente eso.

Este tutorial te guía para crear una configuración de servidor autorreparable en la que tu agente de IA monitoriza la salud del sistema, detecta problemas comunes, aplica correcciones automáticamente y te envía un informe por correo.

Qué vamos a construir

Un sistema en el que OpenClaw:

1. Monitoriza las métricas del servidor cada 5 minutos (disco, memoria, CPU, servicios)
2. Detecta problemas comunes (disco lleno, servicio caído, carga alta, caducidad de SSL)
3. Diagnostica la causa raíz usando el razonamiento de la IA
4. Corrige el problema automáticamente cuando es seguro
5. Notifica por correo con un informe completo de lo ocurrido

El principio clave: corrige lo que es seguro corregir, alerta sobre todo lo demás.

Requisitos previos

• OpenClaw instalado y en ejecución en el servidor que quieres monitorizar
• Skill de ejecución de shell habilitado
• Clave API de Inbounter para las notificaciones por correo
• Familiaridad básica con la administración de sistemas Linux

Paso 1: Configurar el SOUL.md

Añade una sección de operaciones de servidor a tu SOUL.md:

## Server Operations Role

You are responsible for monitoring and maintaining this server. Your priorities:

1. Keep services running
2. Prevent disk and memory exhaustion
3. Maintain security (SSL certificates, updates)
4. Log everything you do

### Auto-Fix Rules (SAFE to do without asking)
- Clear apt/package manager cache when disk > 85%
- Delete old log files (> 30 days) when disk > 85%
- Restart a crashed service (max 3 times, then escalate)
- Renew SSL certificates via certbot
- Clear /tmp files older than 7 days

### Escalate Rules (DO NOT auto-fix, notify admin)
- Disk usage above 95% after cleanup
- Service crashes more than 3 times in 1 hour
- Unusual processes or network connections
- Failed security updates
- Any issue you are not confident about

### Notification Rules
- Auto-fixes: Send summary email via Inbounter
- Escalations: Send urgent email via Inbounter with "URGENT" in subject
- Weekly: Send a health summary every Sunday at 8 AM

### Safety Rules
- NEVER delete user data to free disk space
- NEVER modify firewall rules automatically
- NEVER update the kernel without admin approval
- NEVER restart the server (only restart individual services)
- Always log commands to /var/log/openclaw-ops.log before executing

Paso 2: Crear scripts de comprobación de salud

Crea un conjunto de scripts que el agente pueda ejecutar para recopilar información del sistema.

Script de salud del sistema

#!/bin/bash
# /home/openclaw/scripts/health-check.sh

echo "=== System Health Report ==="
echo "Date: $(date)"
echo ""

echo "=== Disk Usage ==="
df -h / /home /var /tmp 2>/dev/null | grep -v tmpfs
echo ""

echo "=== Memory ==="
free -h
echo ""

echo "=== CPU Load ==="
uptime
echo ""

echo "=== Top Processes (by memory) ==="
ps aux --sort=-%mem | head -6
echo ""

echo "=== Top Processes (by CPU) ==="
ps aux --sort=-%cpu | head -6
echo ""

echo "=== Services Status ==="
for svc in nginx postgresql redis openclaw; do
    if systemctl is-active --quiet "$svc" 2>/dev/null; then
        echo "  $svc: RUNNING"
    else
        echo "  $svc: STOPPED"
    fi
done
echo ""

echo "=== SSL Certificates ==="
for domain in $(ls /etc/letsencrypt/live/ 2>/dev/null); do
    expiry=$(openssl x509 -enddate -noout -in "/etc/letsencrypt/live/$domain/cert.pem" 2>/dev/null | cut -d= -f2)
    if [ -n "$expiry" ]; then
        echo "  $domain: expires $expiry"
    fi
done
echo ""

echo "=== Recent Errors (last 30 min) ==="
journalctl --since "30 minutes ago" --priority=err --no-pager | tail -10
echo ""

echo "=== Open Connections ==="
ss -tuln | grep LISTEN | wc -l
echo "  listening ports"
echo ""

echo "=== Uptime ==="
uptime -p

Hazlo ejecutable:

chmod +x /home/openclaw/scripts/health-check.sh

Paso 3: Configurar la tarea cron de monitorización

Programa OpenClaw para que ejecute comprobaciones de salud automáticamente:

# Every 5 minutes: quick check
openclaw cron add --name "quick-check" "*/5 * * * *" \
  "Run /home/openclaw/scripts/health-check.sh and analyze the output.
   
   CHECK FOR:
   1. Disk usage above 85% on any partition
   2. Memory usage above 90%
   3. CPU load average above 4.0 (for a 4-core server)
   4. Any service in STOPPED state
   5. SSL certificates expiring within 14 days
   
   IF everything is normal: Do nothing. No notification needed.
   
   IF an issue is detected:
   - Apply auto-fix if it matches the Auto-Fix Rules in SOUL.md
   - Log the fix to /var/log/openclaw-ops.log
   - Send a summary email via Inbounter to admin@company.com
   
   IF the issue requires escalation:
   - Send an URGENT email via Inbounter to admin@company.com
   - Include the full health check output and your diagnosis"

# Every hour: deeper analysis
openclaw cron add --name "hourly-analysis" "0 * * * *" \
  "Run a deeper analysis:
   1. Check /var/log/syslog for unusual patterns
   2. Check for failed SSH login attempts
   3. Verify all critical ports are responding
   4. Check if any process is consuming excessive resources
   5. Verify backup job completed (check /var/log/backup.log)
   
   Only notify if something unusual is found."

# Weekly report
openclaw cron add --name "weekly-health-report" "0 8 * * 0" \
  "Generate a weekly server health report:
   - Uptime statistics
   - Average resource usage
   - Auto-fixes performed this week
   - Escalations raised
   - Disk usage trend
   - Top 5 resource-consuming processes (average)
   
   Send the report via Inbounter to admin@company.com with subject
   'Weekly Server Health Report - [date]'"

Paso 4: Definir procedimientos de corrección automática

Instruye al agente sobre pasos de remediación específicos para problemas comunes.

Recuperación de espacio en disco

# Add to SOUL.md

### Disk Space Recovery Procedure
When disk usage exceeds 85%:

1. Check what is using space:
   `du -sh /var/log/* /tmp/* /var/cache/* | sort -rh | head -20`

2. Safe cleanup actions (in order):
   a. Clear apt cache: `sudo apt clean`
   b. Remove old kernels: `sudo apt autoremove -y`
   c. Clear journal logs: `sudo journalctl --vacuum-time=7d`
   d. Delete old log files: `sudo find /var/log -name "*.gz" -mtime +30 -delete`
   e. Clear /tmp: `sudo find /tmp -type f -mtime +7 -delete`
   f. Clear Docker unused images: `docker system prune -f` (if Docker is installed)

3. After cleanup, re-check disk usage.
4. If still above 90%, escalate to admin.

Reinicio de servicio

### Service Restart Procedure
When a service is in STOPPED state:

1. Check why it stopped: `journalctl -u [service] --since "1 hour ago" --no-pager | tail -30`
2. Attempt restart: `sudo systemctl restart [service]`
3. Wait 10 seconds, check status: `sudo systemctl status [service]`
4. If restart succeeds, log it and send notification
5. If restart fails:
   - Try once more after 30 seconds
   - If still failing, escalate to admin with the error logs
6. Track restart count: if a service restarts 3+ times in 1 hour, escalate

Renovación de certificados SSL

### SSL Certificate Renewal
When a certificate expires within 14 days:

1. Attempt renewal: `sudo certbot renew --cert-name [domain]`
2. If successful, reload nginx: `sudo systemctl reload nginx`
3. Verify: `echo | openssl s_client -servername [domain] -connect [domain]:443 2>/dev/null | openssl x509 -noout -enddate`
4. If renewal fails, escalate with the certbot error output

Paso 5: Configurar notificaciones por correo a través de Inbounter

Configura tu agente para que envíe notificaciones a través de Inbounter:

# config.yaml
notifications:
  email:
    provider: "inbounter"
    api_key: "${INBOUNTER_API_KEY}"
    default_to: "admin@company.com"
    from: "server-agent@yourdomain.com"

El agente usará el skill de correo para enviar notificaciones. Ejemplos de prompts que generará:

Notificación de corrección automática:

Subject: [Auto-Fix] Disk cleanup performed on production server

At 14:35 UTC, disk usage on /var reached 87%.

Actions taken:
- Cleared apt cache: freed 1.2 GB
- Removed old journals: freed 800 MB
- Deleted old log archives: freed 400 MB

Current disk usage: 62%

No further action needed.

Notificación de escalado:

Subject: [URGENT] PostgreSQL service crashed on production server

At 14:35 UTC, PostgreSQL was found in STOPPED state.

Diagnosis:
- Error log shows: "FATAL: could not map anonymous shared memory: Cannot allocate memory"
- System memory is at 94% usage
- Top process: java (PID 1234) using 6.2 GB RAM

Actions taken:
- Attempted restart: FAILED (same error)
- Second attempt after 30s: FAILED

Recommended actions:
1. Investigate the Java process (PID 1234) consuming excessive memory
2. Consider increasing server RAM or adding swap
3. Restart PostgreSQL after memory issue is resolved

Full health check output attached.

Paso 6: Registro y rastro de auditoría

Cada acción que realice el agente debe quedar registrada:

# Create the ops log
sudo touch /var/log/openclaw-ops.log
sudo chown openclaw:openclaw /var/log/openclaw-ops.log

Añade al SOUL.md:

### Logging
Before executing ANY command, log it:

echo "[$(date)] ACTION: [description] | CMD: [command]" >> /var/log/openclaw-ops.log

After execution, log the result:

echo "[$(date)] RESULT: [outcome]" >> /var/log/openclaw-ops.log

Ejemplos de entradas de registro:

[2026-04-05 14:35:12] ACTION: Disk cleanup - clearing apt cache | CMD: sudo apt clean
[2026-04-05 14:35:15] RESULT: Success - freed 1.2 GB
[2026-04-05 14:35:16] ACTION: Disk cleanup - clearing old journals | CMD: sudo journalctl --vacuum-time=7d
[2026-04-05 14:35:18] RESULT: Success - freed 800 MB
[2026-04-05 14:35:20] ACTION: Post-cleanup disk check | CMD: df -h /var
[2026-04-05 14:35:20] RESULT: /var at 62% - within acceptable range

Paso 7: Probar tu configuración

Simular disco lleno

# Create a large temporary file
dd if=/dev/zero of=/tmp/test-fill bs=1M count=5000

# Wait for the next health check (or trigger manually)
openclaw cron run --name "quick-check"

# Verify the agent detected and cleaned up
cat /var/log/openclaw-ops.log | tail -10

# Clean up test file
rm /tmp/test-fill

Simular caída de servicio

# Stop a non-critical service
sudo systemctl stop redis

# Trigger health check
openclaw cron run --name "quick-check"

# Check if it was restarted
sudo systemctl status redis

Verificar las notificaciones por correo

# Trigger a test notification
openclaw run "Send a test notification email via Inbounter to admin@company.com 
  with subject 'Test: Self-Healing Server Alert' and body 
  'This is a test notification from your self-healing server setup.'"

Avanzado: monitorización multiservidor

Si gestionas varios servidores, tu agente OpenClaw puede monitorizarlos de forma remota a través de SSH:

#!/bin/bash
# /home/openclaw/scripts/remote-health.sh

SERVERS=("web1:192.168.1.10" "web2:192.168.1.11" "db1:192.168.1.20")

for entry in "${SERVERS[@]}"; do
    name="${entry%%:*}"
    ip="${entry##*:}"
    echo "=== $name ($ip) ==="
    ssh -o ConnectTimeout=5 "openclaw@$ip" '/home/openclaw/scripts/health-check.sh' 2>/dev/null
    if [ $? -ne 0 ]; then
        echo "  CONNECTION FAILED"
    fi
    echo ""
done

openclaw cron add --name "multi-server-check" "*/10 * * * *" \
  "Run /home/openclaw/scripts/remote-health.sh and analyze all servers.
   Report any issues found, specifying which server has the problem."

Salvaguardas de seguridad

La autorreparación es potente pero peligrosa si está mal configurada. Implementa estas salvaguardas:

1. Limitar la tasa de correcciones automáticas

# SOUL.md
### Rate Limits
- Maximum 5 auto-fix actions per hour
- Maximum 3 service restarts per service per hour
- If limits exceeded, stop auto-fixing and escalate everything

2. Modo de simulación

Prueba primero tu configuración en modo de simulación (dry-run):

# config.yaml
ops:
  dry_run: true  # Log what would be done without executing

3. Interruptor de emergencia

Si el agente empieza a causar problemas, deténlo de inmediato:

openclaw cron pause --all
openclaw stop

4. Registro de deshacer

Registra suficiente información para deshacer cada acción si es necesario:

# SOUL.md
### Undo Logging
For each auto-fix action, also log the undo command:

echo "[$(date)] UNDO: [undo command]" >> /var/log/openclaw-ops.log

Preguntas frecuentes

¿Es seguro dar acceso sudo a un agente de IA?

Usa reglas de sudoers específicas en lugar de sudo completo:

# /etc/sudoers.d/openclaw
openclaw ALL=(ALL) NOPASSWD: /usr/bin/apt clean
openclaw ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx
openclaw ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart postgresql
openclaw ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart redis
openclaw ALL=(ALL) NOPASSWD: /usr/bin/journalctl --vacuum-*
openclaw ALL=(ALL) NOPASSWD: /usr/bin/certbot renew *

¿Cómo evito que el agente empeore las cosas?

Reglas estrictas en el SOUL.md, límites de velocidad y una lista conservadora de correcciones automáticas. Empieza solo con la limpieza de disco y los reinicios de servicios. Añade más correcciones gradualmente a medida que ganes confianza.

¿Puedo usar esto en servidores de producción?

Sí, con precaución. Empieza con solo monitorización (sin corrección automática) durante 2-4 semanas. Revisa las alertas. Luego habilita la corrección automática para las correcciones más comunes y seguras.

¿Cuánto cuesta esto en tokens de API?

Una comprobación de salud cada 5 minutos usa aproximadamente 3.000 tokens por comprobación. Con los precios de Claude Sonnet, eso ronda los 3-5 $ al mes. La mayoría de las comprobaciones no encontrarán nada mal y usarán menos tokens.

¿Puedo combinar esto con la monitorización existente (Datadog, Grafana)?

Sí. Usa OpenClaw como la "capa de respuesta inteligente" que recibe alertas de tu monitorización existente y decide qué hacer. Reenvía las alertas de Grafana a OpenClaw mediante webhook.

¿Qué pasa si el propio agente se cae?

Usa un servicio externo de comprobación de salud (UptimeRobot, Healthchecks.io) para monitorizar el endpoint de salud de OpenClaw. Si se cae, recibes una notificación de forma independiente.