Zum Inhalt springen
Trainingslager IT-Trainingslager

Kapitel 1: CI/CD-Ketten selbst betreiben (GitLab CI, Jenkins, Argo CD/Flux)

In diesem Kapitel lernst du:

  • den Unterschied zwischen Push-Deployment und Pull-Deployment (GitOps)
  • wie das Runner- bzw. Agent-Modell funktioniert und warum es das größte Risiko in der Kette ist
  • wann selbst betriebene CI/CD sinnvoll ist und wie du sie härtest
  • wie du GitLab CE mit eigenem Runner aufsetzt und die demo-app ohne Docker-in-Docker baust
  • wie Argo CD die App aus Git in den Cluster bringt und Abweichungen selbst repariert

Worum geht es?

Stell dir eine Bäckerei vor. Das Rezept liegt im Büro (Git). In der Backstube stehen Bäcker, die nach dem Rezept backen (Runner). Die fertigen Brote kommen ins Lager (Registry). Ein Fahrer bringt sie in die Filialen (Deployment).

Jetzt die Sicherheitsfrage: Wer darf in die Backstube? Wenn jeder Lieferant einen Generalschlüssel hat, kann jeder etwas in den Teig mischen. Und der Fahrer: Bekommt er Schlüssel zu allen Filialen, oder holen sich die Filialen ihre Brote selbst ab?

Genau darum geht es in diesem Kapitel. Eine CI/CD-Kette ist eine Fabrik für Software. Wer sie selbst betreibt, entscheidet selbst über Schlüssel, Türen und Wege. Das ist Arbeit, aber auch Kontrolle.

   Entwickler                 CI (Build-Zone)                 CD (Ziel)
  +-----------+  git push  +------------------+  push   +--------------+
  | Laptop    |----------->| GitLab CE :8929  |-------->| reg-build    |
  +-----------+            |  .gitlab-ci.yml  | Image   | :5001/:5000  |
                           +--------+---------+         +------+-------+
                                    | Job                      |
                                    v                          | pull
                           +------------------+                |
                           | gitlab-runner    |                |
                           | (Docker-Executor)|                |
                           | Job: test, kaniko|                |
                           +------------------+                |
                                                               v
  Git-Repo (k8s/) <---------- beobachtet (pull) ------ +---------------+
  "Soll-Zustand"                                       | Argo CD im    |
                                                       | kind-Cluster  |
                                                       | -> Namespace  |
                                                       |    demo       |
                                                       +---------------+

Die CI-Seite baut und testet. Die CD-Seite bringt das Ergebnis in den Cluster. In unserem Labor sind das zwei getrennte Systeme mit getrennten Rechten. Das ist kein Zufall, sondern ein Sicherheitsprinzip.

Die Konzepte in einfach

CI und CD

  • Continuous Integration (CI): Jeder Commit wird automatisch gebaut und getestet. Ergebnis ist ein Artefakt, bei uns ein Container-Image.
  • Continuous Delivery/Deployment (CD): Das Artefakt wird automatisch in eine Umgebung ausgerollt. Bei „Delivery” gibt ein Mensch frei, bei „Deployment” läuft es ganz automatisch.

Push vs. Pull (GitOps)

Beim Push-Modell schiebt die Pipeline das Ergebnis aktiv in den Cluster. Am Ende des CI-Jobs steht etwa kubectl apply oder helm upgrade. Dafür braucht die Pipeline Zugangsdaten zum Cluster.

Beim Pull-Modell läuft im Cluster ein Agent. Er beobachtet ein Git-Repository mit dem gewünschten Zustand und gleicht den Cluster laufend daran an. Diesen Ansatz nennt man GitOps: Git ist die einzige Quelle der Wahrheit (Single Source of Truth).

Aspekt Push (CI deployt) Pull (GitOps)
Cluster-Zugang CI hat Credentials nur Agent im Cluster
Richtung Firewall CI → Cluster eingehend Cluster → Git ausgehend
Abweichungen (Drift) bleiben unbemerkt werden erkannt und repariert
Audit Pipeline-Logs Git-Historie

Merke: Beim Pull-Modell muss kein Weg in die Produktionszone offen sein. Der Agent holt sich, was er braucht. Für Zonenmodelle in Behörden und KRITIS-Umgebungen ist das ein großer Vorteil.

GitOps beruht auf vier Prinzipien (OpenGitOps): Der Zustand ist deklarativ beschrieben, versioniert und unveränderlich gespeichert, wird automatisch gezogen und laufend abgeglichen (Reconciliation).

Das Runner- bzw. Agent-Modell

GitLab selbst führt keine Jobs aus. Es verteilt sie an Runner. Ein Runner ist ein Programm, das regelmäßig fragt: „Gibt es Arbeit für mich?” Dann führt er den Job aus und meldet das Ergebnis zurück. Bei Jenkins heißen die Ausführenden Agents (früher „Slaves”), der zentrale Server Controller.

Der Runner wählt über den Executor, wie ein Job läuft:

Executor Wie der Job läuft Isolation
shell direkt auf dem Runner-Host schwach
docker in einem frischen Container mittel
kubernetes als Pod im Cluster mittel
docker-autoscaler / VM in einer frischen VM pro Job stark

Sicherheit: Der Runner ist der gefährlichste Teil der Kette. Er führt Code aus, den jeder schreiben kann, der eine .gitlab-ci.yml ändern darf. Er sieht Secrets und darf in Registries schreiben. Wer einen Runner übernimmt, kann jedes Artefakt manipulieren, ohne den Quellcode anzufassen.

Runner gibt es in drei Reichweiten:

  • Instance Runner (früher „Shared Runner”): für alle Projekte der Instanz.
  • Group Runner: für alle Projekte einer Gruppe.
  • Project Runner: nur für ein Projekt.

Je größer die Reichweite, desto größer der Schaden bei einer Kompromittierung. Ein Runner, den 300 Projekte teilen, kann von jedem dieser 300 Projekte aus angegriffen werden.

Das Problem mit Docker-in-Docker

Viele Anleitungen bauen Images in CI mit „Docker-in-Docker” (DinD). Dafür braucht der Job-Container privileged = true. Ein privilegierter Container hat praktisch alle Rechte des Hosts. Ein einziger böswilliger Job kann so aus dem Container ausbrechen und andere Jobs, deren Secrets und den Runner selbst übernehmen.

