Limitar memoria y CPU de un servicio con systemd
Configura MemoryHigh=512M, MemoryMax=768M, CPUQuota=80% y TasksMax=128 en un servicio systemd, y verifica el OOM kill sin dejar colgado el VPS.
Limitar la memoria y la CPU de un proceso con un drop-in de systemd
Puede limitar la memoria y la CPU de un proceso en un VPS Linux añadiendo unas líneas a la unidad que ejecuta el proceso. MemoryMax= es el límite máximo de memoria. CPUQuota= es el límite de tiempo de procesador. Ambos se aplican mediante cgroup v2 (grupos de control, versión 2), la función del kernel que systemd ya utiliza para contabilizar cada servicio del sistema.
sudo systemctl edit myapp.serviceSe abre un archivo drop-in con instrucciones en los comentarios. Añada esto encima de ellas:
[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMaxsystemctl show debe devolver los números en las unidades propias del kernel: MemoryMax=805306368 y CPUQuotaPerSecUSec=800ms. Si muestra MemoryMax=infinity, el drop-in no se ha cargado. Compruebe que el archivo se haya creado en /etc/systemd/system/myapp.service.d/override.conf y que comience con la cabecera [Service], porque una línea de configuración sin una sección previa hace que systemd registre Assignment outside of section. Ignoring. e inicie el servicio sin ningún límite.
El resto de esta guía explica cómo elegir esos valores y qué problemas pueden seguir produciéndose después de configurarlos.
Por qué un proceso descontrolado congela un VPS aunque nunca lo llene
Un proceso que alcanza un límite estricto de memoria termina en aproximadamente un segundo y el servicio se reinicia. Ese es el caso bueno. El caso malo es aquel en el que no termina ningún proceso: el equipo responde al ping, SSH acepta la conexión, pero el prompt del shell nunca aparece. La máquina sigue activa y ocupada, pero ninguna de esas operaciones resulta útil.
Este es el mecanismo, porque no es evidente. Cuando queda poca memoria libre, el kernel recupera páginas en lugar de asignar otras nuevas. Las páginas más fáciles de recuperar son las respaldadas por archivos, y la caché de páginas contiene el código ejecutable de todo lo que está en ejecución. Por tanto, el kernel expulsa las páginas de texto de sshd, y la siguiente instrucción que ejecuta sshd provoca un fallo de página que debe volver a leer esos bytes desde el almacenamiento. Todos los procesos terminan esperando al disco en lugar de ejecutarse. Las mismas páginas salen y vuelven en un ciclo, lo que se denomina thrashing.
Dos factores empeoran esta situación en un VPS frente a un portátil. El almacenamiento suele estar conectado por red o ser compartido, por lo que cada fallo cuesta más milisegundos que en un dispositivo NVMe local. Además, el kernel no mide el tiempo, sino el fallo: mientras la recuperación siga devolviendo una página, aunque sea lentamente, el kernel considera que está avanzando y no activa el out of memory (OOM) killer. Un equipo puede permanecer en ese estado durante muchos minutos antes de que se termine algún proceso.
Puede observar cómo ocurre. El kernel exporta pressure stall information (PSI) en Linux 4.20 y versiones posteriores:
cat /proc/pressure/memory
cat /proc/pressure/iosome avg10=63.72 avg60=41.02 avg300=12.33 total=13729481
full avg10=48.15 avg60=30.44 avg300=8.90 total=9114233La línea full es la importante. full avg10=48.15 significa que durante el 48% de los últimos diez segundos, todas las tareas que no estaban inactivas en el equipo estuvieron bloqueadas por falta de memoria al mismo tiempo, por lo que ninguna de sus operaciones avanzaba. En un servidor en buen estado, full suele mostrar un valor cercano a cero. Por encima de 10, el sistema se percibe lento; con 40 o más se encuentra en el estado que normalmente se describe como congelado.
Por eso un límite, por sí solo, no constituye una garantía. Una unidad sometida a MemoryHigh= queda limitada en lugar de terminar, por lo que sigue activa y lenta, y nada la reinicia porque, desde el punto de vista de systemd, nunca ha fallado. Una unidad con un límite que todavía puede usar swap genera lecturas y escrituras que se contabilizan para esa unidad, pero que atiende un único dispositivo compartido. Por tanto, puede elevar /proc/pressure/io para todos los demás servicios del equipo. Los límites determinan quién asume el coste de una escasez, pero no pueden crear capacidad.
Compruebe que su VPS ejecuta cgroup v2
stat -fc %T /sys/fs/cgroupcgroup2fs es la jerarquía unificada que necesitan los ajustes de memoria siguientes. tmpfs indica que el sistema arrancó con la disposición antigua de v1, donde MemoryHigh= y MemorySwapMax= no son compatibles y el comportamiento de OOM por unidad es diferente, aunque CPUQuota= sigue funcionando mediante el archivo heredado cpu.cfs_quota_us. Ubuntu 22.04 y posteriores, y Debian 11 y posteriores, usan v2 de forma predeterminada. Una imagen antigua no lo hace. Tampoco lo hace un kernel arrancado con systemd.unified_cgroup_hierarchy=0 en systemd 257 o anteriores. systemd 258 eliminó la compatibilidad con cgroup v1 y siempre monta la jerarquía unificada durante el arranque. Por tanto, en las versiones que incluyen ese cambio, ese argumento ya no permite volver a v1.
En cgroup v2, systemd activa de forma predeterminada la contabilidad de memoria para todas las unidades, por lo que los valores ya están disponibles:
systemd-cgtop -mEsto muestra los cgroups ordenados por uso de memoria. Es la forma más rápida de responder a «qué está consumiendo este sistema» mientras todavía puede responder. Si el servidor es nuevo, la configuración de la cuenta y del firewall descrita en los primeros diez minutos en un VPS nuevo debe hacerse antes que esto.
MemoryHigh limita. MemoryMax finaliza procesos.
La diferencia entre estos dos ajustes de memoria determina cómo se presenta un fallo.
MemoryHigh=es un límite flexible. Cuando se supera, el kernel recupera memoria de forma agresiva de ese cgroup y ralentiza deliberadamente sus asignaciones. El consumo puede superar el valor y no se finaliza ningún proceso.MemoryMax=es un límite estricto. Cuando no se puede satisfacer una asignación sin superarlo, se ejecuta el OOM killer dentro de ese cgroup y finaliza uno de los procesos propios de esa unidad.
Esta segunda parte es el motivo principal para configurar MemoryMax= en todo lo que no controle por completo. Sin límite, una falta de memoria afecta a todo el equipo y el OOM killer global elige la víctima según oom_score, lo que normalmente significa el proceso más grande. El proceso más grande suele ser la base de datos, no el script que provocó la fuga. Con un límite, la finalización se produce dentro de la unidad que causó el problema.
Configure ambos límites y establezca MemoryHigh= aproximadamente entre un 20 y un 30 por ciento por debajo de MemoryMax=. La diferencia crea una zona de advertencia: una fuga lenta supera High y se manifiesta como un servicio que se vuelve lento, mientras que un aumento repentino atraviesa directamente Max y provoca la finalización del proceso.
Los valores porcentuales se calculan respecto a la memoria física instalada. Por tanto, MemoryMax=25% en un plan de 4 GB equivale a 1 GB y sigue representando una cuarta parte del equipo después de ampliar el plan. MemorySwapMax=0 impide por completo que esa unidad use swap. Cuando alcanza MemoryMax=, la finalización se produce rápidamente en lugar de después de un largo periodo de paginación. Por debajo de ese punto, MemoryHigh= todavía puede limitarla. Superar el límite alto nunca ejecuta el OOM killer, por lo que una unidad que permanece entre ambos límites se mantiene lenta en lugar de finalizar.
Algunos servicios permiten definir por adelantado cuánta memoria necesitan, en lugar de medirla. Una unidad de Ollama calcula el tamaño de su caché KV a partir de la ventana de contexto que se le indique. Consulte qué coste en RAM tiene aumentar num_ctx antes de elegir el límite de una unidad.
Un límite necesita una política de reinicio junto a él. De lo contrario, la finalización sólo deja el servicio detenido.
[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5
[Service]
Restart=on-failure
RestartSec=5sStartLimit* debe estar en [Unit] y Restart= en [Service]. Si coloca cualquiera de los dos en la sección incorrecta, systemd lo ignora. Cinco reinicios en cinco minutos indican una fuga, no un fallo puntual. Después de eso, systemd deja de intentarlo y marca la unidad como fallida. Ese es el estado que conviene encontrar más adelante, en lugar de un bucle de fallos que oculte el problema.
Limite la CPU con CPUQuota o compártala con CPUWeight
CPUQuota= utiliza un porcentaje del tiempo disponible en una CPU. CPUQuota=50% equivale a medio núcleo. CPUQuota=200% equivale a dos núcleos, que la unidad puede distribuir entre tantos hilos como necesite. En un plan con 2 vCPU, CPUQuota=200% equivale a toda la máquina.
CPUWeight= es la opción predeterminada más adecuada para la mayoría de los servicios. Es una proporción relativa de 1 a 10000, y el valor predeterminado del kernel es 100. Sólo tiene efecto cuando existe competencia: una tarea de copia de seguridad con CPUWeight=20 cede tiempo a un servidor web con 100 bajo carga, y sigue utilizando toda la máquina cuando está inactiva. Una cuota estricta desperdicia esa capacidad disponible.
Sea preciso sobre lo que ofrece un límite de CPU. Un proceso limitado por CPU rara vez bloquea Linux, porque el planificador sigue asignando tiempo a todos los procesos. La memoria es lo que puede dejar fuera de servicio una máquina. Use CPUQuota= cuando necesite un límite máximo predecible, por ejemplo, en una compilación o en un agente que, de otro modo, se ejecutaría al máximo durante una hora. Dimensionar ese tipo de carga es otra cuestión, que se trata en cuánta RAM y CPU necesita un VPS para un agente de programación.
Si la CPU aparece ocupada mientras ninguno de sus procesos hace un uso significativo, la causa puede estar al otro lado del hipervisor. Eso es tiempo de CPU robado por un vecino ruidoso, y ninguna cuota que establezca lo cambiará.
TasksMax detiene un bucle de fork
TasksMax= es el número de procesos e hilos que una unidad puede mantener. Los hilos cuentan, por lo que un servicio Java o Go necesita más margen del que sugiere la lista de procesos. Es la protección más sencilla contra un script que ejecuta fork en un bucle, porque fork falla dentro de la unidad en lugar de agotar los identificadores de proceso del servidor.
TasksMax=128Cuando una unidad alcanza el límite, el kernel registra una línea que identifica el cgroup:
cgroup: fork rejected by pids controller in /system.slice/myapp.serviceEl propio programa suele informar fork: retry: Resource temporarily unavailable. Compruebe qué aplica el gestor de forma predeterminada con systemctl show -p DefaultTasksMax.
Limitar un trabajo puntual con systemd-run
No necesita un archivo de unidad para usar nada de esto. systemd-run crea una unidad transitoria alrededor de un único comando.
sudo systemd-run --scope -p MemoryMax=1G -p MemorySwapMax=0 -p CPUQuota=50% -p TasksMax=64 ./import-data.sh--scope ejecuta el comando en su terminal después de mostrar Running scope as unit: run-r7c1a....scope. La salida permanece en pantalla y los límites desaparecen cuando termina el comando. Cualquier propiedad de systemd.resource-control funciona después de -p.
Para un trabajo largo, omita --scope y asígnele un nombre. Se ejecutará en segundo plano como un servicio transitorio y escribirá los registros en el journal:
sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -fLas mismas opciones funcionan con --user cuando no es root, aunque el gestor de usuario sólo tiene los controladores que se le hayan delegado, por lo que una propiedad puede rechazarse. Si ocurre, ejecútelo con sudo. Cuando un trabajo necesita una unidad permanente, traslade la configuración sin cambios a una unidad real: consulte ejecutar un script como servicio y temporizador de systemd.
La pregunta sobre la swap, respondida con honestidad
La swap cambia la forma del fallo, pero no lo evita.
Sin swap, una fuga alcanza el límite y algún proceso muere en cuestión de segundos. La interrupción es evidente, breve y fácil de interpretar después en el journal. Con swap, el kernel escribe en disco las páginas anónimas inactivas y gana tiempo. Si el proceso iba a estabilizarse, la swap ayuda. Si es un proceso descontrolado, la swap convierte una interrupción de cinco segundos en una espera de veinte minutos. La espera es peor, porque un proceso muerto todavía deja un shell operativo, pero un sistema saturado por swapping no.
swapon --show
free -hUna opción equilibrada para un VPS pequeño es mantener un archivo de swap moderado para las páginas que se asignan una vez y nunca vuelven a usarse, y establecer MemorySwapMax=0 en las unidades que esté dispuesto a perder. Los servicios importantes conservan su swap. Los servicios impredecibles alcanzan rápidamente el límite, y la política de reinicio situada junto a ese límite los vuelve a iniciar.
Reducir vm.swappiness es una palanca poco eficaz, y conviene entender por qué. Sólo desplaza el equilibrio entre expulsar la caché de páginas y pasar páginas anónimas a la swap, y ambas operaciones requieren después una lectura desde disco. Cambia qué páginas sufren thrashing, pero no si el sistema lo sufre.
Un demon OOM temprano mata procesos antes del bloqueo
El kernel espera a que la recuperación de memoria falle por completo. En un VPS pequeño, esa espera es precisamente el intervalo en el que se pierde el acceso a la máquina. Dos demonios de espacio de usuario reducen ese intervalo al supervisar la memoria por su cuenta y matar procesos antes.
earlyoom comprueba la memoria disponible y el espacio de intercambio libre hasta diez veces por segundo. Sólo mata el proceso con el valor más alto de oom_score cuando ambos valores caen por debajo de sus umbrales. En un sistema sin espacio de intercambio, sólo decide el umbral de memoria.
sudo apt install earlyoom
systemctl status earlyoomEl paquete de Debian y Ubuntu inicia el servicio durante la instalación. Sus opciones se encuentran en /etc/default/earlyoom:
EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"-m PERCENT establece el mínimo de memoria disponible y -s PERCENT el mínimo de espacio de intercambio libre. Ambos valores son del 10 por ciento de forma predeterminada. El segundo número de cada par es el umbral de SIGKILL: earlyoom envía SIGTERM cuando la memoria y el espacio de intercambio caen por debajo de sus primeros valores, y después envía SIGKILL cuando ambos están por debajo del segundo valor, que de forma predeterminada es la mitad del primero. Deje los patrones --avoid y --prefer sin comillas y sin espacios, porque systemd pasa literalmente los caracteres de comillas y un patrón entrecomillado nunca coincide. Aplique un cambio con sudo systemctl restart earlyoom y consulte journalctl -u earlyoom para ver qué proceso terminó y cuánta memoria ocupaba.
systemd-oomd es la otra opción. Su página del manual lo describe como «un servicio del sistema que usa cgroups-v2 y la información de presión de espera (PSI) para supervisar el sistema y aplicar medidas correctivas antes de que se produzca un OOM en el espacio del kernel». Actúa sobre cgroups completos en lugar de procesos individuales. Por tanto, termina una unidad y no un proceso hijo aislado. Las unidades se habilitan explícitamente con ManagedOOMMemoryPressure=kill o ManagedOOMSwap=kill, y los umbrales se encuentran en /etc/systemd/oomd.conf.
systemctl status systemd-oomd
oomctloomctl muestra qué está supervisando actualmente. En una imagen de servidor, normalmente no muestra nada porque la configuración se habilita de forma explícita para cada unidad. Elija un solo demonio y use únicamente ese. Ejecutar ambos hace que compitan para elegir una víctima y dificulta reconstruir el motivo de cada terminación.
¿Qué unidad fue responsable?
Empiece por el kernel, porque registra cada proceso que termina.
journalctl -k --grep "Killed process" --since "2 hours ago"Un proceso terminado por el OOM killer global aparece así:
Out of memory: Killed process 4127 (node) total-vm:2731084kB, anon-rss:1874232kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:4212kB oom_score_adj:0anon-rss es la memoria anónima, como el heap, que ese proceso mantenía en RAM cuando terminó; aquí son aproximadamente 1.8 GB. Las asignaciones residentes de archivos y la memoria compartida se contabilizan por separado, como file-rss y shmem-rss. Interprete con cautela el nombre entre corchetes. Es la víctima que eligió el kernel, y el kernel elige el proceso más grande, que no siempre es el que causó la falta de memoria.
Un proceso terminado por un límite de cgroup lleva un prefijo diferente, y el informe que aparece encima identifica el cgroup que alcanzó su propio límite:
Memory cgroup out of memory: Killed process 8811 (python3) total-vm:1044320kB, anon-rss:769112kB, file-rss:0kB, shmem-rss:0kB, UID:998 pgtables:1720kB oom_score_adj:0Ese prefijo proporciona la mayor parte del diagnóstico. Memory cgroup out of memory significa que una unidad alcanzó el MemoryMax= que se le asignó y que el resto del sistema funcionaba correctamente. Un Out of memory sin más significa que se agotó la memoria de toda la máquina, por lo que faltaban límites o eran demasiado altos en conjunto.
Después, consulte a systemd sobre lo que detectó:
systemctl status myapp.service
journalctl -u myapp.service -n 50myapp.service: A process of this unit has been killed by the OOM killer.
myapp.service: Main process exited, code=killed, status=9/KILL
myapp.service: Failed with result 'oom-kill'.systemctl status indica lo mismo en una sola línea, como Active: failed (Result: oom-kill).
Los contadores del cgroup son la tercera fuente y la única que registra la limitación de recursos, que nunca genera una línea en el registro:
cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peaklow 0
high 4213
max 118
oom 12
oom_kill 12high cuenta cuántas veces la unidad superó MemoryHigh= y fue limitada. max cuenta cuántas veces alcanzó el límite estricto, y oom_kill cuenta los procesos terminados realmente. Un valor alto de high junto con oom_kill 0 representa el caso silencioso anterior: desde que se creó su cgroup, la unidad ha sido limitada una y otra vez sin que se terminara ningún proceso, por lo que systemd no ha registrado ningún fallo. El contador sólo aumenta, así que léalo dos veces con un minuto de diferencia: un high que siga aumentando indica que la limitación está ocurriendo ahora. memory.peak (Linux 5.19 y posteriores) contiene el uso máximo que alcanzó el cgroup; ese es el valor con el que debe dimensionar MemoryMax=. Ambos archivos se restablecen cuando se reinicia la unidad, porque systemd vuelve a crear el cgroup.
Hay un requisito previo para todo esto. Si no existe /var/log/journal, el journal se almacena en RAM y todas las líneas se pierden después del reinicio que necesitaba para recuperar el sistema.
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-bootsQue journalctl --list-boots muestre algo más que el arranque actual significa que el historial se conserva. Por tanto, journalctl -k -b -1 puede mostrarle los mensajes del kernel del arranque que terminó.
Un punto de partida para un VPS pequeño
En un plan de 2 GB, reserve entre 300 y 400 MB para el kernel y la caché de páginas, y no deje que la suma de los límites alcance los 2 GB completos, porque todas las unidades pueden alcanzar su pico al mismo tiempo. Asigne la mayor parte al servicio más importante y establezca límites para todo lo especulativo que lo rodea.
[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5sVale la pena añadir un ajuste más para conservar una vía de acceso. OOMScoreAdjust=-500 en un drop-in para ssh.service hace mucho menos probable que el OOM killer global elija su daemon SSH como víctima, lo que puede marcar la diferencia entre reparar el equipo y reiniciarlo desde el panel de control. Sólo cambia la elección de la víctima por parte del kernel. No acorta la interrupción.
Los contenedores se ejecutan en cgroups propios, creados por el runtime de contenedores y no por los archivos de unidad, por lo que un límite en docker.service no se convierte en un límite para un contenedor. Los equivalentes por contenedor de MemoryMax= y CPUQuota= se explican en configurar límites de memoria y CPU en Docker Compose.
FAQ
¿Por qué mi VPS se bloqueó en lugar de finalizar el proceso descontrolado?
Porque el kernel evalúa el progreso según si la recuperación devuelve páginas, no según cuánto tarda. Cuando falta memoria, expulsa la caché de páginas, incluidas las páginas ejecutables de los programas en ejecución, y las vuelve a leer en la siguiente instrucción. Todo queda esperando al almacenamiento y ninguna asignación ha fallado técnicamente, por lo que nunca se llama al OOM killer. Compruebe /proc/pressure/memory mientras ocurre: un full avg10 superior a 40 significa que, durante más del 40% de los últimos diez segundos, todas las tareas que no estaban inactivas permanecieron bloqueadas simultáneamente por falta de memoria. Un daemon de espacio de usuario como earlyoom finaliza procesos antes de que el equipo llegue a ese estado.
¿Cuál es la diferencia entre MemoryHigh y MemoryMax?
MemoryHigh= es un límite flexible que aplica regulación. El kernel recupera memoria de forma agresiva de la unidad y ralentiza sus asignaciones, pero el uso puede superar ese valor y no se finaliza ningún proceso. MemoryMax= es un límite estricto: una asignación que no se puede satisfacer dentro de ese límite invoca el OOM killer en el cgroup propio de la unidad, por lo que muere el proceso que causó el problema en lugar del proceso más grande del equipo. Establezca MemoryHigh= por debajo de MemoryMax= y trate la diferencia entre ambos como una zona de advertencia.
¿Cómo averiguo qué servicio alcanzó el OOM killer?
Ejecute journalctl -k --grep "Killed process" --since "2 hours ago". Una línea que empiece por Memory cgroup out of memory significa que una unidad alcanzó su propio MemoryMax=, mientras que un Out of memory sin prefijo significa que se agotó la memoria de todo el equipo. Después, ejecute journalctl -u <unit> -n 50 y busque Failed with result 'oom-kill'. Si /var/log/journal no existe en su servidor, el journal se mantuvo en RAM y las pruebas se perdieron al reiniciar, por lo que debe crear ese directorio antes del próximo incidente.
¿Debo añadir swap a un VPS pequeño?
Un archivo de swap pequeño ayuda con las páginas frías que se asignan una vez y nunca vuelven a utilizarse. No ayuda con un proceso descontrolado: retrasa su finalización y convierte una interrupción breve en un bloqueo prolongado en el que no puede iniciar sesión para solucionarlo. Mantenga la swap en un tamaño moderado y establezca MemorySwapMax=0 en las unidades que esté dispuesto a perder, para que alcancen rápidamente su límite y, con Restart=on-failure configurado, se recuperen por sí solas mientras los servicios importantes conservan su swap.
¿Puedo limitar un comando sin escribir un archivo de unidad?
Sí. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh ejecuta el comando en su terminal dentro de un scope transitorio con esos límites, y los límites desaparecen cuando el comando finaliza. Todas las propiedades de systemd.resource-control están disponibles después de -p, por lo que MemorySwapMax=, TasksMax= y CPUWeight= también funcionan ahí. Quite --scope y añada --unit=name para ejecutar el trabajo en segundo plano con su salida en el journal.