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

VPS ARM ou x86: o que muda na prática

VPS ARM costuma custar menos por core. Veja se sua stack roda em arm64, confira imagens de containers e valide tudo com comandos antes da migração.

O que muda ao mudar para um VPS ARM

Um VPS ARM executa o mesmo Linux e o mesmo Nginx que um VPS x86 e, normalmente, custa menos por core. O risco da mudança está na compatibilidade. Um programa compilado para x86-64 não pode ser executado nativamente em arm64. A emulação do modo de utilizador do QEMU permite executá-lo numa CPU ARM, mas com uma velocidade muito inferior. Na prática, todos os componentes da sua stack têm de disponibilizar uma build arm64 ou de poder ser recompilados.

A maioria das stacks modernas passa este teste sem trabalho adicional. As falhas concentram-se em dois pontos: imagens de contentores que só foram compiladas para uma arquitetura e software de código fechado sem download arm64. Os comandos abaixo respondem a ambas as questões para a sua própria stack antes de pagar por uma instância. Se ainda está a determinar de que tipo de servidor precisa, comece por o que é um VPS e em que difere do alojamento partilhado.

arm64, aarch64, amd64: o que significa cada nome

Execute estes comandos em qualquer instância antes de fazer qualquer outra coisa.

uname -m
dpkg --print-architecture
lscpu | head -n 12
getconf PAGESIZE

uname -m exibe aarch64 numa máquina ARM e x86_64 numa máquina Intel ou AMD. dpkg --print-architecture exibe arm64 e amd64 nessas mesmas duas máquinas. As duas respostas estão corretas. O kernel Linux e o sistema de pacotes Debian escolheram nomes diferentes para o mesmo conjunto de instruções. Por isso, aarch64 e arm64 significam uma coisa, enquanto x86_64 e amd64 significam a outra. O Docker usa os nomes no estilo Debian, e é por isso que a plataforma de uma imagem aparece como linux/arm64.

Em arm64, não existe uma linha model name em /proc/cpuinfo. Em vez disso, existe um campo Features, e a criptografia por hardware aparece nele como flags, como aes pmull sha1 sha2. Essas são as extensões criptográficas do ARMv8. Elas fazem o mesmo que o AES-NI nos processadores Intel e AMD: aceleram por hardware o TLS (transport layer security) e a criptografia de discos. Verificar a aceleração de hardware AES numa VPS explica como fazer o teste nas duas arquiteturas.

Por que os contentores falham primeiro e qual o aspeto do erro

Cada manifest de imagem Docker regista a arquitetura para a qual foi compilada. Se extrair uma imagem que apenas possui um manifest amd64 para um host arm64, o pull é bem-sucedido. A falha ocorre no primeiro arranque do processo:

WARNING: The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
exec /usr/local/bin/docker-entrypoint.sh: exec format error

exec format error é o kernel a recusar a execução do ficheiro, porque o seu cabeçalho ELF (executable and linkable format) indica um tipo de máquina que este CPU não implementa. Nenhuma configuração fará com que o CPU o execute nativamente. As instruções não existem no silício. A única solução é a emulação, que os parágrafos seguintes abordam.

Verifique o manifest antes de implementar:

docker buildx imagetools inspect nginx:1.27

O output lista uma linha Platform: por imagem na lista de manifests, como linux/amd64 e linux/arm64. Se linux/arm64 estiver ausente, essa tag não arrancará nativamente numa VPS ARM. Falhará com exec format error a menos que tenha configurado a emulação, e sob emulação a execução é lenta. docker manifest inspect --verbose nginx:1.27 mostra a mesma informação, mas o Docker documenta docker manifest como um comando experimental cujo comportamento pode mudar entre releases, por isso prefira imagetools.

Para imagens que compila por conta própria, compile ambas as arquiteturas num único comando e faça push de uma lista de manifests:

docker buildx build --platform linux/amd64,linux/arm64 -t registry.example.com/app:1.4 --push .

Compilar para uma arquitetura estrangeira num único host requer emulação de modo de utilizador QEMU registada no handler binfmt_misc do kernel:

docker run --privileged --rm tonistiigi/binfmt --install all

