git remote

Cosa fa git remote

Un remote è un riferimento con nome a un'altra copia del tuo repository — tipicamente una ospitata su un server come GitHub, GitLab o Bitbucket. Il comando git remote crea, elenca, rinomina e rimuove queste connessioni. Non trasferisce alcun commit di per sé; invece, memorizza nomi brevi e facili da ricordare che puntano agli URL dei repository, in modo che i comandi che spostano effettivamente i dati — git fetch, git pull e git push — possano fare riferimento ad essi.

Pensa a un remote come a un segnalibro. Invece di digitare git push https://github.com/acme/app.git main ogni volta, salvi l'URL una volta con il nome origin ed esegui git push origin main. La mappatura dei nomi agli URL risiede nel file .git/config del tuo repository, quindi ogni clone mantiene il proprio elenco di remote.

Il diagramma seguente mostra due connessioni remote da un repository locale: una verso un repository centrale e una verso il repository di un altro sviluppatore. Poiché i nomi sono condivisi per convenzione, puoi dire a un collega di "fare pull da upstream" e lui saprà esattamente quale comando eseguire.

Il remote origin

L'esecuzione di git clone crea automaticamente un remote chiamato origin che punta al repository da cui hai clonato. Per convenzione, origin è la tua copia canonica sul server — quella verso cui fai push e da cui fai pull ogni giorno. Il nome non ha nulla di speciale; è semplicemente il valore predefinito scelto da Git, e puoi rinominarlo o rimuoverlo come qualsiasi altro remote.

Un secondo remote comune è upstream. Quando esegui il fork di un progetto, origin punta al tuo fork e upstream punta al repository originale, così puoi recuperare le nuove modifiche dal progetto mentre carichi il tuo lavoro nel tuo fork.

URL dei repository

Un URL remoto indica a Git dove si trova il repository e quale protocollo di trasporto usare. I due che vedrai più spesso sono HTTPS e SSH.

HTTPS è il più semplice da configurare e funziona attraverso firewall e proxy. I repository pubblici possono essere clonati tramite HTTPS senza credenziali; per i repository privati o per il push, Git chiede un nome utente e un token di accesso personale, di solito memorizzato nella cache da un credential helper.

https://host/path/to/repo.git

SSH si autentica con una coppia di chiavi invece di una password, il che lo rende comodo per push ripetuti una volta che la tua chiave è registrata con l'host. Si presenta in due forme equivalenti — l'URL ssh:// completo e la sintassi più breve simile a SCP:

ssh://user@host/path/to/repo.git

user@host:path/to/repo.git

Non è necessario memorizzare il formato di un URL; lo copi dal pulsante "Clone" del provider di hosting. Il comando git remote memorizza quindi qualunque forma tu abbia usato.

Sottocomandi di git remote

git remote espone diversi sottocomandi. Ognuno modifica la sezione remote di .git/config; potresti apportare le stesse modifiche manualmente in un editor di testo, ma i sottocomandi sono più sicuri e aggiornano automaticamente le impostazioni correlate.

git remote add

Registra un nuovo remote chiamato <name> che punta a <url>.

git remote add <name> <url>

Due opzioni utili:

• -f esegue git fetch <name> immediatamente dopo la creazione del remote, in modo che i suoi branch vengano scaricati subito.
• --tags esegue il fetch del remote e importa anche tutti i suoi tag.

git remote rename

Rinomina un remote da <old> a <new>, aggiornando i branch di tracciamento remoto e qualsiasi configurazione correlata.

git remote rename <old> <new>

git remote remove

Elimina la connessione denominata <name> insieme ai suoi branch di tracciamento remoto e alla configurazione. git remote rm è un alias più vecchio per lo stesso comando.

git remote remove <name>

git remote set-url

Modifica l'URL a cui punta un remote esistente — ad esempio, quando passi un repository da HTTPS a SSH.

git remote set-url <name> <new-url>

git remote get-url

Stampa gli URL di un remote. Aggiungi --push per vedere specificamente l'URL di push, o --all per elencare tutti gli URL configurati.

git remote get-url <name>

git remote show

Stampa informazioni dettagliate su un remote: i suoi URL di fetch e push, i suoi branch e come i tuoi branch locali lo tracciano.

git remote show <name>

git remote prune

Rimuove i branch di tracciamento remoto locali per <name> i cui corrispondenti sono stati eliminati sul server. Usa --dry-run per elencare cosa verrebbe rimosso senza eliminare effettivamente nulla.

git remote prune <name>

Elencare i tuoi remote

L'esecuzione di git remote senza argomenti stampa il nome di ogni remote configurato, uno per riga:

git remote
origin
upstream
other_repo

Aggiungi il flag -v (verbose) per visualizzare anche gli URL di fetch e push di ogni remote:

git remote -v
origin      [email protected]:origin_user/reponame.git (fetch)
origin      [email protected]:origin_user/reponame.git (push)
upstream    https://example.com/upstream_user/reponame.git (fetch)
upstream    https://example.com/upstream_user/reponame.git (push)
other_repo  https://example.com/other_repo/reponame.git (fetch)
other_repo  https://example.com/other_repo/reponame.git (push)

Un remote può avere URL di fetch e push diversi — utile, ad esempio, quando esegui il pull da un mirror veloce ma il push verso il server canonico.

Aggiungere un remote

Per iniziare a collaborare con un altro repository, registralo con git remote add. Il nome che scegli diventa una scorciatoia che puoi usare in fetch, pull e push:

git remote add upstream https://example.com/upstream_user/reponame.git

Connettersi ai repository di altri sviluppatori consente la collaborazione al di fuori del repository centrale. Ad esempio, se un collega gestisce un repository accessibile pubblicamente su dev.example.com/tom.git, aggiungilo così e poi recupera il suo lavoro:

git remote add tom https://dev.example.com/tom.git
git fetch tom

Esaminare un remote

Il sottocomando show contatta il remote e riporta i suoi branch e la configurazione di tracciamento — utile quando vuoi confermare quale branch verrà aggiornato da un push o pull:

git remote show upstream
* remote upstream
  Fetch URL: https://example.com/upstream_user/reponame.git
  Push  URL: https://example.com/upstream_user/reponame.git
  HEAD branch: main
  Remote branches:
    main      tracked
    docs      tracked
    new-input tracked
  Local ref configured for 'git push':
    main pushes to main (fast-forwardable)

Fetch, pull e push

Configurare un remote è solo il passaggio iniziale. Una volta che esiste, passi il suo nome ai comandi che spostano effettivamente i commit:

• git fetch <remote> scarica i nuovi commit dal remote nei tuoi branch di tracciamento remoto senza modificare i tuoi file di lavoro.
• git pull <remote> <branch> esegue il fetch e poi unisce (o effettua il rebase) le modifiche nel tuo branch corrente.
• git push <remote> <branch> carica i tuoi commit locali sul remote.

git push <remote-name> <branch-name>

Ad esempio, per pubblicare il branch main su origin:

git push origin main

Se vuoi approfondire dove vengono memorizzati questi nomi e URL, consulta il capitolo git config, che documenta il file .git/config modificato da git remote.

Esercitati