Installare Claude Code e ChatGPT Codex su un server Linux: passo dopo passo

Questa guida porta da un server Debian o Ubuntu appena installato a un agente IA operativo che analizza log, controlla configurazioni ed esegue compiti di manutenzione. Configuriamo Claude Code (Anthropic) e Codex CLI (OpenAI, lo strumento a riga di comando dietro ChatGPT), entrambi con un utente dedicato dai diritti limitati. Tutti i comandi sono stati provati su un server root KVM KernelHost con Debian 13 e Ubuntu 24.04. Cosa sia in generale un server gestito da IA e quali architetture esistano è spiegato nell articolo Server gestito da IA: collegare agenti in sicurezza.

Aggiornato a settembre 2026. Gli strumenti evolvono rapidamente; in caso di dubbio verifica le opzioni con claude --help o codex --help.

Requisiti

• Un server root con Debian 12 o 13 oppure Ubuntu 22.04 o 24.04 e accesso root via SSH. Su AlmaLinux e Rocky Linux i passaggi sono gli stessi, solo che i comandi dei pacchetti si chiamano dnf invece di apt.
• Hardening di base fatto: accesso SSH con chiave, firewall, aggiornamenti di sicurezza automatici. La checklist per nuovi server root copre tutto questo.
• Un account Anthropic (Claude Pro, Max o Team) o una chiave API, un account ChatGPT (Plus, Pro o Team) o una chiave API OpenAI. Ne basta uno se vuoi configurare un solo strumento.
• HTTPS in uscita verso api.anthropic.com e api.openai.com. Sui server KernelHost è così di serie; un firewall proprio restrittivo deve consentirlo.

Passo 1: creare un utente dedicato e limitare sudo

L agente non gira mai come root. Riceve un proprio account e, tramite una allowlist sudo, esattamente i comandi di cui ha bisogno. Inizia con pochi comandi di sola lettura ed estendi l elenco quando un compito lo richiede davvero.

sudo adduser --disabled-password --gecos "Agente IA" aiagent
sudo tee /etc/sudoers.d/aiagent >/dev/null <<'EOF'
aiagent ALL=(root) NOPASSWD: /usr/bin/journalctl *, /usr/bin/systemctl status *, /usr/bin/systemctl restart nginx, /usr/bin/apt-get update, /usr/bin/apt-get upgrade -y, /usr/bin/tail *, /usr/bin/df *, /usr/bin/ss *
EOF
sudo chmod 440 /etc/sudoers.d/aiagent
sudo visudo -cf /etc/sudoers.d/aiagent

L ultima riga verifica la sintassi. Un errore in un file sudoers può bloccare sudo per tutti, per questo la verifica fa sempre parte del processo. --disabled-password garantisce che nessuno possa accedere come aiagent con una password; più avanti passerai all account con sudo -iu aiagent.

Se l agente deve modificare file in /etc, non concedergli nano via sudo (permetterebbe di modificare qualsiasi file, incluso /etc/sudoers), ma lavora con un gruppo e diritti di scrittura mirati, per esempio setfacl -m u:aiagent:rw /etc/nginx/sites-available/mio-sito.conf. Per iniziare basta ampiamente che l agente proponga le modifiche e tu le applichi.

Passo 2: installare Node.js 22

Entrambi gli strumenti girano con Node.js. Claude Code richiede almeno la versione 18, Codex CLI almeno la 22, quindi installiamo la 22 LTS. I repository di Debian 12 forniscono una versione troppo vecchia; NodeSource fornisce quella attuale:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
node --version
npm --version

Chi non vuole eseguire script da internet con diritti di root usa nvm nella home dell utente agente; in quel caso è possibile completamente senza diritti di root. Dettagli e alternative nella guida a Node.js su Debian.

Passo 3: installare Claude Code ed effettuare l accesso

Da qui in poi lavoriamo nell account dell agente:

sudo -iu aiagent
curl -fsSL https://claude.ai/install.sh | bash
claude --version

L installer nativo colloca Claude Code in ~/.local/bin e si mantiene aggiornato da solo. In alternativa funziona npm con npm install -g @anthropic-ai/claude-code; se fallisce con EACCES, aiuta la sezione sulla risoluzione dei problemi più avanti.

Al primo avvio di claude lo strumento chiede l accesso. Con un account Claude apre normalmente il browser; su un server senza browser mostra un indirizzo e un codice da confermare su portatile o smartphone. Per script e cron job una chiave API è la scelta migliore:

echo 'export ANTHROPIC_API_KEY="sk-ant-..."' >> ~/.bashrc
chmod 600 ~/.bashrc
source ~/.bashrc
claude -p "Rispondi solo con OK" 

La chiave si trova così solo nella home dell utente agente, che gli altri utenti non possono leggere. Creala nella console Anthropic con un limite di spesa mensile: una sessione che sfugge di mano non potrà così diventare costosa.

Passo 4: configurare Claude Code per il server

All avvio Claude Code legge un file CLAUDE.md nella directory corrente. Contiene le regole valide per ogni sessione. Crea nella home dell agente una directory di lavoro con questo file:

