Wat is artefactbeheer in CI/CD?

Question

Accepted Answer

**Artefacten** zijn de outputs van het bouwproces (gecompileerde binaries, packages, Docker images) die worden geïmplementeerd. **Artefactbeheer** — het opslaan, versiebeheer en promoten van deze artefacten via een registry/repository — is belangrijk voor betrouwbare, traceerbare implementaties.

## Wat artefacten zijn

```text
The BUILD produces ARTIFACTS — the deployable outputs:
  → Docker IMAGES, compiled binaries, JARs/WARs, npm packages, zip bundles, etc.
→ These are what actually get DEPLOYED (not the source code directly).
```

## Artefactrepository's/registries

```text
Artifacts are stored in REPOSITORIES/REGISTRIES (versioned, central storage):
  → Container registries: Docker Hub, AWS ECR, GitHub/GitLab Container Registry
  → Package repositories: npm registry, Maven, PyPI, Artifactory, Nexus
→ The pipeline BUILDS an artifact, PUSHES it to the registry, and DEPLOYS from there.
```

## Het sleutelprincipe: eenmaal bouwen, overal implementeren

```text
Build the artifact ONCE, then promote the SAME artifact through environments:
  build → artifact v1.2.3 → deploy to STAGING → (tested) → deploy SAME v1.2.3 to PROD
  ✓ what you TESTED in staging is EXACTLY what you deploy to production (no rebuild)
  ✗ rebuilding per environment risks differences (different deps, build env) → bugs
→ Versioned, immutable artifacts ensure consistency and traceability.
```

## Voordelen en best practices

```text
✓ VERSIONING — each artifact tagged with a version → know exactly what's deployed
✓ TRACEABILITY — trace a deployed artifact back to its commit/build
✓ ROLLBACK — redeploy a previous artifact version easily
✓ IMMUTABILITY — artifacts don't change once built (consistent, reproducible)
✓ Retention/cleanup policies; scan artifacts for vulnerabilities
```

## Waarom het belangrijk is

Het begrijpen van artefactbeheer is waardevol omdat **artefacten datgene zijn wat werkelijk wordt geïmplementeerd**, en het goed beheren ervan is belangrijk voor betrouwbare, traceerbare, consistente implementaties, dus het is nuttige CI/CD-kennis. **Artefacten** (de deploybare outputs van de build — Docker images, binaries, packages) zijn wat wordt geïmplementeerd (niet direct broncode), en deze opslaan in **versioned registries/repositories** (containerregistries, packagerepository's) is hoe de pipeline ze beheert: een artefact bouwen, het naar de registry pushen en vandaar implementeren.

Het **sleutelprincipe — eenmaal bouwen, overal implementeren** — is bijzonder belangrijk: het artefact **eenmaal** bouwen en datzelfde **artefact** promoten door omgevingen (staging en dan productie) zorgt ervoor dat **wat je hebt getest exact is wat je implementeert** (geen per-omgeving herbouwen die verschillen zouden kunnen introduceren van variërende afhankelijkheden of bouwomgevingen, veroorzakend bugs) — een fundamentele praktijk voor betrouwbare, consistente implementaties die de "het werkt in staging" klasse van problemen voorkomen veroorzaakt door herbouwen.

Het begrijpen van de **voordelen** — **versiebeheer** (precies weten wat is geïmplementeerd), **traceerbaarheid** (een geïmplementeerd artefact terugvoeren naar zijn commit en build, waardevol voor debugging en auditing), **gemakkelijk rollback** (het opnieuw implementeren van een vorige artefactversie), en **immutabiliteit** (artefacten veranderen niet eenmaal gebouwd, zodat reproduceerbaarheid wordt gewaarborgd), plus praktijken zoals kwetsbaarheidsscannen — weerspiegelt hoe juist artefactbeheer betrouwbare operaties ondersteunt.

Aangezien artefacten de werkelijk geïmplementeerde eenheden zijn en het goed beheren ervan (versiebeheer, het eenmaal-bouwen-overal-implementeren-principe, traceerbaarheid, immutabiliteit) belangrijk is voor consistente, traceerbare, betrouwbare implementaties, en aangezien het begrijpen van artefacten, registries en vooral het eenmaal-bouwen-principe waardevol is voor degelijke delivery, is het begrijpen van artefactbeheer waardevol, praktisch-relevant CI/CD-kennis — een belangrijk onderdeel van betrouwbare delivery dat consistentie tussen wat wordt getest en geïmplementeerd garandeert, traceerbaarheid en rollback mogelijk maakt, en volwassen implementatiepraktijken weerspiegelt.