Rust 1.100.0: Was DevOps-Ingenieure wissen müssen

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. Die erste Edition, in der ! stabil ist und der Allocator-Trait produktionsreif ist. Die Änderungen betreffen jede Stufe der DevOps-Pipeline: von der Abhängigkeitsverwaltung über Build-Artefakte bis hin zu Speicherverwaltung und Plattform-Support.

Kurzfassung

Details unten — mit copy-paste-fertigen Snippets.

1. Stabiles Allocator-API

Was: Der gesamte Allocator-Trait und alle zugehörigen Typen sind jetzt stabil. Schreiben Sie Custom-Allokatoren für die Produktion.

Schnellstart:

// 30-Sekunden-Allokator (delegiert an Global)
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)
    }
}

// Verwenden
let v = Vec::new_in(MeinAllokator);
let b: Box<i32, MeinAllokator> = Box::new_in(42, MeinAllokator);

Mit jemalloc:

// Cargo.toml: jemallocator = "0.5"
#[global_allocator]
static G: jemallocator::Jemalloc = jemallocator::Jemalloc;

// Oder pro Typ
use jemallocator::Jemalloc;
let vec: Vec<u8, Jemalloc> = Vec::new_in(Jemalloc);

2. Never-Typ ! stabilisiert

Was: Der Never-Typ ist stabil. Infallible ist jetzt ein Alias für !.

Funktion, die nie fehlschlägt:

fn parse_infallible(s: &str) -> Result<i32, !> {
    s.parse().ok().unwrap_unchecked()
}

Match-Vollständigkeit:

match result {
    Ok(v) => v,
    Err(e) => match e {}, // Dieser Zweig ist unerreichbar, Rückgabetyp ist `!`
}

Neue stabile Utilities:

use std::mem::{DropGuard, conjure_zst};

// Aufräumen auch bei Panik
let _guard = DropGuard::new(|| println!("cleanup"), ());

// Zero-Sized-Wert erzeugen
let _zst: MyZst = unsafe { conjure_zst() };

⚠️ Breaking Change: box-Muster entfernt

// ❌ entfernt
let box x = some_box;  // Syntaxfehler

// ✅ so stattdessen
let x = *some_box;

3. Cargo-Lints

Was: Cargo hat jetzt eigene Lints. Nicht verwendete Abhängigkeiten erzeugen standardmäßig Warnungen.

# Cargo.toml
[lints.cargo]
# CI fehlschlagen lassen bei ungenutzten Abhängigkeiten
unused_dependencies = "deny"

# In CI prüfen
cargo build 2>&1 | grep -q "cargo::unused_dependencies" && exit 1

4. Mindestveröffentlichungsalter (RFC 3923)

Was: Abhängigkeiten müssen ein Mindestalter haben, bevor Cargo sie verwendet. Verhindert Überraschungsfehler durch brandneue Releases.

# .cargo/config.toml
[resolver]
publish-age = "24 hours"   # Versionen < 24h ignorieren

# Für CI (konservativer)
[resolver]
publish-age = "7 days"

Hinweise:

• ✅ Lockfile-Versionen sind immer erlaubt (auch wenn Minuten alt)
• ✅ Explizite Versionen in Cargo.toml heben die Sperre auf
• ✅ Verhindert CI-Fehler durch fehlerhafte transitive Dependency-Releases

5. Geändertes Build-Verzeichnis-Layout

Was: Das target/-Layout wurde geändert. Nicht target/ parsen — JSON-Nachrichten verwenden.

# Alle gebauten Dateien als JSON erhalten
cargo build --message-format=json 2>&1 | jq 'select(.message?.files?[] ) | .message.files[]'

# Metadaten erhalten
cargo metadata --format-version=1 | jq '.packages[] | {name: .name, targets: [.targets[].name]}'

6. Neu stabilisierte APIs

Vec::from_fn

// Alter Weg
let mut v = Vec::with_capacity(5);
for i in 0..5 {
    v.push(i * i);
}

// Neuer Weg (stabil in 1.100)
let v: Vec<_> = Vec::from_fn(5, |i| i * i);
// [0, 1, 4, 9, 16]

Box::{take,map}, Rc::map, Arc::map

// Wert nehmen, None hinterlassen
let mut b = Box::new(42);
let v = b.take();

// Über enthaltenen Wert mappen
let b: Box<i32> = Box::new(42);
let b_str: Box<String> = b.map(|n| n.to_string());

str::{trim_prefix, trim_suffix}

let s = "---hello===";
assert_eq!(s.trim_prefix("---"), "hello===");
assert_eq!(s.trim_suffix("==="), "---hello");

[T]::{trim_prefix, trim_suffix}

let bytes = b"HTTP/1.1\r\nGET /\r\n";
let body = bytes.trim_prefix(b"HTTP/1.1\r\n");
// b"GET /\r\n"

Path::trim_prefix

use std::path::Path;
let p = Path::new("/usr/local/bin/rustc");
let rest = p.trim_prefix("/usr");
// Ok("/local/bin/rustc")

bool::toggle

let mut an = true;
an.toggle();   // an ist jetzt false

UnsafeCell::{replace, as_ref_unchecked, as_mut_unchecked}

use std::cell::UnsafeCell;
let cell = UnsafeCell::new(42);
let old = unsafe { cell.replace(100) };  // gibt 42 zurück, cell enthält jetzt 100

Once::default

use std::sync::Once;
let once: Once = Once::default();
once.call_once(|| init());

Windows-spezifisch

// Main-Thread-Handle eines Kindprozesses
use std::os::windows::process::CommandExt;
let handle = child.main_thread_handle();

// Fenster anzeigen/verbergen
use std::os::windows::process::CommandExt;
cmd.show_window(true);

7. Compiler & Solver

Nächster Solver in orphanck:

# Bei Problemen vorübergehend deaktivieren
[unstable]
next_solver_in_orphanck = false

Profile-Guided Optimization stabil:

# Mit Instrumentierung bauen
RUSTFLAGS="-Cprofile-generate" cargo build --release
# Workload ausführen: erzeugt *.profraw-Dateien
./target/release/myapp
# Zusammenführen und mit PGO neu bauen
llvm-profdata merge *.profraw -output=app.profdata
RUSTFLAGS="-Cprofile-use=app.profdata -Cprofile-sample-use" cargo build --release

8. Neues Lint: aligned_fields_in_packed

#[repr(packed)]
struct Schlecht {
    #[repr(align(8))]  // ⚠️ Lint: aligned field in gepackter Struktur
    a: u64,
    b: u8,  // hat trotzdem Padding!
}

// Fix: eins wählen
#[repr(align(8))] struct Fix1 { a: u64, b: u8, }
#[repr(packed)]  struct Fix2 { a: u64, b: u8, }

9. Plattform-Support

Upgrade-Checkliste

• rustup update stable
• cargo check --all-features --all-targets
• box-Muster fixen: let box x → let x = *box
• Tools von target/-Parsing auf JSON-Nachrichten umstellen
• [resolver] publish-age = "24 hours" in CI erwägen

12. November 2026. Fragen? GitHub.