mkdir -p ~/server && cd ~/server
cat > CLAUDE.md <<'EOF'
# Regole per questo server
- Questo è un server di produzione (Debian 13, nginx, PHP-FPM, MariaDB).
- I comandi di sola lettura (journalctl, systemctl status, tail, df, ss) sono sempre consentiti.
- Prima di ogni comando di scrittura, spiegare brevemente cosa cambia e attendere l approvazione.
- Mai rimuovere pacchetti, mai cancellare file sotto /var/lib, mai creare o eliminare utenti.
- Mai ripetere password, chiavi o dati dei clienti negli output.
- Alla fine di ogni compito fornire un riepilogo in tre frasi.
EOF

A questo si aggiunge una allowlist degli strumenti, così Claude Code esegue i comandi di sola lettura senza chiedere e richiede l approvazione per tutto il resto. Il file ~/.claude/settings.json vale per l utente:

mkdir -p ~/.claude
cat > ~/.claude/settings.json <<'EOF'
{
  "permissions": {
    "allow": [
      "Bash(sudo journalctl:*)",
      "Bash(sudo systemctl status:*)",
      "Bash(sudo tail:*)",
      "Bash(df:*)",
      "Bash(free:*)",
      "Bash(ss:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(sudo rm:*)",
      "Bash(dd:*)",
      "Bash(mkfs:*)"
    ]
  }
}
EOF

Ora il primo compito, in modo interattivo:

cd ~/server && claude
> Riassumi gli errori di journalctl delle ultime 24 ore e indica le tre cause più frequenti.

E lo stesso compito non presidiato, per esempio come cron job quotidiano alle 7 il cui risultato arriva via email:

0 7 * * * cd /home/aiagent/server && /home/aiagent/.local/bin/claude -p "Riassumi errori e avvisi di journalctl delle ultime 24 ore. Indica servizio, ora e causa probabile." --allowedTools "Bash(sudo journalctl:*)" 2>&1 | mail -s "Rapporto giornaliero server" admin@example.com

L opzione -p avvia Claude Code senza sessione interattiva, --allowedTools limita gli strumenti esattamente a ciò che serve all esecuzione. Le azioni di scrittura non appartengono alle esecuzioni non presidiate.

Passo 5: installare Codex CLI (ChatGPT) ed effettuare l accesso

Codex CLI è lo strumento di OpenAI che porta i modelli dietro ChatGPT sulla riga di comando. Installazione nello stesso account utente:

npm install -g @openai/codex
codex --version

L accesso avviene con l account ChatGPT (Plus, Pro o Team): avviare codex, scegliere «Sign in with ChatGPT» e aprire l indirizzo mostrato su un dispositivo con browser. Per gli script imposta invece una chiave API della piattaforma OpenAI:

echo 'export OPENAI_API_KEY="sk-..."' >> ~/.bashrc
source ~/.bashrc

Codex ha una propria sandbox e una modalità di approvazione. Entrambe si definiscono in ~/.codex/config.toml; per un server di produzione questa combinazione è sensata:

mkdir -p ~/.codex
cat > ~/.codex/config.toml <<'EOF'
approval_policy = "on-request"
sandbox_mode = "workspace-write"
EOF

workspace-write consente scritture solo nella directory di lavoro corrente, on-request fa chiedere all agente il permesso per tutto ciò che va oltre. Il livello danger-full-access elimina entrambi e non appartiene a un sistema di produzione. Codex legge regole come quelle di CLAUDE.md da un file AGENTS.md nella directory di lavoro; puoi usare lo stesso contenuto:

cp ~/server/CLAUDE.md ~/server/AGENTS.md
cd ~/server && codex "Verifica se tutti i servizi systemd abilitati sono in esecuzione ed elenca quelli falliti con l ultimo messaggio di errore."

Per le esecuzioni non presidiate esiste codex exec "compito", l equivalente di claude -p.

Alternativa: l agente gira sul tuo computer e lavora via SSH

Chi non vuole installare nulla sul server avvia Claude Code o Codex sul portatile e lascia che l agente invii i comandi via SSH. Il server riceve per questo una chiave SSH dedicata dell utente agente e in CLAUDE.md c è la regola di anteporre ssh aiagent@server a tutti i comandi del server. Funziona bene per manutenzione occasionale, ma compiti lunghi e cron job girano meglio direttamente sul server.

Passo 6: mettere in sicurezza e fissare limiti

• Snapshot o backup prima di ogni sessione in cui deve cambiare qualcosa. La strategia di backup per server mostra come automatizzarla.
• Lasciare attiva la modalità di approvazione. --dangerously-skip-permissions in Claude Code e danger-full-access in Codex sono pensati per VM usa e getta.
• Segreti fuori portata. L utente agente non deve poter leggere file .env, password del database e dati dei clienti. Ciò che legge va al fornitore.
• Limite di costo per ogni chiave API nella console del fornitore.
• Tracciabilità: installare etckeeper perché ogni modifica sotto /etc finisca in Git, e conservare i riepiloghi dell agente.
• In entrata non cambia nulla. Entrambi gli strumenti hanno bisogno solo di HTTPS in uscita. Firewall, Fail2ban e la protezione DDoS dell hoster restano invariati.

Errori tipici e soluzioni

Conclusione

Un agente IA sul server si configura in un ora: utente, allowlist sudo, Node.js, strumento, regole. Il vero lavoro sta nei limiti, e qui sono volutamente stretti. Ampliali passo dopo passo quando un compito lo richiede, mai in blocco. Su un server root KernelHost o un server dedicato non c è nulla da attivare: accesso root, libera scelta della distribuzione e connessioni in uscita sono lo standard.