Configurare Git: git config, nome, e-mail e chiavi SSH

Configurazione minima di Git in un minuto

Subito dopo l'installazione eseguite quattro comandi. Senza i primi due Git rifiuta di fare un commit; gli altri vi evitano i fastidi più comuni.

git config --global user.name "Anna Smirnova"
git config --global user.email "anna@example.com"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

Verificate il risultato:

$ git config --global --list
user.name=Anna Smirnova
user.email=anna@example.com
init.defaultbranch=main
core.editor=code --wait

Di seguito vediamo che cosa fa ciascuna impostazione, dove Git le conserva e come collegare l'accesso a GitHub tramite SSH.

Come funziona git config: tre livelli di impostazioni

Il comando git config legge e scrive i parametri in uno di tre file. Il livello più specifico sovrascrive quello più generale.

Quasi tutto ciò che è personale si configura a livello globale, e le eccezioni a livello locale. Per esempio, l'e-mail di lavoro per i progetti dell'azienda si imposta dentro il singolo repository, senza il flag --global.

Comandi utili di git config

git config user.email                    # mostra il valore attuale
git config --list --show-origin          # tutte le impostazioni e il file di provenienza
git config --global --edit               # apre ~/.gitconfig nell'editor
git config --global --unset core.editor  # elimina un parametro

Il flag --show-origin è il miglior aiuto per il debug: mostra perché avete un'e-mail «sbagliata», indicando il file da cui arriva il valore.

Nome ed e-mail: perché non è una formalità

Ogni commit conserva per sempre nome ed e-mail dell'autore. Non sono login né password, e Git non li verifica. Però GitHub e GitLab collegano i commit al vostro account tramite l'e-mail: se l'indirizzo non corrisponde a nessuna e-mail confermata del profilo, i commit non compaiono nel grafico delle attività e vengono mostrati senza avatar.

Modificare nome o e-mail a posteriori senza riscrivere la cronologia non è possibile, quindi controllate le impostazioni prima del primo commit.

Nascondere la propria e-mail reale

Se il repository è pubblico, la vostra e-mail è visibile a chiunque legga la cronologia. GitHub propone un indirizzo di servizio nella forma ID+username@users.noreply.github.com (nelle impostazioni, sezione Emails). Inseritelo in Git:

git config --global user.email "12345678+anna@users.noreply.github.com"

E-mail diverse per il lavoro e per i progetti personali

Per non configurare a mano ogni repository di lavoro, usate l'inclusione condizionale delle configurazioni. In ~/.gitconfig:

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

E in ~/.gitconfig-work:

[user]
    email = anna@company.com

Ora tutti i repository dentro ~/work/ usano automaticamente l'e-mail di lavoro. La barra finale nel percorso è obbligatoria.

Altre impostazioni utili di Git

Editor

Git apre un editor per i messaggi di commit, per il rebase interattivo e per le fusioni. Di default spesso è Vim. Alternative:

git config --global core.editor "code --wait"   # VS Code
git config --global core.editor "nano"          # Nano
git config --global core.editor "subl -n -w"    # Sublime Text

Ramo predefinito

init.defaultBranch main imposta il nome del primo ramo nei nuovi repository (disponibile da Git 2.28). Senza questa impostazione Git crea master e suggerisce di cambiarne il nome.

Fine riga

git config --global core.autocrlf true    # Windows
git config --global core.autocrlf input   # macOS e Linux

In questo modo nel repository si conservano sempre i fine riga LF, e nel team non compaiono «modifiche» su tutte le righe di un file.

Comportamento di git pull

Se non si imposta una strategia, il Git moderno chiede di sceglierla esplicitamente quando i rami divergono. Scegliete una delle opzioni:

git config --global pull.rebase false   # fusione (merge), comportamento predefinito
git config --global pull.rebase true    # rebase, cronologia lineare
git config --global pull.ff only        # solo fast-forward, altrimenti errore

Nomi di file con caratteri cirillici e colori

git config --global core.quotepath false
git config --global color.ui auto

Alias

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --oneline --graph --decorate --all"
git config --global alias.last "log -1 HEAD"

Ora git lg mostra il grafo dei rami e git last l'ultimo commit.

Com'è fatto ~/.gitconfig dopo la configurazione

[user]
    name = Anna Smirnova
    email = anna@example.com
[init]
    defaultBranch = main
[core]
    editor = code --wait
    autocrlf = input
    quotepath = false
[pull]
    rebase = false
[alias]
    st = status
    lg = log --oneline --graph --decorate --all

È un normale file di testo: si può modificare a mano e trasferire da un computer all'altro.

Git login: come accedere a GitHub

Git non ha un comando git login — è una trappola comune per i principianti. Git non conserva un «account»: l'autenticazione avviene quando si contatta il server (clone, push, fetch), con uno dei due protocolli.

Accesso tramite HTTPS

