Hvad er Git LFS, og hvornår har du brug for det?

Question

Accepted Answer

**Git LFS** (Large File Storage) er en udvidelse til effektiv håndtering af **store binære filer** (videoer, datasæt, designressourcer, store binære filer) i Git. Git er designet til tekst/kildekode og håndterer store binære filer dårligt, så LFS gemmer dem separat, mens der bevares lette referencer i repositoriet.

## Problemet: Git og store binære filer

```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.
```

## Sådan fungerer 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
```

## Hvornår skal det bruges

```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.
```

## Hvorfor det betyder noget

At forstå Git LFS er værdifuld viden på seniorni for **håndtering af store binære filer i Git**, et reelt problem for visse projekter, så det er brugbar praktisk viden.

Kerneproblem er, at **Git håndterer store binære filer dårligt**: fordi Git gemmer hver version af hver fil i sin historie, og binære filer diffs ikke godt (hver ændring gemmer endnu en fuld kopi), store binære filer (videoer, datasæt, designressourcer, store artefakter) **oppuster repositoriet enormt** — hvilket gør repoen og hver klon enorm og langsom, og oppustningen er permanent og svær at fjerne.

Dette er et ægte og undertiden alvorligt problem for projekter med medie, datasæt, game assets, designfiler eller ML-modeller. **Git LFS** løser det ved at gemme store filer **separat** (på en LFS-server), mens der kun bevares små **pointerfiler** i Git-historien — således forbliver repositoriet småt og letvægt, med faktiske store filer downloadet efter behov (kun de versioner, der er nødvendige).

At forstå, hvordan det fungerer (pointere i Git, rigtige filer i LFS, transparent udskiftning) og hvordan man bruger det (sporing af filtyper via `.gitattributes`) er den praktiske viden for projekter, der har brug for det.

Ligeså vigtig er dømmekraften omkring **hvornår det skal bruges** (repos med store binære filer) versus hvornår det er unødvendigt (ren kildekode, hvor Git håndterer tekst godt) og bevidsthed om **alternativer** (nogle gange er det bedre slet ikke at gemme store artefakter i Git — at bruge artefaktbutikker, S3 eller pakkeregistre — er det bedre valg).

Dette afspejler fornuftig beslutningstagning omkring håndtering af store filer.

Da nogle projekter virkelig kæmper med store binære filer, der oppuster Git (et reelt, virksomhedspåvirkende problem), og da Git LFS (eller alternativer) er løsningen — hvilket holder repos håndterbare, mens store filer håndteres — er forståelse af Git LFS, det problem det løser, hvordan det fungerer, og hvornår det skal bruges versus alternativer værdifuld seniorni-viden til effektiv håndtering af repositorier med store filer, et brugbart emne for projekter, der arbejder med medie, data eller store ressourcer.