Zum Inhalt springen

Modelle in ein Air-Gap-Netz bringen: Download, Prüfung, Schleuse

Ein Netz ohne Internetverbindung schützt Ihre Daten, aber jedes Modell, jedes Binary und jedes Container-Image muss irgendwann hinein. Genau an dieser Stelle entstehen die Risiken: manipulierte Gewichte, Pickle-Dateien mit eingebettetem Code, unvollständige Kopien und Dateien, deren Herkunft später niemand mehr belegen kann. Diese Anleitung zeigt einen reproduzierbaren Ablauf von der Quelle bis zum laufenden Modell im Zielnetz.

Was bauen wir und was steht am Ende?

Am Ende steht ein dokumentierter Transferweg: Ein Download-Rechner mit Internet holt Ollama, ein Modell und Container-Images, prüft sie und schreibt ein Prüfsummen-Manifest. Ein Datenträger bringt das Paket durch die Schleuse. Im abgeschotteten Netz wird erneut geprüft, eingespielt und ein Protokoll abgelegt, das jede Datei einer Quelle zuordnet.

Den Gesamtrahmen, also Architektur, Hardware und Betriebsmodell für Sprachmodelle ohne Netzanbindung, beschreibt der Überblick zu Air-Gapped KI in vollständig abgeschotteten Netzen. Was der Begriff genau umfasst, klärt der Lexikoneintrag zum Air-Gapped-Betrieb. Hier geht es nur um den Transfer selbst. Konkret entsteht:

  • ein Ollama-Server, installiert aus dem offiziellen Archiv statt per Installationsskript,
  • ein Modell im GGUF- oder safetensors-Format, importiert per Modelfile,
  • eine interne Container-Registry mit den Images, die Ihre Anwendung braucht,
  • ein Schleusenprotokoll mit Hashes, Quellen und Revisionen.

Welche Voraussetzungen und Versionen brauchen Sie?

Sie brauchen zwei Linux-Rechner: einen Download-Rechner mit Internet und einen Zielserver im abgeschotteten Netz, dazu einen freigegebenen Datenträger. Die Befehle wurden gegen die Dokumentation mit Stand November 2026 geprüft: Ollama v0.40.15, huggingface_hub 2.4.0 mit dem CLI hf, skopeo 1.24.1 und das Registry-Image registry:3.

Auf dem Download-Rechner:

  • Python 3 mit pip install huggingface_hub (stellt den Befehl hf bereit),
  • sha256sum aus den GNU coreutils,
  • Docker oder skopeo zum Exportieren von Images,
  • optional pip install model-signing für Signaturprüfungen.

Auf dem Zielserver:

  • tar mit zstd-Unterstützung, sha256sum,
  • Docker oder eine andere OCI-fähige Laufzeit für die interne Registry,
  • ausreichend Speicher: Modelle liegen unter Linux standardmäßig in /usr/share/ollama/.ollama/models, laut Ollama-FAQ per OLLAMA_MODELS änderbar.

Halten Sie außerdem fest, wer den Transfer freigibt. Ohne benannte Verantwortliche wird die Schleuse zum Dateiablageplatz.

Schritt 1: Modell und Binärdateien auf dem Download-Rechner beziehen

Laden Sie nur Artefakte mit fester Version: das Ollama-Archiv eines bestimmten Releases und das Modell zu einer festgehaltenen Commit-Revision. „Neueste Version" ist im Air-Gap kein brauchbarer Zustand, weil Sie später nicht nachvollziehen können, was genau übertragen wurde.

Ollama veröffentlicht für jedes Release Linux-Archive und eine Datei sha256sum.txt, zum Beispiel auf der Release-Seite von v0.40.15. Das Installationsskript lädt zur Laufzeit nach und taugt deshalb nicht für das Zielnetz.

# Arbeitsverzeichnis für genau einen Transfer
mkdir -p transfer-2026-11 && cd transfer-2026-11
VER=v0.40.15
BASE=https://github.com/ollama/ollama/releases/download/$VER
curl -fLO "$BASE/ollama-linux-amd64.tar.zst"
curl -fLO "$BASE/sha256sum.txt"

Für das Modell nutzen Sie hf download mit --revision. Laut CLI-Doku akzeptiert --revision einen Commit-Hash, einen Branch oder einen Tag; nehmen Sie den Commit-Hash, denn nur er ist unveränderlich. Mit --include und --exclude lassen sich Dateien zusätzlich per Muster filtern.