Die Alternative sind Build-Werkzeuge, die ohne Docker-Daemon und ohne Privilegien auskommen:

Werkzeug Prinzip Hinweis
Kaniko baut im Userspace eines normalen Containers Google-Projekt 2025 archiviert, Forks existieren
Buildah daemonlos, OCI-nativ (Red Hat) rootless im Container braucht Feinjustierung
BuildKit rootless Docker-Build-Engine ohne root braucht Anpassungen an seccomp/AppArmor

Wir nehmen im Labor Kaniko. Es läuft ohne jede Zusatzkonfiguration in einem normalen Docker-Executor. In Kapitel 2 bewertest du die Bauverfahren genauer.

Achtung: Google hat das Kaniko-Repository 2025 archiviert. Das Image gcr.io/kaniko-project/executor ist weiterhin abrufbar, bekommt aber keine Updates mehr. Für eine neue Produktivumgebung prüfst du einen gepflegten Fork oder Buildah/BuildKit. Für das Prinzip „bauen ohne Privilegien” ist Kaniko im Labor weiterhin ein gutes Lehrbeispiel.

Selbst betrieben oder SaaS?

Kriterium SaaS (z. B. gitlab.com) Selbst betrieben
Betriebsaufwand gering hoch (Updates, Backups)
Datenhoheit beim Anbieter bei dir
Netzwerk Internet nötig auch air-gapped möglich
Anpassbarkeit eingeschränkt voll

Selbst betreiben lohnt sich, wenn Daten das Haus nicht verlassen dürfen, wenn die Produktionsumgebung vom Internet getrennt ist oder wenn regulatorische Vorgaben (z. B. BSI IT-Grundschutz, KRITIS-Verordnung) Kontrolle über die Build-Umgebung verlangen. Eine Zwischenform ist verbreitet: SaaS-Oberfläche, aber eigene Runner im eigenen Netz.

Härtung in fünf Punkten

  1. Runner-Isolation: Getrennte Runner pro Schutzbedarf. Der Runner, der Produktions-Images baut und signiert, ist ein Project Runner nur für geschützte Branches.
  2. Keine privilegierten Shared Runner: privileged = false, kein eingehängter Docker-Socket in Jobs, Liste erlaubter Images (allowed_images).
  3. Ephemeral Runner: Jeder Job bekommt eine frische Umgebung, die danach verworfen wird. Kein Job kann Reste für den nächsten hinterlassen.
  4. Backups: Datenbank, Repositories und Schlüsseldateien. Ein Backup ohne gitlab-secrets.json ist bei GitLab nur halb so viel wert.
  5. Updates: CI-Server sind beliebte Ziele. Sicherheits-Updates zeitnah einspielen und Upgrade-Pfade beachten.

Argo CD und Flux

Beide sind GitOps-Agenten für Kubernetes und Projekte der CNCF mit Status „graduated”.

Merkmal Argo CD Flux
Oberfläche Web-UI eingebaut keine (CLI, optional Zusatz-UIs)
Konfiguration CRD Application CRDs GitRepository, Kustomization
Mandanten AppProject Namespaces + RBAC
Einstieg sehr anschaulich schlank, sehr Kubernetes-nativ

Wir installieren Argo CD, weil die Oberfläche beim Lernen hilft. Flux schauen wir uns als Konzept an.

Hands-on-Lab: Eigene CI/CD-Kette für die demo-app

Voraussetzung: Kapitel 0 ist erledigt, der Cluster seclab läuft, reg-build hängt im Netz kind. GitLab braucht etwa 4 bis 6 GB RAM. Gib Docker mindestens 12 GB, besser 16 GB.

kubectl config current-context
docker network inspect kind --format '{{range .Containers}}{{.Name}} {{end}}'

Erwartete Ausgabe:

kind-seclab
seclab-control-plane reg-build reg-ziel

Schritt 1: GitLab CE und Runner per docker compose starten

Wir hängen GitLab und den Runner direkt ins Docker-Netz kind. So erreichen die CI-Jobs später GitLab als gitlab und die Registry als reg-build:5000.

mkdir -p ~/seclab/kap01/gitlab
cat > ~/seclab/kap01/gitlab/compose.yaml <<'EOF'
services:
  gitlab:
    # Lab: latest. In echten Umgebungen eine konkrete Version pinnen!
    image: gitlab/gitlab-ce:latest
    container_name: gitlab
    hostname: gitlab
    restart: unless-stopped
    shm_size: "256m"
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://localhost:8929'
        # Ressourcen sparen im Labor
        puma['worker_processes'] = 0
        sidekiq['concurrency'] = 10
        prometheus_monitoring['enable'] = false
    ports:
      - "127.0.0.1:8929:8929"
    volumes:
      - gitlab-config:/etc/gitlab
      - gitlab-logs:/var/log/gitlab
      - gitlab-data:/var/opt/gitlab

  gitlab-runner:
    image: gitlab/gitlab-runner:latest
    container_name: gitlab-runner
    restart: unless-stopped
    volumes:
      - runner-config:/etc/gitlab-runner
      # Der Runner startet Job-Container über den Docker-Daemon des Hosts.
      - /var/run/docker.sock:/var/run/docker.sock

volumes:
  gitlab-config:
  gitlab-logs:
  gitlab-data:
  runner-config:

networks:
  default:
    name: kind
    external: true
EOF
cd ~/seclab/kap01/gitlab
docker compose up -d
docker compose ps

Erwartete Ausgabe (gekürzt):

NAME            IMAGE                         STATUS
gitlab          gitlab/gitlab-ce:latest       Up 30 seconds (health: starting)
gitlab-runner   gitlab/gitlab-runner:latest   Up 30 seconds

Warum external_url 'http://localhost:8929' und Port 8929:8929? GitLab lässt seinen eingebauten Webserver auf dem Port aus external_url lauschen. Innen und außen ist es also derselbe Port. Das hält die URLs in der Oberfläche korrekt.

Sicherheit: Der Runner-Container hat Zugriff auf den Docker-Socket. Damit ist er faktisch root auf deinem Host. Im Labor akzeptieren wir das. In Produktion läuft der Runner auf einer eigenen, wegwerfbaren VM oder als Kubernetes-Executor in einem separaten Cluster.

Schritt 2: Warten und anmelden

