Git lfs

Git è diventato il sistema di controllo della versione di fatto per gli sviluppatori di software in tutto il mondo. Questo sistema di controllo della versione distribuito open source è più veloce dei suoi concorrenti. È facile da usare per il codice di ramificazione e fusione. Tuttavia, ha un problema di prestazioni con file binari di grandi dimensioni. GIT Great File Storage (LFS) è stato sviluppato per affrontare questo problema.

Il problema di grandi file in GIT

Tradizionalmente, alcune aziende e istituzioni sono rimaste lontane da Git a causa dell'inefficienza nella gestione dei file binari di grandi dimensioni. Gli sviluppatori di videogiochi e le società di media devono affrontare trame complesse, video a movimento completo e file audio di alta qualità. Gli istituti di ricerca devono tenere traccia di grandi set di dati che possono essere gigabyte o terabytes. Git ha difficoltà a mantenere questi file di grandi dimensioni.

Per capire il problema, dobbiamo dare un'occhiata a come Git tiene traccia dei file. Ogni volta che c'è un commit, Git crea un nodo oggetto con un puntatore al suo genitore o a più genitori. Il modello di dati GIT è noto come grafico aciclico diretto (DAG). Il modello DAG garantisce che la relazione da genitore a figlio non possa mai formare alcun ciclo.

Possiamo ispezionare i meccanismi interni del modello DAG. Ecco un esempio di tre commit in un repository:

$ git log --oneline
2Beb263 commit c: aggiunto immagine1.jpeg
866178E Commit B: Aggiungi B.TXT
d48dd8b commi a: aggiungi a.TXT

In commit a e b, abbiamo aggiunto il file di testo a.txt e b.TXT. Quindi in commit c, abbiamo aggiunto un file di immagine chiamato image1.jpeg. Possiamo visualizzare il DAG come segue:

Commettere c commi b commi a
2Beb263 -> 866178E -> d48dd8b

Se ispezioniamo l'ultimo commit con il seguente comando:

$ git cat -file -p 2beb263
albero 7cc17ba5b041fb227b9ab5534d81bd836183a4e3
Genitore 866178E37DF64D9F19FA77C00D5BA9D3D4FC68F5
Autore Zak H 1513259427 -0800
Committer Zak H 1513259427 -0800
Commit c: aggiunto immagine1.jpeg

Possiamo vedere che il commit c (2beb263) ha commesso b (866178e) come genitore. Ora, se ispezioniamo l'oggetto albero di commit c (7cc17ba), possiamo vedere le macchie (oggetti binari di grandi dimensioni):

$ git cat -file -p 7cc17ba
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 A.TXT
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 B.TXT
100644 BLOB A44A66F9E06A8FAF324D3FF3E11C9FA6966BFB56 Image1.jpeg

Possiamo controllare le dimensioni del blob dell'immagine:

$ git cat -file -s A44a66f9e
871680

Git sta tenendo traccia dei cambiamenti in questa struttura dell'albero. Facciamo una modifica all'immagine1.jpeg e controlla la storia:

$ git log --oneline
2e257db commit d: immagine modificata1.jpeg
2Beb263 commit c: aggiunto immagine1.jpeg
866178E Commit B: Aggiungi B.TXT
d48dd8b commi a: aggiungi a.TXT

Se controlliamo l'oggetto commit d (2e257db):

$ git cat -file -p 2e257db
albero 2405Fad67610acf0f57b87af36f535c1f4f9ed0d
Genitore 2BEB263523725E1E8F9D96083140A4A5CD30B651
Autore Zak H 1513272250 -0800
Committer Zak H 1513272250 -0800
Commit d: immagine modificata1.jpeg

E l'albero (2405FAD) al suo interno:

$ git cat -file -p 2405Fad
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 A.TXT
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 B.TXT
100644 BLOB CB4A0B67280A92412A81C60DF36A15150E713095 Image1.jpeg

Si noti che l'hash SHA-1 per Image1.JPEG è cambiato. Significa che ha creato un nuovo blob per Image1.jpeg. Possiamo controllare le dimensioni del nuovo blob:

$ git cat -file -s cb4a0b6
1063696

Ecco un modo per visualizzare la struttura DAG sopra:

