GPU-Teams stehen vor einem schlechten Kompromiss: ein Control Plane pro Team oder schwache Isolation in einem gemeinsamen Cluster. Dieses reproduzierbare Labor kombiniert Kamaji (Control Planes als Pods) und HAMi (fraktionierte GPUs) auf einer einzigen Maschine ohne GPU, unter Verwendung von HAMis Mock-Device-Plugin.
Teil der Sektion DevOps & Betrieb — praktische Anleitungen für den operativen Einsatz von Systemen.
Einordnung: Rust Release Notes.
Rust 1.100.0 wurde am 12. November 2026 veröffentlicht. Es ist ein Meilenstein-Release: Einige der enthaltenen Features — wie der Never-Typ und Custom-Allokatoren — waren bis zu zehn Jahre in Arbeit. Dieser Leitfaden erklärt jede Änderung zuerst in einfacher Sprache und zeigt dann den Code. Keine Low-Level-Rust-Kenntnisse nötig.
! (der Never-Typ) ist endlich stabil — nach 10 Jahren. Konventionen, die bisher Infallible nutzten, verwenden jetzt !.jemalloc oder eigene Allokatoren mit Vec und Box zu nutzen.target/ hat sich intern geändert — wenn deine Tools target/-Pfade parsen, stelle sie auf Cargos JSON-Nachrichten um.| Feature | Was es tut | So probierst du es |
|---|---|---|
Stabiles Allocator-API | Custom-Allokatoren ohne Nightly | Vec::new_in(MyAllocator) |
Never-Typ ! | Infallible ist jetzt ! | fn f() -> Result<T, !> |
| Cargo-Lints | unused_dependencies als Lint | [lints.cargo] unused_dependencies = "warn" |
| Mindestveröffentlichungsalter | Abkühlzeit für neue Abhängigkeiten | [registry] global-min-publish-age = "24 hours" |
Was ist ein Allokator? Wenn ein Programm läuft, fordert es Speicherblöcke an (für eine Vec, eine Box, einen String). Der Code, der diesen Speicher ausgibt und wieder einsammelt, ist der Allokator. Rust verwendet normalerweise den Standard-Allokator des Betriebssystems — sicher, aber nicht immer der schnellste oder beste für die eigene Workload.
Warum es wichtig ist: Alternativen wie jemalloc oder mimalloc sind für viele Server-Workloads messbar schneller (niedrigere Latenz, weniger Fragmentierung). Bisher erforderte die Nutzung pro Typ den Nightly-Compiler. Mit Rust 1.100 ist der zentrale Allocator-Trait stabil.
Einfaches Beispiel — ein Custom-Allokator, der an den globalen Allokator delegiert:
// Ein minimaler Custom-Allokator (delegiert an den System-Allokator)
use std::alloc::{Allocator, Global, Layout};
use std::ptr::NonNull;
struct MeinAllokator;
unsafe impl Allocator for MeinAllokator {
fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, std::alloc::AllocError> {
Global.allocate(layout)
}
fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
Global.deallocate(ptr, layout)
}
}
// Jetzt pro Typ nutzbar — das ist der neue Teil
let v = Vec::new_in(MeinAllokator);
let b: Box<i32, MeinAllokator> = Box::new_in(42, MeinAllokator);
Mit jemalloc (die übliche Produktionswahl):
// Cargo.toml: jemallocator = "0.5"
// Variante A: Allokator für das ganze Programm tauschen
#[global_allocator]
static G: jemallocator::Jemalloc = jemallocator::Jemalloc;
// Variante B: nur eine bestimmte Collection nutzt jemalloc, der Rest bleibt Standard
use jemallocator::Jemalloc;
let vec: Vec<u8, Jemalloc> = Vec::new_in(Jemalloc);
Es ist eine große API — weitere Collections und Zeigertypen werden in künftigen Releases Allocator-Unterstützung erhalten. Der Kern ist jetzt stabil; die Oberfläche wird wachsen.
! stabilisiertWas ist der Never-Typ? Manche Funktionen kehren nie normal zurück: Sie rufen panic! auf, laufen in einer Endlosschleife, rufen std::process::exit oder entrollen via ?. Der Never-Typ ! ist der Typ solcher Berechnungen — er kann niemals einen Wert halten. Das macht ihn besonders: Einen Wert vom Typ ! kann man nie erzeugen, daher darf er überall eingesetzt werden.
Warum es wichtig ist: Es hat zehn Jahre und fünf fehlgeschlagene Versuche gedauert, ihn zu stabilisieren. Der Gewinn für dich: sauberere Fehlerbehandlung. Weil ! in jeden anderen Typ konvertierbar ist, passt Code, der „nicht fehlschlagen kann", jetzt nahtlos in die normale Result-Mechanik.
Das klassische Muster — eine Funktion, die infallibel ist (nicht fehlschlagen kann), mit ! ausgedrückt:
// Diese Funktion kann nur einen Fehler liefern, wenn parse() scheitert —
// und unwrap_unchecked() versichert, dass das nie passiert. Der
// Fehlertyp "!" ist unbewohnt: Es gibt keinen Wert vom Typ "!".
fn parse_infallible(s: &str) -> Result<i32, !> {
s.parse().ok().unwrap_unchecked()
}
Match-Vollständigkeit — der Compiler versteht jetzt, dass ein Zweig nie laufen kann:
match result {
Ok(v) => v,
Err(e) => match e {}, // unerreichbar: ein `e: !` lässt sich nie konstruieren
}
Neue stabile Utilities im selben Release:
use std::mem::{DropGuard, conjure_zst};
// Aufräumcode ausführen, egal wie die Funktion endet.
// DropGuard::new(WERT, CLOSURE) — erst der Wert, dann die Closure.
let mut conn = DropGuard::new(
String::from("db-conn"),
|c| println!("schließe {c}"), // läuft, wenn der Guard gedroppt wird
);
// Wert eines Zero-Sized-Typs erzeugen (fortgeschritten; Typ muss bewohnt sein)
let _zst: MeinZst = unsafe { conjure_zst() };
⚠️ Breaking Change: Das instabile box-Muster wurde entfernt.
// ❌ entfernt
let box x = some_box; // Syntaxfehler
// ✅ stattdessen so
let x = *some_box;
Hinweis:
Infallibleist jetzt ein Alias für!, alter Code kompiliert also weiter — neuer Code kann einfach!schreiben.
Was: Cargo hat erstmals ein eigenes Lint-System (getrennt von rustc). Einige Cargo-Warnungen sind jetzt reguläre, konfigurierbare Lints — inklusive einer eingebauten Prüfung auf ungenutzte Abhängigkeiten.
Warum es wichtig ist: Der unused_crate_dependencies-Lint von rustc hat False Positives mit Cargo (eine Abhängigkeit kann von einem Binary im Workspace genutzt werden, von einem anderen nicht). Der neue cargo::unused_dependencies-Lint ist auf Cargos Multi-Target-Realität zugeschnitten.
Als Warnung nutzen (informiert, bricht den Build nicht):
# Cargo.toml
[lints.cargo]
unused_dependencies = "warn"
Oder CI darauf fehlschlagen lassen, sobald der Baum sauber ist:
[lints.cargo]
unused_dependencies = "deny"
# In CI prüfen
cargo build 2>&1 | grep -q "cargo::unused_dependencies" && exit 1
Was: Bösartige oder kaputte Crate-Versionen werden oft in den ersten Stunden oder Tagen nach dem Veröffentlichen entdeckt. Dieses Feature lässt Cargo Versionen ignorieren, die zu kürzlich veröffentlicht wurden — so haben Scanner und Community Zeit, Probleme zu finden, bevor du sie in Produktion ausrollst.
Warum es wichtig ist: Transitive Abhängigkeiten aktualisieren sich still. Ein brandneues kaputtes Release kann deine CI brechen, ohne dass sich an deinem Code etwas ändert. Ein Cooldown-Fenster ist günstige Versicherung.
Konfiguration (die echten Cargo-1.100-Keys — [resolver] publish-age existiert nicht):
# .cargo/config.toml — gilt für alle Registries
[registry]
global-min-publish-age = "24 hours" # Crates ignorieren, die < 24h alt sind
# Konservativer für CI / Produktion
[registry]
global-min-publish-age = "7 days"
# Pro-Registry-Override (z. B. nur crates.io)
[registries.crates-io]
min-publish-age = "24 hours"
Wie man ein kritisches Update durchbringt (es steckt bereits im Lockfile, oder man optiert pro Befehl ein):
CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update -p some-crate
Hinweise:
CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE wird im Lockfile erhalten.Was: Die Interna von target/ wurden reorganisiert (der Build-Konfigurations-Hash sitzt jetzt in der Verzeichnisstruktur, nicht in den Dateinamen). Kein Build wurde gebrochen — aber jedes Tool, das target/-Pfade parst, kann still das falsche Artefakt finden.
Warum es wichtig ist: Das Layout war in Randfällen mehrdeutig (gemeinsame Build-Verzeichnisse, --features-Kombinationen), was zu unnötigen Rebuilds oder falschen Artefakten führte. Der Fix ist strukturell — und bereitet künftige Cache-Verbesserungen vor.
Nicht target/ parsen — Cargos JSON-Nachrichten verwenden:
# Alle vom Build erzeugten Artefakte, als JSON
cargo build --message-format=json 2>&1 | jq 'select(.message?.files?[] ) | .message.files[]'
# Package- und Target-Metadaten ohne Build
cargo metadata --format-version=1 | jq '.packages[] | {name: .name, targets: [.targets[].name]}'
Faustregel:
cargo metadataund--message-format=jsonsind die unterstützten, stabilen Schnittstellen.target/ist ein Implementierungsdetail.
Vec::from_fn — eine Vec aus einer Funktion füllen// Vorher: Länge setzen, dann schleifen
let mut v = Vec::with_capacity(5);
for i in 0..5 {
v.push(i * i);
}
// Nachher (1.100): ein Aufruf, kein Re-Allokieren
let v: Vec<_> = Vec::from_fn(5, |i| i * i);
// v == [0, 1, 4, 9, 16]
Box::{take,map} — Werte aus einer Heap-Allokation heraus- bzw. darin transformieren// take: Wert herausbewegen OHNE den Speicher freizugeben
let b = Box::new(42);
let (value, uninit) = Box::take(b);
// value = 42, uninit = wiederverwendbare Allokation (siehe Box::write)
drop(uninit); // jetzt freigeben — oder aufheben und später wiederverwenden
// map: Boxed-Wert in-place transformieren, Allokation bleibt erhalten
let b: Box<i32> = Box::new(42);
let b_str: Box<String> = b.map(|n| n.to_string());
str::{trim_prefix, trim_suffix} — bekannten Präfix/Suffix entfernenlet s = "---hallo===";
assert_eq!(s.trim_prefix("---"), "hallo===");
assert_eq!(s.trim_suffix("==="), "---hallo");
let bytes = b"HTTP/1.1\r\nGET /\r\n";
let body = bytes.trim_prefix(b"HTTP/1.1\r\n");
// body == b"GET /\r\n"
Path::trim_prefix — Pfad-Variante; gibt den Original-Pfad zurück, wenn der Präfix nicht passtuse std::path::Path;
let p = Path::new("/usr/local/bin/rustc");
let rest = p.trim_prefix("/usr");
// rest == "/local/bin/rustc" (ein &Path, kein Ok(...))
// Präfix fehlt → Original-Pfad unverändert zurück
assert_eq!(p.trim_prefix("/etc"), p);
bool::toggle — ein bool umdrehenlet mut an = true;
an.toggle(); // an == false
an.toggle(); // an == true
UnsafeCell::{replace, as_ref_unchecked, as_mut_unchecked} — unsicher, aber bequemuse std::cell::UnsafeCell;
let cell = UnsafeCell::new(42);
let old = unsafe { cell.replace(100) }; // old == 42, cell enthält jetzt 100
Once::default — einmalige Initialisierung mit weniger Zeremonieuse std::sync::Once;
let once: Once = Once::default();
once.call_once(|| init());
// Main-Thread-Handle eines Kindprozesses holen
use std::os::windows::process::CommandExt;
let handle = child.main_thread_handle();
// Fenster anzeigen/verbergen
let mut cmd = std::process::Command::new("myapp");
cmd.show_window(true);
Nächster Solver standardmäßig in orphanck aktiv — die Typcheck-Regel, die entscheidet, wo Trait-Implementierungen leben dürfen. Projekte mit Problemen können vorerst opt-outen:
# .cargo/config.toml / rustflags — temporärer Ausweg
[unstable]
next_solver_in_orphanck = false
Sample-basierte Profile-Guided Optimization (-Cprofile-sample-use) ist stabil — PGO-Binaries sind jetzt mit einem stabilisierten Flag auslieferbar.
# 1. Mit Instrumentierung bauen
RUSTFLAGS="-Cprofile-generate" cargo build --release
# 2. Repräsentative Workload ausführen → erzeugt *.profraw-Dateien
./target/release/myapp
# 3. Profile zusammenführen
llvm-profdata merge *.profraw -output=app.profdata
# 4. Mit Profil neu bauen (Vorsicht: -Cprofile-use=... und
# -Cprofile-sample-use=... normalerweise NUR EINEN kombinieren,
# je nachdem, was deine LLVM-Toolchain kann)
RUSTFLAGS="-Cprofile-use=app.profdata" cargo build --release
aligned_fields_in_packedWas: #[repr(packed)] deaktiviert das Padding zwischen Feldern für Strukturen, die Wire-/Disk-Formate abbilden. Ein stark ausgerichtetes Feld (wie u64) innerhalb einer gepackten Struktur war bisher ein Fehler — jetzt ist es ein deny-by-default-Lint, der Compiler gibt eine klarere, umsetzbare Meldung.
#[repr(packed)]
struct Schlecht {
#[repr(align(8))] // ⚠️ jetzt ein Lint: aligned field in gepackter Struktur
a: u64,
b: u8, // bekommt trotzdem nicht-aligned Reads → Risiko
}
// Fix: EINE Darstellung wählen, die zu deinen Anforderungen passt
#[repr(align(8))] struct Fix1 { a: u64, b: u8 } // aligned, mit Padding
#[repr(packed)] struct Fix2 { a: u64, b: u8 } // gepackt, wie es ist
| Ziel | Status | Beispiel |
|---|---|---|
wasm32-wasip3 | Tier 2 | cargo build --target wasm32-wasip3 |
i686-pc-windows-gnu | Tier 2 (ohne Host-Tools) | rustup target add i686-pc-windows-gnu |
powerpc64-sony-ps3 | Tier 3 | Experimentell — keine Sicherheitsgarantien |
rustup update stablecargo check --all-features --all-targetsbox-Muster ersetzen: let box x → let x = *boxtarget/-Parsing auf cargo metadata / --message-format=json umstellen[registry] global-min-publish-age = "24 hours" in CI evaluieren[lints.cargo] unused_dependencies = "warn" ergänzen und Befunde bereinigen12. November 2026. Geschrieben für die Sektion DevOps & Betrieb von tobias-weiss.org.