> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Configurazione avanzata
> Requisiti di sistema, installazione specifica per piattaforma, gestione delle versioni e disinstallazione per Claude Code.
Questa pagina copre i requisiti di sistema, i dettagli di installazione specifici per piattaforma, gli aggiornamenti e la disinstallazione. Per una procedura guidata della vostra prima sessione, consultate la [guida rapida](/docs/it/quickstart). Se non avete mai utilizzato un terminale prima, consultate la [guida del terminale](/docs/it/terminal-guide).
Requisiti di sistema
Claude Code funziona sulle seguenti piattaforme e configurazioni:
* **Sistema operativo**:
* macOS 13.0+
* Windows 10 1809+ o Windows Server 2019+
* Ubuntu 20.04+
* Debian 10+
* Alpine Linux 3.19+
* **Hardware**: 4 GB+ di RAM, processore x64 o ARM64
* **Rete**: connessione a Internet richiesta. Consultate la [configurazione di rete](/docs/it/network-config#network-access-requirements).
* **Shell**: Bash, Zsh, PowerShell o CMD.
* **Posizione**: [paesi supportati da Anthropic](https://www.anthropic.com/supported-countries)
Dipendenze aggiuntive
* **ripgrep**: solitamente incluso con Claude Code. Se la ricerca non funziona, consultate la [risoluzione dei problemi di ricerca](/docs/it/troubleshooting#search-and-discovery-issues).
Installare Claude Code
Preferite un'interfaccia grafica? L'[app Desktop](/docs/it/desktop-quickstart) vi consente di utilizzare Claude Code senza il terminale. Scaricatela per [macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs), [Windows](https://claude.com/download?utm_source=claude_code\&utm_medium=docs) o [Linux](/docs/it/desktop-linux).
Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.
**macOS, Linux, WSL:**
```bash theme={null}
curl -fsSL https://claude.ai/install.sh | bash
```
Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.
**Windows PowerShell:**
```powershell theme={null}
irm https://claude.ai/install.ps1 | iex
```
**Windows CMD:**
```batch theme={null}
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```
Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](/docs/it/troubleshoot-install#command-not-found-claude-after-installation).
Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.
Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](/docs/it/troubleshoot-install#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.
[Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.
Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.
```bash theme={null}
brew install --cask claude-code
```
Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.
Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.
```powershell theme={null}
winget install Anthropic.ClaudeCode
```
Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.
Puoi anche installare con [apt, dnf, o apk](/docs/it/setup#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.
Dopo il completamento dell'installazione, aprite un terminale nel progetto su cui desiderate lavorare e avviate Claude Code:
```bash theme={null}
claude
```
Claude Code apre una sessione interattiva nel vostro terminale.
Se riscontrate problemi durante l'installazione, consultate [Risoluzione dei problemi di installazione e accesso](/docs/it/troubleshoot-install).
Configurazione su Windows
Potete eseguire Claude Code nativamente su Windows o all'interno di WSL. Scegliete in base a dove si trovano i vostri progetti e quali funzionalità vi servono:
| Opzione | Richiede | [Sandboxing](/docs/it/sandboxing) | Quando utilizzare |
| - | - | - | - |
| [Windows nativo](#install-on-native-windows) | Nessuno; [Git for Windows](https://git-scm.com/downloads/win) è facoltativo | Non supportato | Progetti e strumenti nativi di Windows |
| [WSL 2](#install-in-wsl) | WSL 2 abilitato | Supportato | Toolchain Linux o esecuzione di comandi in sandbox |
| [WSL 1](#install-in-wsl) | WSL 1 abilitato | Non supportato | Se WSL 2 non è disponibile |
Installare su Windows nativo
Esegui il [comando di installazione](#install-claude-code) da PowerShell o CMD. Non è necessario eseguire come Amministratore. L'installazione di [Git for Windows](https://git-scm.com/downloads/win) è facoltativa. Fornisce Git Bash, necessario per lo [strumento Bash](/docs/it/tools-reference#bash-tool-behavior) e lo [strumento Monitor](/docs/it/tools-reference#monitor-tool).
Se eseguite l'installazione da PowerShell o CMD influisce solo su quale comando di installazione eseguite. Il vostro prompt mostra `PS C:\Users\YourName>` in PowerShell e `C:\Users\YourName>` senza il `PS` in CMD. Se siete nuovi al terminale, la [guida del terminale](/docs/it/terminal-guide#windows) vi guida attraverso ogni passaggio.
Dopo l'installazione, avviate `claude` da qualsiasi terminale.
* **Senza Git for Windows**, Claude Code esegue i comandi della shell tramite lo [strumento PowerShell](/docs/it/tools-reference#powershell-tool).
* **Con Git for Windows**, Claude Code utilizza Git Bash per lo [strumento Bash](/docs/it/tools-reference#bash-tool-behavior). Se Claude Code non riesce a trovare Git Bash, impostate il percorso nel vostro [file settings.json](/docs/it/settings):
```json theme={null}
{
"env": {
"CLAUDE_CODE_GIT_BASH_PATH": "C:\\Program Files\\Git\\bin\\bash.exe"
}
}
```
Quando Git for Windows è installato, lo strumento PowerShell è disponibile insieme a Bash: attivato per impostazione predefinita per gli account claude.ai e Console, e abilitato con `CLAUDE_CODE_USE_POWERSHELL_TOOL=1` nelle sessioni Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry. Impostatelo a `0` per disattivare lo strumento. Consultate [PowerShell tool](/docs/it/tools-reference#powershell-tool) per la configurazione e le limitazioni.
Installare in WSL
Apri la tua distribuzione WSL ed esegui l'installer Linux dalle [istruzioni di installazione](#install-claude-code). Installi e avvii `claude` all'interno del terminale WSL, non da PowerShell o CMD.
Alpine Linux e distribuzioni basate su musl
L'installazione di Claude Code su Alpine e altre distribuzioni basate su musl/uClibc richiede `bash` e `curl` per il comando di installazione, e `libgcc`, `libstdc++` e `ripgrep` al runtime. Alpine non include `bash` o `curl` per impostazione predefinita, quindi il comando di installazione documentato non riesce con un errore `not found` finché non li installate. Installate questi pacchetti utilizzando il gestore di pacchetti della vostra distribuzione, quindi impostate `USE_BUILTIN_RIPGREP=0`.
Questo esempio installa i pacchetti richiesti su Alpine:
```bash theme={null}
apk add bash curl libgcc libstdc++ ripgrep
```
Su Alpine, `ripgrep` si trova nel repository community. Se `apk` segnala che il pacchetto è mancante, aggiungete il repository community a `/etc/apk/repositories`, utilizzando la vostra versione di Alpine:
```bash theme={null}
echo "https://dl-cdn.alpinelinux.org/alpine/v3.22/community" >> /etc/apk/repositories
```
Eseguite `apk update` per aggiornare l'indice dei pacchetti e riprovate il comando `apk add`.
Quindi impostate `USE_BUILTIN_RIPGREP` a `0` nel vostro file [`settings.json`](/docs/it/settings-reference#all-settings):
```json theme={null}
{
"env": {
"USE_BUILTIN_RIPGREP": "0"
}
}
```
Verificare l'installazione
Dopo l'installazione, confermate che Claude Code funziona:
```bash theme={null}
claude --version
```
Un'installazione funzionante stampa un numero di versione come `2.1.211 (Claude Code)`.
Se questo fallisce con `command not found` o un altro errore, consultate [Risoluzione dei problemi di installazione e accesso](/docs/it/troubleshoot-install).
Per un controllo più dettagliato dell'installazione e della configurazione, eseguite [`claude doctor`](/docs/it/troubleshooting#get-more-help):
```bash theme={null}
claude doctor
```
`claude doctor` stampa diagnostiche di installazione e impostazioni di sola lettura senza avviare una sessione, inclusi lo stato di salute dell'installazione, errori di convalida del file di impostazioni e eventuali avvisi con correzioni suggerite.
Autenticazione
Claude Code richiede un account Pro, Max, Team, Enterprise o Console. Il piano gratuito di Claude.ai non include l'accesso a Claude Code. Potete anche utilizzare Claude Code con un provider API di terze parti come [Amazon Bedrock](/docs/it/amazon-bedrock), [Google Cloud's Agent Platform](/docs/it/google-vertex-ai) o [Microsoft Foundry](/docs/it/microsoft-foundry).
Dopo l'installazione, accedi eseguendo `claude` e seguendo i prompt del browser. Se hai impostato la variabile d'ambiente `ANTHROPIC_API_KEY` e approvi la chiave quando Claude Code ti chiede se utilizzarla, Claude Code salta il prompt di accesso. Consulta [Autenticazione](/docs/it/authentication) per tutti i tipi di account e le opzioni di configurazione del team.
Aggiornare Claude Code
Le installazioni native si aggiornano automaticamente in background. Potete [configurare il canale di rilascio](#configure-release-channel) per controllare se ricevere gli aggiornamenti immediatamente o secondo una pianificazione stabile ritardata, oppure [disabilitare gli aggiornamenti automatici](#disable-auto-updates) completamente. Le installazioni Homebrew, WinGet e [gestori di pacchetti Linux](#install-with-linux-package-managers) richiedono aggiornamenti manuali per impostazione predefinita.
Aggiornamenti automatici
Claude Code verifica la disponibilità di aggiornamenti all'avvio e periodicamente durante l'esecuzione. Gli aggiornamenti si scaricano e si installano in background, quindi hanno effetto la prossima volta che avviate Claude Code.
Eseguite `claude doctor` per visualizzare il risultato del tentativo di aggiornamento più recente.
Su macOS e Linux, il programma di installazione nativo gestisce il launcher in `~/.local/bin/claude` come un collegamento simbolico in `~/.local/share/claude/versions/`. Se sostituisci quel launcher con il tuo script o collegamento simbolico, l'aggiornamento automatico e `claude update` lo lasciano in posizione: le nuove versioni si installano comunque nella directory `versions/`, e il tuo launcher decide quale versione viene eseguita.
Con un launcher personalizzato, Claude Code mantiene anche ogni versione installata su disco perché non può determinare quale versione il launcher necessita. `claude doctor` segnala un launcher che il programma di installazione nativo non ha creato.
Per consentire a Claude Code di gestire di nuovo il launcher, rimuovete `~/.local/bin/claude` ed eseguite `claude update`.
Se un'installazione globale npm non può aggiornarsi automaticamente perché la directory globale npm non è scrivibile, Claude Code mostra un avviso una sola volta all'avvio, e `claude doctor` elenca le correzioni disponibili. Consultate [errori di autorizzazione durante l'installazione](/docs/it/troubleshoot-install#permission-errors-during-installation) per i dettagli.
Le installazioni Homebrew, WinGet, apt, dnf e apk non si aggiornano automaticamente per impostazione predefinita; consultate di seguito per attivare l'opzione per Homebrew e WinGet. Per aggiornare Homebrew manualmente, eseguite `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask avete installato. Per WinGet, eseguite `winget upgrade Anthropic.ClaudeCode`. Per i gestori di pacchetti Linux, consultate i comandi di aggiornamento in [Installare con gestori di pacchetti Linux](#install-with-linux-package-managers).
Per fare in modo che Claude Code esegua il comando di aggiornamento per voi su Homebrew o WinGet, impostate [`CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE`](/docs/it/env-vars) a `1`. Claude Code esegue quindi l'aggiornamento in background quando una nuova versione è disponibile e mostra un prompt di riavvio al completamento. L'aggiornamento riguarda solo il pacchetto Claude Code e non influisce su altro software che avete installato.
Su WinGet l'aggiornamento potrebbe non riuscire mentre Claude Code è in esecuzione perché Windows blocca l'eseguibile. In questo caso Claude Code mostra il comando manuale. apt, dnf e apk continuano a richiedere un aggiornamento manuale perché questi comandi necessitano di privilegi elevati.
**Problema noto:** Claude Code potrebbe notificarvi gli aggiornamenti prima che la nuova versione sia disponibile in questi gestori di pacchetti. Se un aggiornamento non riesce, attendete e riprovate più tardi.
Homebrew mantiene le versioni precedenti su disco dopo gli aggiornamenti. Eseguite `brew cleanup` periodicamente per recuperare spazio su disco.
Controllate quale canale di rilascio Claude Code segue per gli aggiornamenti automatici e `claude update` con l'impostazione `autoUpdatesChannel`:
* `"latest"`, l'impostazione predefinita: ricevete le nuove funzionalità non appena vengono rilasciate
* `"stable"`: utilizzate una versione che è tipicamente circa una settimana più vecchia, saltando i rilasci con regressioni importanti
Configurate questo tramite `/config` → **Auto-update channel**, oppure aggiungetelo al vostro [file settings.json](/docs/it/settings):
```json theme={null}
{
"autoUpdatesChannel": "stable"
}
```
Un modello appena lanciato può richiedere una versione di Claude Code più recente di quella fornita dal canale stable. Per eseguire subito il modello, passa al canale latest.
Per le distribuzioni aziendali, potete applicare un canale di rilascio coerente in tutta l'organizzazione utilizzando [impostazioni gestite](/docs/it/managed-settings).
Le installazioni Homebrew scelgono un canale in base al nome del cask invece di questa impostazione: `claude-code` traccia stable e `claude-code@latest` traccia latest.
Le installazioni dai repository apt, dnf e apk scelgono un canale in base al repository invece di questa impostazione. Per cambiarlo, segui [Installare con gestori di pacchetti Linux](#install-with-linux-package-managers).
Fissare una versione minima
L'impostazione `minimumVersion` stabilisce un limite inferiore. Gli aggiornamenti automatici in background e `claude update` rifiutano di installare qualsiasi versione al di sotto di questo valore, quindi il passaggio al canale `"stable"` non vi fa regredire se siete già su una build `"latest"` più recente.
Il passaggio da `"latest"` a `"stable"` tramite `/config` vi chiede di rimanere sulla versione corrente o di consentire il downgrade. Se scegliete di rimanere, viene impostato `minimumVersion` a quella versione. Il passaggio di nuovo a `"latest"` lo cancella.
Aggiungetelo al vostro [file settings.json](/docs/it/settings) per fissare un limite inferiore esplicitamente:
```json theme={null}
{
"autoUpdatesChannel": "stable",
"minimumVersion": "2.1.100"
}
```
Nelle [impostazioni gestite](/docs/it/managed-settings), questo applica un minimo a livello di organizzazione che le impostazioni utente e di progetto non possono ignorare.
Il pin `minimumVersion` vincola solo gli aggiornamenti. Per fare in modo che Claude Code rifiuti di avviarsi al di fuori di un intervallo di versioni, utilizzate invece le impostazioni gestite `requiredMinimumVersion` e `requiredMaximumVersion`. Gli aggiornamenti rispettano anche il limite `requiredMaximumVersion`. Consultate [`requiredMinimumVersion`](/docs/it/settings-reference#requiredminimumversion) e [`requiredMaximumVersion`](/docs/it/settings-reference#requiredmaximumversion).
Disabilitare gli aggiornamenti automatici
Impostate `DISABLE_AUTOUPDATER` a `"1"` nella chiave `env` del vostro file [`settings.json`](/docs/it/settings-reference#all-settings):
```json theme={null}
{
"env": {
"DISABLE_AUTOUPDATER": "1"
}
}
```
Su un'installazione nativa o npm, confermate che la modifica ha avuto effetto eseguendo `claude doctor` e verificando che la riga `Auto-updates` mostri `disabled (set by env: DISABLE_AUTOUPDATER)` invece di `enabled`.
`DISABLE_AUTOUPDATER` arresta solo il controllo in background; `claude update` e `claude install` continuano a funzionare. Per bloccare tutti i percorsi di aggiornamento, inclusi gli aggiornamenti manuali, impostate invece [`DISABLE_UPDATES`](/docs/it/env-vars). Utilizzate questo quando distribuite Claude Code attraverso i vostri canali e avete bisogno che gli utenti rimangano sulla versione che fornite.
Aggiornare manualmente
Per applicare un aggiornamento immediatamente senza attendere il prossimo controllo in background, eseguite:
```bash theme={null}
claude update
```
Quando un aggiornamento si installa, il comando segnala `Successfully updated from to version `. Se siete già sulla versione più recente, segnala `Claude Code is up to date ()`. Gli aggiornamenti gestiti da Homebrew, WinGet o apk segnalano invece `Claude is up to date!`.
Opzioni di installazione avanzate
Queste opzioni sono per il pinning delle versioni, i gestori di pacchetti Linux, npm, lo storage di rete e la verifica dell'integrità dei binari.
Installare una versione specifica
L'installer nativo accetta un numero di versione specifico o un canale di rilascio (`latest` o `stable`). Il canale che scegliete al momento dell'installazione diventa il vostro predefinito per gli aggiornamenti automatici. Consultate [configurare il canale di rilascio](#configure-release-channel) per ulteriori informazioni.
Per installare la versione più recente (predefinita):
```bash theme={null}
curl -fsSL https://claude.ai/install.sh | bash
```
```powershell theme={null}
irm https://claude.ai/install.ps1 | iex
```
```batch theme={null}
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```
Per installare la versione stabile:
```bash theme={null}
curl -fsSL https://claude.ai/install.sh | bash -s stable
```
```powershell theme={null}
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) stable
```
```batch theme={null}
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd stable && del install.cmd
```
Per installare un numero di versione specifico:
```bash theme={null}
curl -fsSL https://claude.ai/install.sh | bash -s 2.1.89
```
```powershell theme={null}
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 2.1.89
```
```batch theme={null}
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd 2.1.89 && del install.cmd
```
Per confermare quale versione è stata installata, eseguite `claude --version`: il comando stampa la versione esatta che avete passato, come ad esempio `2.1.89 (Claude Code)`.
Installare con i gestori di pacchetti Linux
Claude Code pubblica repository apt, dnf e apk firmati. Ogni repository offre due canali: `stable` fornisce una versione che è tipicamente circa una settimana vecchia, saltando i rilasci con regressioni importanti, e `latest` fornisce ogni rilascio non appena viene spedito. I comandi seguenti configurano il canale `stable`, che si adatta alla maggior parte degli utenti; ogni scheda mostra anche l'URL del repository `latest`. Le installazioni tramite gestore di pacchetti non si aggiornano automaticamente tramite Claude Code; gli aggiornamenti arrivano attraverso il vostro normale flusso di lavoro di aggiornamento del sistema.
Tutti i repository sono firmati con la [chiave di firma del rilascio di Claude Code](#binary-integrity-and-code-signing). Prima di fidarvi della chiave, verificatela come descritto in ogni scheda.
Per Debian e Ubuntu. I comandi di installazione seguenti scaricano la chiave di firma con `curl` e la verificano con `gpg`, che le installazioni fresche di Debian e Ubuntu potrebbero non includere. Se uno dei due comandi riporta `command not found`, installate prima entrambi:
```bash theme={null}
sudo apt install curl gnupg
```
Scaricate la chiave di firma:
```bash theme={null}
sudo install -d -m 0755 /etc/apt/keyrings
sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \
-o /etc/apt/keyrings/claude-code.asc
```
Se questo download fallisce, `apt update` in seguito fallisce con `NO_PUBKEY BAA929FF1A7ECACE`. Confermate che la chiave sia stata scaricata e appartenga ad Anthropic prima di continuare:
```bash theme={null}
gpg --show-keys /etc/apt/keyrings/claude-code.asc
```
L'impronta digitale che gpg stampa dovrebbe essere `31DDDE24DDFAB679F42D7BD2BAA929FF1A7ECACE`. Se gpg riporta che il file non può essere aperto o non contiene dati OpenPGP validi, il download è fallito o ha restituito il contenuto sbagliato: confermate che la vostra rete possa raggiungere `downloads.claude.ai`, quindi rieseguite il comando di download.
Registrate il repository sul canale `stable` e installate:
```bash theme={null}
echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" \
| sudo tee /etc/apt/sources.list.d/claude-code.list
sudo apt update
sudo apt install claude-code
```
Per utilizzare il canale `latest` invece, sia il percorso dell'URL che il nome della suite cambiano. Utilizzate questa riga `deb`:
```bash theme={null}
echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/latest latest main" \
| sudo tee /etc/apt/sources.list.d/claude-code.list
```
Per aggiornare in seguito, eseguite `sudo apt update && sudo apt upgrade claude-code`.
Per Fedora e RHEL. I comandi seguenti configurano il canale `stable`:
```bash theme={null}
sudo tee /etc/yum.repos.d/claude-code.repo <<'EOF'
[claude-code]
name=Claude Code
baseurl=https://downloads.claude.ai/claude-code/rpm/stable
enabled=1
gpgcheck=1
gpgkey=https://downloads.claude.ai/keys/claude-code.asc
EOF
sudo dnf install claude-code
```
Per utilizzare il canale `latest` invece, impostate `baseurl` al repository `latest`:
```ini theme={null}
baseurl=https://downloads.claude.ai/claude-code/rpm/latest
```
dnf scarica la chiave al primo install e vi chiede di confermare l'impronta digitale. Verificate che corrisponda a `31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE` prima di accettare.
Per aggiornare in seguito, eseguite `sudo dnf upgrade claude-code`.
Per Alpine Linux. I comandi seguenti configurano il canale `stable`:
```sh theme={null}
wget -O /etc/apk/keys/claude-code.rsa.pub \
https://downloads.claude.ai/keys/claude-code.rsa.pub
echo "https://downloads.claude.ai/claude-code/apk/stable" >> /etc/apk/repositories
apk add claude-code
```
Per passare al canale `latest`, rimuovete la riga del repository `stable` e aggiungete il repository `latest`:
```sh theme={null}
sed -i '\|downloads.claude.ai/claude-code/apk/stable|d' /etc/apk/repositories
echo "https://downloads.claude.ai/claude-code/apk/latest" >> /etc/apk/repositories
```
Verificate la chiave scaricata con `sha256sum /etc/apk/keys/claude-code.rsa.pub`, che dovrebbe riportare `395759c1f7449ef4cdef305a42e820f3c766d6090d142634ebdb049f113168b6`.
Per aggiornare in seguito, eseguite `apk update && apk upgrade claude-code`.
Installare con npm
Puoi anche installare Claude Code come pacchetto npm globale. Il pacchetto npm richiede [Node.js 22 o successivo](https://nodejs.org/en/download). Su una versione più vecchia di Node.js, npm stampa un avviso `EBADENGINE` durante l'installazione anziché fallire; l'installazione si completa e `claude` continua a funzionare, poiché il pacchetto scarica un binario nativo che non utilizza il tuo Node.js al runtime.
```bash theme={null}
npm install -g @anthropic-ai/claude-code
```
Il pacchetto npm installa lo stesso binario nativo dell'installer standalone. npm estrae il binario attraverso una dipendenza opzionale per piattaforma come `@anthropic-ai/claude-code-darwin-arm64`, e un passaggio postinstall lo collega in posizione. Il binario `claude` installato non invoca Node stesso.
Le piattaforme di installazione npm supportate sono `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` e `win32-arm64`. Il vostro gestore di pacchetti deve consentire dipendenze opzionali. Consultate la [risoluzione dei problemi](/docs/it/troubleshoot-install#native-binary-not-found-after-npm-install) se il binario manca dopo l'installazione.
Per aggiornare un'installazione npm, eseguite `npm install -g @anthropic-ai/claude-code@latest`. Evitate `npm update -g`, che rispetta l'intervallo semver dall'installazione originale e potrebbe non portarvi al rilascio più recente.
NON utilizzate `sudo npm install -g` poiché ciò può portare a problemi di permessi e rischi di sicurezza. Se riscontrate errori di permessi, consultate la [risoluzione dei problemi di permessi](/docs/it/troubleshoot-install#permission-errors-during-installation).
Installare su storage di rete
Una sessione in esecuzione legge parti dell'eseguibile di Claude Code dal disco mentre lavora, non solo all'avvio. Se il file diventa illeggibile a metà sessione, ad esempio perché è stato troncato o eliminato sullo storage di rete, la sessione si arresta in modo anomalo. Su Linux, la tua shell lo segnala come `Bus error`.
Quando le directory home risiedono su storage di rete, come una home NFS montata su più macchine, organizza le installazioni in modo che l'eseguibile di ogni sessione resti leggibile fino al termine della sessione:
* **Installa su disco locale**: metti il binario sul filesystem locale di ogni macchina, ad esempio con un [gestore di pacchetti Linux](#install-with-linux-package-managers) o con i tuoi strumenti di distribuzione. Un prefisso npm per utente e la directory predefinita `~/.local/share/claude/versions/` dell'installer nativo si trovano entrambi nella directory home.
* **Mantieni ogni versione nella propria directory**: aggiornare sul posto un'installazione npm con `npm install -g` elimina il binario precedente. Su uno storage condiviso da più macchine, questo rimuove il file che le sessioni sulle altre macchine stanno ancora eseguendo. Installa ogni nuova versione accanto a quelle vecchie e sposta gli utenti su di essa.
* **Elimina una versione vecchia solo quando nessuna macchina può ancora eseguirla**: una macchina non può vedere i processi in esecuzione su altre macchine, quindi controllare i processi in esecuzione prima di eliminare non basta.
* **Disattiva gli aggiornamenti propri di Claude Code**: imposta [`DISABLE_UPDATES`](/docs/it/env-vars) e installa le nuove versioni con i tuoi strumenti. Altrimenti un aggiornamento automatico di un'installazione npm su una macchina esegue lo stesso aggiornamento sul posto e rimuove il binario che le sessioni su altre macchine stanno eseguendo. Impostare solo `DISABLE_AUTOUPDATER` non basta, perché gli utenti possono comunque eseguire `claude update` e `claude install`. Consulta [Disattivare gli aggiornamenti automatici](#disable-auto-updates).
L'installer nativo elimina autonomamente le versioni vecchie da `~/.local/share/claude/versions/`, cosa rilevante quando quella directory si trova su storage condiviso. Oltre alla versione a cui punta il launcher e a qualsiasi versione in esecuzione in una sessione sulla stessa macchina, mantiene le due versioni più recenti ed elimina le altre. Una sessione su un'altra macchina che sta eseguendo una versione eliminata perde il proprio binario. Con un [launcher personalizzato](#auto-updates), Claude Code mantiene ogni versione installata e lascia a te la pulizia.
Integrità dei binari e firma del codice
Ogni rilascio pubblica un `manifest.json` contenente checksum SHA256 per ogni binario di piattaforma. Il manifest è firmato con una chiave GPG di Anthropic, quindi la verifica della firma sul manifest verifica transitivamente ogni binario che elenca.
Verificare la firma del manifest
I passaggi 1-3 richiedono una shell POSIX con `gpg` e `curl`. Su Windows, eseguiteli in Git Bash o WSL. Il passaggio 4 include un'opzione PowerShell.
La chiave di firma del rilascio è pubblicata a un URL fisso.
```bash theme={null}
curl -fsSL https://downloads.claude.ai/keys/claude-code.asc | gpg --import
```
Visualizzate l'impronta digitale della chiave importata.
```bash theme={null}
gpg --fingerprint security@anthropic.com
```
Confermate che l'output includa questa impronta digitale:
```text theme={null}
31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE
```
Impostate `VERSION` al rilascio che desiderate verificare.
```bash theme={null}
REPO=https://downloads.claude.ai/claude-code-releases
VERSION=2.1.89
curl -fsSLO "$REPO/$VERSION/manifest.json"
curl -fsSLO "$REPO/$VERSION/manifest.json.sig"
```
Verificate la firma staccata rispetto al manifest.
```bash theme={null}
gpg --verify manifest.json.sig manifest.json
```
Un risultato valido riporta `Good signature from "Anthropic Claude Code Release Signing "`.
`gpg` stampa anche `WARNING: This key is not certified with a trusted signature!` per qualsiasi chiave appena importata. Questo è previsto. La riga `Good signature` conferma che il controllo crittografico è passato. Il confronto dell'impronta digitale nel Passaggio 1 conferma che la chiave stessa è autentica.
Confrontate il checksum SHA256 del binario con il valore elencato sotto `platforms..checksum` in `manifest.json`. I comandi seguenti presuppongono un binario `claude` nella directory corrente. Per verificare un binario nativo installato invece, eseguite il comando rispetto a `~/.local/share/claude/versions/VERSION`, sostituendo VERSION con il rilascio che avete impostato nel Passaggio 2.
```bash theme={null}
sha256sum claude
```
```bash theme={null}
shasum -a 256 claude
```
```powershell theme={null}
(Get-FileHash claude.exe -Algorithm SHA256).Hash.ToLower()
```
Le firme del manifest sono disponibili per i rilasci da `2.1.89` in poi. I rilasci precedenti pubblicano checksum in `manifest.json` senza una firma staccata.
Oltre al manifest firmato, i singoli binari portano firme del codice native della piattaforma dove supportate.
* **macOS**: firmato da "Anthropic PBC" e notarizzato da Apple. Verificate con `codesign --verify --verbose ./claude`.
* **Windows**: firmato da "Anthropic, PBC". Verificate con `Get-AuthenticodeSignature .\claude.exe`.
* **Linux**: i binari non sono individualmente firmati dal codice. Se scaricate direttamente dal bucket `claude-code-releases` o utilizzate l'installer nativo, verificate l'integrità con la firma del manifest sopra. Se installate con [apt, dnf o apk](#install-with-linux-package-managers), il vostro gestore di pacchetti verifica automaticamente le firme utilizzando la chiave di firma del repository.
Disinstallare Claude Code
Per rimuovere Claude Code, seguite le istruzioni per il vostro metodo di installazione. Se `claude` continua a funzionare in seguito, probabilmente avete una seconda installazione o un alias shell residuo da un programma di installazione più vecchio. Consultate [Verificare le installazioni in conflitto](/docs/it/troubleshoot-install#check-for-conflicting-installations) per trovarla e rimuoverla.
Disinstallare un'installazione nativa
Rimuovete il binario di Claude Code e i file di versione:
```bash theme={null}
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude
```
```powershell theme={null}
Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force
Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force
```
Disinstallare con Homebrew
Rimuovete il cask Homebrew che avete installato. Se avete installato il cask stabile:
```bash theme={null}
brew uninstall --cask claude-code
```
Se avete installato il cask latest:
```bash theme={null}
brew uninstall --cask claude-code@latest
```
Disinstallare con WinGet
Rimuovete il pacchetto WinGet:
```powershell theme={null}
winget uninstall Anthropic.ClaudeCode
```
Disinstallare con apt, dnf o apk
Rimuovete il pacchetto e la configurazione del repository:
```bash theme={null}
sudo apt remove claude-code
sudo rm /etc/apt/sources.list.d/claude-code.list /etc/apt/keyrings/claude-code.asc
```
```bash theme={null}
sudo dnf remove claude-code
sudo rm /etc/yum.repos.d/claude-code.repo
```
```sh theme={null}
apk del claude-code
sed -i '\|downloads.claude.ai/claude-code/apk|d' /etc/apk/repositories
rm /etc/apk/keys/claude-code.rsa.pub
```
Disinstallare con npm
Rimuovete il pacchetto npm globale:
```bash theme={null}
npm uninstall -g @anthropic-ai/claude-code
```
Rimuovere i file di configurazione
La rimozione dei file di configurazione eliminerà tutte le vostre impostazioni, gli strumenti consentiti, le configurazioni del server MCP e la cronologia delle sessioni.
L'estensione VS Code, il plugin JetBrains e l'app Desktop scrivono anche in `~/.claude/`. Se uno di essi è ancora installato, la directory viene ricreata la prossima volta che viene eseguito. Per rimuovere Claude Code completamente, disinstallate l'[estensione VS Code](/docs/it/vs-code#uninstall-the-extension), il plugin JetBrains e l'app Desktop prima di eliminare questi file.
Per rimuovere le impostazioni di Claude Code e i dati memorizzati nella cache:
```bash theme={null}
# Rimuovere le impostazioni utente e lo stato
rm -rf ~/.claude
rm ~/.claude.json
# Rimuovere le impostazioni specifiche del progetto (eseguire dalla directory del progetto)
rm -rf .claude
rm -f .mcp.json
```
```powershell theme={null}
# Rimuovere le impostazioni utente e lo stato
Remove-Item -Path "$env:USERPROFILE\.claude" -Recurse -Force
Remove-Item -Path "$env:USERPROFILE\.claude.json" -Force
# Rimuovere le impostazioni specifiche del progetto (eseguire dalla directory del progetto)
Remove-Item -Path ".claude" -Recurse -Force
Remove-Item -Path ".mcp.json" -Force
```