Phenquestions
Le problème des gros fichiers dans Git
Traditionnellement, certaines entreprises et institutions sont restées à l'écart de Git en raison de l'inefficacité de la gestion des gros fichiers binaires. Les développeurs de jeux vidéo et les sociétés de médias doivent gérer des textures complexes, des vidéos animées et des fichiers audio de haute qualité. Les instituts de recherche doivent garder une trace de grands ensembles de données pouvant atteindre des gigaoctets ou des téraoctets. Git a des difficultés à maintenir ces gros fichiers.
Pour comprendre le problème, nous devons examiner comment Git garde une trace des fichiers. Chaque fois qu'il y a un commit, Git crée un nœud d'objet avec un pointeur vers son parent ou plusieurs parents. Le modèle de données Git est connu sous le nom de graphe acyclique dirigé (DAG). Le modèle DAG garantit que la relation parent-enfant ne peut jamais former de cycles.
Nous pouvons inspecter le fonctionnement interne du modèle DAG. Voici un exemple de trois commits dans un dépôt :
$ git log --oneline2beb263 Commit C : ajout de l'image1.jpeg
866178e Commit B : ajouter b.SMS
d48dd8b Commit A : ajouter un.SMS
Dans Commit A et B, nous avons ajouté le fichier texte a.txt et b.SMS. Ensuite, dans Commit C, nous avons ajouté un fichier image appelé image1.jpeg. Nous pouvons visualiser le DAG comme suit :
Commit C Commit B Commit A2beb263 --> 866178e --> d48dd8b
Si nous inspectons le dernier commit avec la commande suivante :
$ git fichier-cat -p 2beb263arbre 7cc17ba5b041fb227b9ab5534d81bd836183a4e3
parent 866178e37df64d9f19fa77c00d5ba9d3d4fc68f5
auteur Zak H
le commis Zak H
Commit C : ajout de l'image1.jpeg
Nous pouvons voir que Commit C (2beb263) a Commit B (866178e) comme parent. Maintenant, si nous inspectons l'objet arbre de Commit C (7cc17ba), nous pouvons voir les blobs (grands objets binaires):
$ git fichier-cat -p 7cc17ba100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 un.SMS
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 b.SMS
100644 goutte a44a66f9e06a8faf324d3ff3e11c9fa6966bfb56 image1.jpeg
Nous pouvons vérifier la taille du blob de l'image :
$ git fichier-cat -s a44a66f9e871680
Git garde une trace des changements dans cette structure arborescente. Apportons une modification à l'image1.jpeg et vérifiez l'historique :
$ git log --oneline2e257db Commit D : image modifiée1.jpeg
2beb263 Commit C : ajout de l'image1.jpeg
866178e Commit B : ajouter b.SMS
d48dd8b Commit A : ajouter un.SMS
Si nous vérifions l'objet Commit D (2e257db):
$ git fichier-cat -p 2e257dbarbre 2405fad67610acf0f57b87af36f535c1f4f9ed0d
parent 2beb263523725e1e8f9d96083140a4a5cd30b651
auteur Zak H
le commis Zak H
Commit D : image modifiée1.jpeg
Et l'arbre (2405fad) à l'intérieur :
$ git fichier-cat -p 2405fad100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 un.SMS
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 b.SMS
100644 blob cb4a0b67280a92412a81c60df36a15150e713095 image1.jpeg
Notez que le hachage SHA-1 pour image1.jpeg a changé. Cela signifie qu'il a créé un nouveau blob pour image1.jpeg. Nous pouvons vérifier la taille du nouveau blob :
$ git fichier-cat -s cb4a0b61063696
Voici un moyen de visualiser la structure DAG ci-dessus :
Engagement D Engagement C Engagement B Engagement A| | | |
2e257db --> 2beb263 --> 866178e --> d48dd8b
| | | |
Arbre4 Arbre3 Arbre2 Arbre1
| | | |
Blobs Blobs Blobs Blobs
Chaque objet commit maintient sa propre arborescence. Les blobs sont maintenus à l'intérieur de cet arbre. Git optimise l'espace en s'assurant qu'il ne stocke que les différences et utilise la compression pour le stockage. Mais pour les modifications de fichiers binaires, Git doit stocker des fichiers entiers dans les blobs car il est difficile de déterminer les différences. De plus, les fichiers image, vidéo et audio sont déjà compressés. En conséquence, pour chaque instance d'un fichier binaire modifié, l'arbre se termine par un gros blob.
Pensons à un exemple où nous apportons plusieurs modifications à un fichier image de 100 Mo.
Commit C --> Commit B --> Commit A| | |
Arbre3 Arbre2 Arbre1
| | |
Blob3 Blob2 Blob1
300 Mo 200 Mo 100 Mo
Chaque fois que nous modifions le fichier, Git doit créer un blob de 100 Mo. Donc seulement après 3 commits, le dépôt Git est de 300 Mo. Vous pouvez voir que la taille du dépôt Git peut rapidement exploser. Comme Git est un contrôle de version distribué, vous allez télécharger l'intégralité du référentiel sur votre instance locale et travailler beaucoup avec les branches. Ainsi, les gros blobs deviennent un goulot d'étranglement des performances.
Le Git LFS résout le problème en remplaçant les blobs par des fichiers de pointeurs légers (PF) et en créant un mécanisme pour stocker les blobs ailleurs.
Commit C --> Commit B --> Commit A| | |
Arbre3 Arbre2 Arbre1
| | |
PF3 PF2 PF1
Localement, Git stocke les blobs dans le cache Git LFS, et à distance, il les stockera dans le magasin Git LFS sur GitHub ou BitBucket.
PF1 --> Blob1PF2 --> Blob2
PF3 --> Blob3
Maintenant, lorsque vous traitez avec le référentiel Git, les fichiers PF légers seront utilisés pour les opérations de routine. Les blobs ne seront récupérés que si nécessaire. Par exemple, si vous extrayez Commit C, Git LFS recherchera le pointeur PF3 et téléchargera Blob3. Ainsi, le référentiel de travail sera plus léger et les performances seront meilleures. Vous n'avez pas à vous soucier des fichiers de pointeur. Git LFS va les gérer en coulisses.
Installer et exécuter Git LFS
Il y a eu une tentative précédente pour résoudre le problème de gros fichier Git. Mais Git LFS a réussi parce qu'il est facile à utiliser. Vous n'avez qu'à installer LFS et lui dire quels fichiers suivre.
Vous pouvez installer Git LFS à l'aide des commandes suivantes :
$ sudo apt-get install software-properties-common$ curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
$ sudo apt-get install git-lfs
$ git lfs installer
Une fois que vous avez installé Git LFS, vous pouvez suivre les fichiers que vous souhaitez :
$ git lfs piste "*.jpeg"Suivi "*.jpeg"
La sortie vous montre que Git LFS suit les fichiers JPEG. Lorsque vous commencez le suivi avec LFS, vous trouverez un .gitattributes fichier qui aura une entrée montrant les fichiers suivis. le .le fichier gitattributes utilise la même notation que .fichier gitignore. Voici comment le contenu de .gitattributes ressemble à :
$ chat .gitattributes*.jpeg filter=lfs diff=lfs merge=lfs -text
Vous pouvez également trouver quels fichiers sont suivis à l'aide de la commande suivante :
$ git lfs pisteListe des modèles suivis
*.jpeg (.gitattributes)
Si vous souhaitez arrêter le suivi d'un fichier, vous pouvez utiliser la commande suivante :
$ git lfs untrack "*.jpeg"Untracking "*.jpeg"
Pour les opérations Git générales, vous n'avez pas à vous soucier de LFS. Il s'occupera automatiquement de toutes les tâches du backend. Une fois que vous avez configuré Git LFS, vous pouvez travailler sur le référentiel comme n'importe quel autre projet.
Une étude plus approfondie
Pour des sujets plus avancés, consultez les ressources suivantes :
- Déplacer le référentiel Git LFS entre les hôtes
- Suppression des fichiers Git LFS locaux
- Suppression des fichiers Git LFS distants du serveur
- Site Web Git LFS
- Documentation Git LFS
Les références:
- git-lfs.github.com : dépôt GitHub
- github.com/git-lfs/git-lfs/tree/master/docs : Documentation GitHub pour Git LFS
- atlassien.com/git/tutorials/git-lfs : Tutoriels Atlassian
- Youtube.com : Qu'est-ce que Git LFS ?
- Youtube.com : Suivi d'énormes fichiers avec Git LFS par Tim Pettersen, Atlassian
- Youtube.com : Gérer des fichiers volumineux sur le bon stockage avec Git LFS, YouTube
- Youtube.com : Git Large File Storage - Comment travailler avec de gros fichiers, YouTube
- Askubuntu.com/questions/799341: comment-installer-git-lfs-on-ubuntu-16-04
- github.com/git-lfs/git-lfs/blob/master/INSTALLATION.md : Guide d'installation