Der erste Start dauert 3 bis 6 Minuten. GitLab richtet Datenbank, Redis und alle Dienste ein.

until [ "$(curl -s -o /dev/null -w '%{http_code}' \
  http://localhost:8929/users/sign_in)" = "200" ]; do
  echo "GitLab startet noch ..."; sleep 15
done
echo "GitLab ist bereit."
docker exec gitlab grep 'Password:' /etc/gitlab/initial_root_password

Erwartete Ausgabe:

GitLab startet noch ...
...
GitLab ist bereit.
Password: AbC...xyz=

Öffne http://localhost:8929, melde dich als root mit diesem Passwort an. Ändere das Passwort sofort (Avatar oben, „Edit profile”, „Password”).

Achtung: Die Datei initial_root_password wird nach 24 Stunden automatisch gelöscht. Hast du das Passwort verpasst, setzt du es mit docker exec -it gitlab gitlab-rake "gitlab:password:reset[root]" zurück.

Schritt 3: Zugriffstoken anlegen und demo-app pushen

Für Git über HTTP nimmst du nicht dein Passwort, sondern ein persönliches Zugriffstoken (Personal Access Token, PAT). Es ist widerrufbar, hat ein Ablaufdatum und nur die Rechte, die du ihm gibst.

So öffnest du das Formular:

  1. Klicke oben rechts auf deinen Avatar und dann auf „Edit profile”.
  2. Wähle in der linken Seitenleiste „Access”, „Personal access tokens”.
  3. Klicke auf „Generate token” und wähle im Menü „Legacy token”.

Fülle das Formular so aus:

Feld Wert Warum
Token name seclab-git Am Namen erkennst du später, wofür das Token da ist, etwa wenn du es widerrufen willst
Token description Git über HTTP im Lab (optional) Hilft, sobald du mehrere Tokens hast
Expiration date heute + 30 Tage Ohne Eingabe setzt GitLab 365 Tage. Kurz ist besser: Ein vergessenes Token läuft von selbst ab
Scopes nur read_repository und write_repository Klonen und Pushen über HTTP, sonst nichts

Lass alle anderen Scopes frei, vor allem api. Er gäbe dem Token vollen Zugriff auf die GitLab-API: Projekte löschen, Einstellungen ändern, weitere Tokens anlegen. Klicke dann unten auf „Generate token”.

GitLab zeigt das neue Token oben auf der Seite an. Es beginnt mit glpat-. Kopiere es über das Kopier-Symbol neben dem Feld und lege es in deinem Passwortmanager ab. Sobald du die Seite verlässt oder neu lädst, kannst du es nicht mehr ansehen. Dann hilft nur ein neues Token.

Achtung: Seit GitLab 19.2 bietet „Generate token” zwei Arten an. Ein Fine-grained token vergibt Rechte einzeln pro Ressource und Projekt. Das ist für Produktion die genauere Wahl, kostet aber deutlich mehr Klicks. Im Lab nimmst du das Legacy token mit den klassischen Scopes. Ältere GitLab-Versionen zeigen statt des Menüs die Schaltfläche „Add new token” mit demselben Formular.

Tipp: In Kapitel 11 holst du Build-Artefakte über die API und brauchst dafür den Scope read_api. Lege dafür dann ein zweites Token an, statt diesem hier mehr Rechte zu geben. Ein Token pro Zweck lässt sich einzeln widerrufen.

Jetzt schiebst du die demo-app nach GitLab. GitLab legt das Projekt beim ersten Push automatisch an („push to create”, privat):

cd ~/seclab/demo-app
git remote add origin http://localhost:8929/root/demo-app.git
git push -u origin main

Als Benutzername gibst du root ein, als Passwort das Token.

Erwartete Ausgabe (gekürzt):

remote: The private project root/demo-app was successfully created.
...
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.

Prüfe in der Oberfläche unter http://localhost:8929/root/demo-app, dass die Dateien da sind.

Schritt 4: Runner anlegen und registrieren

Seit GitLab 16 läuft die Registrierung über ein Runner-Authentifizierungstoken (beginnt mit glrt-). Den Runner legst du zuerst in der Oberfläche an. Die alten Registrierungstoken sind abgekündigt.

In GitLab: „Admin” (unten links), „CI/CD”, „Runners”, „New instance runner”. Setze den Haken bei „Run untagged jobs” und beschreibe den Runner mit seclab-runner. Klicke auf „Create runner”. GitLab zeigt das Token glrt-… genau einmal an.

Tipp: Für ein einzelnes Projekt wäre ein Project Runner die bessere Wahl (Projekt, „Settings”, „CI/CD”, „Runners”). Wir nehmen im Labor einen Instance Runner, damit er später auch für andere Übungsprojekte zur Verfügung steht.

Registrieren:

read -rs RUNNER_TOKEN   # Token einfügen, Enter (wird nicht angezeigt)
docker exec gitlab-runner gitlab-runner register \
  --non-interactive \
  --url "http://gitlab:8929" \
  --token "$RUNNER_TOKEN" \
  --executor "docker" \
  --docker-image "alpine:3.20" \
  --docker-network-mode "kind" \
  --clone-url "http://gitlab:8929" \
  --description "seclab-runner"
unset RUNNER_TOKEN

Erwartete Ausgabe (gekürzt):

Verifying runner... is valid      runner=xxxxxxx
Runner registered successfully. Feel free to start it, ...

Die zwei wichtigen Optionen für unser Labor:

  • --docker-network-mode kind: Job-Container starten im Netz kind. Dort finden sie gitlab und reg-build.
  • --clone-url http://gitlab:8929: Jobs klonen über den Container-Namen. Die external_url (localhost) würde im Job-Container auf den Job selbst zeigen.

Schritt 5: Runner-Konfiguration prüfen

docker exec gitlab-runner cat /etc/gitlab-runner/config.toml

Erwartete Ausgabe (Ausschnitt):

[[runners]]
  name = "seclab-runner"
  url = "http://gitlab:8929"
  token = "glrt-..."
  executor = "docker"
  clone_url = "http://gitlab:8929"
  [runners.docker]
    image = "alpine:3.20"
    privileged = false
    network_mode = "kind"
    volumes = ["/cache"]

Achte auf zwei Zeilen: privileged = false und volumes = ["/cache"]. Der Docker-Socket ist nicht in die Jobs eingehängt. Genau so soll es sein.