# REPO und REV selbst festlegen: Repository-Name und Commit-Hash
REPO="<organisation>/<modell>"
REV="<commit-hash>"
hf download "$REPO" --revision "$REV"

Für Ollama genügt oft eine einzelne GGUF-Datei. Für Transformers-basierte Server nehmen Sie den Ordner mit safetensors-Dateien und Konfiguration.

Schritt 2: Herkunft und Integrität prüfen

Zwei Fragen sind getrennt zu beantworten: Ist die Datei unverändert angekommen, und stammt sie von dem Herausgeber, dem Sie vertrauen? Prüfsummen beantworten die erste Frage, Signaturen oder eine belegte Bezugsquelle die zweite. Zusätzlich schließen Sie Formate aus, die beim Laden Code ausführen können.

Zuerst das Ollama-Archiv gegen die veröffentlichte Prüfsumme:

# nur die Zeile des geladenen Archivs prüfen
grep ' ollama-linux-amd64.tar.zst$' sha256sum.txt | sha256sum -c -

Für Modelle im Hugging-Face-Cache gibt es hf cache verify, das die lokalen Dateien laut Cache-Doku mit den Prüfsummen auf dem Hub vergleicht. Danach kopieren Sie den geprüften Snapshot als echte Dateien (Symlinks aufgelöst) in den Transferordner:

hf cache verify "$REPO" --revision "$REV"
SNAP=$(ls -d ~/.cache/huggingface/hub/models--*/snapshots/"$REV")
cp -rL "$SNAP" ./model

Zum Format: Pickle-basierte Gewichte (.bin, .pt, .pkl) können beim Laden beliebigen Code ausführen; Hugging Face erklärt den Mechanismus ausführlich in der Seite zu Pickle Scanning. Das safetensors-Format besteht dagegen aus einem 8-Byte-Längenfeld, einem JSON-Header und einem Datenpuffer. Legen Sie als Regel fest: Ins Zielnetz gehen nur safetensors oder GGUF. Pickle-Dateien entfernen Sie vor dem Manifest:

# Pickle-Formate aus dem Transferordner aussortieren
find ./model -type f \( -name "*.bin" -o -name "*.pt" -o -name "*.pth" -o -name "*.pkl" \) -print -delete

Signaturen prüfen Sie dort, wo der Herausgeber signiert. Das Projekt sigstore/model-transparency stellt dafür das Werkzeug model_signing bereit, das neben Sigstore auch öffentliche Schlüssel unterstützt:

model_signing verify key ./model --signature model.sig --public-key publisher.pub

Viele öffentliche Modelle sind nicht signiert. Dann halten Sie im Protokoll fest, dass nur die Integrität gegen den Hub geprüft wurde, und verweisen auf Repository und Commit.

Schritt 3: Prüfsummen-Manifest erzeugen und Paket schnüren

Das Manifest ist das zentrale Dokument der Schleuse: eine Liste aller Dateien mit SHA-256-Hash, erzeugt nach der Prüfung und vor dem Kopieren. Im Zielnetz wird genau diese Liste erneut geprüft. Weicht eine Zeile ab oder fehlt eine Datei, geht das Paket zurück.

# Manifest über alle Dateien des Transfers (ohne das Manifest selbst)
find . -type f ! -name MANIFEST.sha256 -print0 \
  | sort -z | xargs -0 sha256sum > MANIFEST.sha256
wc -l MANIFEST.sha256

Ergänzen Sie eine kurze Begleitdatei, die ein Mensch lesen kann. In unserem eigenen Betrieb hat sich ein schlichtes Textformat bewährt:

transfer: 2026-11-06-01
freigabe: Name der freigebenden Person
artefakte:
  - datei: ollama-linux-amd64.tar.zst
    quelle: https://github.com/ollama/ollama/releases/tag/v0.40.15
    pruefung: sha256sum.txt des Releases
  - datei: model/
    quelle: Hugging Face, Repository und Commit-Hash
    pruefung: hf cache verify, Format safetensors
    signatur: keine veröffentlicht

Danach kopieren Sie den Ordner auf den Datenträger. Signieren Sie das Manifest zusätzlich mit einem internen Schlüssel, wenn Ihre Organisation dafür bereits eine Infrastruktur hat.

Schritt 4: Container-Images für die Schleuse vorbereiten

