# 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.

> 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`.

João Rizzon · 2026-10-22 · Servidores

---

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

```bash
#!/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](https://docs.cpanel.net/tags/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 `failcnt` em `/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:

> **** O seu servidor usa um tipo de virtualização em que o sistema operacional é compartilhado com outros servidores da mesma máquina física. Isso significa que recursos como cota de disco por usuário, swap e módulos do sistema não podem ser alterados de dentro dele: a configuração pertence à máquina hospedeira. Não é uma limitação do painel de controle nem do seu site. Para o que você precisa, o ambiente adequado é uma máquina virtual com sistema operacional próprio (KVM), em que esses controles ficam sob nosso gerenciamento.

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.sh` via Ansible (`ansible all -m script -a virtcheck.sh`) ou por um laço de `ssh` com 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.

