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

> Laden Sie Modell und Binärdateien auf einem separaten Rechner, prüfen Sie Hashes und, wo vorhanden, Signaturen, und schreiben Sie ein SHA-256-Manifest. Im Zielnetz prüfen Sie das Manifest erneut, installieren Ollama aus dem Archiv, importieren das Modell per Modelfile und befüllen eine interne Registry.

Kanonische URL: https://www.ruebstudio.de/de/wissen/lokale-ki/modelle-air-gap-uebertragen  
Autor: Dr.-Ing. Marcus Rüb, CEO  
Veröffentlicht: 2026-11-06

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](https://www.ruebstudio.de/de/wissen/lokale-ki/air-gapped-ki-abgeschottetes-netz). Was der Begriff genau umfasst, klärt der Lexikoneintrag zum [Air-Gapped-Betrieb](https://www.ruebstudio.de/de/lexikon/air-gapped-ki). 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](https://docs.ollama.com/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](https://github.com/ollama/ollama/releases/tag/v0.40.15). Das Installationsskript lädt zur Laufzeit nach und taugt deshalb nicht für das Zielnetz.

```bash
# 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](https://huggingface.co/docs/huggingface_hub/guides/cli) 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.

```bash
# 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:

```bash
# 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](https://huggingface.co/docs/huggingface_hub/guides/manage-cache) mit den Prüfsummen auf dem Hub vergleicht. Danach kopieren Sie den geprüften Snapshot als echte Dateien (Symlinks aufgelöst) in den Transferordner:

```bash
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](https://huggingface.co/docs/hub/security-pickle). Das [safetensors-Format](https://github.com/huggingface/safetensors) 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:

```bash
# 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](https://github.com/sigstore/model-transparency) stellt dafür das Werkzeug `model_signing` bereit, das neben Sigstore auch öffentliche Schlüssel unterstützt:

```bash
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.

```bash
# 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:

```yaml
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](https://docs.docker.com/reference/cli/docker/image/save/) auch auf eine Plattform eingeschränkt:

```bash
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](https://github.com/containers/skopeo) zeigt:

```bash
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.

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

Ollama installieren Sie aus dem Archiv. Die [Linux-Doku](https://docs.ollama.com/linux) entpackt nach `/usr` und empfiehlt bei einem Update, vorher `/usr/lib/ollama` zu entfernen:

```bash
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](https://docs.ollama.com/import) zeigt `FROM` entweder auf eine GGUF-Datei oder auf einen Ordner mit safetensors-Gewichten; GGUF wird beim Import nicht quantisiert.

```bash
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](https://distribution.github.io/distribution/about/deploying/) beschrieben:

```bash
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.

```bash
# 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](https://huggingface.co/docs/huggingface_hub/package_reference/environment_variables) 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](https://www.ruebstudio.de/de/wissen/lokale-ki/lokale-ki-betrieb) beschreibt, und auf die Wahl des Inferenz-Servers, die der [Überblick über Ollama, vLLM und llama.cpp](https://www.ruebstudio.de/de/wissen/lokale-ki/llm-inferenz-server-ueberblick) vergleicht.

Wie Datenhaltung, Modellauswahl und Betrieb ohne Cloud-Anbieter zusammenpassen, beschreibt die Seite zu [souveräner KI im eigenen Betrieb](https://www.ruebstudio.de/de/souveraene-ki). Für die Architekturentscheidung davor, also welche Hardware, welche Modellklasse und welches Betriebsmodell, ist der Pillar-Artikel zu [Air-Gapped KI](https://www.ruebstudio.de/de/wissen/lokale-ki/air-gapped-ki-abgeschottetes-netz) 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

- [Ollama: Linux-Installation (manuelle Installation)](https://docs.ollama.com/linux)
- [Ollama: Modelle importieren (GGUF und Safetensors)](https://docs.ollama.com/import)
- [Ollama FAQ: Speicherort der Modelle, OLLAMA_MODELS](https://docs.ollama.com/faq)
- [Ollama Release v0.40.15 mit sha256sum.txt](https://github.com/ollama/ollama/releases/tag/v0.40.15)
- [Hugging Face: hf CLI, hf download](https://huggingface.co/docs/huggingface_hub/guides/cli)
- [Hugging Face: Cache verstehen, hf cache verify](https://huggingface.co/docs/huggingface_hub/guides/manage-cache)
- [Hugging Face: Umgebungsvariablen, HF_HUB_OFFLINE](https://huggingface.co/docs/huggingface_hub/package_reference/environment_variables)
- [Hugging Face: Pickle Scanning und Risiken von Pickle](https://huggingface.co/docs/hub/security-pickle)
- [safetensors: Format und Sicherheitseigenschaften](https://github.com/huggingface/safetensors)
- [sigstore/model-transparency: Model Signing](https://github.com/sigstore/model-transparency)
- [Docker: docker image save](https://docs.docker.com/reference/cli/docker/image/save/)
- [skopeo: Images ohne Daemon kopieren und synchronisieren](https://github.com/containers/skopeo)
- [CNCF Distribution: eine Registry betreiben](https://distribution.github.io/distribution/about/deploying/)