Images exportieren Sie als Archiv und laden sie im Zielnetz in eine interne Registry. So ziehen alle Server ihre Images aus einer Quelle, statt dass Archive auf einzelnen Rechnern verteilt werden. Zwei Wege funktionieren: docker image save oder skopeo, das ohne laufenden Daemon und meist ohne Root auskommt.

Mit Docker, laut Doku zu docker image save auch auf eine Plattform eingeschränkt:

docker pull registry:3
docker image save --platform=linux/amd64 -o registry-3.tar registry:3

Mit skopeo lassen sich ganze Repositories in ein Verzeichnis synchronisieren, wie es die skopeo-README zeigt:

skopeo sync --src docker --dest dir registry.example.com/busybox /media/usb

Nehmen Sie das Registry-Image selbst mit in den ersten Transfer, sonst fehlt im Zielnetz der Ort, an dem die übrigen Images landen. Danach das Manifest aus Schritt 3 neu erzeugen, damit die Archive enthalten sind.

Schritt 5: Im abgeschotteten Netz prüfen und einspielen

Im Zielnetz läuft der Ablauf rückwärts: erst das Manifest prüfen, dann installieren. Wird nur eine einzige Abweichung gemeldet, spielen Sie nichts ein. Erst wenn alle Zeilen OK melden, folgen Ollama, Modellimport und Registry.

cd /mnt/transfer-2026-11
sha256sum -c --quiet MANIFEST.sha256 && echo "Manifest OK"

Ollama installieren Sie aus dem Archiv. Die Linux-Doku entpackt nach /usr und empfiehlt bei einem Update, vorher /usr/lib/ollama zu entfernen:

sudo rm -rf /usr/lib/ollama          # nur bei Update
sudo tar --zstd -x -C /usr -f ollama-linux-amd64.tar.zst
ollama -v

Das Modell importieren Sie per Modelfile. Laut Import-Doku zeigt FROM entweder auf eine GGUF-Datei oder auf einen Ordner mit safetensors-Gewichten; GGUF wird beim Import nicht quantisiert.

cat > Modelfile <<'EOF'
FROM ./model/modell.gguf
EOF
ollama create firmen-modell -f Modelfile
ollama list

Die Registry starten Sie aus dem mitgebrachten Image und befüllen sie, wie in der Distribution-Doku beschrieben:

docker load -i registry-3.tar
docker run -d -p 5000:5000 --restart=always --name registry \
  -v /srv/registry:/var/lib/registry registry:3
docker tag mein-image:1.0 localhost:5000/mein-image:1.0
docker push localhost:5000/mein-image:1.0

Soll die Registry von anderen Servern erreichbar sein, braucht sie TLS; die Distribution-Doku nennt Zugriff ohne geprüftes Zertifikat ausdrücklich „for testing only".

Testen: Läuft wirklich alles ohne Internet?

Ein Transfer gilt erst als abgeschlossen, wenn das Modell antwortet und keine Komponente versucht, nach außen zu verbinden. Testen Sie deshalb nicht nur die Funktion, sondern auch das Netzverhalten. Hugging-Face-Bibliotheken zwingen Sie mit HF_HUB_OFFLINE=1 in den reinen Cache-Betrieb.

# Antwort des importierten Modells
ollama run firmen-modell "Antworten Sie mit genau einem Wort: bereit"

# Hugging-Face-Werkzeuge nur aus dem Cache
export HF_HUB_OFFLINE=1

Laut Hugging-Face-Doku macht huggingface_hub mit dieser Variable keine HTTP-Aufrufe mehr und meldet einen Fehler, wenn eine Datei im Cache fehlt. Das ist gewollt: Ein fehlender Tokenizer fällt sofort auf, statt dass ein Prozess minutenlang auf eine Zeitüberschreitung wartet. Prüfen Sie zusätzlich in den Firewall-Protokollen, dass keine ausgehenden Verbindungsversuche auftauchen.

Betrieb, Sicherheit und Grenzen

Der Ablauf schützt vor beschädigten und vertauschten Dateien sowie vor Code in Pickle-Gewichten. Er schützt nicht vor einem Modell, das schon an der Quelle problematisch ist, etwa durch manipulierte Trainingsdaten. Dagegen helfen nur eine bewusste Auswahl der Herausgeber und eigene Tests mit Ihren Aufgaben vor der Freigabe.

