blog
Servidores

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.

JR · · 6 min de leitura · 2 tabelas · 5 blocos de código

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
  1. Os quatro comandos, na ordem em que vale rodar
  2. Tabela de sinais para cruzar as saídas e fechar o diagnóstico
  3. O que cada ambiente bloqueia na prática, do cPanel ao modprobe
  4. Três verificações que resolvem sem trocar o cliente de plano
  5. Texto pronto para explicar a limitação ao cliente final
  6. 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.

Ordem dos quatro comandos de diagnosticosystemd-detect-virtResolve a maioria em uma linhalscpuHipervisor na pilha, nao quem/proc/user_beancountersSe existe, e OpenVZfree -m vs dmidecodeDivergencia grosseira indica containerConclusaoVM com kernel proprio ou container
Ordem de execucao: cada comando confirma ou explica o anterior.

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:

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:

  1. Rode o virtcheck.sh via Ansible (ansible all -m script -a virtcheck.sh) ou por um laço de ssh com chave.
  2. Grave em uma planilha: host, tipo de virtualização, swap sim/não, quota funcional sim/não, kernel.
  3. 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.
  4. 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.

Do diagnostico ao inventario da carteiraRodar virtcheck.shAnsible ou laco de sshRegistrar saidaHost, virtualizacao, swap, quota, kernelMarcar exigencia de KVMProjetos com quota, modulo, DockerReavaliar na troca de planoUpgrade nao habilita quota retroativa
Transformar o diagnostico pontual em inventario reutilizavel da carteira.

Referências

  1. Documentação oficial (cpanel) — Virtualization (tag). Consultado em 2026-10-20.
Leia também