Docker Registry Private Container-Images sicher verwalten und mit K3Nova nutzen

4. September 2025 Andrej Schefer Kommentare 0 Kommentare

This article is also available in English: What is a private docker registry..?

Einführung

Container bilden das Rückgrat moderner Cloud-Infrastrukturen – egal, ob du Anwendungen, Microservices oder Datenbanken betreibst. Damit Container effizient funktionieren, müssen ihre Images an einem zentralen Ort gespeichert, versioniert und verwaltet werden.
Genau dafür gibt es Docker Registries.

Mit K3Nova, unserem interaktiven CLI-Tool, kannst du nicht nur produktionsnahe K3s-Cluster installieren, sondern auch automatisch eine eigene private Docker Registry bereitstellen, die nahtlos in deinen Cluster integriert ist.

In diesem Artikel erfährst du:

Was eine Docker Registry ist
Welche Arten von Registries es gibt
Warum eine eigene private Registry sinnvoll ist
Wie K3Nova die Einrichtung einer Private Registry automatisiert
Wie du eigene Container-Images baust, hochlädst und im Cluster nutzt

Was ist eine Docker Registry?

Eine Docker Registry ist ein zentraler Speicherort, an dem Container-Images verwaltet und verteilt werden.
Sie fungiert als „Bibliothek“ für deine Images und ermöglicht dir:

Speichern → Images werden versioniert und zentral abgelegt
Teilen → Entwickler, CI/CD-Pipelines und Cluster können darauf zugreifen
Verwalten → Zugriffsrechte, Tags und Versionen kontrollieren
Bereitstellen → Images lassen sich von jedem Host per docker pull oder containerd abrufen

Beispiele für öffentliche Registries

Diese Plattformen sind praktisch, aber in produktiven Umgebungen oft problematisch: keine volle Kontrolle, Abhängigkeit von Dritten und teilweise Limitierungen bei Geschwindigkeit und Zugriff.

Warum eine eigene private Registry sinnvoll ist

Gerade in Kubernetes-Clustern – insbesondere mit sensiblen Daten oder proprietärem Code – empfiehlt es sich, eigene Images intern zu hosten.

Vorteile einer privaten Docker Registry:

Sicherheit Du entscheidest, wer Zugriff bekommt
Geschwindigkeit Images werden direkt aus deinem lokalen Netzwerk geladen
Stabilität Keine Abhängigkeit von externen Registries
Integration Perfekt eingebunden in CI/CD-Pipelines
Kostenkontrolle Keine Rate-Limits wie bei Docker Hub

Docker Registry in K3Nova

Wenn du Container-Images in deinem Kubernetes-Cluster betreibst, brauchst du eine zentrale Lösung, um diese Images bereitzustellen.
Docker Registries ermöglichen genau das – und mit K3Nova kannst du deine eigene lokale private Registry nahtlos in deinen K3s-Cluster integrieren.

Der Vorteil:

Keine externen Abhängigkeiten
Schnellere Image-Bereitstellung
Perfekte Integration mit Traefik und Kubernetes
Zugriff über registry.local:5000 ohne zusätzliche TLS-Konfiguration

Voraussetzungen

Ein funktionierender K3s-Cluster, installiert z. B. mit K3Nova
Traefik als Ingress-Controller (wird automatisch über K3Nova integriert)
Cert-Manager (optional, nur erforderlich bei öffentlicher Nutzung mit HTTPS)
NFS Provisioner für PVC oder ein anderes Persistent Volume (PV)
k3nova-config.json mit aktiviertem lokalen Registry-Support

{
  "docker_registry": {
    "local": true,
    "url": "registry.local",
    "pvc_storage_capacity": "10Gi",
    "user": "registry",
    "pass": "123456"
  }
}

Schritt 1 – /etc/hosts konfigurieren

Damit dein lokaler Rechner registry.local auflöst, musst du einen Eintrag in der /etc/hosts-Datei setzen:

sudo tee -a /etc/hosts <<EOF
# Local Docker Registry
<IP-of-first-control-plane-node>   registry.local
EOF