Weitere Punkte für den laufenden Betrieb:

  • Updates sind neue Transfers. Jede neue Ollama-Version und jedes neue Modell läuft durch dieselben Schritte, mit eigenem Manifest.
  • Rechte im Zielsystem. Ein abweichendes Modellverzeichnis muss laut Ollama-FAQ für den Benutzer ollama les- und schreibbar sein.
  • Bindung des Servers. Ollama lauscht standardmäßig nur auf 127.0.0.1:11434; wer es für andere Rechner öffnet, braucht davor Authentifizierung.
  • Aufbewahrung. Manifest, Begleitdatei und Prüfausgaben gehören in ein Archiv, das unabhängig vom Server erhalten bleibt.

Wann der Ansatz nicht passt: Wenn Modelle wöchentlich wechseln oder Dutzende Teams eigene Varianten brauchen, wird die manuelle Schleuse zum Engpass. Dann lohnt eine Datendiode oder ein automatisierter Spiegel mit festgelegten Prüfregeln.

Nächste Schritte

Ist der erste Transfer durch, machen Sie daraus eine Routine: ein Skript für die Schritte 1 bis 3, eine feste Ablage für Manifeste und eine Freigaberegel, wer welche Quellen zulassen darf.

Danach lohnt der Blick auf den laufenden Betrieb mit Updates und Monitoring, den der Artikel zu lokaler KI im Dauerbetrieb beschreibt, und auf die Wahl des Inferenz-Servers, die der Überblick über Ollama, vLLM und llama.cpp vergleicht.

Wie Datenhaltung, Modellauswahl und Betrieb ohne Cloud-Anbieter zusammenpassen, beschreibt die Seite zu souveräner KI im eigenen Betrieb. Für die Architekturentscheidung davor, also welche Hardware, welche Modellklasse und welches Betriebsmodell, ist der Pillar-Artikel zu Air-Gapped KI der passende Einstieg; dieser Artikel ergänzt ihn um den konkreten Weg der Dateien durch die Schleuse.

Häufige Fragen

Kann ich Ollama ohne Internet installieren?

Ja. Laden Sie das Linux-Archiv samt sha256sum.txt von der GitHub-Release-Seite auf einem verbundenen Rechner, prüfen Sie die Prüfsumme und entpacken Sie das Archiv im Zielnetz nach /usr. Modelle importieren Sie dort per Modelfile statt mit ollama pull.

Warum safetensors statt .bin oder .pt?

Pickle-basierte Gewichtsdateien können beim Laden beliebigen Python-Code ausführen. Das safetensors-Format besteht nur aus einem JSON-Header und Rohdaten und führt beim Laden keinen Code aus.

Reicht ein SHA-256-Hash als Nachweis?

Ein Hash belegt, dass die Datei auf dem Weg nicht verändert wurde. Er belegt nicht, wer sie erstellt hat; dafür braucht es eine Signatur des Herausgebers oder eine nachvollziehbare Bezugsquelle mit festgehaltener Commit-Revision.

Wie halte ich Hugging-Face-Bibliotheken im Zielnetz offline?

Setzen Sie HF_HUB_OFFLINE=1. Dann macht huggingface_hub keine HTTP-Aufrufe und liest nur aus dem lokalen Cache; fehlt eine Datei, gibt es einen Fehler statt eines stillen Downloadversuchs.

Quellen

  1. Ollama: Linux-Installation (manuelle Installation) docs.ollama.com
  2. Ollama: Modelle importieren (GGUF und Safetensors) docs.ollama.com
  3. Ollama FAQ: Speicherort der Modelle, OLLAMA_MODELS docs.ollama.com
  4. Ollama Release v0.40.15 mit sha256sum.txt github.com
  5. Hugging Face: hf CLI, hf download huggingface.co
  6. Hugging Face: Cache verstehen, hf cache verify huggingface.co
  7. Hugging Face: Umgebungsvariablen, HF_HUB_OFFLINE huggingface.co
  8. Hugging Face: Pickle Scanning und Risiken von Pickle huggingface.co
  9. safetensors: Format und Sicherheitseigenschaften github.com
  10. sigstore/model-transparency: Model Signing github.com
  11. Docker: docker image save docs.docker.com
  12. skopeo: Images ohne Daemon kopieren und synchronisieren github.com
  13. CNCF Distribution: eine Registry betreiben distribution.github.io