docs: add SGLang, Fluent Bit, Helm, Dapr, Camel, Pulsar integration guides

content/de/developer/integration/ai/meta.json

@@ -3,6 +3,7 @@
   "pages": [
     "mlflow",
     "ray",
+    "sglang",
     "vllm"
   ]
 }

content/de/developer/integration/ai/sglang.md

@@ -0,0 +1,144 @@
+---
+title: "SGLang"
+description: "LLM-Inferenz mit SGLang betreiben, das Modellgewichte direkt aus einem RustFS-Bucket streamt."
+---
+
+In dieser Anleitung verbinden Sie [SGLang](https://github.com/sgl-project/sglang) — das Serving-Framework für große Sprach- und multimodale Modelle — mit **RustFS** als Speicher für die Modellgewichte. Sie laden ein Modell in einen RustFS-Bucket hoch, richten SGLang auf die `s3://`-URI und bedienen OpenAI-kompatible Anfragen, während die Gewichte direkt aus dem Bucket gestreamt werden. Der Ablauf wurde mit `lmsysorg/sglang:v0.5.22-xeon` (SGLang 0.5.22, CPU-Engine) verifiziert, das `Qwen/Qwen2.5-0.5B-Instruct` aus einem RustFS-Bucket auf einem Nur-CPU-Host ausliefert.
+
+Sie benötigen Docker und ein kleines Hugging-Face-Modell. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb.
+
+## Architektur
+
+```mermaid
+flowchart LR
+	Upload["aws s3 cp"] -->|"weights"| RustFS["RustFS :9000"]
+	RustFS -->|"s3:// runai streamer"| SGLang["SGLang :30000"]
+	Client["OpenAI SDK / curl"] -->|"completions"| SGLang
+```
+
+Wenn `--model-path` eine Objektspeicher-URI ist, wechselt SGLang automatisch zum Ladeformat `runai_streamer`: Die Metadatendateien (`config.json`, Tokenizer) werden einmal in den lokalen Cache geladen, danach streamen die Gewichtstensoren verzögert während das Engine lädt. Der Bucket bleibt die einzige Kopie des Modells, Serving-Hosts brauchen keinen lokalen Modellspeicher.
+
+:::note[Das CPU-Image enthält keinen S3-Streamer]
+
+Das `xeon`-CPU-Image enthält kein `runai-model-streamer-s3`; der Serverstart mit einem `s3://`-Modellpfad schlägt mit `ImportError: S3 files module not found` fehl. Installieren Sie das Paket vor dem Start im Container — die virtuelle Umgebung des Images wird mit `uv` verwaltet und hat kein `pip`-Modul.
+
+:::
+
+## 1. Modell nach RustFS hochladen
+
+Laden Sie die Modelldateien von Hugging Face und kopieren Sie sie in den Bucket. Ersetzen Sie alle Verbindungsplatzhalter:
+
+```bash
+docker run --rm -v "$PWD/models:/models" --entrypoint python3 \
+  lmsysorg/sglang:v0.5.22-xeon -c \
+  'from huggingface_hub import snapshot_download; snapshot_download("Qwen/Qwen2.5-0.5B-Instruct", local_dir="/models/qwen2.5-0.5b-instruct")'
+
+aws s3 cp models/qwen2.5-0.5b-instruct \
+  s3://my-bucket/sglang-models/qwen2.5-0.5b-instruct --recursive \
+  --endpoint-url http://<your-rustfs-endpoint>:9000 \
+  --acl private
+```
+
+Exportieren Sie die Zugangsdaten für die folgenden Befehle:
+
+```bash
+export AWS_ACCESS_KEY_ID=<your-access-key>
+export AWS_SECRET_ACCESS_KEY=<your-secret-key>
+export AWS_DEFAULT_REGION=us-east-1
+```
+
+Verwenden Sie ein Präfix pro Modell, sodass mehrere Modelle denselben Bucket teilen. Der Streamer liest Gewichtsdateien ausschließlich im Format `.safetensors`.
+
+## 2. SGLang gegen den Bucket starten
+
+Starten Sie das CPU-Image, installieren Sie das S3-Streamer-Paket und starten Sie den Server mit der Bucket-URI:
+
+```bash
+docker run -d --name sglang -p 30000:30000 \
+  -e AWS_ACCESS_KEY_ID \
+  -e AWS_SECRET_ACCESS_KEY \
+  -e AWS_DEFAULT_REGION \
+  -e AWS_ENDPOINT_URL=http://<your-rustfs-endpoint>:9000 \
+  --entrypoint bash lmsysorg/sglang:v0.5.22-xeon -c \
+  'uv pip install -q runai-model-streamer-s3 && \
+   python3 -m sglang.launch_server \
+     --model-path s3://my-bucket/sglang-models/qwen2.5-0.5b-instruct \
+     --served-model-name qwen2.5-0.5b-instruct \
+     --host 0.0.0.0 --port 30000 \
+     --device cpu --trust-remote-code \
+     --disable-overlap-schedule \
+     --mem-fraction-static 0.45'
+```
+
+`AWS_ENDPOINT_URL` richtet den Streamer auf RustFS; Anfragen an den eigenen Endpunkt verwenden Path-Style-Adressierung. `--mem-fraction-static` bestimmt den KV-Cache-Anteil am Hostspeicher auf dem CPU-Backend — erhöhen Sie den Wert auf Hosts mit mehr freiem RAM. Warten Sie auf die Startzeile:
+
+```bash
+docker logs -f sglang
+```
+
+```text
+The server is fired up and ready to roll!
+```
+
+## 3. Inferenz ausführen
+
+Prüfen Sie, dass das Modell bereitgestellt wird, und senden Sie eine OpenAI-kompatible Completion-Anfrage:
+
+```bash
+curl -s http://localhost:30000/v1/models
+```
+
+```json
+{"object":"list","data":[{"id":"qwen2.5-0.5b-instruct","object":"model","owned_by":"sglang","root":"qwen2.5-0.5b-instruct","max_model_len":32768}]}
+```
+
+```bash
+curl -s http://localhost:30000/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{"model":"qwen2.5-0.5b-instruct","prompt":"RustFS is","max_tokens":16,"temperature":0}'
+```
+
+```json
+{"object":"text_completion","model":"qwen2.5-0.5b-instruct","choices":[{"index":0,"text":" a file system for the Linux kernel that is designed to be used in embedded systems","finish_reason":"length"}],"usage":{"prompt_tokens":4,"total_tokens":20,"completion_tokens":16}}
+```
+
+![SGLang-Modellgewichte in der RustFS-Konsole](./images/rustfs-sglang-models.png)
+
+## 4. Anhalten oder Zurücksetzen
+
+Demo abreißen und die Bucket-Objekte behalten:
+
+```bash
+docker rm -f sglang
+```
+
+Gespeichertes Modell löschen:
+
+```bash
+aws s3 rm s3://my-bucket/sglang-models --recursive \
+  --endpoint-url http://<your-rustfs-endpoint>:9000
+```
+
+## Fehlerbehebung
+
+### `ImportError: S3 files module not found`
+
+Das S3-Backend des RunAI-Streamers fehlt. Führen Sie wie in Schritt 2 gezeigt `uv pip install runai-model-streamer-s3` im Container aus, bevor Sie den Server starten.
+
+### `pip: command not found` oder `No module named pip`
+
+Das `/opt/.venv` des Images wurde von `uv` ohne `pip` erstellt. Verwenden Sie `uv pip install` statt `pip install`.
+
+### `Loaded weights leave no GPU memory for the KV cache`
+
+`--mem-fraction-static` ist für die geladenen Gewichte auf diesem Host zu klein. Die Fehlermeldung nennt den minimal machbaren Wert — starten Sie den Server mit einem größeren Anteil neu (zum Beispiel `0.45` auf einem 16-GB-Host für ein 0,5-B-Modell).
+
+### Anfragen schlagen mit Signatur- oder Zugriffsfehlern fehl
+
+Stellen Sie sicher, dass im Server-Container alle vier Variablen gesetzt sind: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_DEFAULT_REGION` und `AWS_ENDPOINT_URL` einschließlich des Schemas.
+
+## Nächste Schritte
+
+- Lesen Sie vor weiteren Serving-Operationen die [S3-Kompatibilitätshinweise](/administration/protocols/s3).
+- Erstellen Sie dedizierte Produktionszugangsdaten mit [Zugangsdatenverwaltung](/security-compliance/iam/access-token).
+- Folgen Sie der [SGLang-Dokumentation](https://docs.sglang.io/) für Tensorparallelität, Quantisierung und größere Modelle auf demselben bucket-gestützten Modelllager.

content/de/developer/integration/big-data/meta.json

@@ -14,6 +14,7 @@
     "pyiceberg",
     "spark",
     "seatunnel",
-    "zeppelin"
+    "zeppelin",
+    "pulsar"
   ]
 }

content/de/developer/integration/big-data/pulsar.md

@@ -0,0 +1,170 @@
+---
+title: "Apache Pulsar"
+description: "Kalten Pulsar-Topic-Backlog aus BookKeeper mit Tiered Storage in einen RustFS-Bucket auslagern."
+---
+
+In dieser Anleitung verbinden Sie [Apache Pulsar](https://github.com/apache/pulsar) über seinen Tiered-Storage-S3-Offloader mit **RustFS**. Sie betreiben einen Standalone-Broker, dessen Offloading auf einen RustFS-Bucket zeigt, produzieren Nachrichten, lösen eine Ledger-Auslagerung aus und lesen die ausgelagerten Nachrichten aus dem Bucket zurück. Der Ablauf wurde mit `apachepulsar/pulsar-all:4.0.4` verifiziert, das ein Topic nach RustFS auslagert und Kaltlesevorgänge daraus bedient.
+
+Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb.
+
+## Architektur
+
+```mermaid
+flowchart LR
+	Producer["pulsar-client produce"] --> Broker["Pulsar standalone"]
+	Broker -->|"hot ledgers"| BK["BookKeeper"]
+	Broker -->|"offload ledgers"| RustFS["RustFS :9000"]
+	Consumer["pulsar-client consume"] -->|"cold reads"| Broker
+```
+
+Alte Ledgers werden als `<offloader-id>-ledger-<n>`-Datenblöcke plus ein kleines `-index`-Objekt in den Bucket hochgeladen. Fordert ein Konsument Nachrichten an, die nicht mehr in BookKeeper liegen, liest der Broker sie transparent aus dem Bucket zurück.
+
+## 1. Standalone-Broker mit Offloading starten
+
+Das einfache `apachepulsar/pulsar`-Image enthält keine Offloader-Pakete und schlägt mit `No offloader found for driver 'S3'` fehl — verwenden Sie das `pulsar-all`-Image, das sie mitbringt. Der Broker wird auf einen kleinen Heap begrenzt:
+
+```bash
+docker run -d --name pulsar -p 6650:6650 -p 8080:8080 \
+  -e ACCESS_KEY_ID=<your-access-key> \
+  -e ACCESS_KEY_SECRET=<your-secret-key> \
+  -e PULSAR_MEM="-Xms512m -Xmx512m" \
+  --entrypoint bash apachepulsar/pulsar-all:4.0.4 -c '
+    sed -i -e "s|^managedLedgerMaxEntriesPerLedger=.*|managedLedgerMaxEntriesPerLedger=100|" \
+           -e "s|^managedLedgerMinLedgerRolloverTimeMinutes=.*|managedLedgerMinLedgerRolloverTimeMinutes=1|" \
+           /pulsar/conf/standalone.conf
+    printf "\nmanagedLedgerOffloadDriver=S3\nmanagedLedgerOffloadBucket=my-bucket\nmanagedLedgerOffloadServiceEndpoint=http://<your-rustfs-endpoint>:9000\nmanagedLedgerOffloadRegion=us-east-1\n" >> /pulsar/conf/standalone.conf
+    exec bin/pulsar standalone -nss
+  '
+```
+
+Die beiden `managedLedger*`-Änderungen verkleinern die Ledgers, sodass ein Roll noch in der Demo passiert; der angehängte Block aktiviert das Offloading.
+
+:::note[Der Treiber S3 liest managedLedgerOffload*-Schlüssel, nicht s3ManagedLedgerOffload*]
+
+Für den Treiber `S3` löst der Offloader die generischen Schlüssel `managedLedgerOffloadBucket`, `managedLedgerOffloadServiceEndpoint` und `managedLedgerOffloadRegion` auf. Die Namen `s3ManagedLedgerOffload*` gehören zum Treiber `aws-s3` und werden hier ignoriert — mit ihnen stürzt der Offloader mit `NullPointerException: endpoint` ab. Dasselbe gilt für Zugangsdaten: Der Treiber `S3` liest die Umgebungsvariablen `ACCESS_KEY_ID` und `ACCESS_KEY_SECRET`, nicht das Paar `AWS_*`.
+
+:::
+
+Warten Sie auf den Broker:
+
+```bash
+docker logs -f pulsar 2>&1 | grep -m1 "The ledger offloader was created"
+```
+
+## 2. Nachrichten produzieren und das Topic am Leben halten
+
+Topics ohne Subscription löscht der Inactive-Topic-Aufräumdienst binnen Minuten, womit die Demo vorzeitig endet. Produzieren Sie eine erste Charge und legen Sie danach eine dauerhafte Subscription an, die das Topic registriert hält:
+
+```bash
+docker exec pulsar bin/pulsar-client produce -m "hello rustfs offload" -n 300 \
+  persistent://public/default/rustfs-test
+```
+
+```text
+300 messages successfully produced
+```
+
+```bash
+timeout 30 docker exec pulsar bin/pulsar-client consume -s keepalive -n 1 -p Earliest \
+  persistent://public/default/rustfs-test
+```
+
+## 3. Ledger rollen und Offloading auslösen
+
+Ein Ledger rollt nur, wenn nach Ablauf von `managedLedgerMinLedgerRolloverTimeMinutes` noch ein Schreibvorgang erfolgt — die Prüfung läuft beim Schreiben, nicht im Hintergrund. Warten Sie mindestens eine Minute, produzieren Sie eine weitere Charge, um das Rollen zu erzwingen, und lagern Sie alles vor dem letzten Kilobyte aus:
+
+```bash
+sleep 65
+docker exec pulsar bin/pulsar-client produce -m "rollover" -n 120 \
+  persistent://public/default/rustfs-test
+docker exec pulsar bin/pulsar-admin topics offload -s 1K \
+  persistent://public/default/rustfs-test
+```
+
+```text
+Offload triggered for persistent://public/default/rustfs-test for messages before 11:0:-1
+```
+
+Das Offloading dauert einen Moment — warten Sie auf den Abschluss:
+
+```bash
+sleep 30
+docker exec pulsar bin/pulsar-admin topics offload-status \
+  persistent://public/default/rustfs-test
+```
+
+```text
+Offload was a success
+```
+
+Bestätigen Sie, dass die Ledger-Objekte in RustFS gelandet sind — Datenblock plus Index, im Bucket-Wurzelverzeichnis:
+
+```bash
+aws s3 ls s3://my-bucket/ --recursive \
+  --endpoint-url http://<your-rustfs-endpoint>:9000 | grep ledger
+```
+
+```text
+2026-10-25 02:34:49      21057 7f9379cc-c21d-4829-a857-4c39ec02e391-ledger-9
+2026-10-25 02:34:49        214 7f9379cc-c21d-4829-a857-4c39ec02e391-ledger-9-index
+```
+
+## 4. Ausgelagerte Nachrichten zurücklesen
+
+Konsumieren Sie mit einer frischen Subscription ab der frühesten Position. Das erste Ledger liegt jetzt nur noch in RustFS, daher ist jede Nachricht, die der Broker liefert, ein Kaltlesevorgang aus dem Bucket:
+
+```bash
+timeout 90 docker exec pulsar bin/pulsar-client consume -s coldread -n 420 -p Earliest \
+  persistent://public/default/rustfs-test 2>&1 | grep -c "^-----"
+```
+
+```text
+420
+```
+
+Alle 420 Nachrichten — die 300 aus dem ausgelagerten Ledger plus die 120 aus dem aktiven — kommen über den Bucket zurück.
+
+![Ausgelagerte Pulsar-Ledger-Objekte in der RustFS-Konsole](./images/rustfs-pulsar-offload.png)
+
+## 5. Anhalten oder Zurücksetzen
+
+Broker abreißen und die Bucket-Objekte behalten:
+
+```bash
+docker rm -f pulsar
+```
+
+Ausgelagerte Ledgers löschen:
+
+```bash
+aws s3 rm s3://my-bucket/ --recursive --exclude "*" --include "*ledger*" \
+  --endpoint-url http://<your-rustfs-endpoint>:9000
+```
+
+## Fehlerbehebung
+
+### `No offloader found for driver 'S3'. Please make sure you dropped the offloader nar packages`
+
+Das Image enthält die Offloader-NARs nicht. Verwenden Sie wie in Schritt 1 `apachepulsar/pulsar-all`.
+
+### `NullPointerException: endpoint` beim Offloading
+
+Der Offloader hat keinen Service-Endpoint gelesen — die Schlüssel `managedLedgerOffload*` fehlen oder wurden mit den Namen `s3ManagedLedgerOffload*` des `aws-s3`-Treibers geschrieben. Hängen Sie den Block aus Schritt 1 an und starten Sie neu.
+
+### `Couldn't get the access key id.` im Broker-Log
+
+Der Treiber `S3` liest nicht `AWS_ACCESS_KEY_ID`. Exportieren Sie `ACCESS_KEY_ID` und `ACCESS_KEY_SECRET` auf dem Broker-Container.
+
+### `Topic ... not found` während der Demo
+
+Der Inactive-Topic-Aufräumdienst hat das Topic gelöscht, weil es keine Subscription hatte. Wiederholen Sie Schritt 2 und belassen Sie die `keepalive`-Subscription.
+
+### `Offload was a success`, aber keine Objekte erscheinen
+
+Hochgeladen werden nur geschlossene Ledgers unterhalb der Größenschwelle, und ein Ledger rollt beim nächsten Schreibvorgang nach Ablauf des Mindestalters. Produzieren Sie eine weitere Charge und lösen Sie das Offloading erneut aus.
+
+## Nächste Schritte
+
+- Lesen Sie vor automatischen Offload-Schwellwerten auf Namespaces die [S3-Kompatibilitätshinweise](/administration/protocols/s3).
+- Erstellen Sie dedizierte Produktionszugangsdaten mit [Zugangsdatenverwaltung](/security-compliance/iam/access-token).
+- Folgen Sie der [Pulsar-Tiered-Storage-Dokumentation](https://pulsar.apache.org/docs/next/cookbooks-tiered-storage/) für Namespace-Schwellwerte, Retention-Richtlinien und Multi-Node-Broker gegen denselben Bucket.