SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor · Atualizado 2026-10-30

Como limitar memória e CPU com systemd

Configure MemoryHigh, MemoryMax, CPUQuota e TasksMax no serviço systemd. Veja por que MemoryMax=805306368 e CPUQuotaPerSecUSec=800ms confirmam o limite.

Limite a memória e a CPU dos processos com um drop-in do systemd

Para limitar a memória e a CPU de um processo numa VPS Linux, adicione algumas linhas à unidade que executa o processo. MemoryMax= é o limite máximo de memória. CPUQuota= é o limite de tempo de processador. Ambos são aplicados pelo cgroup v2 (control groups, versão 2), a funcionalidade do kernel que o systemd já utiliza para contabilizar cada serviço no sistema.

sudo systemctl edit myapp.service

Isto abre um ficheiro drop-in com instruções em comentários. Adicione o seguinte antes dessas instruções:

[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128
sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMax

systemctl show deve repetir os seus valores nas unidades utilizadas pelo próprio kernel: MemoryMax=805306368 e CPUQuotaPerSecUSec=800ms. Se apresentar MemoryMax=infinity, o drop-in não foi carregado. Verifique se o ficheiro foi criado em /etc/systemd/system/myapp.service.d/override.conf e se começa pelo cabeçalho [Service], porque uma linha de configuração sem uma secção anterior faz o systemd registar Assignment outside of section. Ignoring. e iniciar o serviço sem quaisquer limites.

O restante deste guia explica como escolher esses valores e que problemas ainda podem ocorrer depois de os definir.

Por que um processo descontrolado congela um VPS sem o encher

Um processo que atinge um limite rígido de memória termina em cerca de um segundo e o serviço é reiniciado. Esse é o caso bom. O caso mau é aquele em que nada termina: a máquina responde a ping, o SSH aceita a ligação, mas a prompt da shell nunca aparece. A máquina está ativa e ocupada, mas nenhum desse trabalho é útil.

Este é o mecanismo, porque não é óbvio. Quando a memória livre fica baixa, o kernel recupera páginas em vez de atribuir páginas novas. As páginas mais fáceis de recuperar são as associadas a ficheiros, e a cache de páginas contém o código executável de tudo o que está em execução. Por isso, o kernel expulsa as páginas de código de sshd, e a instrução seguinte sshd executada provoca uma falha de página que tem de ler esses bytes novamente do armazenamento. Todos os processos acabam por esperar pelo disco em vez de executar. As mesmas páginas são expulsas e carregadas novamente num ciclo, um fenómeno chamado thrashing.

Duas características tornam este problema pior num VPS do que num portátil. O armazenamento está muitas vezes ligado através da rede ou é partilhado, por isso cada falha de página custa mais milissegundos do que num dispositivo NVMe local. Além disso, o kernel não mede o tempo; mede as falhas: enquanto a recuperação continuar a devolver uma página, por mais lentamente que isso aconteça, o kernel considera que está a progredir e não chama o out of memory (OOM) killer. Uma máquina pode permanecer nesse estado durante muitos minutos antes de qualquer processo ser terminado.

Pode observar este comportamento. O kernel exporta informações de pressão e bloqueio (PSI) no Linux 4.20 e posteriores:

cat /proc/pressure/memory
cat /proc/pressure/io
some avg10=63.72 avg60=41.02 avg300=12.33 total=13729481
full avg10=48.15 avg60=30.44 avg300=8.90 total=9114233

A linha full é a importante. full avg10=48.15 significa que, durante 48% dos últimos dez segundos, todas as tarefas não inativas da máquina ficaram bloqueadas à espera de memória no mesmo momento. Por isso, nenhum dos seus trabalhos estava a progredir. Um servidor saudável apresenta um valor próximo de zero em full. Acima de 10, a lentidão já é percetível para uma pessoa. Valores de 40 ou superiores correspondem ao estado que as pessoas descrevem como congelado.

É também por isso que um limite, por si só, não é uma garantia. Uma unidade limitada por MemoryHigh= é estrangulada em vez de ser terminada. Continua ativa e lenta, e nada a reinicia porque, do ponto de vista do systemd, nunca falhou. Uma unidade limitada que ainda pode usar swap gera leituras e escritas contabilizadas nessa unidade, mas servidas por um único dispositivo partilhado. Isso pode aumentar /proc/pressure/io para todos os outros serviços da máquina. Os limites determinam quem suporta os custos de uma falta de recursos, mas não criam capacidade.

Verifique se o seu VPS utiliza cgroup v2

stat -fc %T /sys/fs/cgroup

cgroup2fs é a hierarquia unificada, necessária para as definições de memória abaixo. tmpfs significa que o servidor arrancou com a disposição antiga do v1, na qual MemoryHigh= e MemorySwapMax= não são suportados e o comportamento de OOM por unidade é diferente, embora CPUQuota= continue a funcionar através do ficheiro legado cpu.cfs_quota_us. Ubuntu 22.04 e versões posteriores, bem como Debian 11 e versões posteriores, utilizam v2 por predefinição. Uma imagem antiga não utiliza v2 e, no systemd 255 ou anterior, também não utiliza v2 se o kernel arrancar com systemd.unified_cgroup_hierarchy=0. O systemd 256 e 257 recusam arrancar em v1, a menos que SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1 também esteja na linha de comandos do kernel. O systemd 258 removeu o suporte para cgroup v1 e monta sempre a hierarquia unificada durante o arranque. Por isso, nas versões que o incluem, nenhum dos argumentos faz o v1 voltar.

No cgroup v2, o systemd ativa por predefinição a contabilização de memória para cada unidade. Por isso, os valores já estão disponíveis:

systemd-cgtop -m

Isto lista os cgroups por ordem de utilização de memória. É a forma mais rápida de responder a "o que está a consumir este servidor" enquanto ele ainda consegue responder. Se o servidor for novo, o trabalho de configuração da conta e da firewall em os primeiros dez minutos num VPS novo deve ser feito antes disto.

Limites de memória: MemoryHigh abranda, MemoryMax termina.

A diferença entre as duas definições de memória determina o aspeto de uma falha.

  • MemoryHigh= é um limite flexível. Acima desse valor, o kernel recupera memória de forma agressiva desse cgroup e abranda deliberadamente as respetivas alocações. O uso pode continuar acima do valor definido e nenhum processo é terminado.
  • MemoryMax= é um limite rígido. Quando uma alocação não pode ser satisfeita dentro desse limite, o OOM killer é executado dentro desse cgroup e termina um dos processos da própria unidade.

Esta segunda parte é o verdadeiro motivo para definir MemoryMax= em tudo aquilo em que não confia totalmente. Sem limite, a falta de memória afeta todo o servidor, e o OOM killer global escolhe a vítima com base em oom_score, o que normalmente significa o processo maior. O processo maior costuma ser a base de dados, não o script que causou a fuga de memória. Com um limite, o processo terminado pertence à unidade que causou o problema.

Defina ambos, com MemoryHigh= cerca de 20 a 30 por cento abaixo de MemoryMax=. O intervalo entre os dois é uma zona de aviso: uma fuga lenta ultrapassa High e manifesta-se como um serviço que ficou lento, enquanto um pico súbito ultrapassa diretamente Max e termina o processo.

Os valores percentuais são calculados com base na memória física instalada. Assim, MemoryMax=25% num plano de 4 GB corresponde a 1 GB e continua a representar um quarto do servidor depois de aumentar o plano. MemorySwapMax=0 impede completamente que essa unidade use swap. Quando atinge MemoryMax=, o processo é terminado rapidamente, em vez de isso acontecer apenas depois de uma longa degradação causada pela swap. Abaixo desse valor, MemoryHigh= ainda pode abrandar a unidade. Ultrapassar o limite alto nunca ativa o OOM killer. Por isso, uma unidade que permanece entre os dois limites fica lenta em vez de terminar.

Alguns serviços permitem definir antecipadamente o consumo esperado, em vez de o medir. Uma unidade Ollama dimensiona a cache KV a partir da janela de contexto que definir. Por isso, leia o custo em RAM de aumentar num_ctx antes de escolher um limite para essa unidade.

Um limite precisa de uma política de reinício associada. Caso contrário, o processo terminado deixa apenas um serviço parado.

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Restart=on-failure
RestartSec=5s

StartLimit* deve ficar em [Unit] e Restart= em [Service]. Se colocar qualquer um deles na secção errada, o systemd ignora-o. Cinco reinícios em cinco minutos indicam uma fuga, não uma falha momentânea. Depois disso, o systemd desiste e deixa a unidade no estado failed. É esse o estado que pretende encontrar mais tarde, em vez de um ciclo de falhas que oculta o problema.

Limite a CPU com CPUQuota ou partilhe-a com CPUWeight

CPUQuota= usa uma percentagem do tempo disponível num CPU. CPUQuota=50% corresponde a metade de um core. CPUQuota=200% equivale a dois cores, que a unidade pode distribuir pelo número de threads que entender. Num plano com 2 vCPUs, CPUQuota=200% corresponde à máquina inteira.

CPUWeight= é a melhor predefinição para a maioria dos serviços. É uma quota relativa entre 1 e 10000, e o valor predefinido do kernel é 100. Só tem efeito quando existe concorrência: uma tarefa de backup com CPUWeight=20 cede capacidade a um servidor Web com 100 durante a carga, mas continua a usar toda a máquina quando esta está inativa. Uma quota rígida desperdiça essa capacidade disponível.

Seja realista quanto ao que um limite de CPU oferece. Um processo limitado pela CPU raramente bloqueia o Linux, porque o escalonador continua a atribuir tempo a todos os processos. É a memória que pode fazer uma máquina deixar de responder. Use CPUQuota= quando precisar de um limite previsível, por exemplo numa compilação ou num agente que, de outro modo, usaria toda a CPU durante uma hora. Dimensionar esse tipo de carga é uma questão separada, abordada em quanta RAM e CPU um VPS para um agente de programação precisa.

Se a CPU aparecer como ocupada quando nenhum dos seus processos estiver a fazer muito, a causa pode estar do outro lado do hipervisor. Trata-se de tempo de CPU steal causado por um vizinho ruidoso, e nenhum limite que defina alterará essa situação.

TasksMax impede um loop de fork

TasksMax= é o número de processos e threads que uma unidade pode manter. As threads contam, por isso um serviço Java ou Go precisa de mais margem do que a lista de processos sugere. Esta é a proteção mais simples contra um script que executa fork num loop, porque o fork falha dentro da unidade em vez de o servidor ficar sem IDs de processos.

TasksMax=128

Quando uma unidade atinge o limite, o kernel regista uma linha que identifica o cgroup:

cgroup: fork rejected by pids controller in /system.slice/myapp.service

O próprio programa normalmente comunica fork: retry: Resource temporarily unavailable. Verifique o que o gestor aplica por predefinição com systemctl show -p DefaultTasksMax.

Limite um trabalho pontual com systemd-run

Não precisa de um ficheiro de unidade para usar nada disto. systemd-run cria uma unidade transitória à volta de um único comando.

sudo systemd-run --scope -p MemoryMax=1G -p MemorySwapMax=0 -p CPUQuota=50% -p TasksMax=64 ./import-data.sh

--scope executa o comando no seu terminal, depois de apresentar Running scope as unit: run-r7c1a....scope. O resultado permanece no ecrã e os limites desaparecem quando o comando termina. Qualquer propriedade de systemd.resource-control funciona depois de -p.

Para um trabalho demorado, remova --scope e atribua-lhe um nome. O trabalho é executado em segundo plano como um serviço transitório e regista os eventos no journal:

sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -f

As mesmas opções funcionam com --user quando não é root, embora o gestor do utilizador tenha apenas os controladores que lhe foram delegados, pelo que uma propriedade pode ser rejeitada nesse contexto. Execute-o com sudo se isso acontecer. Quando um trabalho passa a ter uma configuração permanente, as definições são transferidas sem alterações para uma unidade real: consulte executar um script como serviço e temporizador do systemd.

A questão do swap, respondida com honestidade

O swap altera a forma como a falha acontece, em vez de a impedir.

Sem swap, uma fuga de memória atinge o limite e algum processo termina em segundos. A interrupção é evidente, curta e fácil de analisar depois no journal. Com swap, o kernel grava em disco as páginas anónimas frias e ganha tempo. Se o processo ia estabilizar, o swap ajuda. Se for um processo descontrolado, o swap transforma uma interrupção de cinco segundos num bloqueio de vinte minutos. E o bloqueio é pior, porque um processo terminado ainda deixa um shell funcional, enquanto um sistema em thrashing não.

swapon --show
free -h

Uma opção equilibrada para um VPS pequeno é manter um ficheiro de swap moderado para páginas alocadas uma vez e nunca mais utilizadas, e definir MemorySwapMax=0 nas unidades que aceita perder. Os serviços importantes mantêm acesso ao swap. Os serviços imprevisíveis atingem rapidamente o limite, e a política de reinício junto ao respetivo limite volta a iniciá-los.

Reduzir vm.swappiness é uma medida pouco eficaz, e é importante perceber porquê. Apenas altera o equilíbrio entre expulsar a cache de páginas e trocar páginas anónimas, e ambas as opções exigem uma leitura do disco mais tarde. Altera quais páginas entram em thrashing, mas não impede que o sistema entre em thrashing.

Um daemon de OOM antecipado termina processos antes da paragem

O kernel espera que a recuperação de memória falhe completamente. Numa VPS pequena, essa espera é precisamente o intervalo em que perde a máquina. Dois daemons de espaço do utilizador eliminam esse intervalo ao monitorizarem a memória e terminarem processos mais cedo.

earlyoom verifica a memória disponível e o swap livre até dez vezes por segundo. Só termina o processo com o maior valor de oom_score quando ambos descem abaixo dos respetivos limites. Numa máquina sem swap, apenas o limite de memória determina a ação.

sudo apt install earlyoom
systemctl status earlyoom

O pacote Debian e Ubuntu inicia o serviço durante a instalação. As opções estão em /etc/default/earlyoom:

EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"

-m PERCENT define o mínimo de memória disponível e -s PERCENT o mínimo de swap livre. Ambos têm o valor predefinido de 10 por cento. O segundo número de cada par é o limite de SIGKILL. O earlyoom envia SIGTERM quando a memória e o swap descem abaixo dos primeiros valores. Depois envia SIGKILL quando ambos ficam abaixo do segundo valor, que por predefinição corresponde a metade do primeiro. A unidade passa esta variável ao earlyoom como $EARLYOOM_ARGS. Por isso, o systemd divide-a em argumentos nos espaços em branco. Colocar entre aspas os padrões --avoid e --prefer é seguro. O systemd remove as aspas duplas exteriores ao ler o ficheiro. Depois, ao dividir o valor, interpreta e remove as aspas simples interiores. Assim, --avoid '^(sshd|systemd)$' funciona da mesma forma que a forma sem aspas acima. Um padrão que contenha um espaço precisa dessas aspas simples. Caso contrário, é dividido em dois argumentos. Aplique uma alteração com sudo systemctl restart earlyoom. Consulte journalctl -u earlyoom para ver qual processo foi terminado e quanta memória esse processo tinha alocada.

systemd-oomd é a outra opção. A respetiva página de manual descreve-o como "um serviço de sistema que utiliza cgroups-v2 e informações de pressão de recursos (PSI) para monitorizar e tomar medidas corretivas antes de ocorrer um OOM no espaço do kernel". Atua sobre cgroups completos, e não sobre processos individuais. Por isso, termina uma unidade, e não um processo filho isolado. As unidades podem ativá-lo com ManagedOOMMemoryPressure=kill ou ManagedOOMSwap=kill. Os limites estão em /etc/systemd/oomd.conf.

systemctl status systemd-oomd
oomctl

oomctl mostra o que está a monitorizar atualmente. Num servidor, muitas vezes não mostra nada, porque a configuração tem de ser ativada individualmente em cada unidade. Escolha um daemon e use apenas esse. Executar ambos significa que há dois componentes a competir pela escolha de uma vítima. Também fica mais difícil determinar a causa de qualquer processo terminado.

Que unidade foi responsável?

Comece pelo kernel, porque ele regista todos os processos que termina.

journalctl -k --grep "Killed process" --since "2 hours ago"

Um kill do OOM killer global tem este aspeto:

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:0

anon-rss é a memória anónima, como a heap, que esse processo mantinha na RAM quando morreu, cerca de 1.8 GB neste caso. Os mapeamentos de ficheiros residentes e a memória partilhada são contabilizados separadamente, como file-rss e shmem-rss. Leia com desconfiança o nome entre parênteses. Esse é o processo vítima escolhido pelo kernel, e o kernel escolhe o processo maior, que nem sempre é o que causou a falta de memória.

Um kill causado por um limite de cgroup tem um prefixo diferente, e o relatório apresentado acima identifica o cgroup que atingiu o seu próprio limite:

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:0

Esse prefixo fornece a maior parte do diagnóstico. Memory cgroup out of memory significa que uma unidade atingiu o MemoryMax= que lhe atribuiu e que o resto do sistema estava normal. Um Out of memory simples significa que a máquina ficou sem memória no conjunto, portanto os seus limites estavam ausentes ou eram suficientemente elevados para exceder a memória disponível quando somados.

Depois, consulte o systemd para saber o que detetou:

systemctl status myapp.service
journalctl -u myapp.service -n 50
myapp.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 diz o mesmo numa linha, como Active: failed (Result: oom-kill).

Os contadores do cgroup são a terceira fonte e a única que regista a limitação de recursos, que nunca produz uma linha de log:

cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peak
low 0
high 4213
max 118
oom 12
oom_kill 12

high contabiliza quantas vezes a unidade ultrapassou MemoryHigh= e foi limitada. max contabiliza quantas vezes atingiu o limite rígido, e oom_kill contabiliza os processos efetivamente terminados. Um high elevado com oom_kill 0 é o caso silencioso referido anteriormente: desde que o cgroup foi criado, a unidade foi limitada repetidamente sem um único kill, pelo que o systemd não registou nenhuma falha. O contador só aumenta, por isso leia-o duas vezes com um minuto de intervalo: um high que continua a aumentar significa que a limitação está a ocorrer agora. memory.peak (Linux 5.19 e versões posteriores) contém o maior consumo atingido pelo cgroup. Esse é o valor contra o qual deve dimensionar MemoryMax=. Ambos os ficheiros são repostos quando a unidade reinicia, porque o systemd cria novamente o cgroup.

Existe um pré-requisito subjacente a tudo isto. Se /var/log/journal não existir, o journal fica na RAM e todas as linhas desaparecem depois do reboot necessário para recuperar o sistema.

sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-boots

Se journalctl --list-boots mostrar mais do que o boot atual, o histórico passa a ser persistente, e journalctl -k -b -1 pode mostrar as mensagens do kernel relativas ao boot que falhou.

Um ponto de partida para um VPS pequeno

Num plano de 2 GB, reserve 300 a 400 MB para o kernel e a cache de páginas. Não deixe que os limites somem os 2 GB completos, porque todas as unidades podem atingir o pico ao mesmo tempo. Dê ao serviço mais importante a maior parcela. Depois, limite tudo o que for secundário à sua volta.

[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5s

Manter uma forma de acesso vale mais uma configuração. OOMScoreAdjust=-500 num drop-in para ssh.service torna muito menos provável que o OOM killer global escolha o daemon SSH como vítima. Isso pode ser a diferença entre corrigir o servidor e reiniciá-lo no painel de controlo. A alteração afeta apenas a escolha da vítima pelo kernel. Não reduz a duração da paragem.

Os contentores são executados nos seus próprios cgroups. Estes cgroups são criados pelo runtime de contentores, e não pelos ficheiros das suas unidades. Por isso, um limite em docker.service não se transforma num limite para um contentor individual. Os equivalentes por contentor de MemoryMax= e CPUQuota= são abordados em configurar limites de memória e CPU no Docker Compose.

FAQ

Porque é que o meu VPS bloqueou em vez de terminar o processo descontrolado?

Porque o kernel avalia o progresso verificando se a recuperação liberta páginas, e não quanto tempo essa operação demora. Enquanto a memória é insuficiente, expulsa a cache de páginas, incluindo as páginas executáveis dos programas em execução, e lê-as novamente na instrução seguinte. Tudo fica à espera do armazenamento e nenhuma alocação falha tecnicamente, pelo que o OOM killer nunca é chamado. Consulte /proc/pressure/memory enquanto isto acontece: um full avg10 acima de 40 significa que, durante mais de 40% dos últimos dez segundos, todas as tarefas que não estavam inativas ficaram bloqueadas à espera de memória ao mesmo tempo. Um daemon em userspace, como earlyoom, termina processos antes de o servidor chegar a esse estado.

Qual é a diferença entre MemoryHigh e MemoryMax?

MemoryHigh= é um limite flexível que aplica limitação de velocidade. O kernel recupera memória agressivamente da unidade e abranda as respetivas alocações, mas o uso pode ultrapassar o valor e nenhum processo é terminado. MemoryMax= é um limite rígido: uma alocação que não possa ser satisfeita dentro desse limite invoca o OOM killer no cgroup da própria unidade. Assim, morre o processo que causou o problema, em vez do maior processo do servidor. Defina MemoryHigh= abaixo de MemoryMax= e trate a diferença entre ambos como uma zona de aviso.

Como descubro que serviço foi atingido pelo OOM killer?

Execute journalctl -k --grep "Killed process" --since "2 hours ago". Uma linha que comece por Memory cgroup out of memory significa que uma unidade atingiu o seu próprio MemoryMax=, enquanto um Out of memory simples significa que toda a máquina ficou sem memória. Em seguida, execute journalctl -u <unit> -n 50 e procure Failed with result 'oom-kill'. Se /var/log/journal não existir no seu servidor, o journal estava mantido em RAM e as provas perderam-se com o reboot. Por isso, crie esse diretório antes do próximo incidente.

Devo adicionar swap a um VPS pequeno?

Um ficheiro de swap pequeno ajuda com páginas frias que são alocadas uma vez e nunca mais são acedidas. Não ajuda com um processo descontrolado: atrasa a terminação e substitui uma indisponibilidade curta por um bloqueio prolongado, durante o qual não consegue iniciar sessão para corrigir o problema. Mantenha a swap moderada e defina MemorySwapMax=0 nas unidades que aceita perder. Assim, atingem rapidamente o seu limite e, com Restart=on-failure definido, recuperam sozinhas, enquanto os serviços importantes continuam a usar a sua swap.

Posso limitar um comando sem escrever um ficheiro de unidade?

Sim. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh executa o comando no seu terminal dentro de um scope transitório com esses limites, e os limites desaparecem quando o comando termina. Todas as propriedades de systemd.resource-control ficam disponíveis depois de -p, pelo que MemorySwapMax=, TasksMax= e CPUWeight= também funcionam nesse contexto. Remova --scope e adicione --unit=name para executar o trabalho em segundo plano, com o respetivo output no journal.

Este artigo foi útil?