In der Oberfläche steht der Runner unter „Admin”, „CI/CD”, „Runners” jetzt mit grünem Punkt („Online”).

Schritt 6: Die Pipeline schreiben

Die Pipeline hat zwei Stufen. test führt die Unit-Tests aus. build baut das Image mit Kaniko und schiebt es nach reg-build.

cd ~/seclab/demo-app
cat > .gitlab-ci.yml <<'EOF'
stages:
  - test
  - build

variables:
  # Cluster-/Netz-Adresse der Build-Registry (Docker-Netz "kind")
  IMAGE_NAME: "reg-build:5000/demo-app"

test:
  stage: test
  image: python:3.12-slim
  script:
    - pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt
    - python -m pytest -q

build:
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:v1.23.2-debug
    entrypoint: [""]
  script:
    - /kaniko/executor
      --context "$CI_PROJECT_DIR"
      --dockerfile "$CI_PROJECT_DIR/Dockerfile"
      --destination "$IMAGE_NAME:$CI_COMMIT_SHORT_SHA"
      --digest-file "$CI_PROJECT_DIR/image-digest.txt"
      --insecure
    - echo "Gebaut: $IMAGE_NAME@$(cat image-digest.txt)"
  artifacts:
    paths:
      - image-digest.txt
    expire_in: 1 week
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
EOF

Was hier passiert:

Teil Bedeutung
-debug-Image enthält eine Shell, die GitLab für script braucht
entrypoint: [""] überschreibt den Kaniko-Startbefehl, damit GitLab steuern kann
--insecure Push an eine http-Registry erlaubt (nur Labor)
--digest-file schreibt den Digest des gebauten Images in eine Datei
rules gebaut wird nur auf dem Standard-Branch
Tag $CI_COMMIT_SHORT_SHA jedes Image ist eindeutig einem Commit zugeordnet

Merke: Der Digest als Pipeline-Artefakt ist Gold wert. Spätere Schritte wie Signieren (Kapitel 5) oder SBOM-Erzeugung (Kapitel 7) arbeiten mit genau diesem Digest. So signierst du garantiert das Image, das du gebaut hast, und nicht eines, auf das zufällig gerade ein Tag zeigt.

Committen und pushen:

git add .gitlab-ci.yml
git commit -m "ci: test- und build-Stufe mit Kaniko"
git push

Schritt 7: Pipeline beobachten und Ergebnis prüfen

Öffne http://localhost:8929/root/demo-app/-/pipelines. Die Pipeline läuft mit zwei Jobs. Der erste Lauf dauert länger, weil die Images geladen werden.

Im Log des build-Jobs steht am Ende:

INFO[0042] Pushing image to reg-build:5000/demo-app:3f9a1c2b
INFO[0043] Pushed reg-build:5000/demo-app@sha256:7d4e...
$ echo "Gebaut: $IMAGE_NAME@$(cat image-digest.txt)"
Gebaut: reg-build:5000/demo-app@sha256:7d4e...
Job succeeded

Vom Host aus prüfst du, ob das Image wirklich angekommen ist:

crane ls localhost:5001/demo-app
crane digest localhost:5001/demo-app:"$(git rev-parse --short HEAD)"

Erwartete Ausgabe:

1.0.0
3f9a1c2b
sha256:7d4e...

Der Digest stimmt mit dem im Job-Log überein. Die Registry ist dieselbe, nur einmal über das Netz kind und einmal über Port 5001 angesprochen.

Tipp: Weicht die Länge des Kurz-Hashes ab (git rev-parse --short liefert manchmal 7, GitLab 8 Zeichen), nimm den Tag aus crane ls.

Schritt 8: Jenkins zum Vergleich starten

Jenkins ist der Klassiker unter den CI-Servern. Er ist extrem flexibel, aber diese Flexibilität kommt über Plugins. Jedes Plugin ist eine weitere Abhängigkeit, die gepflegt und aktualisiert werden muss.

docker run -d --name jenkins --restart=unless-stopped \
  --network kind \
  -p 127.0.0.1:8090:8080 \
  -v jenkins-home:/var/jenkins_home \
  jenkins/jenkins:lts-jdk21

sleep 30
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Erwartete Ausgabe:

3c5d0b... (32 Zeichen)

Öffne http://localhost:8090, gib das Passwort ein, wähle „Install suggested plugins” und lege einen Admin-Benutzer an. Die vorgeschlagenen Plugins enthalten „Pipeline” und „Git”.

Schritt 9: Ein deklaratives Jenkinsfile

Lege im Repo ein Jenkinsfile an. Es ist bewusst klein und läuft ohne Python oder Docker auf dem Jenkins-Controller. Es soll nur die Struktur zeigen.

cd ~/seclab/demo-app
cat > Jenkinsfile <<'EOF'
pipeline {
  agent any
  options {
    timeout(time: 10, unit: 'MINUTES')
    disableConcurrentBuilds()
    buildDiscarder(logRotator(numToKeepStr: '20'))
  }
  stages {
    stage('Dockerfile-Check') {
      steps {
        sh 'test -f Dockerfile'
        // Mini-Regel: Das Image muss als non-root User laufen
        sh 'grep -q "^USER 10001" Dockerfile'
      }
    }
    stage('Info') {
      steps {
        sh 'git log -1 --oneline'
        sh 'sha256sum requirements.txt'
      }
    }
  }
  post {
    always {
      echo "Build ${env.BUILD_NUMBER}: ${currentBuild.currentResult}"
    }
  }
}
EOF
git add Jenkinsfile
git commit -m "ci: Jenkinsfile zum Vergleich"
git push

In Jenkins:

  1. „Manage Jenkins”, „Credentials”, „System”, „Global credentials”, „Add Credentials”. Typ „Username with password”, Benutzer root, Passwort = dein glpat--Token, ID gitlab-pat.
  2. „New Item”, Name demo-app, Typ „Pipeline”.
  3. Unter „Pipeline”: Definition „Pipeline script from SCM”, SCM „Git”, Repository URL http://gitlab:8929/root/demo-app.git, Credentials gitlab-pat, Branch */main, Script Path Jenkinsfile.
  4. Speichern, „Build Now”.

Erwartete Konsolenausgabe (gekürzt):