In Git for Windows e nelle build per macOS con Git Credential Manager, al primo git push si apre una finestra del browser per accedere a GitHub, e le credenziali vengono salvate nel sistema. Un'alternativa è lo strumento ufficiale GitHub CLI: il comando gh auth login guida l'autorizzazione e configura Git. Se preferite fare tutto a mano, create un Personal access token nelle impostazioni di GitHub (Developer settings) e inseritelo al posto della password.

SSH per Git: configurazione passo passo

La chiave SSH è una coppia di file: la chiave privata resta a voi, quella pubblica la consegnate a GitHub. Il server verifica che possediate la parte privata, e non viene mai più chiesta una password.

Passo 1. Verificate se avete già una chiave

ls -la ~/.ssh

Se ci sono già id_ed25519 e id_ed25519.pub, passate al passo 3.

Passo 2. Create la chiave

ssh-keygen -t ed25519 -C "anna@example.com"

Premete Invio per salvare la chiave nel percorso predefinito, e impostate una passphrase: proteggerà la chiave se il portatile venisse rubato. Ed25519 è l'algoritmo moderno consigliato. Se un vecchio sistema non lo supporta, usate ssh-keygen -t rsa -b 4096 -C "anna@example.com".

Passo 3. Aggiungete la chiave all'ssh-agent

L'agente mantiene la chiave decifrata in memoria, così non dovete inserire la passphrase a ogni push.

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Su macOS aggiungete in ~/.ssh/config le righe seguenti, in modo che la passphrase venga conservata nel Portachiavi:

Host github.com
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/id_ed25519

e poi eseguite ssh-add --apple-use-keychain ~/.ssh/id_ed25519.

Passo 4. Aggiungete la chiave pubblica su GitHub

cat ~/.ssh/id_ed25519.pub

Copiate l'intera riga, a partire da ssh-ed25519. Su GitHub aprite Settings → SSH and GPG keys → New SSH key, incollate la chiave e assegnatele un nome riconoscibile, per esempio «Portatile 2026». Non inviate né pubblicate mai il file senza .pub: è la chiave privata.

Passo 5. Verificate la connessione

$ ssh -T git@github.com
Hi anna! You've successfully authenticated, but GitHub does not provide shell access.

Alla prima connessione SSH chiede se fidarvi dell'host: confrontate l'impronta con quella pubblicata nella documentazione di GitHub e rispondete yes.

Passo 6. Passate il repository a SSH

Se il repository è stato clonato tramite HTTPS, cambiate l'indirizzo del remote:

git remote -v
git remote set-url origin git@github.com:anna/my-project.git
git push

Più account GitHub sullo stesso computer

Una chiave SSH si può associare a un solo account GitHub. Per l'account di lavoro e quello personale create due chiavi e degli alias di host in ~/.ssh/config:

Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_work
    IdentitiesOnly yes

Clonate i repository di lavoro tramite l'alias: git clone git@github-work:company/app.git. Insieme a includeIf per l'e-mail, si ottengono ambienti di lavoro e personale completamente separati.

Errori frequenti durante la configurazione

«Please tell me who you are»

Non sono impostati user.name e user.email. Eseguite i comandi dell'inizio dell'articolo e ripetete il commit.

«Permission denied (publickey)»

GitHub non trova una chiave adatta. Verificate che la chiave sia caricata nell'agente (ssh-add -l) e che la parte pubblica sia stata aggiunta all'account; i dettagli li mostra ssh -vT git@github.com.

«Support for password authentication was removed»

Avete inserito la password dell'account lavorando via HTTPS. Usate un token, l'accesso tramite Credential Manager oppure passate a SSH.

Commit su GitHub senza avatar

L'e-mail in git config user.email non è aggiunta al profilo GitHub. Aggiungetela in Settings → Emails: i commit vecchi si collegheranno automaticamente.

La porta 22 è bloccata nella rete

GitHub accetta SSH anche sulla porta 443. In ~/.ssh/config indicate Host github.com, Hostname ssh.github.com, Port 443.

Ordine di configurazione su un nuovo computer

1. Installate Git e verificate con git --version.
2. Impostate user.name, user.email, init.defaultBranch e l'editor.
3. Trasferite o create ~/.gitconfig con gli alias e la strategia di pull.
4. Create una nuova chiave SSH (non copiate la chiave privata da una macchina all'altra senza necessità) e aggiungetela su GitHub.
5. Verificate l'accesso con ssh -T git@github.com e clonate il repository di lavoro tramite l'indirizzo SSH.

Una chiave separata per ogni dispositivo ha anche il vantaggio che, in caso di furto del portatile, basta eliminare una sola chiave su GitHub senza toccare l'accesso dagli altri computer.

Riepilogo

La configurazione di Git si riduce a tre passi: impostare nome ed e-mail con git config --global, scegliere editor, ramo predefinito e strategia di pull, poi collegare l'accesso a GitHub — nel modo più semplice e affidabile tramite chiave SSH. Ricordate che il comando git login non esiste: l'autenticazione avviene quando si contatta il server. La configurazione e l'accesso SSH li analizziamo in pratica nel corso di Git.