Utilize a emulação para compilar e testar. Não a utilize para servir tráfego. A própria documentação do Docker afirma que a emulação com QEMU "pode ser muito mais lenta do que compilações nativas, especialmente para tarefas que exigem muito processamento, como compilação e compressão ou descompressão", pelo que um serviço x86 emulado numa instância ARM anula a poupança que o levou a mudar. A configuração do host para o caso nativo é idêntica em ambas as arquiteturas: executar Docker numa VPS aborda o tema, e um ficheiro Compose existente funciona sem alterações assim que cada imagem nele contida possuir um manifest arm64. Se o plano ARM que está a considerar tiver apenas 1 ou 2 GB de RAM, meça o que o daemon do Docker e os contentores consomem realmente num VPS pequeno antes de escolher esse tamanho.

Os pacotes de que preciso existem para arm64?

O Ubuntu e o Debian compilam quase todo o arquivo para arm64, por isso apt install nginx postgresql redis-server funciona da mesma forma nas duas arquiteturas. As lacunas encontram-se principalmente nos repositórios de terceiros.

Consulte diretamente o apt na instância ARM:

apt-cache policy some-vendor-agent
apt-get install -s some-vendor-agent

A mensagem apt-cache policy com Candidate: (none) significa que nenhum repositório ativado publica uma compilação desse pacote para esta arquitetura. apt-get install -s simula a instalação e não escreve nada. No mesmo caso, termina com E: Unable to locate package.

Leia também a saída de apt update em vez de a ignorar. Um repositório de fornecedor disponível apenas para amd64 indica isso:

N: Skipping acquire of configured file 'main/binary-arm64/Packages' as repository 'https://repo.example.com/apt stable InRelease' doesn't support architecture 'arm64'

O repositório está configurado e acessível, mas não contém nada que esta máquina possa instalar. Verifique também a própria entrada da origem. Uma linha fixada com [arch=amd64] é ignorada num host arm64. Nesse caso, o pacote parece estar em falta, mas a causa real é a fixação.

Quais workloads são seguros e quais exigem uma verificação prévia

Runtimes interpretados e de bytecode são portáveis por definição. PHP, Python, Ruby e Node.js têm pacotes arm64 nas principais distribuições. Go e Rust fazem compilação cruzada para arm64. No caso do Rust, rustup target add instala apenas a biblioteca padrão para o destino, por isso normalmente também precisa de um linker para esse destino. Uma stack LEMP, uma API Node, um binário Go atrás do Nginx ou uma base de dados Postgres são tarefas comuns em arm64.

Um compilador just in time (JIT) produz código de máquina enquanto o programa é executado, por isso precisa de um gerador de código para a arquitetura de destino. As versões atuais têm esse suporte: OpenJDK, .NET, o motor V8 incluído no Node.js e o PyPy suportam arm64 no Linux. O verdadeiro risco está nas versões antigas fixadas. Um script de deploy que instala uma versão de runtime lançada há vários anos deve ser verificado nas notas dessa versão quanto ao suporte para aarch64, em vez de se assumir que funcionará.

Bibliotecas que incluem assembly x86 escrito manualmente ou intrinsics SSE e AVX são um caso menos evidente. A maioria também tem um caminho NEON (NEON é o conjunto de instruções vetoriais do ARM) ou um fallback em C simples, por isso compila e executa. O desempenho pode ser diferente do da build x86 em qualquer direção. Meça o desempenho na sua instância, em vez de o prever com base num artigo.

Software de código fechado é o verdadeiro bloqueio. Um agente de monitorização do fornecedor, um driver de base de dados licenciado, um painel de controlo comercial ou um daemon de antivírus é fornecido como um binário compilado. Quando o fornecedor não publica uma build arm64, não é possível recompilá-lo. A emulação QEMU em modo de utilizador ainda pode executar um binário x86-64 de userspace em ARM, mas lentamente. Além disso, saber se o fornecedor oferece suporte a essa utilização é uma questão separada. cPanel e WHM são o caso mais claro no alojamento: os requisitos de sistema indicam que o cPanel não suporta sistemas com arquitetura ARM. Por isso, um servidor com painel de controlo deve permanecer em x86 (verificado em October 2026; vale a pena voltar a consultar a página de requisitos do próprio fornecedor). Se esse for o único fator que o impede, as alternativas ao cPanel que vale a pena executar numa VPS são o ponto de partida. Verifique o suporte de arquitetura de cada uma da mesma forma.

