Phenquestions
Capire Git Shallow Clone e Clone Depth
Git è un sistema di controllo di versione distribuito. Questo è uno dei vantaggi dell'utilizzo di Git. Non devi dipendere da un server o repository centrale per lavorare localmente. Tutto ciò di cui hai bisogno per la cronologia dei tuoi moduli è a portata di mano. Tuttavia, può diventare un problema quando hai a che fare con repository con file binari di grandi dimensioni o repository che hanno una lunga storia. Soprattutto se hai una situazione in cui devi scaricarlo fresco ogni volta, come un server di compilazione, le dimensioni e i tempi di download possono diventare un problema.
La soluzione di Git al problema è il clone superficiale in cui puoi usare la profondità del clone per definire quanto in profondità dovrebbe andare il tuo clone. Ad esempio, se usi -depth 1, durante la clonazione, Git otterrà solo l'ultima copia dei file rilevanti. Può farti risparmiare molto spazio e tempo.
Git Shallow Clone and Size
Diamo un'occhiata al popolare repository Git per Django. Se cloni completamente il repository, ottieni quanto segue:
$ git clone https://github.com/django/django.idiotaClonazione in 'django'..
remoto: Conteggio oggetti: 409053, fatto.
remoto: Compressione di oggetti: 100% (26/26), fatto.
remoto: Totale 409053 (delta 6), riutilizzato 8 (delta 1), confezione riutilizzata 409026
Ricezione di oggetti: 100% (409053/409053), 167.77 MiB | 5.95 MiB/s, fatto.
Risoluzione dei delta: 100% (297045/297045), fatto.
Controllo della connettività... fatto.
Estrazione dei file: 100% (5860/5860), fatto.
Ora se controlli la dimensione della tua copia locale, è:
$ du -sh django/225M django/
Prendiamo lo stesso repository Django con un clone superficiale:
$ git clone --depth 1 https://github.com/django/django.idiotaClonazione in 'django'..
remoto: Conteggio oggetti: 8091, fatto.
remoto: Compressione di oggetti: 100% (4995/4995), fatto.
remoto: Total 8091 (delta 2036), riutilizzato 5507 (delta 1833), pacco riutilizzato 0
Ricezione di oggetti: 100% (8091/8091), 8.82 MiB | 3.29 MiB/s, fatto.
Risoluzione dei delta: 100% (2036/2036), fatto.
Controllo della connettività... fatto.
Estrazione dei file: 100% (5860/5860), fatto.
Ora se controlli la dimensione della tua copia locale, dovrebbe essere significativamente inferiore:
$ du -sh django/55M django/
Quando il tuo server ha a che fare con centinaia di linee di prodotti, questo tipo di risparmio di spazio su disco può essere utile. Nei casi di progetti di gioco in cui ci sono binari pesanti, questo può avere un effetto drammatico. Aiuta anche con progetti a lungo termine. Ad esempio, la clonazione completa del repository Linux da GitHub è superiore a 7 GB, ma è possibile clonarla in modo superficiale per meno di 1 GB.
Git Shallow Clone e cronologia
Puoi controllare localmente la clonazione superficiale con il tuo repository. Creiamo un file nel nostro repository locale, apportiamo modifiche e eseguiamo il commit 10 volte. E poi possiamo clonare il repository:
$ mkdir _esempio$ cd _esempio
$ ls
$ git init
Repository Git vuoto inizializzato in /Users/zakh/git_repo/_example/.idiota/
$ echo x > large_file
$ git add -A
$ git commit -m "Commit iniziale"
[master (root-commit) dd11686] commit iniziale
1 file modificato, 1 inserimento(+)
crea modalità 100644 large_file
$ echo xx > file_grande
$ git add -A
$ git commit -m "Modifica a large_file 1"
[master 9efa367] Modifica a large_file 1
1 file modificato, 1 inserimento(+), 1 cancellazione(-)
…
…
$ mkdir test
$ cd test
$ git clone file:////Users/zakh/git_repo/_example
Clonazione in '_esempio'..
remoto: Conteggio oggetti: 33, fatto.
remoto: Compressione di oggetti: 100% (22/22), fatto.
remoto: Totale 33 (delta 10), riutilizzato 0 (delta 0)
Ricezione di oggetti: 100% (33/33), 50.03 MiB | 42.10 MiB/s, fatto.
Risoluzione dei delta: 100% (10/10), fatto.
Controllo della connettività... fatto.
In questo esempio, abbiamo creato il repository _example git nella cartella /Users/zakh/git_repo/ con un singolo large_file. Vengono mostrati solo i primi due commit. Quindi stiamo creando un clone completo di quel repository in una posizione diversa.
Quindi controlliamo la cronologia dei nostri commit:
$ git log --oneline7fa451f Modifica a large_file 10
648d8c9 Modifica a large_file 9
772547a Modifica a large_file 8
13dd9ab Modifica a large_file 7
5e73b67 Modifica a large_file 6
030a6e7 Modifica a large_file 5
1d14922 Modifica a large_file 4
bc0f2c2 Modifica a large_file 3
2794f11 Modifica a large_file 2
d4374fb Modifica a large_file 1
924829d Commessa iniziale
Vediamo tutti i commit nel clone completo.
Ora eliminiamo la copia corrente e quindi clone superficiale con una profondità di 1:
Clonazione in '_esempio'..
remoto: Conteggio oggetti: 3, fatto.
remoto: Compressione di oggetti: 100% (2/2), fatto.
remoto: Totale 3 (delta 0), riutilizzato 0 (delta 0)
Ricezione di oggetti: 100% (3/3), 50.02 MiB | 65.12 MiB/s, fatto.
Controllo della connettività... fatto.
Se guardiamo ora la cronologia, vediamo solo l'ultima cronologia di commit:
$ git log --oneline7fa451f Modifica a large_file 10
Cloniamo poco profondo con una profondità di 3:
$ git clone --depth 3 file:////Users/zakh/git_repo/_exampleClonazione in '_esempio'..
remoto: Conteggio oggetti: 9, fatto.
remoto: Compressione oggetti: 100% (6/6), fatto.
remoto: Totale 9 (delta 2), riutilizzato 0 (delta 0)
Ricezione di oggetti: 100% (9/9), 50.02 MiB | 65.15 MiB/s, fatto.
Risoluzione dei delta: 100% (2/2), fatto.
Controllo della connettività... fatto.
Ora vediamo più commit:
$ git log --oneline7fa451f Modifica a large_file 10
648d8c9 Modifica a large_file 9
772547a Modifica a large_file 8
Problemi con Git Shallow Clone
Gli utenti dovrebbero capire che le dimensioni e il risparmio di tempo di download dipendono dall'organizzazione dei commit. Possono differire in modo significativo da un repository all'altro. È una buona idea testare il repository con un clone poco profondo per verificare quanto spazio su disco rigido e tempo di download ti farà risparmiare.
Un'altra considerazione è che anche se puoi inviare il codice da un clone superficiale, potrebbe richiedere più tempo a causa dei calcoli tra il server remoto e quello locale. Quindi, se stai eseguendo il commit del codice regolarmente dalla copia locale, probabilmente ha senso usare un clone completo.
Opzione di rami multipli
Quando usi il flag -depth con il comando clone, Git assume il flag -single-branch per impostazione predefinita. Ma puoi usare il flag -no-single-branch per dire a Git di ottenere le cronologie dalla profondità specificata di ogni ramo.
Ecco i rami Django senza l'opzione -no-single-branch (profondità 1):
$ git ramo -a* maestro
telecomandi/origine/HEAD -> origine/master
telecomandi/origine/master
È presente solo il ramo principale.
Ecco i rami Django dopo aver usato l'opzione -no-single-branch:
$ git clone --depth 1 --no-single-branch https://github.com/django/django.idiotaClonazione in 'django'..
remoto: Conteggio oggetti: 95072, fatto.
remoto: Compressione di oggetti: 100% (42524/42524), fatto.
remoto: Totale 95072 (delta 52343), riutilizzato 82284 (delta 42389), pacco riutilizzato 0
Ricezione di oggetti: 100% (95072/95072), 74.69 MiB | 3.95 MiB/s, fatto.
Risoluzione dei delta: 100% (52343/52343), fatto.
Controllo della connettività... fatto.
Estrazione dei file: 100% (5860/5860), fatto.
$ du -sh django
124M django
Notare che anche se la profondità è ancora 1, la dimensione del clone è 124M invece dei 55M del caso precedente.
Se controlliamo i rami, dovremmo vedere molti più rami su questo clone:
$ git ramo -a
* maestro
telecomandi/origine/HEAD -> origine/master
telecomandi/origine/attico/boulder-oracle-sprint
telecomandi/origine/soffitta/storia-completa
telecomandi/origine/attico/generic-auth
telecomandi/origine/soffitta/gis
telecomandi/origine/attico/i18n
telecomandi/origine/soffitta/rimozione-magica
telecomandi/origine/attico/multi-auth
telecomandi/origine/attico/supporto-db-multiplo
telecomandi/origine/soffitta/nuovo-amministratore
telecomandi/origine/attico/newforms-admin
telecomandi/origine/soffitta/permessi-per-oggetto
telecomandi/origine/attico/queryset-refactor
telecomandi/origine/attico/schema-evolution
telecomandi/origine/attico/schema-evolution-ng
telecomandi/origine/attico/search-api
telecomandi/origine/attico/sqlalchemy
telecomandi/origine/attico/unicode
telecomandi/origine/master
remotes/origin/soc2009/admin-ui
remotes/origin/soc2009/http-wsgi-improvements
remotes/origin/soc2009/i18n-improvements
remotes/origine/soc2009/model-validation
remotes/origine/soc2009/multidb
remotes/origine/soc2009/test-improvements
remotes/origine/soc2010/app-loading
remotes/origine/soc2010/query-refactor
remotes/origine/soc2010/test-refactor
telecomandi/origine/stabile/0.90.X
telecomandi/origine/stabile/0.91.X
telecomandi/origine/stabile/0.95.X
telecomandi/origine/stabile/0.96.X
telecomandi/origine/stabile/1.0.X
telecomandi/origine/stabile/1.1.X
telecomandi/origine/stabile/1.10.X
telecomandi/origine/stabile/1.11.X
telecomandi/origine/stabile/1.2.X
telecomandi/origine/stabile/1.3.X
telecomandi/origine/stabile/1.4.X
telecomandi/origine/stabile/1.5.X
telecomandi/origine/stabile/1.6.X
telecomandi/origine/stabile/1.7.X
telecomandi/origine/stabile/1.8.X
telecomandi/origine/stabile/1.9.X
telecomandi/origine/stabile/2.0.X
Sommario
Il clone superficiale di Git può aiutarti a risparmiare tempo e spazio sul disco rigido. Ma ha un prezzo. Se si invia regolarmente codice a repository remoti, aumenterà i tempi di commit. Quindi, per flussi di lavoro regolari, è una buona idea evitare cloni superficiali.
Riferimenti:
- git-clones-vs-shallow-git-clones/
- Comunità.atlante.com => clona-profondità-fa-cosa-perché-mi-importa-di-questa-impostazione/
- git-scm.com/docs/git-clone
- jenkins.io => large-git-repos.PDF
- medio.com/@wdyluis => git-gc-e-git-shallow-clone
- stackoverflow.com => git-clone-di-predefinito-superficiale-o-non
- unix.stackexchange.com => differenza-dimensione-codice-sorgente-linux-kernel
- atlante.com => handle-big-repository-git
- forzatamente.com => git-beyond-basics-usando-cloni-superficiali
