Descobrir se o VPS é KVM ou OpenVZ em 4 comandos
Quatro comandos, uma tabela do que cada tipo de virtualização bloqueia e a frase pronta para explicar ao cliente que cota zerada e RAM divergente não são culpa do painel.

Resposta curta: rode `systemd-detect-virt`: se a saída for `kvm`, `xen` ou `vmware`, é virtualização completa com kernel próprio; se for `openvz`, `lxc` ou `docker`, é container. Confirme com `lscpu`, `/proc/user_beancounters` e `free -m` contra `dmidecode`.
Neste artigo
- Os quatro comandos, na ordem em que vale rodar
- Tabela de sinais para cruzar as saídas e fechar o diagnóstico
- O que cada ambiente bloqueia na prática, do cPanel ao modprobe
- Três verificações que resolvem sem trocar o cliente de plano
- Texto pronto para explicar a limitação ao cliente final
- Transformando o diagnóstico em inventário de carteira
Cliente abre chamado dizendo que o cPanel mostra cota de disco zerada, ou que contratou 4 GB de RAM e o painel exibe 32 GB, ou que o módulo que o antivírus precisa não carrega. Nenhum desses três é bug de painel. Os três são sintoma da camada de virtualização embaixo do sistema operacional.
Antes de abrir ticket com o provedor ou de recompilar qualquer coisa, vale rodar quatro comandos. Eles levam dois minutos e dizem se você está dentro de uma VM com kernel próprio (KVM, Xen, VMware, Hyper-V) ou dentro de um container que compartilha o kernel do host (OpenVZ, LXC, Virtuozzo, Docker).
Os quatro comandos, na ordem em que vale rodar
Rode como root. A ordem importa: o primeiro já resolve a maioria dos casos, os outros confirmam e explicam o sintoma.
`systemd-detect-virt` resolve a maioria dos casos em uma linha
# systemd-detect-virt
kvm
Saídas típicas: kvm, qemu, xen, vmware, microsoft, oracle (VirtualBox) para virtualização completa; openvz, lxc, lxc-libvirt, docker, podman para container; none quando é metal puro. Use systemd-detect-virt -c para perguntar só "é container?" e -v para "é VM?". O comando sai com código 0 quando detecta algo e 1 quando não detecta, o que é útil em script.
Se o binário não existir (sistema sem systemd), caia para virt-what, que precisa ser instalado, ou siga para os comandos seguintes.
`lscpu` mostra se existe hipervisor na pilha, não se você é a VM
# lscpu | grep -i -E 'hypervisor|model name|virtuali'
Flags: ... hypervisor ...
Hypervisor vendor: KVM
Virtualization type: full
A flag hypervisor na CPU indica que o kernel está rodando sob um hipervisor. A flag não é anulada pelo container: se o host for uma VM, ela aparece dentro do container também. Ou seja, lscpu responde "existe um hipervisor em algum ponto da pilha", não "eu sou uma VM". É por isso que ele vem depois do systemd-detect-virt, nunca antes.
Repare também no Model name da CPU. QEMU Virtual CPU version 2.5+ é VM. Um Xeon ou EPYC real com flag hypervisor costuma ser KVM com CPU passada por modelo host.
`/proc/user_beancounters` existe apenas em OpenVZ e Virtuozzo
# cat /proc/user_beancounters
Version: 2.5
uid resource held maxheld barrier limit failcnt
101: kmemsize ...
numproc ...
privvmpages ...
Esse arquivo é a assinatura do OpenVZ e do Virtuozzo. Se ele existe, você está dentro de um container OpenVZ e os limites reais do seu ambiente estão nessa tabela, não no free. A coluna failcnt é o que interessa no diagnóstico: cada incremento ali é uma alocação que o kernel do host negou ao seu container. failcnt subindo em privvmpages ou kmemsize explica processo morto sem OOM visível no log.
Se o arquivo não existe, o comando retorna No such file or directory, e isso já elimina OpenVZ clássico. Não elimina LXC nem Virtuozzo 7, que usam cgroups.
`free -m` contra `dmidecode`: quando a RAM do painel não bate
# free -m
total used free
Mem: 3947 812 2103
Swap: 0 0 0
# dmidecode -t memory | grep -E 'Size|Type:' | head
Em uma VM KVM honesta, o total do free bate com o hardware anunciado pelo SMBIOS no dmidecode, menos o que o kernel reserva. Em container, o dmidecode lê a tabela DMI do host, então ele pode anunciar 256 GB enquanto o free mostra 4 GB, ou o comando simplesmente falha por falta de acesso a /dev/mem.
Divergência grosseira entre os dois, somada a Swap: 0, é o par de sintomas clássico de container. Containers normalmente não têm swap próprio: swap é função do kernel do host, e você não administra o kernel do host.
Script para rodar os quatro de uma vez no primeiro acesso
#!/bin/bash
echo "== detect-virt =="
if command -v systemd-detect-virt >/dev/null; then systemd-detect-virt; else echo "(binario ausente)"; fi
echo "== cpu =="; lscpu | grep -i -E 'hypervisor|model name'
echo "== beancounters =="
if [ -f /proc/user_beancounters ]; then head -5 /proc/user_beancounters; else echo "(ausente)"; fi
echo "== memoria =="; free -m; dmidecode -t memory 2>/dev/null | grep -m3 'Size:'
echo "== cgroup =="; cat /proc/1/cgroup | head -3
Salve como virtcheck.sh, dê chmod +x e deixe no seu repositório de scripts de onboarding. Rodar isso no primeiro acesso a um servidor de cliente novo poupa descoberta tardia.
Tabela de sinais para cruzar as saídas e fechar o diagnóstico
| Sinal | KVM / Xen / VMware | OpenVZ / Virtuozzo | LXC / Docker |
|---|---|---|---|
systemd-detect-virt |
kvm, xen, vmware |
openvz |
lxc, docker |
Flag hypervisor no lscpu |
sim | depende do host | depende do host |
/proc/user_beancounters |
ausente | presente | ausente |
free -m vs dmidecode |
coerente | divergente ou falha | divergente ou falha |
| Swap | existe se configurado | geralmente 0 | geralmente 0 |
uname -r combina com a distro instalada |
sim | não, é o kernel do host | não, é o kernel do host |
O teste do uname -r é um quinto sinal barato: um container CentOS 7 rodando em host Ubuntu moderno mostra um kernel que não existe no repositório do CentOS. Isso sozinho já encerra a discussão.
O que cada ambiente bloqueia na prática, do cPanel ao modprobe
| Sintoma no dia a dia | Causa | Vale em |
|---|---|---|
| Cota de disco volta zero no cPanel | o filesystem do container não expõe quota de usuário; sem suporte a quota no kernel visível, o painel reporta 0 | OpenVZ, LXC, alguns setups com disco em arquivo |
modprobe falha com "Operation not permitted" |
carregar módulo mexe no kernel, que é do host e é compartilhado | qualquer container |
| RAM do painel diferente da contratada | o painel lê /proc/meminfo, que em container antigo reflete o host |
container sem virtualização de /proc/meminfo (simfs/ploop no OpenVZ, lxcfs no LXC) |
| Swap inexistente | swap pertence ao kernel do host | container em geral |
| Não dá para trocar a versão do kernel | só o host decide | container |
| iptables/nftables com regra que não aplica | capacidades de rede restritas no container | LXC/Docker sem privilégio |
| CSF/LFD reclamando de módulos ausentes | mesmo motivo do modprobe |
container |
A documentação do cPanel mantém uma trilha dedicada ao tema em Virtualization, e é a referência que vale colar no ticket quando o cliente pede comprovação de que a limitação não é do painel.
Nada disso significa que container é ruim. Este texto não compara desempenho nem custo dos dois modelos, então não afirma qual entrega mais. A escolha se decide pelos requisitos da tabela acima: se o projeto exige quota por usuário, módulo de kernel, firewall com regra exótica ou swap de emergência, container não atende. Se não exige nenhum deles, o tipo de virtualização deixa de ser o critério.
Três verificações que resolvem sem trocar o cliente de plano
Ser container não explica tudo. Três verificações que resolvem sem migrar ninguém:
- Lentidão intermitente: olhe o log de consulta lenta do MySQL antes de culpar a virtualização. Query sem índice derruba KVM dedicado igual.
- "Falta memória": em OpenVZ, confira
failcntem/proc/user_beancounters. Se está em zero e há tempo, o problema é consumo de PHP-FPM, não teto do container. - Cota zerada: às vezes é só o cPanel precisar recontar. Vale tentar o recálculo de cotas do próprio painel antes de concluir que o filesystem não suporta quota.
Se depois disso o bloqueio persistir e ele estiver na tabela acima, aí sim a conversa é sobre ambiente.
Texto pronto para explicar a limitação ao cliente final
Frase pronta, sem jargão, para colar no e-mail:
Anexe a saída dos quatro comandos. Cliente técnico aceita o diagnóstico na hora, cliente não técnico aceita porque vê que houve verificação, não chute.
Transformando o diagnóstico em inventário de carteira
Se você administra dezenas de servidores de clientes diferentes, transforme o diagnóstico em dado de inventário em vez de investigação pontual:
- Rode o
virtcheck.shvia Ansible (ansible all -m script -a virtcheck.sh) ou por um laço desshcom chave. - Grave em uma planilha: host, tipo de virtualização, swap sim/não, quota funcional sim/não, kernel.
- Marque na proposta comercial quais projetos exigem KVM: loja com backup por usuário, servidor de e-mail com filtro que depende de módulo, qualquer coisa com Docker dentro.
- Reavalie quando o cliente trocar de plano. Upgrade de disco em container não habilita quota retroativamente.
Esse inventário se paga na primeira vez que alguém pedir "instala o módulo X" e você responder em trinta segundos em vez de abrir sessão no servidor para descobrir.
Referências
- Documentação oficial (cpanel) — Virtualization (tag). Consultado em 2026-10-20.