[Pipeline] stage (Dockerfile-Check)
+ test -f Dockerfile
+ grep -q ^USER 10001 Dockerfile
[Pipeline] stage (Info)
+ git log -1 --oneline
b7e2f10 ci: Jenkinsfile zum Vergleich
...
Build 1: SUCCESS
Finished: SUCCESS

Sicherheit: agent any lässt den Build hier auf dem Controller laufen. Das ist nur im Labor akzeptabel. In Produktion setzt du die Executoren des Controllers auf 0 („Manage Jenkins”, „Nodes”, „Built-In Node”) und lässt Builds nur auf Agents laufen, etwa mit dem Kubernetes-Plugin als wegwerfbare Pods (agent { kubernetes { ... } }).

GitLab CI und Jenkins im Vergleich:

Aspekt GitLab CI Jenkins
Pipeline-Definition YAML (.gitlab-ci.yml) Groovy (Jenkinsfile)
Integration Git, CI, Registry in einem über Plugins
Erweiterung Komponenten, Templates über 1.800 Plugins
Härtungsfokus Runner, Variablen, Branches Plugins, Controller, Credentials

Schritt 10: Argo CD im Cluster installieren

Jetzt die CD-Seite. Argo CD läuft im Cluster im Namespace argocd.

kubectl create namespace argocd
kubectl apply -n argocd --server-side --force-conflicts \
  -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
kubectl -n argocd wait --for=condition=available deployment --all --timeout=300s
kubectl -n argocd get pods

Erwartete Ausgabe (gekürzt):

deployment.apps/argocd-server condition met
...
NAME                                  READY   STATUS    RESTARTS   AGE
argocd-application-controller-0       1/1     Running   0          2m
argocd-repo-server-6c8f...            1/1     Running   0          2m
argocd-server-7b9d...                 1/1     Running   0          2m
...

Warum --server-side? Einige Argo-CD-CRDs sind so groß, dass der klassische Client-Side-Apply an der Größengrenze für Annotationen scheitert. Die Argo-CD-Doku empfiehlt deshalb Server-Side-Apply.

Tipp: stable zeigt immer auf die neueste stabile Version. Für reproduzierbare Installationen ersetzt du stable in der URL durch eine konkrete Version, etwa v3.1.0. Genau das tust du in Produktion, und zwar aus deinem Spiegel (siehe Kapitel 3).

Schritt 11: Bei Argo CD anmelden

kubectl -n argocd port-forward svc/argocd-server 8443:443 >/dev/null 2>&1 &
ARGO_PF=$!
sleep 3
ARGO_PW=$(argocd admin initial-password -n argocd | head -n1)
argocd login localhost:8443 --username admin --password "$ARGO_PW" --insecure

Erwartete Ausgabe:

'admin:login' logged in successfully
Context 'localhost:8443' updated

Die Oberfläche erreichst du unter https://localhost:8443 (Zertifikatswarnung bestätigen, es ist selbstsigniert).

Schritt 12: Argo CD Zugriff auf das Repository geben

Argo CD läuft in einem Pod. Container-Namen aus dem Docker-Netz löst der Cluster-DNS (CoreDNS) nicht zuverlässig auf. Wir sprechen GitLab deshalb über seine IP-Adresse im Netz kind an. Pods erreichen diese Adresse über den Knoten.

GITLAB_IP=$(docker inspect -f \
  '{{(index .NetworkSettings.Networks "kind").IPAddress}}' gitlab)
echo "$GITLAB_IP"

Erwartete Ausgabe (Adresse kann abweichen):

172.18.0.5

Für den Lesezugriff legst du ein Deploy-Token an. Es gehört zum Projekt, nicht zu einer Person, und darf nur lesen. In GitLab: Projekt demo-app, „Settings”, „Repository”, „Deploy tokens”, „Add token”. Name argocd, Scope nur read_repository. Notiere Benutzername (etwa gitlab+deploy-token-1) und Token.

read -r DT_USER    # z. B. gitlab+deploy-token-1
read -rs DT_PASS   # Token, wird nicht angezeigt
argocd repo add "http://${GITLAB_IP}:8929/root/demo-app.git" \
  --username "$DT_USER" --password "$DT_PASS"
unset DT_PASS
argocd repo list

Erwartete Ausgabe:

Repository 'http://172.18.0.5:8929/root/demo-app.git' added
TYPE  NAME  REPO                                       ...  STATUS      MESSAGE
git         http://172.18.0.5:8929/root/demo-app.git   ...  Successful

Sicherheit: Argo CD speichert die Zugangsdaten als Kubernetes-Secret im Namespace argocd. Lege solche Secrets nie als YAML-Datei ins Git-Repo. Wie du Zugangsdaten sauber aus Vault in den Cluster bringst, zeigt Kapitel 6.

Achtung: Die IP-Adresse kann sich nach einem Neustart von GitLab ändern. Dann meldet Argo CD einen Verbindungsfehler. Ermittle die IP neu und lege Repository und Application mit der neuen Adresse an.

Schritt 13: Die Application anlegen

Eine Application sagt Argo CD: „Nimm den Ordner k8s aus diesem Repo und halte den Namespace demo genau so.”

cat > ~/seclab/kap01/argocd-app.yaml <<EOF
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: demo-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: http://${GITLAB_IP}:8929/root/demo-app.git
    targetRevision: main
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: demo
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
EOF
kubectl apply -f ~/seclab/kap01/argocd-app.yaml
sleep 20
argocd app get demo-app

Erwartete Ausgabe (gekürzt):

Name:               argocd/demo-app
Project:            default
Server:             https://kubernetes.default.svc
Namespace:          demo
Repo:               http://172.18.0.5:8929/root/demo-app.git
Target:             main
Path:               k8s
Sync Policy:        Automated (Prune)
Sync Status:        Synced to main (b7e2f10)
Health Status:      Healthy

GROUP  KIND        NAMESPACE  NAME      STATUS  HEALTH   HOOK  MESSAGE
       Service     demo       demo-app  Synced  Healthy        service/demo-app ...
apps   Deployment  demo       demo-app  Synced  Healthy        deployment.apps/...

Die Ressourcen aus Kapitel 0 existierten schon. Argo CD hat sie übernommen, weil sie zum Soll-Zustand passen. Ab jetzt ist Git die Wahrheit.