Commit d commit c commi b impegno a
| | | |
2e257db -> 2Beb263 -> 866178E -> d48dd8b
| | | |
Albero4 albero3 albero2 albero1
| | | |
BLOBS BLOBS BLOBS BLOBS
[/cce_c]
Ogni oggetto commit mantiene il proprio albero. Le chiazze sono mantenute all'interno di quell'albero. GIT ottimizza lo spazio assicurandoti che memorizza solo le differenze e utilizza la compressione per la conservazione. Ma per le modifiche ai file binari, Git deve archiviare file interi nelle chiazze perché è difficile determinare le differenze. Inoltre, i file di immagini, video e audio sono già compressi. Di conseguenza, per ogni istanza di un file binario modificato, l'albero finisce con una BLOB di grandi dimensioni.
Pensiamo a un esempio in cui apporiamo più modifiche a un file di immagine da 100 MB.
[cc width = "100%" altezza = "100%" sfuggito = "true" tema = "blackboard" nowRap = "0"]
Commit c -> commit b -> commetti a
| | |
Tree3 Tree2 Tree1
| | |
BLOB3 BLOB2 BLOB1
300 MB 200 MB 100 MB
[/cce_c]
Ogni volta che cambiamo il file, Git deve creare un BLOB da 100 MB. Quindi solo dopo 3 impegni, il repository Git è di 300 MB. Puoi vedere che le dimensioni del repository Git possono rapidamente esplodere. Poiché Git è un controllo della versione distribuita, scaricherai l'intero repository sull'istanza locale e lavorerai molto con le filiali. Quindi le grandi chiazze diventano un collo di bottiglia per le prestazioni.
Il GIT LFS risolve il problema sostituendo i BLOB con file di puntar leggeri (PF) e creando un meccanismo per archiviare le macchie altrove.
[cc width = "100%" altezza = "100%" sfuggito = "true" tema = "blackboard" nowRap = "0"]
Commit c -> commit b -> commetti a
| | |
Tree3 Tree2 Tree1
| | |
PF3 PF2 PF1
[/cce_c]
GIT localmente memorizza le macchie nella cache Git LFS e le memorizzerà nel negozio Git LFS su GitHub o Bitbucket.
[cc width = "100%" altezza = "100%" sfuggito = "true" tema = "blackboard" nowRap = "0"]
Pf1 -> blob1
Pf2 -> blob2
Pf3 -> blob3
[/cce_bash]
Ora, quando hai a che fare con il repository Git, i file PF leggeri verranno utilizzati per le operazioni di routine. Le chiazze verranno recuperate solo quando necessario. Ad esempio, se il checkout commette C, Git LFS cercherà il puntatore PF3 e scaricherà BLOB3. Quindi il repository di lavoro sarà più snello e le prestazioni saranno migliori. Non devi preoccuparti dei file di punta. Git LFS li gestirà dietro le quinte.

Installazione e in esecuzione Git LFS

Ci sono stati i precedenti tentativi di risolvere il problema dei file di grandi dimensioni git. Ma Git LFS è riuscito perché è facile da usare. Devi solo installare LFS e dirlo quali file tracciare.
È possibile installare Git LFS utilizzando i seguenti comandi:
[cc width = "100%" altezza = "100%" sfuggito = "true" tema = "blackboard" nowRap = "0"]
$ sudo apt-get Installa software-Properties-Common
$ CURL -S https: // packagecloud.IO/INSTAL/REPOSITIES/GITHUB/GIT-LFS/Script.Deb.Sh | sudo bash
$ sudo apt-get installa git-lfs
$ git lfs Installa

Una volta installato Git LFS, puoi tracciare i file desiderati:

$ git lfs track "*.jpeg "
Tracciamento "*.jpeg "

L'output mostra che Git LFS sta monitorando i file JPEG. Quando inizi a monitorare con LFS, troverai un .file gitattributes che avrà una voce che mostra i file tracciati. IL .Il file gitattributes usa la stessa notazione di .file gitignore. Ecco come il contenuto di .Gitattributes sembra:

$ cat .gitattributes
*.JPEG Filter = LFS Diff = LFS Merge = LFS -Text

Puoi anche trovare quali file vengono tracciati utilizzando il seguente comando:

Traccia $ git lfs
Elenco motivi tracciati
*.jpeg (.gitattributes)

Se si desidera interrompere il tracciamento di un file, è possibile utilizzare il seguente comando:

$ git lfs Untrack "*.jpeg "
Non trattenimento "*.jpeg "

Per le operazioni Generali Git, non devi preoccuparti di LFS. Si occuperà automaticamente di tutte le attività di back -end. Una volta impostato Git LFS, puoi lavorare sul repository come qualsiasi altro progetto.

---

Ulteriori studi

Per argomenti più avanzati, esaminare le seguenti risorse:

• Spostamento del repository Git LFS tra gli host
• Eliminazione di file LFS GIT locali
• Rimozione dei file Git LFS remoti dal server
• Sito Web Git LFS
• Documentazione Git LFS

Riferimenti:

• git-lfs.github.com: Github Repo
• github.com/git-lfs/git-lfs/albero/master/docs: documentazione github per git lfs
• Atlassian.com/git/tutorials/git-lfs: tutorial atlassian
• Youtube.com: cos'è git lfs
• Youtube.com: Tracciamento di file enormi con Git LFS di Tim Pettersen, Atlassian
• Youtube.com: Gestire file enormi sulla giusta archiviazione con Git LFS, YouTube
• Youtube.com: git grande archivio file - come lavorare con file grandi, youtube
• github.com/git-lfs/git-lfs/blob/master/installazione.MD: Guida all'installazione