Hinweis:
Ersetze <IP-of-first-control-plane-node> durch die IP-Adresse deines ersten Control-Plane-Nodes.

Schritt 2 – Insecure Registry aktivieren

Da wir die lokale Registry ohne TLS betreiben, muss Docker wissen, dass es diese Verbindung explizit erlauben soll.

Docker Desktop (macOS / Windows)

Settings → Docker Engine öffnen
Im JSON-Bereich folgendes ergänzen:

{
  /* ... existing settings ... */
  "features": {
    "buildkit": true
  },
  "insecure-registries": ["registry.local:5000"]
}

Auf Apply & Restart klicken.

Docker CLI / Linux

Unter Linux kannst du die Konfiguration direkt anpassen:

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<EOF
{
  "insecure-registries": ["registry.local:5000"]
}
EOF
sudo systemctl restart docker

Schritt 3 – Lokale Registry mit K3Nova installieren

Starte K3Nova:

k3nova

Wähle im interaktiven Menü:
📦 Install Local Docker Registry

K3Nova übernimmt automatisch:

Deployment der Registry im Cluster
Einrichtung der IngressRouteTCP über Traefik
Konfiguration des Service unter registry.local:5000
Persistente Speicherung via NFS

Schritt 4 – Registry nutzen

1. Anmelden

docker login registry.local:5000

Falls du eine Authentifizierung konfiguriert hast, gib Benutzername und Passwort an.

2. Image bauen

Angenommen, du hast ein Go-basiertes API-Projekt:

docker build -t registry.local:5000/meine-api:v1 .

3. Image pushen

docker push registry.local:5000/meine-api:v1

4. Image im Cluster verwenden

Sobald das Image in deiner lokalen Registry liegt, kannst du es direkt in Deployments oder StatefulSets nutzen:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: meine-api
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: meine-api
  template:
    metadata:
      labels:
        app: meine-api
    spec:
      containers:
        - name: meine-api
          image: registry.local:5000/meine-api:v1
          ports:
            - containerPort: 8080

Schritt 5 – Kubernetes imagePullSecrets

Falls du deine lokale Registry mit Benutzername/Passwort abgesichert hast, musst du Kubernetes die Zugangsdaten mitteilen.

1. Secret erstellen

kubectl create secret docker-registry my-private-docker-registry \
  --docker-server="http://registry.local:5000" \
  --docker-username="meinuser" \
  --docker-password="meinpasswort" \
  --namespace="default"

2. Secret im Deployment referenzieren

spec:
  imagePullSecrets:
    - name: my-private-docker-registry

Schritt 6 – Zusammenspiel mit Traefik

K3Nova integriert deine Registry nahtlos über IngressRouteTCP.
Der Datenverkehr auf registry.local:5000 wird direkt an den internen Registry-Service im Cluster weitergeleitet.
Vorteil: Kein manuelles Routing, keine zusätzlichen Load-Balancer, volle Kontrolle.

Best Practices mit Docker Registry & K3Nova

TLS verwenden → Auch wenn K3Nova HTTP unterstützt, empfiehlt sich HTTPS für produktive Umgebungen.
Versionierung nutzen → Arbeite konsequent mit Image-Tags (v1, v2, latest).
Automatisieren mit CI/CD → Nutze GitHub Actions oder GitLab CI, um Images direkt in die Registry zu pushen.
Storage überwachen → Die Registry wächst schnell; plane genug Speicher ein.
Backups einrichten → K3Nova kann NFS-Snapshots automatisieren.

Fazit

Eine eigene Docker Registry gibt dir volle Kontrolle über deine Container-Images und macht deinen Kubernetes-Workflow stabiler, schneller und sicherer.
Mit K3Nova ist die Einrichtung denkbar einfach: Ein Klick im CLI, und du hast eine vollständig integrierte, private Registry in deinem Cluster.

IGNEOS.blog

Softwareentwicklung, Softwarearchitektur und ein wenig Philosophie