Option Wirkung
automated Änderungen in Git werden automatisch ausgerollt
prune: true in Git gelöschte Ressourcen werden im Cluster gelöscht
selfHeal: true manuelle Änderungen im Cluster werden zurückgedreht
CreateNamespace=true Namespace wird bei Bedarf angelegt

Schritt 14: GitOps erleben

Erst eine Änderung über Git. Erhöhe die Replikate auf 2:

cd ~/seclab/demo-app
yq -i '.spec.replicas = 2' k8s/deployment.yaml
git commit -am "deploy: 2 Replikate"
git push
argocd app sync demo-app   # sonst prüft Argo CD etwa alle 3 Minuten
kubectl -n demo get pods

Erwartete Ausgabe:

NAME                        READY   STATUS    RESTARTS   AGE
demo-app-6d9f8b7c5d-x2k4q   1/1     Running   0          40m
demo-app-6d9f8b7c5d-p8m3z   1/1     Running   0          10s

Jetzt der Gegentest: Jemand ändert den Cluster von Hand.

kubectl -n demo scale deployment demo-app --replicas=5
sleep 15
kubectl -n demo get deployment demo-app

Erwartete Ausgabe:

NAME       READY   UP-TO-DATE   AVAILABLE   AGE
demo-app   2/2     2            2           41m

Argo CD hat die Abweichung (Drift) erkannt und auf den Stand aus Git zurückgesetzt. Unter „History and Rollback” in der Oberfläche siehst du jeden Abgleich mit Commit-Hash.

Merke: Wer etwas am Cluster ändern will, muss jetzt einen Commit machen. Damit gibt es automatisch Vier-Augen-Prinzip (Merge Request), Historie und einfachen Rollback per git revert.

Die Brücke zwischen CI und CD fehlt noch: Die Pipeline baut demo-app:<sha>, das Deployment zeigt aber auf 1.0.0. In der Praxis schreibt ein CI-Job den neuen Digest per Commit in das Deployment-Repo, oder ein Werkzeug wie Argo CD Image Updater bzw. Flux Image Automation erledigt das. Diesen Schritt bauen wir im Abschlussprojekt (Kapitel 11) mit Signaturprüfung zusammen.

Schritt 15: Flux als Alternative (Konzept)

Flux arbeitet ähnlich, aber ohne Oberfläche. Der Einstieg heißt Bootstrap: Die Flux-CLI installiert die Controller im Cluster, schreibt deren eigene Manifeste in ein Git-Repo und lässt Flux sich ab dann selbst aus diesem Repo verwalten.

flux bootstrap git
   |
   +--> installiert Flux-Controller im Cluster (flux-system)
   +--> committet clusters/seclab/flux-system/*.yaml ins Repo
   +--> Flux zieht ab jetzt sich selbst UND deine Apps aus Git

Ein Bootstrap gegen unser GitLab sähe etwa so aus (Flux-CLI z. B. per brew install fluxcd/tap/flux):

# Nur zur Illustration - nicht parallel zu Argo CD auf dieselbe App ansetzen!
flux bootstrap git \
  --url="http://${GITLAB_IP}:8929/root/fleet.git" \
  --branch=main \
  --path=clusters/seclab \
  --allow-insecure-http=true \
  --token-auth=true \
  --username=root \
  --password="$GITLAB_PAT"

Die eigentliche App beschreibst du dann mit zwei Ressourcen:

apiVersion: source.toolkit.fluxcd.io/v1
kind: GitRepository
metadata:
  name: demo-app
  namespace: flux-system
spec:
  interval: 1m
  url: http://172.18.0.5:8929/root/demo-app.git
  ref:
    branch: main
  secretRef:
    name: demo-app-git
---
apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: demo-app
  namespace: flux-system
spec:
  interval: 5m
  sourceRef:
    kind: GitRepository
    name: demo-app
  path: ./k8s
  prune: true
  targetNamespace: demo

GitRepository entspricht dem Repo-Eintrag in Argo CD, Kustomization der Application. prune: true hat dieselbe Bedeutung. Selbstheilung ist bei Flux immer eingebaut: Bei jedem Intervall wird der Soll-Zustand neu angewendet.

Achtung: Lass nie zwei GitOps-Agenten dieselben Ressourcen verwalten. Sie würden sich gegenseitig überschreiben. Willst du Flux ausprobieren, nimm einen zweiten kind-Cluster.

Schritt 16: Aufräumen

GitLab und Jenkins brauchen viel RAM. Stoppe sie, wenn du sie nicht brauchst. Die Volumes bleiben erhalten, spätere Kapitel nutzen GitLab wieder.

kill "$ARGO_PF" 2>/dev/null
cd ~/seclab/kap01/gitlab && docker compose stop
docker stop jenkins
docker ps --format '{{.Names}}'

Erwartete Ausgabe:

seclab-control-plane
reg-ziel
reg-build

Argo CD bleibt im Cluster. Wieder starten geht mit docker compose start im Ordner ~/seclab/kap01/gitlab und docker start jenkins. Ganz entfernen würdest du alles mit docker compose down -v und docker rm -f jenkins plus docker volume rm jenkins-home.

Fortschritt speichern? Kostenlos registrieren

Typische Stolperfallen

Symptom Ursache Lösung
GitLab-Seite lädt mit 502 GitLab startet noch 3–6 Minuten warten, docker logs -f gitlab
GitLab-Container startet ständig neu zu wenig RAM Docker 12–16 GB geben, Jenkins stoppen
network kind declared as external, but could not be found Cluster aus Kapitel 0 fehlt Cluster anlegen, dann compose up
Job hängt bei „Waiting for runner” Runner offline oder nur getaggte Jobs „Run untagged jobs” setzen, docker logs gitlab-runner
Job: Could not resolve host: localhost o. Ä. beim Klonen clone_url fehlt clone_url = "http://gitlab:8929" in config.toml
Kaniko: http: server gave HTTP response to HTTPS client --insecure fehlt Flag ergänzen
Kaniko: no such host reg-build Job nicht im Netz kind network_mode = "kind" in config.toml
Argo CD Repo „Failed”: Verbindungsfehler falsche oder geänderte GitLab-IP IP neu ermitteln, Repo neu hinzufügen
Argo CD „authentication required” Deploy-Token falsch oder Scope fehlt Token mit read_repository neu anlegen
kubectl apply von Argo CD: „metadata.annotations: Too long” Client-Side-Apply bei großen CRDs --server-side --force-conflicts nutzen
Jenkins: „Couldn’t find any revision to build” Branch */master statt */main Branch-Spezifikation anpassen

