Qu'est-ce que Git LFS et quand en avez-vous besoin ?

Question

Accepted Answer

**Git LFS** (Large File Storage) est une extension pour gérer efficacement les **fichiers binaires volumineux** (vidéos, ensembles de données, ressources de conception, grands binaires) dans Git. Git est conçu pour le texte/code source et gère mal les gros binaires, donc LFS les stocke séparément tout en conservant des références légères dans le référentiel.

## Le problème : Git et les gros binaires

```text
Git stores every version of every file in its history (the full content):
  → LARGE BINARY files (videos, datasets, PSDs, big binaries) bloat the repo ENORMOUSLY:
    - every change stores another full copy (binaries don't diff well)
    - the repo and EVERY clone become huge and slow (clone/fetch download all history)
    - history can't be shrunk easily (the large blobs are permanent)
→ Git is great for source code (text, diffable), POOR for large binaries.
```

## Comment fonctionne Git LFS

```text
Git LFS replaces large files in the repo with small POINTER files (a reference/hash),
and stores the ACTUAL large files on a separate LFS server:
  → the Git repo stays small (just pointers in history)
  → the actual large files are downloaded on demand (only the versions you need)
→ You work normally; LFS transparently swaps pointers ↔ real files.
```

```bash
git lfs install                    # set up LFS
git lfs track "*.psd"             # track a file type with LFS (records in .gitattributes)
git lfs track "*.mp4"
git add .gitattributes
# now large files of these types go to LFS automatically (pointers in Git)
git lfs ls-files                   # list LFS-tracked files
```

## Quand l'utiliser

```text
✓ Repos with large binaries: media (video/audio/images), datasets, game assets,
  design files (PSD/Sketch), large compiled artifacts, ML models
✗ Pure source code repos don't need it (Git handles text well)
Alternatives: don't store large artifacts in Git at all (use artifact stores, S3,
  package registries) — sometimes the better choice.
```

## Pourquoi c'est important

Comprendre Git LFS est une connaissance précieuse de niveau senior pour **gérer les fichiers binaires volumineux dans Git**, un problème réel pour certains projets, donc c'est une connaissance pratique utile.

Le problème fondamental est que **Git gère mal les gros binaires** : parce que Git stocke chaque version de chaque fichier dans son historique et que les binaires ne se comparent pas bien (chaque modification stocke une autre copie complète), les fichiers binaires volumineux (vidéos, ensembles de données, ressources de conception, grands artefacts) **gonflent énormément le référentiel** — rendant le repo et chaque clone énorme et lent, avec le gonflement étant permanent et difficile à supprimer.

C'est un problème genuine, parfois sérieux, pour les projets impliquant des médias, des ensembles de données, des ressources de jeu, des fichiers de conception ou des modèles ML. **Git LFS** le résout en stockant les fichiers volumineux **séparément** (sur un serveur LFS) tout en conservant uniquement de petits **fichiers pointeurs** dans l'historique Git — de sorte que le référentiel reste petit et léger, avec les fichiers volumineux réels téléchargés à la demande (uniquement les versions nécessaires).

Comprendre son fonctionnement (pointeurs dans Git, fichiers réels dans LFS, échange transparent) et comment l'utiliser (suivi des types de fichiers via `.gitattributes`) est la connaissance pratique pour les projets qui en ont besoin.

Également important est le jugement sur **quand l'utiliser** (référentiels avec gros binaires) par rapport à quand c'est inutile (code source pur, où Git gère bien le texte) et la conscience des **alternatives** (parfois ne pas stocker les gros artefacts dans Git du tout — utiliser des magasins d'artefacts, S3 ou des registres de paquets — est le meilleur choix).

Cela reflète une prise de décision saine concernant la gestion des fichiers volumineux.

Puisque certains projets ont réellement du mal avec les gros binaires qui gonflent Git (un problème réel et impactant), et puisque Git LFS (ou les alternatives) est la solution — garder les référentiels gérables tout en gérant les fichiers volumineux — comprendre Git LFS, le problème qu'il résout, comment il fonctionne et quand l'utiliser par rapport aux alternatives est une connaissance précieuse de niveau senior pour gérer efficacement les référentiels avec des fichiers volumineux, un sujet utile pour les projets traitant des médias, des données ou de grands actifs.