Kernels e tamanho de página: onde as instâncias ARM ainda diferem

Os servidores x86-64 são quase intercambiáveis. Os servidores ARM são menos uniformes, e as diferenças existem abaixo da camada da aplicação.

O tamanho de página é a diferença que chega à produção. A maioria dos kernels arm64 usa páginas de 4 KiB, tal como o x86-64. Alguns usam 64 KiB. O Red Hat Enterprise Linux 8 para aarch64 incluía por predefinição um kernel com páginas de 64 KiB, e o RHEL 9 voltou a usar 4 KiB por predefinição, mantendo um pacote kernel-64k separado para cargas de trabalho que pretendem o tamanho maior. Um tamanho de página de 64 KiB aumenta o consumo mínimo de memória de um processo com muitos mapeamentos pequenos, porque o menor bloco que o kernel pode atribuir é dezasseis vezes maior. Execute getconf PAGESIZE na instância e leia o valor, em vez de fazer suposições. O tamanho de página não é a única decisão do kernel que o afeta, porque a versão fornecida pelo seu fornecedor também determina como o trabalho é agendado nos cores, e o agendamento consciente da cache adicionado no Linux 7.2 aplica-se igualmente a arm64 e x86-64.

Vale a pena conhecer algumas diferenças menores. Não existe um pacote de microcódigo de CPU do sistema operativo em arm64, por isso as atualizações de firmware vêm do fornecedor e não de apt. Os servidores ARM arrancam através de UEFI (unified extensible firmware interface) e descrevem o hardware através de ACPI (advanced configuration and power interface). Algumas funcionalidades x86 não estão disponíveis em ARM, incluindo a encriptação de memória AMD SEV e as GPUs mediadas Intel GVT-g. A ARM tem uma abordagem própria à computação confidencial, em vez de SEV: Arm CCA, em que a extensão Memory Encryption Contexts permite que cada Realm use um contexto distinto de encriptação de memória.

A plataforma de servidores ARM amadureceu?

No lado do software, sim. Debian, Ubuntu, Fedora e RHEL disponibilizam versões arm64 de primeira classe, e as imagens oficiais no Docker Hub são normalmente multi-arquitetura. O estado oficial não é uma garantia, no entanto: as tags atuais da Percona Docker Official Image listam apenas linux/amd64 (verificado em outubro de 2026), por isso inspecione cada imagem de qualquer forma.

A evidência recente mais clara é o Proxmox. Em 5 de agosto de 2026, a Proxmox anunciou a primeira edição arm64 oficialmente suportada do Proxmox Virtual Environment, a versão 9.2, partilhando os repositórios de pacotes e o ciclo de lançamento com a edição x86-64. O anúncio da versão indicava que esta era baseada no Debian 13.5 (o roteiro do Proxmox lista agora o Debian 13.6 para a versão arm64), com Linux 7.0, QEMU 11.0, LXC 7.0 e ZFS 2.4. A configuração e as ferramentas correspondem às da x86-64, exceto por um pequeno conjunto de itens específicos da arquitetura.

Leia as ressalvas no mesmo anúncio, porque mostram como o suporte oficial ao hardware de servidores ARM ainda é limitado. A Proxmox validou sistemas NVIDIA Grace e NVIDIA Vera no primeiro dia, após testes conjuntos com a NVIDIA e a Supermicro em hardware Grace Hopper. Outros equipamentos UEFI baseados em ARMv8-A e ARMv9-A recebem suporte de melhor esforço. Computadores de placa única baseados apenas em device tree, como o Raspberry Pi, não são suportados. Um guest só é executado num node da sua própria arquitetura, a migração em tempo real funciona apenas entre nodes da mesma arquitetura e os clusters com arquiteturas mistas não são oficialmente suportados.

Essa é a situação real em agosto de 2026. Um fornecedor de hypervisor disponibilizar arm64 com o mesmo ciclo de vida da x86-64 representa um progresso efetivo para a plataforma. A lista de hardware suportado no primeiro dia inclui duas famílias de CPU.