Übung: Den Runner härten

Dein Instance Runner nimmt jedes Image an, das in einer .gitlab-ci.yml steht. Ein Entwickler könnte so ein beliebiges Image aus dem Internet ausführen, etwa ein manipuliertes „Hilfs-Image”, das Secrets ausliest.

Aufgabe: Beschränke den Runner auf genau die Images, die die Pipeline braucht: alpine:3.20, python:3.12-slim und das Kaniko-Image. Stelle außerdem sicher, dass Images bei jedem Job frisch aus der Registry geholt werden und kein Job im privilegierten Modus läuft. Beweise mit einem Test-Job auf einem eigenen Branch, dass ein nicht erlaubtes Image (z. B. docker:27-cli) abgelehnt wird, während die normale Pipeline weiter grün ist.

Hinweis 1: Alle Einstellungen liegen im Abschnitt [runners.docker] der Datei /etc/gitlab-runner/config.toml im Container gitlab-runner. Der Container hat keinen Editor. Hol dir die Datei mit docker cp auf den Host, bearbeite sie dort und kopiere sie zurück. Der Runner liest Änderungen nach wenigen Sekunden von selbst neu ein.

Hinweis 2: Die gesuchten Schlüssel heißen allowed_images (Liste, Platzhalter * erlaubt), pull_policy und privileged. Den Test-Job legst du auf einem Branch test-allowlist an. Der build-Job läuft dort wegen seiner rules gar nicht erst.

Lösung

Konfiguration holen und bearbeiten:

docker cp gitlab-runner:/etc/gitlab-runner/config.toml ~/seclab/kap01/config.toml

Den Abschnitt [runners.docker] ergänzt du so (übrige Zeilen bleiben):

  [runners.docker]
    image = "alpine:3.20"
    privileged = false
    network_mode = "kind"
    volumes = ["/cache"]
    pull_policy = ["always"]
    allowed_images = [
      "alpine:3.20",
      "python:3.12-slim",
      "gcr.io/kaniko-project/executor:*",
    ]

Zurückkopieren und prüfen:

docker cp ~/seclab/kap01/config.toml gitlab-runner:/etc/gitlab-runner/config.toml
sleep 5
docker logs --tail 5 gitlab-runner

Im Log erscheint ein Hinweis wie Configuration loaded. Notfalls hilft docker restart gitlab-runner.

Test-Job auf eigenem Branch:

cd ~/seclab/demo-app
git switch -c test-allowlist
cat >> .gitlab-ci.yml <<'EOF'

verboten:
  stage: test
  image: docker:27-cli
  script:
    - docker info
EOF
git commit -am "test: nicht erlaubtes Image"
git push -u origin test-allowlist

Erwartetes Ergebnis in der Pipeline des Branches: test ist grün, verboten scheitert sofort mit einer Meldung wie:

ERROR: The "docker:27-cli" image is not present on list of allowed images:
- alpine:3.20
- python:3.12-slim
- gcr.io/kaniko-project/executor:*

Danach räumst du den Test-Branch weg:

git switch main
git branch -D test-allowlist
git push origin --delete test-allowlist

Warum das wirkt:

  • allowed_images verhindert, dass Pipelines beliebigen fremden Code als Job-Image einschleusen. Die Liste ist eine erste Form von „Policy as Code” auf Runner-Ebene (ausführlich in Kapitel 9).
  • pull_policy = ["always"] sorgt dafür, dass ein Job nicht ein lokal gecachtes, eventuell von einem anderen Job manipuliertes Image nutzt. Kommen die Images später aus deinem Spiegel (Kapitel 3), kostet das kaum Zeit.
  • privileged = false war schon gesetzt. Explizit hinschreiben macht die Absicht für Prüfer sichtbar.

Tipp: Noch strenger wird es, wenn du statt Tags Digests in die Liste schreibst, etwa python@sha256:…. Dann muss auch die Pipeline Digests verwenden. Das Thema greift Kapitel 2 auf.

Fortschritt speichern? Kostenlos registrieren

Aus der Praxis

Zonen und Runner: In regulierten Umgebungen (Behörden, KRITIS) gibt es meist mehrere Netzzonen. Üblich ist: GitLab steht in der internen Zone, Runner für normale Builds daneben. Für die Freigabe in Produktion gibt es einen separaten, besonders geschützten Runner (Project Runner, nur geschützte Branches und Tags, nur bestimmte Personen dürfen auslösen). Die Produktionszone selbst bekommt keinen eingehenden Zugang. Ein GitOps-Agent in der Zielzone holt sich den Zustand aus einem gespiegelten Repo und die Images aus der Ziel-Registry (siehe Kapitel 4).

Ephemere Runner: Große Organisationen betreiben Runner mit dem Docker-Autoscaler oder als Kubernetes-Executor in einem eigenen Build-Cluster. Jeder Job läuft in einer frischen VM oder einem frischen Pod. Nach dem Job wird alles verworfen. Das schließt ganze Angriffsklassen aus, etwa vergiftete Caches oder zurückgelassene Hintergrundprozesse.

Geschützte Variablen und Branches: Secrets für Registry-Push oder Signatur sind als „protected” und „masked” markiert. Sie stehen nur Pipelines auf geschützten Branches zur Verfügung. So kann ein Feature-Branch die Secrets nicht abgreifen. Das CI_JOB_TOKEN wird über die „Job token allowlist” auf die Projekte beschränkt, die es wirklich brauchen.

Backups: Für GitLab gehören drei Dinge ins Backup:

docker exec -t gitlab gitlab-backup create
docker exec gitlab ls /var/opt/gitlab/backups
docker cp gitlab:/etc/gitlab/gitlab-secrets.json ~/seclab/kap01/
docker cp gitlab:/etc/gitlab/gitlab.rb ~/seclab/kap01/

gitlab-backup sichert Datenbank und Repositories. gitlab-secrets.json enthält die Schlüssel, mit denen GitLab CI-Variablen und Zwei-Faktor-Daten verschlüsselt. Ohne diese Datei sind diese Daten nach einem Restore unbrauchbar. Bewahre sie getrennt und verschlüsselt auf. Und: Ein Backup, dessen Wiederherstellung nie geübt wurde, ist nur eine Hoffnung.

