Kapitel 3: Gespiegelte Bezugsquellen als einziger Bezugsweg (Harbor, Nexus, Artifactory)
In diesem Kapitel lernst du:
- den Unterschied zwischen Proxy-Cache, kuratiertem Spiegel und Offline-Spiegel
- wie du „einziger Bezugsweg” technisch durchsetzt: Client-Konfiguration, Egress-Sperre, Policy
- wie du mit der Nexus-REST-API Spiegel für Container-Images, PyPI, Debian-Pakete und npm anlegst
- wie du die
demo-appso baust, dass sie ausschließlich über den Spiegel bezieht, und das mit einem gesperrten Netz beweist- wie Proxy-Cache-Projekte und Replikation in Harbor und Remote-/Virtual-Repositories in Artifactory funktionieren
Worum geht es?
Denk an eine Krankenhausapotheke. Die Stationen bestellen nicht selbst bei irgendeinem Großhändler im Internet. Alles läuft über die Apotheke. Die Apotheke kennt ihre Lieferanten, prüft die Ware, lagert sie und gibt sie an die Stationen aus. Kommt ein Rückruf, weiß sie sofort, welche Station welche Charge bekommen hat. Und weil die Stationen gar keinen anderen Bezugsweg haben, kann auch niemand „mal eben schnell” etwas Ungeprüftes bestellen.
Ein Spiegel (Mirror) für Softwarepakete ist diese Apotheke. Statt dass jeder Build direkt bei Docker Hub, PyPI, npm oder Debian bestellt, holen alle Builds ihre Zutaten aus einem zentralen Repository-Manager wie Nexus, Harbor oder Artifactory. Der Spiegel lädt beim ersten Mal aus dem Internet nach, speichert eine Kopie und liefert sie ab dann selbst aus.
Das allein ist Komfort. Sicherheit wird daraus erst durch den zweiten Teil der Überschrift: einziger Bezugsweg. Die Build-Umgebung darf das Internet gar nicht erreichen, nur den Spiegel. Dann ist der Spiegel der einzige Ort, an dem du kontrollieren, protokollieren und sperren musst.
VORHER: jeder holt selbst NACHHER: einziger Bezugsweg
+-------+ +----------------+ +-------+ +------------+
| Build |-->| Docker Hub | | Build |--+ | Docker Hub |
| |-->| PyPI | +-------+ | +-------+ | PyPI |
| |-->| deb.debian.org | +->|Spiegel|>| Debian |
| |-->| npm, curl ... | +-------+ | Nexus | | npm |
+-------+ +----------------+ | Build |---->| | +------------+
+-------+ +-------+
Kontrolle: keine | nur der Spiegel darf
Protokoll: verteilt X ins Internet
Sperren: unmöglich | Firewall: direkter Weg
v ins Internet gesperrt
Internet
Die Konzepte in einfach
Drei Arten von Spiegeln
Nicht jeder Spiegel ist gleich. Die drei Grundformen unterscheiden sich darin, wann und wie geprüft wird.
| Art | Wie er funktioniert | Stärke | Schwäche |
|---|---|---|---|
| Proxy/Cache | lädt bei Bedarf nach, speichert | bequem, sofort nutzbar | lässt alles durch |
| Kuratierter Spiegel | nur freigegebene Pakete | volle Kontrolle | Pflegeaufwand |
| Offline-Spiegel | Kopie ohne Internetverbindung | air-gapped möglich | Aktualität, Transport |
Proxy/Cache (Pull-Through-Cache). Der Spiegel ist
ein Zwischenhändler. Fragt ein Build nach flask==3.0.3,
schaut der Spiegel in seinem Lager nach. Ist das Paket da, liefert er
es. Wenn nicht, holt er es vom Original, speichert es und liefert dann.
Vorteile: Du hast ein zentrales Protokoll, schnellere Builds und
Unabhängigkeit von Ausfällen oder Rate-Limits beim Original. Gelöschte
oder manipulierte Upstream-Versionen erreichen dich nicht mehr, sobald
du sie einmal im Cache hast. Nachteil: Ohne weitere Regeln lässt ein
Proxy jedes Paket durch, auch ein brandneues Schadpaket.
Kuratierter Spiegel. Nur Pakete, die jemand freigegeben hat, sind verfügbar. Das kann manuell geschehen (Antrag und Prüfung) oder regelbasiert: „nur Pakete, die älter als 14 Tage sind, keine kritische Schwachstelle haben und eine erlaubte Lizenz tragen”. Kommerzielle Produkte wie Sonatype Repository Firewall oder JFrog Curation automatisieren das. Mit Bordmitteln baust du es aus einem Proxy plus einem internen (hosted) Repository und einem Freigabeprozess.
Offline-Spiegel. In einer Umgebung ohne Internet
(air-gapped) gibt es keinen Upstream. Pakete werden außerhalb gesammelt,
geprüft und über eine kontrollierte Übergabe (Datenträger, Datendiode)
eingespielt. Werkzeuge dafür sind zum Beispiel skopeo sync
oder Harbor-Replikation für Images, pip download für
Python-Pakete und aptly oder apt-mirror für
Debian. Wie die Übergabe sicher abläuft, zeigt Kapitel 4.
Merke: In der Praxis kombiniert man die Formen. Typisch: ein Proxy in der Build-Zone mit Regeln, dahinter ein kuratiertes Repository für Produktion und für hochsensible Netze ein Offline-Spiegel.
Repository-Typen: proxy, hosted, group
Nexus und Artifactory kennen dieselben drei Bausteine, nur heißen sie leicht anders.
| Nexus | Artifactory | Zweck |
|---|---|---|
| proxy | remote | spiegelt eine externe Quelle |
| hosted | local | eigene, intern gebaute Pakete |
| group | virtual | bündelt mehrere Repos unter einer URL |
Ein Group-Repository ist praktisch: Die Clients kennen nur eine URL,
dahinter liegen interne und gespiegelte Pakete. Genau hier lauert aber
eine Falle, die Dependency Confusion (Verwechslung von Abhängigkeiten).
Gibt es ein internes Paket firma-utils in Version 1.2 und
lädt ein Angreifer ein gleichnamiges Paket in Version 99.0 auf PyPI
hoch, nimmt der Client womöglich die höhere Version aus dem Proxy.
Sicherheit: Gegenmaßnahmen gegen Dependency Confusion: interne Paketnamen mit eindeutigem Präfix oder Scope (
@firma/...bei npm), interne Namen öffentlich reservieren, im Spiegel Routing- oder Ausschlussregeln für interne Namen auf dem Proxy setzen. Und niemalspip install --extra-index-urlverwenden, denn pip behandelt alle Indizes gleichrangig.
„Einziger Bezugsweg” durchsetzen
Ein Spiegel, den man umgehen kann, ist eine Empfehlung, keine Kontrolle. Durchsetzen ist eine Sache mehrerer Schichten:
| Schicht | Maßnahme | Erzwingt? |
|---|---|---|
| 1. Client-Konfiguration | pip.conf, .npmrc, apt-Quellen,
Registry-Mirror |
nein, nur bequem |
| 2. Netzwerk | Egress-Sperre, Firewall, NetworkPolicy | ja |
| 3. Admission | nur Images aus erlaubter Registry (Kapitel 9) | ja, im Cluster |
| 4. Prüfung | Linter sucht fremde URLs im Build | erkennt Abweichungen |
| 5. Monitoring | Alarm bei geblockten Verbindungen | macht sichtbar |
Schicht 1 sorgt dafür, dass der normale Weg der richtige ist. Entwickler sollen nicht kämpfen müssen. Schicht 2 ist der eigentliche Zwang. Build-Hosts und Runner-Pods dürfen nur den Spiegel und wenige interne Dienste erreichen (DNS, Git-Server). Alles andere wird an der Firewall oder per Kubernetes-NetworkPolicy verworfen. Wichtig: Der Spiegel selbst braucht natürlich Zugriff nach außen, aber nur auf die Upstream-Adressen, die du konfiguriert hast.
Für Kubernetes-Runner sieht eine Egress-Sperre so aus (Adressen sind Beispiele):
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: build-egress-nur-spiegel
namespace: ci-runner
spec:
podSelector: {}
policyTypes: ["Egress"]
egress:
- to:
- ipBlock:
cidr: 10.20.30.40/32 # Nexus
ports:
- { protocol: TCP, port: 8081 }
- { protocol: TCP, port: 8082 }
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- { protocol: UDP, port: 53 }
- { protocol: TCP, port: 53 }Sobald eine NetworkPolicy mit Egress einen Pod auswählt,
ist für diesen Pod jeder ausgehende Verkehr verboten, der nicht
ausdrücklich erlaubt ist. Voraussetzung: Das Netzwerk-Plugin (CNI) des
Clusters setzt NetworkPolicies auch um, zum Beispiel Calico oder
Cilium.
Schicht 3 greift beim Deployment. Eine Kyverno- oder
OPA-Regel lehnt jeden Pod ab, dessen Image nicht mit
nexus.intern:8082/ oder harbor.intern/
beginnt. Das baust du in Kapitel 9.
Was alles gespiegelt werden muss
Ein typischer Container-Build bezieht aus drei Welten:
- Container-Images: Basisimages wie
python:3.12-slim. Clients: Docker, containerd, Podman, BuildKit. - Betriebssystem-Pakete:
apt-get installbei Debian/Ubuntu,dnf installbei RHEL/Fedora. Die Paketlisten sind mit GPG signiert, der Spiegel reicht die Signaturen unverändert durch. - Sprachpakete: PyPI (pip), npm, Maven Central, Go-Module, NuGet, crates.io.
Die Client-Konfiguration auf einen Blick:
| Ökosystem | Konfiguration | Beispielwert |
|---|---|---|
| pip | /etc/pip.conf oder PIP_INDEX_URL |
index-url = https://nexus.intern/repository/pypi-proxy/simple |
| npm | .npmrc |
registry=https://nexus.intern/repository/npm-proxy/ |
| apt | /etc/apt/sources.list.d/*.sources |
URIs: https://nexus.intern/repository/debian-bookworm/ |
| dnf | /etc/yum.repos.d/*.repo |
baseurl=https://nexus.intern/repository/rocky-baseos/ |
Für Maven trägst du in der settings.xml einen Mirror für
alle Repositories ein:
<settings>
<mirrors>
<mirror>
<id>nexus</id>
<mirrorOf>*</mirrorOf>
<url>https://nexus.intern/repository/maven-public/</url>
</mirror>
</mirrors>
</settings>Für Container-Images gibt es zwei Wege. Entweder schreibst du den
Spiegel direkt in die Image-Referenz
(nexus.intern:8082/library/python:3.12-slim). Oder du
konfigurierst die Container-Runtime so, dass sie Anfragen an
docker.io auf den Spiegel umlenkt. Bei containerd geschieht
das über hosts.toml:
# /etc/containerd/certs.d/docker.io/hosts.toml
server = "https://registry-1.docker.io"
[host."https://nexus.intern:8082"]
capabilities = ["pull", "resolve"]Achtung: containerd fällt auf den
server-Eintrag zurück, wenn der Spiegel nicht antwortet. Ohne Egress-Sperre ist die Umlenkung also kein Zwang. Bei Docker gilt die Optionregistry-mirrorsin derdaemon.jsonaußerdem nur für Images von Docker Hub, nicht fürghcr.iooderquay.io.
Merke: Der Digest eines Images ändert sich durch einen Spiegel nicht.
python:3.12-slim@sha256:abc…ist über Docker Hub und über Nexus derselbe Inhalt. Digest-Pinning aus Kapitel 2 und Spiegel ergänzen sich also perfekt.
Harbor: Proxy-Cache-Projekte und Replikation
Harbor ist eine CNCF-Registry speziell für OCI-Artefakte (Images, Helm-Charts, Signaturen, SBOMs). Für Sprachpakete ist Harbor nicht gedacht. Für Images bringt es zwei passende Funktionen mit.
Proxy-Cache-Projekt. Du legst einen
Registry-Endpunkt an (zum Beispiel Docker Hub) und ein Projekt, das als
Proxy-Cache für diesen Endpunkt dient. Clients ziehen dann über
harbor.intern/<projekt>/<image>. Über die
Harbor-API (v2.0) sieht das verkürzt so aus:
# 1. Registry-Endpunkt für Docker Hub anlegen
curl -s -u "admin:${HARBOR_PW}" -H 'Content-Type: application/json' \
-X POST https://harbor.intern/api/v2.0/registries -d '{
"name": "dockerhub",
"type": "docker-hub",
"url": "https://hub.docker.com",
"credential": {"type": "basic", "access_key": "hubuser",
"access_secret": "<Token aus Vault>"}
}'
# 2. Proxy-Cache-Projekt anlegen (registry_id aus GET /api/v2.0/registries)
curl -s -u "admin:${HARBOR_PW}" -H 'Content-Type: application/json' \
-X POST https://harbor.intern/api/v2.0/projects -d '{
"project_name": "dockerhub-proxy",
"registry_id": 1,
"metadata": {"public": "false"}
}'
# 3. Nutzen
docker pull harbor.intern/dockerhub-proxy/library/python:3.12-slimBei offiziellen Docker-Hub-Images gehört library/ in den
Pfad. In ein Proxy-Cache-Projekt kann niemand pushen, es ist reiner
Lesezugriff auf den Upstream.
Replikation. Harbor kann Artefakte regelbasiert zwischen Registries kopieren, per Push (von Harbor weg) oder Pull (zu Harbor hin), zeitgesteuert, ereignisgesteuert oder manuell. So verteilst du freigegebene Basisimages von einer zentralen Harbor-Instanz in die Standorte oder in eine Zielzone. Eine Regel per API, verkürzt:
{
"name": "basisimages-in-zielzone",
"dest_registry": { "id": 3 },
"dest_namespace": "basis",
"filters": [
{ "type": "name", "value": "basis/**" },
{ "type": "tag", "value": "v*" }
],
"trigger": {
"type": "scheduled",
"trigger_settings": { "cron": "0 0 2 * * *" }
},
"override": true,
"enabled": true
}Die Regel wird per POST /api/v2.0/replication/policies
angelegt. Ohne src_registry ist die lokale Harbor-Instanz
die Quelle (Push-Replikation). Harbor nutzt ein Cron-Format mit sechs
Feldern, das erste Feld sind Sekunden. Diese Regel läuft also täglich um
02:00 Uhr. Für die Übergabe über Zonengrenzen ist Replikation allein zu
wenig, weil Prüfung und Freigabe fehlen. Das ergänzt Kapitel 4.
Artifactory: Remote- und Virtual-Repositories
JFrog Artifactory ist ein kommerzieller Repository-Manager mit sehr breiter Formatunterstützung. Das Modell entspricht Nexus:
- Remote Repository: Proxy für eine externe Quelle,
zum Beispiel
pypi-remoteaufhttps://files.pythonhosted.org. - Local Repository: eigene Artefakte, zum Beispiel
docker-localfür gebaute Images. - Virtual Repository: bündelt Local und Remote unter
einem Namen, zum Beispiel
pypiauspypi-localundpypi-remote. Die Reihenfolge der Auflösung ist konfigurierbar.
Die Client-URLs folgen einem festen Schema:
pip: https://art.intern/artifactory/api/pypi/pypi/simple
npm: https://art.intern/artifactory/api/npm/npm/
Docker: art.intern/docker/python:3.12-slim (je nach Docker-Zugriffsmethode)
Für Automatisierung gibt es die JFrog-CLI jf und die
REST-API. Die Prinzipien „einziger Bezugsweg” und „Egress-Sperre” gelten
genauso.
Hands-on-Lab: Nexus als einziger Bezugsweg
Du startest Nexus Repository, legst per REST-API vier
Proxy-Repositories an und baust die demo-app so, dass sie
alles über Nexus bezieht. Zum Schluss sperrst du das Internet für den
Build-Container und beweist, dass es trotzdem funktioniert.
Voraussetzungen aus Kapitel 0: Docker läuft mit mindestens 8 GB RAM,
~/seclab/demo-app existiert, curl,
jq und crane sind installiert.
Host (localhost)
+-------------------------------------------------------------+
| Docker-Netz "bridge" (mit Internet) |
| +---------------------------+ |
| | nexus :8081 (UI, PyPI, |----> Docker Hub, PyPI, |
| | apt, npm) | deb.debian.org, npm |
| | :8082 (Docker) | |
| +---------------------------+ |
| | |
| Docker-Netz "seclab-intern" (--internal, KEIN Internet) |
| +------------------+ |
| | Build-Container |---- nur http://nexus:8081 ------> |
| +------------------+ |
+-------------------------------------------------------------+
Schritt 1: Arbeitsverzeichnis und internes Netz anlegen
mkdir -p ~/seclab/kap03
cd ~/seclab/kap03
cp -r ~/seclab/demo-app demo-app
docker network create --internal seclab-intern
docker network inspect seclab-intern -f '{{.Internal}}'Erwartete Ausgabe (die erste Zeile ist die ID des neuen Netzes):
3f9c1a...
true
--internal bedeutet: Container in diesem Netz können
sich gegenseitig erreichen, aber nicht nach außen. Das ist unsere
Simulation der Firewall vor den Build-Hosts.
Schritt 2: Nexus starten
docker run -d --name nexus \
-p 8081:8081 -p 8082:8082 \
-v nexus-data:/nexus-data \
-e INSTALL4J_ADD_VM_PARAMS="-Xms1g -Xmx1g -XX:MaxDirectMemorySize=1g" \
sonatype/nexus3
docker network connect seclab-intern nexusNexus hängt jetzt in zwei Netzen: im Standardnetz bridge
mit Internet (für den Upstream) und in seclab-intern (für
die Builds). Port 8081 ist UI und REST-API sowie der Zugang für PyPI,
apt und npm. Port 8082 reservieren wir für den Docker-Proxy, denn
Docker-Clients erwarten eine Registry an der Wurzel eines Hosts und
Ports.
Der Start dauert ein bis drei Minuten. Warte, bis die Status-API antwortet:
NEXUS=http://localhost:8081
until [ "$(curl -s -o /dev/null -w '%{http_code}' \
"$NEXUS/service/rest/v1/status")" = "200" ]; do
echo "warte auf Nexus ..."; sleep 10
done
echo "Nexus ist bereit"Erwartete Ausgabe:
warte auf Nexus ...
warte auf Nexus ...
Nexus ist bereit
Tipp: Die Heap-Einstellung über
INSTALL4J_ADD_VM_PARAMShält Nexus im Lab bei rund 2 GB Speicherbedarf. In Produktion gibt Sonatype deutlich mehr vor. Seit Version 3.77 heißt die freie Variante „Community Edition” und hat Nutzungsgrenzen, für das Lab spielen die keine Rolle.
Schritt 3: Admin-Passwort holen und ändern
Beim ersten Start erzeugt Nexus ein zufälliges Admin-Passwort in einer Datei:
INITIAL_PW=$(docker exec nexus cat /nexus-data/admin.password)
echo "$INITIAL_PW"Erwartete Ausgabe: eine UUID, zum Beispiel
5c1d8a3e-....
Ändere es per API auf ein Lab-Passwort:
NEXUS_PW='lab-nexus-123' # Lab-Wert, niemals in Produktion
curl -s -o /dev/null -w '%{http_code}\n' -u "admin:${INITIAL_PW}" \
-X PUT -H 'Content-Type: text/plain' --data "${NEXUS_PW}" \
"$NEXUS/service/rest/v1/security/users/admin/change-password"Erwartete Ausgabe:
204
204 No Content heißt Erfolg. Ab jetzt nutzen wir eine
kleine Hilfsfunktion, damit die Befehle kurz bleiben:
nx() { curl -s -u "admin:${NEXUS_PW}" -H 'Content-Type: application/json' "$@"; }
nx "$NEXUS/service/rest/v1/security/users?userId=admin" | jq -r '.[0].userId'Erwartete Ausgabe:
admin
Achtung: Neuere Nexus-Versionen (Community Edition) verlangen beim ersten Login die Zustimmung zur Lizenz (EULA). Melde dich dafür einmal in der UI unter
http://localhost:8081alsadminan und folge dem Assistenten. Wähle dort „Enable anonymous access”, das brauchen wir im nächsten Schritt. Ältere Versionen fragen nicht nach einer EULA.
Schritt 4: Anonymen Lesezugriff und Docker-Realm aktivieren
Damit Build-Clients ohne Login lesen können, aktivieren wir den anonymen Zugriff. Für anonyme Docker-Pulls braucht Nexus zusätzlich den „Docker Bearer Token Realm”:
nx -X PUT "$NEXUS/service/rest/v1/security/anonymous" \
-d '{"enabled": true, "userId": "anonymous",
"realmName": "NexusAuthorizingRealm"}' | jq '.enabled'
REALMS=$(nx "$NEXUS/service/rest/v1/security/realms/active" \
| jq -c '. + ["DockerToken"] | unique')
nx -o /dev/null -w '%{http_code}\n' -X PUT \
"$NEXUS/service/rest/v1/security/realms/active" -d "$REALMS"
nx "$NEXUS/service/rest/v1/security/realms/active"Erwartete Ausgabe:
true
204
["DockerToken","NexusAuthenticatingRealm"]
Die genaue Liste der Realms kann je nach Version abweichen. Wichtig
ist, dass DockerToken enthalten ist.
Sicherheit: Anonymes Lesen ist im Lab bequem. In Produktion vergibst du für jede Pipeline einen eigenen technischen Benutzer mit Leserechten oder nutzt Tokens. Dann siehst du im Protokoll, welche Pipeline welches Paket geholt hat.
Schritt 5: Docker-Proxy auf Docker Hub anlegen
Lege die Konfiguration als JSON-Datei an:
cat > docker-hub.json <<'EOF'
{
"name": "docker-hub",
"online": true,
"storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
"proxy": {
"remoteUrl": "https://registry-1.docker.io",
"contentMaxAge": 1440,
"metadataMaxAge": 1440
},
"negativeCache": { "enabled": true, "timeToLive": 1440 },
"httpClient": { "blocked": false, "autoBlock": true },
"docker": { "v1Enabled": false, "forceBasicAuth": false, "httpPort": 8082 },
"dockerProxy": { "indexType": "HUB" }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @docker-hub.json \
"$NEXUS/service/rest/v1/repositories/docker/proxy"Erwartete Ausgabe:
201
Die wichtigsten Felder:
remoteUrl: der Upstream, hier die Registry-API von Docker Hub.contentMaxAge/metadataMaxAge: Minuten, die Inhalte und Metadaten (etwa die Zuordnung Tag zu Digest) als frisch gelten.docker.httpPort: 8082: Nexus öffnet einen eigenen HTTP-Connector auf Port 8082 für dieses Repository.forceBasicAuth: false: erlaubt anonyme Pulls über den Token-Realm aus Schritt 4.indexType: HUB: Suche und Index laufen gegen Docker Hub.
Jetzt der Test. Docker erlaubt HTTP-Registries auf
localhost ohne Zusatzkonfiguration:
docker pull localhost:8082/library/python:3.12-slim
crane digest localhost:8082/library/python:3.12-slim
crane digest python:3.12-slimErwartete Ausgabe (gekürzt):
3.12-slim: Pulling from library/python
...
Status: Downloaded newer image for localhost:8082/library/python:3.12-slim
localhost:8082/library/python:3.12-slim
sha256:4a3f...
sha256:4a3f...
Beide Digests sind identisch. Der Spiegel liefert bitgleich dasselbe Image wie Docker Hub.
Tipp: Docker Hub begrenzt anonyme Pulls pro IP-Adresse. Weil jetzt nur noch Nexus bei Docker Hub anfragt und alles cached, sinkt die Zahl der Pulls drastisch. In Produktion hinterlegst du zusätzlich ein Docker-Hub-Konto im Proxy unter
httpClient.authentication.
Schritt 6: PyPI-Proxy anlegen
cat > pypi-proxy.json <<'EOF'
{
"name": "pypi-proxy",
"online": true,
"storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
"proxy": {
"remoteUrl": "https://pypi.org",
"contentMaxAge": 1440,
"metadataMaxAge": 1440
},
"negativeCache": { "enabled": true, "timeToLive": 1440 },
"httpClient": { "blocked": false, "autoBlock": true }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @pypi-proxy.json \
"$NEXUS/service/rest/v1/repositories/pypi/proxy"
curl -s "$NEXUS/repository/pypi-proxy/simple/flask/" \
| grep -o 'flask-3.0.3[^<"#]*' | sort -uErwartete Ausgabe:
201
flask-3.0.3-py3-none-any.whl
flask-3.0.3.tar.gz
Die Seite /simple/flask/ ist der „Simple Repository
Index” nach PEP 503, genau das, was pip abfragt. Nexus schreibt die
Download-Links darin so um, dass sie auf Nexus selbst zeigen und nicht
auf files.pythonhosted.org.
Schritt 7: APT-Proxy für Debian bookworm anlegen
cat > apt-proxy.json <<'EOF'
{
"name": "debian-bookworm",
"online": true,
"storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
"proxy": {
"remoteUrl": "http://deb.debian.org/debian/",
"contentMaxAge": 1440,
"metadataMaxAge": 1440
},
"negativeCache": { "enabled": true, "timeToLive": 1440 },
"httpClient": { "blocked": false, "autoBlock": true },
"apt": { "distribution": "bookworm", "flat": false }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @apt-proxy.json \
"$NEXUS/service/rest/v1/repositories/apt/proxy"Erwartete Ausgabe:
201
Jetzt testen wir aus dem internen Netz heraus. Debian-Images
ab bookworm nutzen das deb822-Format unter
/etc/apt/sources.list.d/debian.sources. Wir ersetzen diese
Datei durch eine, die auf Nexus zeigt:
cat > nexus.sources <<'EOF'
Types: deb
URIs: http://nexus:8081/repository/debian-bookworm/
Suites: bookworm
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg
EOF
docker pull localhost:8082/library/debian:bookworm-slim
docker run --rm --network seclab-intern \
-v "$PWD/nexus.sources:/etc/apt/sources.list.d/debian.sources:ro" \
localhost:8082/library/debian:bookworm-slim \
bash -c 'apt-get update && apt-get install -y --no-install-recommends jq \
&& jq --version'Erwartete Ausgabe (gekürzt):
Get:1 http://nexus:8081/repository/debian-bookworm bookworm InRelease [151 kB]
Get:2 http://nexus:8081/repository/debian-bookworm bookworm/main amd64 Packages ...
...
Setting up jq (1.6-2.1) ...
jq-1.6
Beachte zwei Dinge. Erstens: Der Container steht im internen Netz
ohne Internet, trotzdem klappt die Installation. Zweitens:
Signed-By zeigt auf den Debian-Schlüsselbund im Image. apt
prüft die Signatur der Paketlisten weiterhin gegen den Debian-Schlüssel.
Ein manipulierter Spiegel könnte keine gefälschten Pakete unterschieben,
ohne dass apt abbricht.
Merke: Sicherheitsupdates kommen bei Debian aus einem eigenen Archiv (
security.debian.org, Suitebookworm-security). Dafür legst du in der Praxis ein zweites APT-Proxy-Repository an. Das ist Teil der Übung.
Schritt 8: npm-Proxy anlegen
cat > npm-proxy.json <<'EOF'
{
"name": "npm-proxy",
"online": true,
"storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
"proxy": {
"remoteUrl": "https://registry.npmjs.org",
"contentMaxAge": 1440,
"metadataMaxAge": 1440
},
"negativeCache": { "enabled": true, "timeToLive": 1440 },
"httpClient": { "blocked": false, "autoBlock": true }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @npm-proxy.json \
"$NEXUS/service/rest/v1/repositories/npm/proxy"
curl -s "$NEXUS/repository/npm-proxy/lodash" | jq -r '."dist-tags".latest'Erwartete Ausgabe:
201
4.17.21
Die Versionsnummer kann bei dir höher sein. Ein npm-Client nutzt den
Proxy mit einer Zeile in der .npmrc des Projekts:
registry=http://localhost:8081/repository/npm-proxy/Prüfe zum Schluss, welche Repositories jetzt existieren:
nx "$NEXUS/service/rest/v1/repositories" \
| jq -r '.[] | select(.type=="proxy") | "\(.format)\t\(.name)"'Erwartete Ausgabe (Auszug, Nexus bringt zusätzlich eigene
Standard-Repositories wie maven-central mit):
docker docker-hub
pypi pypi-proxy
apt debian-bookworm
npm npm-proxy
maven2 maven-central
Schritt 9: Gegenprobe – ohne Spiegel geht nichts
Jetzt beweisen wir, dass das interne Netz wirklich gesperrt ist. Ein Build-Container versucht, direkt von PyPI zu laden:
docker run --rm --network seclab-intern \
localhost:8082/library/python:3.12-slim \
pip download --no-deps --retries 0 --timeout 5 -d /tmp flask==3.0.3Erwartete Ausgabe (gekürzt, Fehlermeldung je nach Docker-Version):
WARNING: ... Failed to establish a new connection: [Errno -3] Temporary
failure in name resolution ...
ERROR: Could not find a version that satisfies the requirement flask==3.0.3
(from versions: none)
ERROR: No matching distribution found for flask==3.0.3
Statt des Namensauflösungsfehlers kann auch
[Errno 101] Network is unreachable erscheinen. Beides
heißt: Kein Weg ins Internet.
Jetzt derselbe Container mit Spiegel. Lege dazu eine
pip.conf an:
cat > pip.conf <<'EOF'
[global]
index-url = http://nexus:8081/repository/pypi-proxy/simple
trusted-host = nexus
EOF
docker run --rm --network seclab-intern \
-v "$PWD/pip.conf:/etc/pip.conf:ro" \
localhost:8082/library/python:3.12-slim \
pip download --no-deps -d /tmp flask==3.0.3Erwartete Ausgabe:
Looking in indexes: http://nexus:8081/repository/pypi-proxy/simple
Collecting flask==3.0.3
Downloading http://nexus:8081/repository/pypi-proxy/packages/flask/3.0.3/...
Saved /tmp/flask-3.0.3-py3-none-any.whl
Successfully downloaded flask
pip liest /etc/pip.conf als systemweite Konfiguration.
trusted-host ist nötig, weil wir im Lab HTTP statt HTTPS
nutzen. In Produktion steht Nexus hinter TLS mit einem Zertifikat deiner
eigenen PKI, dann entfällt trusted-host.
Schritt 10: Abhängigkeiten der demo-app über den Spiegel holen
Jetzt der echte Build-Schritt. Der Build-Container im internen Netz
lädt alle Abhängigkeiten der demo-app als Wheels in ein
Verzeichnis. Er läuft mit deiner UID, damit die Dateien dir gehören:
cd ~/seclab/kap03/demo-app
cp ../pip.conf .
docker run --rm --network seclab-intern \
--user "$(id -u):$(id -g)" -e HOME=/tmp \
-v "$PWD/pip.conf:/etc/pip.conf:ro" -v "$PWD":/w -w /w \
localhost:8082/library/python:3.12-slim \
pip download --only-binary=:all: -r requirements.txt -d wheels
ls wheelsErwartete Ausgabe (Versionen der transitiven Pakete können abweichen):
blinker-1.8.2-py3-none-any.whl
certifi-2024.8.30-py3-none-any.whl
chardet-4.0.0-py2.py3-none-any.whl
click-8.1.7-py3-none-any.whl
flask-3.0.3-py3-none-any.whl
gunicorn-22.0.0-py3-none-any.whl
idna-2.10-py2.py3-none-any.whl
itsdangerous-2.2.0-py3-none-any.whl
jinja2-3.1.4-py3-none-any.whl
markupsafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64....whl
packaging-24.1-py3-none-any.whl
requests-2.25.0-py2.py3-none-any.whl
urllib3-1.26.20-py2.py3-none-any.whl
werkzeug-3.0.4-py3-none-any.whl
--only-binary=:all: verhindert, dass pip Quellpakete
lädt, die beim Installieren Code ausführen könnten. Hast du in Kapitel 2
ein requirements.lock mit Hashes erzeugt, kannst du es hier
statt requirements.txt verwenden. Die Hashes stimmen, weil
Nexus die Dateien unverändert ausliefert.
Schritt 11: Das Image hermetisch bauen
Jetzt bauen wir das Image ohne jeden Netzzugang. Das Basisimage kommt
aus dem Spiegel, die Pakete aus dem Verzeichnis wheels:
cat > Dockerfile.mirror <<'EOF'
# syntax=docker/dockerfile:1
ARG BASE_IMAGE=localhost:8082/library/python:3.12-slim
FROM ${BASE_IMAGE} AS build
WORKDIR /build
COPY requirements.txt .
COPY wheels/ /wheels/
RUN pip install --no-cache-dir --no-index --find-links=/wheels \
--prefix=/install -r requirements.txt
FROM ${BASE_IMAGE}
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
COPY --from=build /install /usr/local
WORKDIR /app
COPY app.py .
USER 10001:10001
EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]
EOF
docker build --network=none -f Dockerfile.mirror \
-t localhost:5001/demo-app:1.0.0-mirror .Erwartete Ausgabe (letzte Zeilen):
=> [build 5/5] RUN pip install --no-cache-dir --no-index --find-links=/wheels ...
...
=> => naming to localhost:5001/demo-app:1.0.0-mirror
Was hier passiert:
--network=nonenimmt allenRUN-Schritten das Netz weg. Der Build ist damit hermetisch: Er kann nichts nachladen, was nicht vorher im Build-Kontext lag.--no-index --find-links=/wheelszwingt pip, nur aus dem lokalen Verzeichnis zu installieren.- Das Basisimage löst der Docker-Daemon auf, nicht der
RUN-Schritt. Es kommt überlocalhost:8082aus Nexus. - Die globale
ARG BASE_IMAGEvor dem erstenFROMgilt in beidenFROM-Zeilen. In Produktion übergibst du hier per--build-argden Spiegel deiner Organisation, idealerweise mit Digest.
Achtung: Falls die
.dockerignoreaus Kapitel 0 das Verzeichniswheels/ausschließt, schlägtCOPY wheels/fehl. Prüfe das mitcat .dockerignore.
Starte das Image zur Kontrolle und schiebe es in die Build-Registry:
docker run -d --rm --name demo-mirror -p 18001:8000 \
localhost:5001/demo-app:1.0.0-mirror
sleep 2 && curl -s http://localhost:18001/ && docker stop demo-mirror
docker push localhost:5001/demo-app:1.0.0-mirror
crane digest localhost:5001/demo-app:1.0.0-mirrorErwartete Ausgabe:
{"status":"ok"}
demo-mirror
...
sha256:b81f...
Schritt 12: Nachweis im Spiegel prüfen
Der Spiegel weiß jetzt genau, was deine Builds bezogen haben. Das ist die Grundlage für Audit und Schwachstellen-Reaktion:
nx "$NEXUS/service/rest/v1/components?repository=pypi-proxy" \
| jq -r '.items[] | "\(.name) \(.version)"' | sort
nx "$NEXUS/service/rest/v1/components?repository=docker-hub" \
| jq -r '.items[] | "\(.name):\(.version)"'Erwartete Ausgabe (Auszug):
flask 3.0.3
gunicorn 22.0.0
requests 2.25.0
urllib3 1.26.20
...
library/debian:bookworm-slim
library/python:3.12-slim
Die API liefert pro Aufruf eine Seite. Bei vielen Komponenten enthält
die Antwort ein Feld continuationToken, das du für die
nächste Seite als Parameter anhängst.
Stell dir vor, morgen wird eine kritische Lücke in
urllib3 1.26.20 bekannt. Mit dieser Liste weißt du sofort,
ob deine Builds die Version je bezogen haben. Zusammen mit SBOMs
(Kapitel 7) siehst du auch, in welchen Images sie steckt.
Schritt 13: Aufräumen
docker stop nexus
docker network disconnect seclab-intern nexus
docker network rm seclab-intern
docker image rm localhost:8082/library/debian:bookworm-slimDas Volume nexus-data bleibt erhalten. Mit
docker start nexus hast du den Spiegel samt Cache wieder.
Wenn du komplett neu anfangen willst:
docker rm nexus && docker volume rm nexus-data.
Fortschritt speichern? Kostenlos registrieren
Typische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
curl auf Status liefert 000 |
Nexus startet noch | 1–3 Minuten warten, docker logs nexus prüfen |
401 Unauthorized bei docker pull |
Docker-Realm fehlt oder forceBasicAuth |
DockerToken aktivieren,
forceBasicAuth: false |
http: server gave HTTP response to HTTPS client |
Registry nicht auf localhost |
insecure-registries setzen oder TLS nutzen |
400 beim Anlegen eines Repos |
Pflichtfeld im JSON fehlt oder Name belegt | Antworttext lesen, -w weglassen |
| Port 8082 antwortet nicht | httpPort nicht gesetzt oder Port nicht gemappt |
-p 8082:8082 und docker.httpPort
prüfen |
pip: not a trusted or secure host |
HTTP ohne trusted-host |
trusted-host setzen oder HTTPS nutzen |
apt: NO_PUBKEY oder not signed |
falscher Signed-By-Pfad |
Pfad zum Debian-Keyring prüfen |
| Proxy liefert plötzlich nichts mehr | autoBlock nach Upstream-Fehlern |
Status in der UI prüfen, Upstream-Erreichbarkeit testen |
Übung: Den Spiegel erweitern
Deine Organisation braucht zwei weitere Bezugsquellen:
- Debian-Sicherheitsupdates für bookworm als eigenes
APT-Proxy-Repository
debian-security. - Maven Central als eigenes Proxy-Repository
maven-proxy.
Lege beide per REST-API an. Prüfe die Sicherheitsupdates mit einem
apt-get update im internen Netz und Maven mit einem
curl auf eine POM-Datei, zum Beispiel
org/apache/commons/commons-lang3/3.14.0/commons-lang3-3.14.0.pom.
Hinweis 1: Die Debian-Sicherheitsupdates liegen
unter http://security.debian.org/debian-security/, die
Suite heißt bookworm-security. In der deb822-Datei kannst
du mehrere Abschnitte untereinander schreiben, getrennt durch eine
Leerzeile.
Hinweis 2: Der Endpunkt für Maven ist
/service/rest/v1/repositories/maven/proxy.
Maven-Repositories brauchen zusätzlich einen Block "maven"
mit versionPolicy (zum Beispiel RELEASE) und
layoutPolicy (zum Beispiel STRICT).
Lösung
APT-Proxy für die Sicherheitsupdates:
cat > apt-security.json <<'EOF'
{
"name": "debian-security",
"online": true,
"storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
"proxy": {
"remoteUrl": "http://security.debian.org/debian-security/",
"contentMaxAge": 1440,
"metadataMaxAge": 1440
},
"negativeCache": { "enabled": true, "timeToLive": 1440 },
"httpClient": { "blocked": false, "autoBlock": true },
"apt": { "distribution": "bookworm-security", "flat": false }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @apt-security.json \
"$NEXUS/service/rest/v1/repositories/apt/proxy"Die Quellen-Datei mit zwei Abschnitten:
Types: deb
URIs: http://nexus:8081/repository/debian-bookworm/
Suites: bookworm
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg
Types: deb
URIs: http://nexus:8081/repository/debian-security/
Suites: bookworm-security
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg
Nach apt-get update im internen Netz erscheinen Zeilen
mit debian-security bookworm-security InRelease.
Maven-Proxy:
cat > maven-proxy.json <<'EOF'
{
"name": "maven-proxy",
"online": true,
"storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
"proxy": {
"remoteUrl": "https://repo1.maven.org/maven2/",
"contentMaxAge": -1,
"metadataMaxAge": 1440
},
"negativeCache": { "enabled": true, "timeToLive": 1440 },
"httpClient": { "blocked": false, "autoBlock": true },
"maven": { "versionPolicy": "RELEASE", "layoutPolicy": "STRICT" }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @maven-proxy.json \
"$NEXUS/service/rest/v1/repositories/maven/proxy"
POM=org/apache/commons/commons-lang3/3.14.0/commons-lang3-3.14.0.pom
curl -s -o /dev/null -w '%{http_code}\n' "$NEXUS/repository/maven-proxy/$POM"Erwartet: zweimal 201, dann 200.
contentMaxAge: -1 bedeutet „nie neu prüfen”. Das ist für
Maven-Releases richtig, denn ein veröffentlichtes Release darf sich nie
ändern. Warum ein eigener Name? Nexus bringt bereits ein Repository
maven-central mit. In Produktion entfernst du nicht
genutzte Standard-Repositories, damit niemand versehentlich daran vorbei
bezieht.
Fortschritt speichern? Kostenlos registrieren
Aus der Praxis
Architektur in regulierten Umgebungen. In Behörden und KRITIS-Unternehmen steht der Spiegel typischerweise in einer DMZ oder einer eigenen „Bezugszone”. Nur er darf über einen Forward-Proxy mit Allowlist ins Internet, und zwar ausschließlich zu den konfigurierten Upstreams. Die Build-Zone erreicht nur den Spiegel. Die Produktionszone erreicht nur eine zweite, kuratierte Registry, die über eine kontrollierte Übergabe befüllt wird (Kapitel 4). In air-gapped Netzen gibt es gar keinen Upstream, dort wird der Spiegel über Datenträger oder eine Datendiode aktualisiert.
Kuratierung mit Bordmitteln. Ohne kommerzielle Firewall-Produkte arbeiten viele Organisationen mit zwei Stufen. Ein Proxy in der Build-Zone ist für Entwickler offen und wird kontinuierlich gescannt. Ein hosted Repository für Produktion enthält nur Pakete und Images, die einen Freigabeprozess durchlaufen haben: Scan, Lizenzprüfung, ggf. Mindestalter. Nexus OSS bietet zusätzlich Routing Rules, mit denen du Pfade per regulärem Ausdruck erlauben oder sperren kannst, etwa um interne Paketnamen auf dem PyPI-Proxy zu blockieren.
Betrieb. Ein Spiegel wird zur kritischen Abhängigkeit. Fällt er aus, baut niemand mehr. Plane deshalb Hochverfügbarkeit oder zumindest schnelles Wiederherstellen, Backups des Blob-Stores und der Datenbank, Speicherüberwachung und Bereinigungsregeln (Cleanup Policies) für alte Inhalte. Nexus und Harbor stellen Metriken im Prometheus-Format bereit, die du in dein Monitoring übernimmst.
Monitoring der Durchsetzung. Der Beweis, dass der Spiegel wirklich der einzige Bezugsweg ist, kommt aus der Firewall. Werte geblockte Egress-Verbindungen von Build-Hosts aus und alarmiere darauf. Ein Anstieg zeigt dir ein Team, das versucht, am Spiegel vorbei zu bauen, oft unabsichtlich, weil ein Werkzeug eine eigene Download-URL eingebaut hat. Diese Fälle behandelst du mit den Teams, nicht gegen sie (Kapitel 10).
Zugangsdaten. Der Spiegel braucht eigene Zugangsdaten für die Upstreams, etwa ein Docker-Hub-Konto, und die Pipelines brauchen Lesezugänge zum Spiegel. Diese Daten gehören in ein Secrets-Management und werden regelmäßig rotiert (Kapitel 6). Pro Pipeline ein eigener technischer Benutzer macht das Zugriffsprotokoll aussagekräftig.
Audit. Prüfer wollen typischerweise drei Dinge sehen: eine Liste der erlaubten Upstreams mit Begründung, den technischen Nachweis der Egress-Sperre (Firewall-Regeln, NetworkPolicies) und Protokolle, welche Komponenten wann bezogen wurden. Halte die Repository-Konfiguration als Code fest, zum Beispiel als JSON-Dateien wie in diesem Lab in Git oder mit dem Terraform-Provider für Nexus oder Harbor. Dann ist jede Änderung am Bezugsweg ein nachvollziehbarer Merge Request.
Interviewfragen
F: Was ist der Unterschied zwischen einem Proxy-Cache und einem kuratierten Spiegel?
A: Ein Proxy-Cache lädt jedes angefragte Paket bei Bedarf vom Upstream und speichert es. Er bringt Protokoll, Geschwindigkeit und Unabhängigkeit, lässt aber alles durch. Ein kuratierter Spiegel enthält nur freigegebene Pakete, manuell oder regelbasiert geprüft. Er gibt mehr Kontrolle, kostet aber Pflegeaufwand.
F: Wie stellst du sicher, dass der Spiegel wirklich der einzige Bezugsweg ist?
A: Mit mehreren Schichten. Client-Konfiguration macht den richtigen Weg bequem. Durchgesetzt wird über Netzwerk: Egress-Sperre an der Firewall oder per NetworkPolicy, nur der Spiegel darf ins Internet. Im Cluster zusätzlich eine Admission-Policy, die nur Images aus der eigenen Registry zulässt. Und Monitoring der geblockten Verbindungen.
F: Was ist Dependency Confusion und wie schützt du dich?
A: Ein Angreifer veröffentlicht ein öffentliches
Paket mit dem Namen eines internen Pakets und einer höheren Version.
Clients, die mehrere Indizes gleichrangig nutzen, nehmen die höhere
Version. Schutz: kein --extra-index-url, interne Namen mit
Scope oder Präfix, Namen öffentlich reservieren, im Spiegel interne
Namen auf dem Proxy blockieren.
F: Verändert ein Spiegel den Digest eines Images?
A: Nein. Der Digest ist der Hash des Manifests. Ein Spiegel liefert Manifest und Layer unverändert aus, deshalb funktionieren Digest-Pinning und Signaturprüfung auch über den Spiegel.
F: Warum kann ein kompromittierter APT-Spiegel nicht einfach Pakete austauschen?
A: Die Paketlisten sind vom Debian-Archiv signiert,
und die Listen enthalten die Hashes aller Pakete. apt prüft die Signatur
gegen den lokalen Schlüsselbund. Ein Spiegel kann höchstens alte,
korrekt signierte Stände ausliefern oder Updates zurückhalten. Dagegen
helfen die Valid-Until-Felder in den Release-Dateien und
Monitoring.
F: Wie funktioniert ein Proxy-Cache-Projekt in Harbor?
A: Man legt einen Registry-Endpunkt an, etwa Docker
Hub, und ein Projekt mit Bezug auf diesen Endpunkt. Clients ziehen über
harbor/<projekt>/<image>. Harbor holt fehlende
Images vom Upstream und cached sie. Pushen in das Projekt ist nicht
möglich.
F: Was ist ein hermetischer Build und wie hängt er mit dem Spiegel zusammen?
A: Ein hermetischer Build hat während der Ausführung
keinen Netzzugang. Alle Eingaben werden vorher deklariert und
bereitgestellt. Der Spiegel ist die kontrollierte Quelle, aus der diese
Eingaben in einem vorgelagerten Schritt geholt werden, zum Beispiel per
pip download. Der eigentliche Build läuft dann mit
--network=none.
Zusammenfassung
Das hast du gelernt:
- Ein Spiegel ist die Apotheke deiner Lieferkette: zentral beziehen, speichern, protokollieren, sperren können.
- Proxy-Cache, kuratierter Spiegel und Offline-Spiegel ergänzen sich. Die Wahl hängt von Zone und Schutzbedarf ab.
- „Einziger Bezugsweg” entsteht erst durch eine Egress-Sperre. Client-Konfiguration allein ist nur eine Empfehlung.
- Mit der Nexus-REST-API hast du Proxys für Docker Hub, PyPI, Debian und npm angelegt, als nachvollziehbaren Code in JSON-Dateien.
- Ein Container im
--internal-Netz konnte PyPI nicht erreichen, über Nexus aber problemlos installieren. Der eigentliche Image-Build lief mit--network=nonehermetisch. - Digests und Signaturen bleiben über den Spiegel gültig. Digest-Pinning, apt-Signaturen und pip-Hashes funktionieren weiter.
- Harbor bietet Proxy-Cache-Projekte und regelbasierte Replikation für OCI-Artefakte, Artifactory bildet dasselbe Modell mit Remote-, Local- und Virtual-Repositories ab.