Uma lista de verificação para executar antes de se comprometer

  1. Execute uname -m numa instância de teste e confirme que apresenta aarch64.
  2. Execute docker buildx imagetools inspect em cada imagem do seu ficheiro Compose e confirme uma linha de plataforma linux/arm64 para cada uma.
  3. Execute apt update na instância ARM e leia todos os avisos Skipping acquire apresentados.
  4. Abra a página de download de cada agente de código fechado de que depende e procure pelo nome uma compilação arm64 ou aarch64.
  5. Execute getconf PAGESIZE e registe a resposta antes de dimensionar a memória.
  6. Execute o seu próprio benchmark tanto no plano ARM como no plano x86 entre os quais está a escolher.

O que este artigo não afirma

Não vamos fornecer uma relação preço/desempenho entre ARM e x86. Os preços por núcleo variam conforme o fornecedor e o plano, e um valor medido no hardware de outra pessoa não permite prever o seu. Meça em vez disso. O nosso guia de benchmarking de um VPS aborda sysbench e fio com um método que pode repetir, e quanto custa realmente um VPS aborda a componente de preços da comparação. O armazenamento é uma decisão separada da arquitetura da CPU, e como o NVMe se compara com um SSD SATA num VPS trata dessa parte. Execute o mesmo teste nos dois planos, usando a sua própria carga de trabalho sempre que possível, e deixe os seus números decidir.

FAQ

Os meus contentores Docker vão funcionar numa VPS ARM?

Funcionam nativamente se todas as imagens da stack tiverem uma entrada linux/arm64 no respetivo manifesto. Verifique cada uma com docker buildx imagetools inspect <image> e procure uma linha Platform: linux/arm64. Muitas imagens oficiais no Docker Hub suportam várias arquiteturas, mas isso não se aplica a todas: as tags das imagens oficiais da Percona listam apenas linux/amd64. As imagens de fornecedores mais pequenos e as imagens que criou num computador x86 também muitas vezes não suportam várias arquiteturas. Para as suas próprias imagens, faça o rebuild com docker buildx build --platform linux/amd64,linux/arm64 ... --push para que uma tag sirva ambas as arquiteturas.

O que significa exec format error num servidor ARM?

O kernel tentou executar um binário cujo cabeçalho ELF identifica um tipo de máquina diferente e recusou. Num host arm64, isto significa quase sempre um binário ou uma imagem de contentor x86-64. Primeiro, o Docker mostra um aviso a indicar que a plataforma da imagem pedida, linux/amd64, não corresponde à plataforma detetada no host, linux/arm64/v8. A correção é fazer o build para a arquitetura correta. Nenhuma alteração de configuração faz um binário x86-64 ser executado nativamente em ARM.

arm64 é a mesma coisa que aarch64?

Sim. São dois nomes para o conjunto de instruções ARM de 64 bits. O kernel comunica aarch64 através de uname -m, enquanto os pacotes do Debian e do Ubuntu e as strings de plataforma do Docker usam arm64. A mesma distinção existe no outro lado, onde uname -m indica x86_64 e os pacotes usam amd64. Se uma página de downloads oferecer apenas ficheiros aarch64, esses são os ficheiros corretos para uma máquina que dpkg --print-architecture identifica como arm64.

Uma VPS ARM é mais rápida do que uma VPS x86?

Essa pergunta não tem uma resposta geral, e qualquer proporção que leia foi medida em hardware diferente do seu. A velocidade depende do modelo específico do CPU, do número de cores que lhe são atribuídos, da forma como o fornecedor gere a contenção entre tenants e da eficiência com que a sua carga de trabalho utiliza instruções vetoriais. Faça um benchmark dos dois planos entre os quais está realmente a escolher, usando a sua própria carga de trabalho se possível, e compare esses resultados.

O que devo verificar antes de mover um servidor de produção para arm64?

Faça quatro verificações, nesta ordem. Confirme que todas as imagens de contentores têm um manifesto arm64. Confirme que todos os repositórios apt de terceiros publicam binary-arm64. Confirme que todos os agentes de código fechado disponibilizam um download aarch64. Depois, execute getconf PAGESIZE na instância de destino, porque um kernel com páginas de 64 KiB altera o consumo de memória dos processos com muitos mapeamentos pequenos. Qualquer elemento que falhe uma destas quatro verificações é motivo para manter esse servidor específico em x86.

Este artigo foi útil?

#arm64#cpu-architecture#vps#docker#performance