Updates: GitLab erscheint monatlich, Sicherheits-Patches oft dazwischen. Bei großen Versionssprüngen gibt es Pflicht-Zwischenstationen („upgrade path”). Plane regelmäßige Wartungsfenster. Bei Jenkins ist der Plugin-Bestand das größte Risiko. Halte ihn klein, nutze Configuration as Code (JCasC) und prüfe die Jenkins-Sicherheitshinweise regelmäßig.

Argo CD im Betrieb: Den lokalen admin-Benutzer deaktiviert man nach der Einrichtung und meldet sich per SSO (OIDC) an. AppProject-Objekte begrenzen, aus welchen Repos und in welche Namespaces ein Team ausrollen darf. Die Metriken von Argo CD und GitLab gehen in Prometheus. Alarme gibt es zum Beispiel für Apps, die länger als 15 Minuten „OutOfSync” oder „Degraded” sind.

Audit: Prüfer fragen typischerweise: Wer darf Pipelines ändern? Wer darf in Produktion ausrollen? Wie ist nachgewiesen, welches Image aus welchem Commit stammt? Mit GitOps beantwortest du die letzten beiden Fragen aus der Git-Historie. Die erste beantwortest du mit geschützten Branches, CODEOWNERS für .gitlab-ci.yml und Pflicht-Reviews.

Interviewfragen

F: Was ist der Unterschied zwischen Push- und Pull-basiertem Deployment?

A: Beim Push-Modell führt die CI-Pipeline das Deployment aus und braucht dafür Zugangsdaten zum Cluster. Beim Pull-Modell (GitOps) läuft ein Agent wie Argo CD oder Flux im Cluster, beobachtet ein Git-Repo und gleicht den Cluster an. Vorteile von Pull: keine Cluster-Credentials in der CI, kein eingehender Netzweg nötig, Drift-Erkennung und Git als Audit-Log.

F: Warum vermeidest du Docker-in-Docker auf gemeinsam genutzten Runnern?

A: DinD braucht privilegierte Container. Damit kann ein Job aus dem Container auf den Host ausbrechen und andere Jobs, deren Secrets und den Runner übernehmen. Besser sind Werkzeuge wie Kaniko, Buildah oder rootless BuildKit, die ohne Privilegien bauen, oder eine eigene, wegwerfbare VM pro Job.

F: Wie härtest du einen GitLab Runner?

A: Getrennte Runner nach Schutzbedarf, sensible Runner nur für geschützte Branches. privileged = false, kein Docker-Socket in Jobs, allowed_images und pull_policy = always. Möglichst ephemere Umgebungen pro Job. Runner-Host selbst patchen und überwachen. Registrierung über Runner-Authentifizierungstoken, die widerrufbar sind.

F: Was ist ein ephemerer Runner und welches Problem löst er?

A: Ein Runner bzw. eine Ausführungsumgebung, die nur für einen Job existiert und danach verworfen wird. Er verhindert, dass ein Job Spuren für den nächsten hinterlässt, etwa manipulierte Caches, Images oder laufende Prozesse. Das begrenzt den Schaden eines kompromittierten Jobs auf genau diesen Job.

F: Wann würdest du CI/CD selbst betreiben statt SaaS zu nutzen?

A: Wenn Quellcode oder Artefakte die eigene Infrastruktur nicht verlassen dürfen, wenn Zielumgebungen vom Internet getrennt sind (air-gapped) oder regulatorische Vorgaben Kontrolle über die Build-Umgebung verlangen. Der Preis ist Betriebsaufwand: Updates, Backups, Monitoring, Härtung.

F: Was gehört bei GitLab ins Backup?

A: Das Ergebnis von gitlab-backup create (Datenbank, Repositories, Uploads), dazu gitlab-secrets.json und gitlab.rb. Ohne gitlab-secrets.json lassen sich verschlüsselte Daten wie CI-Variablen nicht wiederherstellen. Restore regelmäßig testen.

F: Argo CD oder Flux – wie entscheidest du?

A: Beide sind ausgereifte CNCF-Projekte. Argo CD bietet eine starke Web-Oberfläche und AppProject für Mandanten, was Teams den Einstieg erleichtert. Flux ist schlanker, rein CRD-basiert und gut für Plattform-Teams, die alles als Code verwalten. Entscheidend sind vorhandenes Know-how, Mandantenmodell und Integration in SSO und Monitoring.

F: Wie kommen Secrets in einen GitOps-Workflow, ohne im Git zu landen?

A: Im Git liegt nur ein Verweis, nicht das Secret selbst. Der External Secrets Operator holt den Wert zur Laufzeit aus Vault oder OpenBao. Alternativ verschlüsselte Secrets mit Sealed Secrets oder SOPS. Details in Kapitel 6.

Zusammenfassung

Das hast du gelernt:

  • CI baut und testet, CD bringt das Ergebnis aus. Beim Pull-Modell (GitOps) holt sich ein Agent im Cluster den Soll-Zustand aus Git, die CI braucht keinen Cluster-Zugang.
  • Der Runner ist der kritischste Teil der Kette, weil er fremden Code mit Zugriff auf Secrets ausführt. Isolation, keine Privilegien, Image-Allowlist und ephemere Umgebungen sind die wichtigsten Schutzmaßnahmen.
  • GitLab-Runner registrierst du heute mit einem in der Oberfläche erzeugten Runner-Authentifizierungstoken (glrt-…).
  • Kaniko baut Images ohne Docker-Daemon und ohne privilegierten Container. Den Digest des Ergebnisses sicherst du als Pipeline-Artefakt.
  • Jenkins definiert Pipelines deklarativ im Jenkinsfile. Härtung heißt dort vor allem: Controller ohne Builds, wenige Plugins, Agents als wegwerfbare Pods.
  • Argo CD gleicht den Cluster mit dem Ordner k8s/ im Repo ab, rollt Änderungen automatisch aus und dreht manuelle Änderungen per Self-Heal zurück.
  • Flux verfolgt dasselbe Ziel mit GitRepository und Kustomization und verwaltet sich nach dem Bootstrap selbst aus Git.
  • Selbstbetrieb bedeutet Verantwortung: Backups inklusive gitlab-secrets.json, regelmäßige Updates, Monitoring und nachvollziehbare Berechtigungen.