systemd-run con cgroups v2: límites de CPU, memoria e IO
En el ecosistema Linux moderno, la gestión de recursos dejó de ser un arte de ajustar ulimit y esperar que nadie abuse del sistema. Los cgroups v2 (unified hierarchy) introdujeron una API mucho más coherente para controlar CPU, memoria, IO y procesos, y systemd se convirtió en el administrador natural de esa jerarquía. La herramienta systemd-run permite lanzar procesos efímeros o transitorios con límites aplicados desde el primer instante, sin escribir un archivo .service ni recargar el daemon. Esto es oro puro para tareas puntuales, scripts de CI, benchmarks o para aislar un proceso sospechoso que consume toda la máquina.
Qué es systemd-run y por qué importa
systemd-run es una utilidad que crea unidades transitorias (services, scopes o slices) en systemd en tiempo de ejecución. A diferencia de un systemctl start clásico, aquí no hay archivo de unidad persistente: systemd genera la unidad en memoria, la asocia a un cgroup y la destruye cuando el proceso termina. Esa asociación al cgroup es precisamente lo que habilita los límites de recursos.
Si systemd está corriendo sobre cgroups v2 (lo cual es la norma en distribuciones actuales como Fedora, Debian 12+, Ubuntu 22.04+ y RHEL 9), entonces cada unidad transitoria hereda un cgroup propio con controladores de CPU, memoria, IO, pids, etc. Verificarlo es trivial:
stat -fc %T /sys/fs/cgroup
# systemd cgroup2fs -> v2
# tmpfs -> v1 (o híbrido)
Si la salida es cgroup2fs, todo lo que sigue aplica sin trucos. Si es híbrido, algunos controladores pueden no estar disponibles en el cgroup generado.
Anatomía de una invocación con límites
La forma canónica de lanzar un comando con restricciones es:
sudo systemd-run \
--unit=mi-tarea \
--slice=limite.slice \
--property=CPUQuota=50% \
--property=MemoryMax=512M \
--property=IOWeight=100 \
--property=TasksMax=64 \
--collect \
/usr/bin/mi_programa --flag
Cada propiedad se traduce directamente en un atributo de cgroup v2. Vamos por partes:
- --unit: nombre de la unidad transitoria. Útil para consultarla con
systemctl statusosystemd-cgtop. - --slice: la slice padre. Organizar por slices ayuda a jerarquizar límites (un slice puede tener su propio techo).
- --collect: elimina la unidad al terminar, incluso si falla. Evita basura en
systemctl list-units --failed. - --property: cada par clave=valor aplica un límite del cgroup.
Límites de CPU
Hay dos mecanismos principales en cgroups v2:
CPUQuota=— porcentaje de un solo núcleo.CPUQuota=200%equivale a dos núcleos completos. Internamente se traduce encpu.maxcon un período de 100ms.CPUWeight=— peso relativo (1–10000, por defecto 100). No limita el techo, solo la proporción bajo contención. Traduce acpu.weight.
sudo systemd-run --property=CPUQuota=150% --property=CPUWeight=200 \
--collect stress-ng --cpu 4 --timeout 30s
El proceso podrá usar hasta 1.5 núcleos, y bajo contención tendrá prioridad doble respecto a otras unidades con peso 100. Es una combinación frecuente: techo duro con quota, prioridad relativa con weight.
Límites de memoria
La memoria es donde los cgroups v2 brillan frente a v1, porque ahora hay una sola contabilidad unificada. Las propiedades clave son:
MemoryMax=— techo absoluto (acepta sufijosK,M,G). Al alcanzarlo, el kernel invoca el OOM killer dentro del cgroup.MemoryHigh=— umbral de throttle. Al superarlo, el kernel empuja a swap y ralentiza la asignación antes de llegar al OOM.MemoryMin=— memoria protegida frente a reclaim global.MemorySwapMax=— limita el uso de swap dentro del cgroup.
sudo systemd-run \
--property=MemoryHigh=400M \
--property=MemoryMax=512M \
--property=MemorySwapMax=128M \
--collect ./mi_servicio_efimero
La estrategia recomendada es poner MemoryHigh un 20–30% por debajo de MemoryMax: así el proceso sufre backpressure antes de ser sacrificado. Si además quieres evitar que el OOM mate a otros procesos del host, añade OOMPolicy=stop, que detiene la unidad entera en lugar de matar selectivamente.
Límites de IO
El controlador io de cgroups v2 usa el modelo de pesos y límites por dispositivo. En systemd se exponen estas propiedades:
IOWeight=— peso relativo global (1–10000).IODeviceWeight=/dev/sda 500— peso por dispositivo específico.IOReadBandwidthMax=/dev/sda 10MyIOWriteBandwidthMax=— ancho de banda máximo por dispositivo.IOReadIOPSMax=yIOWriteIOPSMax=— límites por operaciones.
sudo systemd-run \
--property=IOWeight=50 \
--property=IOWriteBandwidthMax="/dev/nvme0n1 50M" \
--property=IOReadIOPSMax="/dev/nvme0n1 2000" \
--collect rsync -a /datos/ /backup/
Ojo: los límites por dispositivo requieren que el kernel tenga habilitado el controlador io (en v2 suele venir como io o bfq). Con el scheduler none (típico en NVMe modernos), los pesos funcionan pero el bandwidth max puede tener efecto limitado.
Inspeccionar, ajustar en caliente y matar
Una vez lanzada la unidad, la puedes consultar en vivo:
systemctl status mi-tarea.service
systemd-cgtop -M mi-tarea.service
systemctl show mi-tarea.service -p MemoryCurrent -p CPUUsageNSec -p IOReadBytes
Y ajustar límites sin reiniciar el proceso:
sudo systemctl set-property mi-tarea.service MemoryMax=1G CPUQuota=80%
systemd aplica el cambio al vuelo escribiendo directamente en los archivos de cgroup v2 (memory.max, cpu.max). Esto es invaluable cuando detectas en producción que un job necesita más aire sin relanzarlo.
Para terminar la unidad:
sudo systemctl stop mi-tarea.service
sudo systemctl kill -s SIGKILL mi-tarea.service
Casos prácticos y advertencias
Escenarios donde systemd-run es la herramienta adecuada:
- Aislar un compilador pesado durante un despliegue:
CPUQuota=300%,MemoryMax=4G. - Ejecutar scrapers o crawlers con
IOWeight=20para no saturar el disco del host. - Probar carga con
stress-ngsin miedo a colgar la sesión SSH. - Contener un binario sospechoso con
TasksMax=16yMemoryMax=256M.
Advertencias importantes:
- Los límites solo aplican si el kernel tiene cgroups v2 montado unificado. En híbrido, algunas propiedades fallan silenciosamente.
--scopese ejecuta de forma síncrona en el shell actual y hereda el cgroup del usuario;--service(por defecto) crea una unidad nueva. Para límites estrictos, usa siempre el modo service.- Si ejecutas como usuario sin privilegios, necesitas
--usery una sesión systemd de usuario activa (loginctl enable-linger