ARMper Svogliati
Per trent'anni il mondo era diviso in due: i computer avevano Intel o AMD, i telefoni avevano ARM. Poi Apple ha messo un processore da telefono nei Mac ed è andato più veloce, Amazon ha messo i suoi nei server, e il Raspberry sul tuo scaffale ce l'aveva già. Oggi la domanda "ARM o x86?" te la fa anche il pannello del cloud. Ecco cosa cambia davvero, e cosa si rompe se scegli quello sbagliato.
"Ho preso il server ARM che costava meno." — "E l'immagine Docker?" — "exec format error."
Cos'è ARM, e cosa non è
Arm non fabbrica processori. Vende il progetto, e la licenza per usarlo. È la differenza da cui discende tutto il resto.
Intel progetta i suoi processori e (in gran parte) li fabbrica; AMD li progetta e li fa fabbricare. Si vendono chip finiti. Arm, un'azienda inglese di Cambridge, non vende chip: vende due cose diverse. La licenza dell'architettura, cioè il diritto di costruire un processore che capisce le istruzioni ARM, progettandolo da zero (è quello che fa Apple). Oppure i progetti dei core già pronti (Cortex per telefoni e Raspberry, Neoverse per i server), che un'azienda mette nel suo chip insieme ad altro e fa produrre da TSMC o Samsung.
Un'architettura
Il "linguaggio" del processore: quali istruzioni esistono e come si scrivono. ARMv8 e ARMv9 a 64 bit sono quelle di oggi.
Tanti costruttori
Apple, Qualcomm, Amazon, Google, Microsoft, NVIDIA, Ampere, Broadcom (quella del Raspberry), MediaTek, Samsung. Ognuno fa il suo chip.
Nato per consumare poco
Trent'anni di telefoni e dispositivi a batteria: l'efficienza è nel DNA. Le prestazioni sono arrivate dopo.
aarch64 per il kernel Linux e per uname, arm64 per Debian, Docker, Go e macOS, ARMv8 o ARMv9 quando si parla di architettura. È sempre la stessa cosa. L'ARM a 32 bit, quello dei Raspberry vecchi, si chiama invece armhf o armv7, ed è un altro mondo.
Da un computer per le scuole inglesi a metà del cloud
Quarant'anni di storia, quasi tutti passati nell'ombra, dentro oggetti che nessuno apriva.
Acorn RISC Machine
Acorn, che faceva computer per le scuole britanniche, progetta il suo processore: semplice, poche istruzioni, pochi transistor. Il primo esemplare funziona al primo colpo, e consuma così poco che, si racconta, funzionava anche con l'alimentazione staccata, grazie alla corrente che arrivava dai circuiti di prova.
Nasce Arm, con Apple tra i soci
Acorn, Apple e VLSI fondano Advanced RISC Machines. Apple cerca un processore per il Newton, un'agenda elettronica che sarà un flop. Arm decide di non fabbricare niente e di vivere di licenze.
Dentro tutto, senza che nessuno lo sappia
Telefoni Nokia, Game Boy Advance, iPod, router, stampanti, hard disk. Miliardi di chip all'anno, e il nome lo conoscono solo gli ingegneri.
Smartphone e Raspberry Pi
iPhone, poi Android: ogni smartphone è ARM. Nel 2012 il Raspberry Pi mette un ARM con Linux nelle mani di milioni di studenti e smanettoni. Microsoft prova Windows su ARM con Windows RT: fallimento.
SoftBank, il tentativo di NVIDIA, il ritorno in Borsa
Il gruppo giapponese SoftBank compra Arm. Nel 2020 NVIDIA prova a comprarla per 40 miliardi: le autorità antitrust di mezzo mondo si mettono di traverso e l'accordo salta nel 2022. Nel 2023 Arm torna in Borsa, con SoftBank azionista di maggioranza.
I server e il Mac
Amazon presenta Graviton, il suo processore ARM per il cloud. Nel 2020 il supercomputer più potente del mondo è giapponese e ARM (Fugaku). A novembre Apple lancia il Mac con M1: più veloce degli Intel che sostituisce, con il doppio dell'autonomia. È il momento in cui tutti capiscono.
Tutti i grandi cloud hanno il loro ARM
Google con Axion, Microsoft con Cobalt, Amazon arriva a Graviton5 con 192 core. I PC Windows con Snapdragon X tornano a provarci, questa volta sul serio. SoftBank compra anche Ampere, l'azienda che vende CPU ARM per server a tutti gli altri. Apple annuncia che dopo macOS 27 Rosetta 2, il traduttore per le vecchie app Intel, resterà solo per alcuni giochi.
ARM contro x86, oggi
"RISC contro CISC" è la risposta da manuale, e conta molto meno di quanto si dice. Le differenze vere sono altre.
Una volta la distinzione era netta: ARM è RISC (poche istruzioni semplici), x86 è CISC (tante istruzioni complesse). Oggi i processori x86 traducono internamente le loro istruzioni complesse in operazioni semplici, e quelli ARM hanno istruzioni tutt'altro che poche. La filosofia ha lasciato il segno, ma non è più quella la ragione per cui un Mac M4 consuma meno di un portatile Intel.
| Dove cambia davvero | ARM | x86 (Intel, AMD) |
|---|---|---|
| Modello di business | Chiunque prenda la licenza può fare il suo chip, su misura | Due aziende, chip uguali per tutti |
| Consumo | Progettato da sempre per la batteria: ottimo rapporto prestazioni/watt | Migliorato molto, ma parte da un'eredità desktop |
| vCPU nel cloud | Di solito un core fisico intero per ogni vCPU (niente hyperthreading) | Spesso una vCPU è metà core: un thread su due |
| Compatibilità | Tutto il software va compilato per ARM | Quarant'anni di programmi che funzionano e basta |
| Istruzioni vettoriali | NEON, SVE | SSE, AVX, AVX-512: il software ottimizzato a mano spesso c'è solo per queste |
| Core diversi nello stesso chip | Normale da anni (core veloci + core efficienti) | Arrivato più tardi (Intel dal 2021) |
Il concetto chiave: il programma parla una lingua sola
Un programma compilato è scritto nella lingua di un processore. Se il processore parla un'altra lingua, non lo capisce. Punto.
Il codice sorgente è il manoscritto dell'autore; il programma compilato è il libro tradotto in una lingua. Un libro in inglese (x86) non lo legge chi parla solo giapponese (ARM). Hai tre strade: far tradurre il manoscritto anche in giapponese (ricompilare per ARM, la soluzione vera), dare al lettore un interprete che traduce mentre legge (emulazione: funziona, ma più lento), oppure comprare un'edizione con dentro tutte e due le lingue (le immagini multi-architettura e i binari universali).
Linguaggi interpretati: quasi gratis
Python, PHP, Node.js, Java, Ruby: il tuo codice gira uguale. Serve solo che l'interprete e le estensioni compilate esistano per ARM. Ormai quasi sempre è così.
Linguaggi compilati: si ricompila
C, C++, Go, Rust: il codice di solito è portabile, il binario no. Con i sorgenti, ricompilare è facile. Senza sorgenti (software proprietario), dipendi dal produttore.
Controlla le dipendenze, non il tuo codice
Quasi mai è il tuo programma a non funzionare: è un'immagine Docker solo x86, un agente di monitoraggio, un driver, una libreria chiusa. È lì che va fatto l'inventario.
Chi fa processori ARM, e dove li trovi
Dal Raspberry sullo scaffale ai supercomputer, passando per il tuo Mac.
| Dove | Chi | Note |
|---|---|---|
| Mac | Apple (serie M) | Core progettati da Apple su licenza dell'architettura. Dal 2020 tutti i Mac nuovi |
| PC Windows | Qualcomm Snapdragon X | Dal 2024. Le app x86 girano tramite Prism, l'emulatore di Windows. Con Arm c'è una lunga causa sulle licenze, finora favorevole a Qualcomm |
| Raspberry Pi | Broadcom, con core Cortex di Arm | Pi 3, 4 e 5 sono a 64 bit; usa il sistema a 64 bit se puoi (vedi Raspberry Pi per Svogliati) |
| Telefoni e tablet | Apple, Qualcomm, MediaTek, Samsung, Google | Tutti, da vent'anni |
| Server cloud | Amazon, Google, Microsoft (per sé); Ampere (per tutti) | Sezione 6 |
| IA e supercomputer | NVIDIA Grace, Fujitsu | Grace sta accanto alle GPU NVIDIA nei grandi sistemi di IA |
I server ARM nel cloud
I grandi cloud se li fanno in casa; gli altri comprano da Ampere. In tutti i casi, il pannello ti chiede di scegliere l'architettura.
| Fornitore | Processore | Cosa sapere |
|---|---|---|
| AWS | Graviton (dal 2018), oggi Graviton4 e Graviton5 | Il più maturo. Le istanze con la "g" nel nome (m8g, c8g, r8g…). Graviton5 arriva a 192 core per chip |
| Google Cloud | Axion | Su core Neoverse di Arm, istanze C4A e N4A |
| Microsoft Azure | Cobalt 100, poi Cobalt 200 | Microsoft lo usa anche per i propri servizi |
| Oracle Cloud | Ampere | Famoso per il piano gratuito "Always Free" con macchine ARM: da giugno 2026 ridotto a 2 core e 12 GB |
| Hetzner | Ampere Altra (serie CAX) | Solo in Germania e Finlandia. Sezione 7 per i prezzi |
| Ampere | Altra, AmpereOne | Vende CPU ARM per server a chi non se le fa da solo. Dal novembre 2025 è di SoftBank, come Arm |
Conviene davvero?
"ARM costa meno" è stato vero per anni. Oggi dipende dal fornitore, e va controllato ogni volta.
Un esempio concreto: i prezzi di Hetzner (Germania e Finlandia, IVA e IPv4 esclusi) dopo i due rincari del 2026, verificati a fine ottobre:
| Server | Architettura | vCPU | RAM | Disco | Al mese |
|---|---|---|---|---|---|
| CX23 | x86 (Intel/AMD condiviso) | 2 | 4 GB | 40 GB | 5,49 € |
| CAX11 | ARM (Ampere) | 2 | 4 GB | 40 GB | 5,99 € |
| CX33 | x86 | 4 | 8 GB | 80 GB | 8,49 € |
| CAX21 | ARM | 4 | 8 GB | 80 GB | 10,49 € |
Fino a inizio 2026 la CAX11 costava meno della CX equivalente; oggi costa un po' di più. Il vantaggio rimasto è un altro: una vCPU ARM è un core intero, una vCPU x86 condivisa spesso è un thread su un core diviso con altri. Sotto carico continuo, la CAX regge meglio. Negli hyperscaler (AWS, Google, Azure) invece le istanze ARM restano di solito più economiche delle x86 equivalenti, e i fornitori dichiarano un rapporto prezzo/prestazioni migliore del 20–40%: dichiarazioni loro, da misurare sul tuo carico.
ARM va benissimo per
- Server web, reverse proxy, PHP, Node, Python, Go, Java
- Container e Kubernetes, se le immagini sono multi-architettura
- Database open source: PostgreSQL, MariaDB, Redis
- Compilazione e CI: tanti core veri a buon prezzo
- Tutto quello che gira 24 ore su 24 e consuma
Meglio x86 se
- Usi software proprietario disponibile solo per x86
- Ti serve Windows Server o un'applicazione Windows
- Hai codice ottimizzato con AVX (alcuni calcoli scientifici, codec video)
- Hai un agente o un driver di un fornitore che non lo supporta
- Il server costa poco e il tempo per migrarlo costa di più
Cosa si rompe passando ad ARM
Il 95% funziona e basta. Il 5% è sempre lo stesso elenco di trappole.
| Trappola | Cosa succede | Rimedio |
|---|---|---|
| Immagini Docker solo amd64 | Il container non parte, o parte in emulazione lentissima | Cerca il tag multi-architettura, o costruisci l'immagine per arm64 (sezione 9) |
| Binari scaricati a mano | Lo script d'installazione scarica la versione x86_64 | Scarica la versione arm64/aarch64; correggi gli script che hanno amd64 scritto dentro |
| Pacchetti .deb di terze parti | Il repository del fornitore ha solo amd64 | Chiedi al fornitore, o cerca un'alternativa nei repository della distribuzione |
| Estensioni compilate (Python, Node, PHP) | pip o npm provano a compilare e falliscono | Installa compilatore e header (build-essential, python3-dev), o aggiorna la libreria: le versioni recenti hanno i pacchetti pronti per arm64 |
| Istruzioni troppo nuove | Un programma compilato per ARMv8.2 su un processore ARMv8.0 (come il Pi 4) muore con Illegal instruction. Esempio famoso: MongoDB dalla 5.0 sul Raspberry | Una versione compilata per il processore più vecchio, o hardware più recente |
| Pagine di memoria da 16 o 64 KB | Alcuni sistemi ARM (Asahi Linux sui Mac, alcuni kernel per server) usano pagine più grandi dei soliti 4 KB; programmi che lo danno per scontato si rompono | getconf PAGESIZE per sapere com'è; per i server, un kernel con pagine da 4 KB evita sorprese |
| Bug nascosti nel codice C | Codice che funzionava "per caso" su x86: char che su ARM è senza segno, accessi alla memoria tra thread senza sincronizzazione corretta | Sono bug veri, x86 li nascondeva. Si correggono nel codice |
Docker multi-architettura
Un nome di immagine, più versioni dentro: Docker scarica da solo quella giusta per il processore. Quando c'è.
Un'immagine come nginx:latest in realtà è un indice (manifest list) che punta a una versione per ogni architettura. Quando fai docker pull, Docker sceglie quella del tuo processore. Le immagini ufficiali e quelle dei grandi progetti hanno quasi tutte arm64; quelle fatte da un singolo sviluppatore, o vecchie, spesso no.
# per quali architetture esiste un'immagine?
docker manifest inspect nginx:latest | grep -A2 '"platform"'
# di che architettura è l'immagine che ho scaricato?
docker image inspect --format '{{.Os}}/{{.Architecture}}' nginx:latest
# forzare un'architettura diversa (girerà in emulazione)
docker run --platform linux/amd64 --rm alpine uname -m
# costruire la tua immagine per entrambe e pubblicarla con un nome solo
docker buildx create --use
docker buildx build --platform linux/amd64,linux/arm64 -t utente/app:1.0 --push .
Il resto del mondo Docker, dai volumi alla rete, è in Docker per Svogliati.
Compilare per ARM da x86, e viceversa
Cross-compilare: costruire sul tuo computer un programma per un processore diverso. Più facile di quanto sembri, con i linguaggi moderni.
# Go: due variabili e basta
GOOS=linux GOARCH=arm64 go build -o app-arm64
GOOS=linux GOARCH=amd64 go build -o app-amd64
# Rust: il target, e cargo-zigbuild usa zig come linker (niente toolchain da installare)
rustup target add aarch64-unknown-linux-gnu
cargo zigbuild --release --target aarch64-unknown-linux-gnu
# C su Debian: il compilatore incrociato
sudo apt install gcc-aarch64-linux-gnu
aarch64-linux-gnu-gcc -O2 -o prog prog.c
# macOS: un "binario universale" con dentro sia ARM sia Intel
lipo -create -output app app-arm64 app-x86_64
lipo -info app # Architectures in the fat file: x86_64 arm64
cargo zigbuild, con la versione minima di glibc scelta apposta per farlo girare anche su distribuzioni vecchie. Il Mac è ARM, il server è x86, nessuno dei due se ne accorge.
Su Debian e derivate, il multiarch permette di installare librerie di un'altra architettura accanto alle tue (dpkg --add-architecture arm64), utile per compilare programmi che le richiedono. Il funzionamento dei pacchetti è in Pacchetti .deb per Svogliati.
L'emulazione: far girare x86 su ARM
Quando non puoi ricompilare, puoi tradurre. Ogni sistema ha il suo traduttore, e ognuno ha i suoi limiti.
| Traduttore | Dove | Quanto è buono |
|---|---|---|
| Rosetta 2 | macOS su chip M | Molto: traduce le app Intel quasi senza che te ne accorga. Apple ha annunciato che dopo macOS 27 resterà solo per alcuni giochi: le app Intel vanno aggiornate |
| Prism | Windows 11 su ARM | Buono per le app normali, meno per giochi e programmi con driver. Le app ARM native girano molto meglio |
| QEMU user + binfmt | Linux | Fa girare singoli programmi di un'altra architettura, anche dentro Docker. Lento (da 5 a 20 volte), ma va bene per un build o un test |
| box64, FEX | Linux su ARM | Traduzione più veloce di QEMU per programmi x86_64, anche giochi. Usati sui Raspberry e sui portatili ARM con Linux |
# registra gli emulatori QEMU nel kernel (binfmt_misc), una volta
docker run --privileged --rm tonistiigi/binfmt --install all
# ora un container amd64 parte anche su arm64, in emulazione
docker run --platform linux/amd64 --rm debian:stable uname -m # x86_64
Migrare un server su ARM, passo per passo
Non si migra "il server". Si verifica ogni pezzo, si prova su una macchina gemella, e si misura.
L'inventario
Tutto quello che gira: pacchetti della distribuzione (di solito nessun problema), repository di terze parti, binari scaricati a mano in /usr/local/bin e /opt, immagini Docker, agenti di monitoraggio e backup, script che scaricano qualcosa.
La verifica, componente per componente
Per ognuno: esiste per arm64? Pacchetti della distribuzione: sì. Immagini: docker manifest inspect. Binari e repository esterni: la pagina dei download del fornitore. Segna i "no" e decidi cosa fare per ognuno.
Un server di prova
Una macchina ARM piccola, pagata a ore, con la stessa distribuzione. Installa con gli stessi script o la stessa configurazione Ansible: è anche il modo di scoprire cosa non era scritto da nessuna parte.
La misura
Stessi test sulle due macchine: tempi di risposta, CPU sotto carico, durata di un backup o di un build. Il prezzo ha senso solo diviso per quello che il server fa.
Il passaggio, e la porta aperta
Sposta i dati, cambia il DNS, tieni il vecchio server spento ma esistente per qualche giorno. Se qualcosa non va, torni indietro in cinque minuti.
Errori tradotti
Quando l'architettura è sbagliata, i messaggi sono sempre questi. Nessuno dice "architettura sbagliata".
| Cosa vedi | Cosa vuol dire | Cosa fare |
|---|---|---|
exec format error | Il file è un programma per un altro processore | file nomeprogramma ti dice per quale; scarica la versione giusta o usa l'emulazione |
cannot execute binary file: Exec format error | Lo stesso, detto da bash | Idem |
no matching manifest for linux/arm64/v8 in the manifest list entries | L'immagine Docker non esiste per ARM | Cerca un'immagine alternativa o costruiscila; in emergenza --platform linux/amd64 |
The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) | Docker sta per far girare l'immagine in emulazione | Funzionerà, ma lento: cerca la versione arm64 |
package architecture (amd64) does not match system (arm64) | Stai installando un .deb per x86 | Scarica il .deb per arm64 |
Illegal instruction (core dumped) | Il programma usa istruzioni che il tuo processore non ha (troppo vecchio, o compilato per uno più nuovo) | Una versione compilata per un processore più vecchio |
Unsupported system page size | Un programma (spesso tramite jemalloc) non sopporta le pagine da 16 o 64 KB | Kernel con pagine da 4 KB, o una versione del programma ricompilata |
No such file or directory su un file che c'è | Spesso manca il "loader" dell'architettura giusta: il file c'è, l'interprete per lanciarlo no | file sul programma: probabilmente è di un'altra architettura |
error: command 'gcc' failed durante pip install | Non c'è un pacchetto già compilato per arm64, e pip prova a compilarlo | Installa build-essential e gli header, o aggiorna la libreria |
I comandi per capire su cosa sei
Prima di scaricare qualsiasi cosa, sapere che architettura hai e che architettura ha il file.
uname -m # aarch64 = ARM 64 bit, x86_64 = Intel/AMD, armv7l = ARM 32 bit
dpkg --print-architecture # arm64, amd64, armhf (i nomi di Debian)
lscpu # modello, core, e se è Neoverse, Cortex o altro
grep -m1 Features /proc/cpuinfo # le estensioni del processore (asimd, sve…)
getconf PAGESIZE # 4096 di solito; 16384 o 65536 su alcuni sistemi ARM
file /usr/local/bin/qualcosa # "ELF 64-bit LSB executable, ARM aarch64" oppure "x86-64"
uname -m # arm64 su chip M, x86_64 su Intel (o sotto Rosetta!)
sysctl -n machdep.cpu.brand_string # "Apple M4" e simili
lipo -archs /Applications/Firefox.app/Contents/MacOS/firefox # x86_64 arm64 = universale
arch -x86_64 /bin/bash # una shell in modalità Intel, tramite Rosetta
Cheat sheet
Quando scegliere ARM, e i nomi da non confondere.
| Situazione | Scelta |
|---|---|
| Server web, API, container con immagini multi-arch | ARM, se il prezzo è uguale o migliore |
| Carico continuo su poche vCPU | ARM: core veri, non thread condivisi |
| Software proprietario solo x86, Windows Server | x86 |
| Un componente su dieci solo x86 | ARM per gli altri nove, una macchina x86 per quello. Non emularlo |
| Compilazione e CI | ARM con tanti core, o tutte e due se rilasci per entrambe |
| Portatile per sviluppare | Mac con chip M: ottimo, se i tuoi server sono Linux e usi container multi-arch |
| Nome | Cos'è |
|---|---|
aarch64 = arm64 | ARM a 64 bit (kernel e uname contro Debian, Docker, macOS) |
armhf, armv7l | ARM a 32 bit: Raspberry vecchi e sistemi a 32 bit |
x86_64 = amd64 | Intel e AMD a 64 bit |
linux/arm64/v8 | Il nome della piattaforma per Docker |
| Cortex, Neoverse | I core progettati da Arm: per dispositivi e per server |
| Graviton, Axion, Cobalt, Altra, M4, Snapdragon X | I chip dei vari costruttori |