Die Beispielwerte (wordpress-ibr4-*, jryy_, abow.info, IP 72.61.92.170) stammen aus dem realen Umzug. Passe sie an deinen Stack an.

Ziel

WordPress läuft im vorhandenen Docker-Stack, ist über https://abow.info öffentlich erreichbar, Zertifikat von Let’s Encrypt – ohne Datenverlust.

Mentales Modell (vorab verstehen, spart 2 Stunden)

• Named Volume: Der WP-Container mountet …/<volume>/_data → /var/www/html. Deine Files müssen in _data liegen, nicht daneben. Und: _data niemals löschen – ein Named Volume braucht diesen Ordner, sonst startet der Container nicht.
• Die wp-config.php erzeugt das offizielle Image selbst – aber nur, wenn keine existiert, und zwar aus den WORDPRESS_*-ENV-Variablen. Eine mitgebrachte Strato-wp-config.php wird nicht überschrieben.
• DB-Verbindung geht über den Service-Namen (db), nie localhost/rdbms.strato.de.
• Traefik im Host-Mode routet nicht über das Docker-Netz, sondern über einen festen veröffentlichten Port des Containers.

Schritt 0: Stack inspizieren

ssh root@DEINE_VPS_IP

docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Ports}}"

Du suchst den WP- und den DB-Container (hier wordpress-ibr4-wordpress-1 / wordpress-ibr4-db-1, DB-Image mysql:8) und den Reverse Proxy (traefik-traefik-1). Projektpfad und Volume finden:

docker inspect wordpress-ibr4-wordpress-1 \
  --format '{{ index .Config.Labels "com.docker.compose.project.working_dir" }}'
# -> z.B. /docker/wordpress-ibr4

docker inspect wordpress-ibr4-wordpress-1 \
  --format '{{ range .Mounts }}{{ .Name }} | {{ .Source }} -> {{ .Destination }}{{ println }}{{ end }}'
# -> wordpress-ibr4_wordpress | …/_data -> /var/www/html

DB-Zugangsdaten + Prefix aus den Containern (nur ansehen):

docker exec wordpress-ibr4-wordpress-1 env | grep -i WORDPRESS_DB
docker exec wordpress-ibr4-db-1          env | grep -iE 'MYSQL_DATABASE|MYSQL_USER'

Schritt 1: Files an die richtige Stelle (_data)

Liegen deine Strato-Files in einem Ordner neben _data (z. B. _app), sieht WordPress sie nicht. Ist _data nur die nackte Standard-Installation, deine echte Seite aber in _app, machst du _app zum Live-Verzeichnis:

cd /var/lib/docker/volumes/wordpress-ibr4_wordpress
# Falls _data noch die Default-Files enthaelt: sichern statt loeschen
mv _app  _data

# Core vollstaendig? (muessen existieren)
ls _data/wp-admin _data/wp-includes _data/wp-load.php

Falle: _data zu löschen killt den Mountpunkt → Error response from daemon: open …/_data: no such file or directory. Immer umbenennen, nie löschen.

Schritt 2: Alte Strato-wp-config raus, ENV-Prefix korrekt setzen

Die mitgebrachte wp-config.php zeigt noch auf Strato:

grep -E "table_prefix|DB_HOST|DB_NAME|DB_USER" _data/wp-config.php
# define('DB_HOST','rdbms.strato.de');  <- muss weg
# $table_prefix = 'jryy_';              <- Prefix merken!

Prefix merken (hier jryy_) und die alte Config wegsichern, damit das Image neu generiert:

mv _data/wp-config.php _data/wp-config.php.strato-bak

Jetzt den Table-Prefix in die Compose – und zwar im environment:-Block des wordpress-Service (nicht beim db-Service!). Häufigster Fehler: Zeile landet bei den MYSQL_*-Variablen und greift nie.

services:
  wordpress:
    environment:
      - WORDPRESS_DB_HOST=db
      - WORDPRESS_DB_NAME=wordpress
      - WORDPRESS_DB_USER=wordpress
      - WORDPRESS_DB_PASSWORD=${MYSQL_PASSWORD}
      - WORDPRESS_TABLE_PREFIX=jryy_          # <- HIER, beim wordpress-Service

Schritt 3: Container neu erzeugen und Prefix effektiv prüfen

docker compose up -d allein startet einen laufenden Container nicht neu – dann läuft der Entrypoint nicht und die wp-config.php wird nicht geschrieben. Daher --force-recreate:

cd /docker/wordpress-ibr4
docker compose up -d --force-recreate wordpress

Jetzt nicht nur grep (das offizielle Image schreibt getenv_docker('…','wp_') mit Fallback). Den aufgelösten Wert prüfen:

docker exec wordpress-ibr4-wordpress-1 \
  php -r 'require "/var/www/html/wp-config.php"; echo DB_HOST.PHP_EOL.DB_NAME.PHP_EOL.$table_prefix.PHP_EOL;'

Zielausgabe:

db
wordpress
jryy_

Kommt wp_ statt jryy_: Die ENV-Zeile steht im falschen Service-Block oder die alte wp-config.php existiert noch. Beides fixen, --force-recreate wiederholen. Effektiv-Check mit docker exec … env | grep WORDPRESS_TABLE_PREFIX zeigt, ob die Variable im Container überhaupt ankommt.

Schritt 4: Datenbank importieren

docker exec -i … < dump.sql liest die Datei vom Host und pipet sie in den Container – der Pfad im Container ist egal, nur der Host-Pfad muss stimmen. Passwort kommt aus der Container-ENV, du tippst nichts:

docker exec -i wordpress-ibr4-db-1 \
  sh -c 'exec mysql -uwordpress -p"$MYSQL_PASSWORD" wordpress' \
  < /var/lib/docker/volumes/wordpress-ibr4_wordpress/dbs12659889.sql

Falle ERROR 1050 … Table already exists: In der DB liegen schon Tabellen (Reste der Default-Installation oder ein abgebrochener Import). Schema einmal komplett leeren, dann neu importieren:

docker exec wordpress-ibr4-db-1 sh -c '
  exec mysql -uwordpress -p"$MYSQL_PASSWORD" -N -e "
    SET FOREIGN_KEY_CHECKS=0; SET GROUP_CONCAT_MAX_LEN=1000000;
    SELECT IFNULL(CONCAT(\"DROP TABLE IF EXISTS \", GROUP_CONCAT(\"\`\",table_name,\"\`\"), \";\"), \"SELECT 1;\")
    FROM information_schema.tables WHERE table_schema=\"wordpress\";
  " wordpress' \
| docker exec -i wordpress-ibr4-db-1 sh -c 'exec mysql -uwordpress -p"$MYSQL_PASSWORD" wordpress'

Danach SHOW TABLES; muss leer sein → Import wiederholen.

Rechte setzen und verifizieren (Prefix beachten – hier jryy_):

docker exec wordpress-ibr4-wordpress-1 chown -R www-data:www-data /var/www/html

docker exec wordpress-ibr4-db-1 \
  sh -c 'exec mysql -uwordpress -p"$MYSQL_PASSWORD" wordpress \
  -e "SELECT option_name,option_value FROM jryy_options WHERE option_name IN (\"siteurl\",\"home\");"'

docker exec wordpress-ibr4-wordpress-1 \
  php -r 'require "/var/www/html/wp-load.php"; echo "WP ".$GLOBALS["wp_version"]." | ".get_option("blogname").PHP_EOL;'

Erwartung: deine siteurl/home und WP-Version + Blogname.

Schritt 5: URLs (nur bei Domain-/Protokollwechsel)

Stehen siteurl/home bereits korrekt (z. B. https://abow.info), ist nichts zu tun – diesen Schritt überspringen. Andernfalls serialisierungssicher mit WP-CLI ersetzen, nie per rohem SQL:

docker compose exec wordpress bash -c '
  curl -sO https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
  php wp-cli.phar search-replace "http://alt.tld" "https://abow.info" --all-tables --allow-root --dry-run'

Sieht der Probelauf gut aus → --dry-run weglassen.

Schritt 6: HTTPS hinter Traefik

Traefik terminiert TLS und spricht intern per HTTP mit WordPress. Ohne Hinweis baut WordPress Redirect-Loops / Mixed-Content. Per ENV in den wordpress-Service (die $$ sind Absicht – Compose würde einfaches $ als Variable interpretieren):

      - WORDPRESS_CONFIG_EXTRA=if (isset($$_SERVER['HTTP_X_FORWARDED_PROTO']) && $$_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') { $$_SERVER['HTTPS'] = 'on'; }

Schritt 7: Traefik-Routing im Host-Mode

Prüfen, wie Traefik tickt:

docker inspect traefik-traefik-1 --format '{{ json .Config.Cmd }}'
# -> providers.docker=true, entrypoints web:80 / websecure:443,
#    HTTP->HTTPS-Redirect, certresolver "letsencrypt" (HTTP-Challenge)

docker inspect traefik-traefik-1 \
  --format '{{ range $n,$v := .NetworkSettings.Networks }}{{ $n }} {{ end }}'
# -> host   (= Host-Mode!)

Host-Mode-Konsequenzen (das ist die größte Falle):

• docker network connect ist nicht möglich (Container im Host-Namespace).
• Traefik erreicht den WP-Container nur über einen festen, veröffentlichten Port auf 127.0.0.1.
• Im Label statt loadbalancer.server.port → loadbalancer.server.url mit der festen URL.

Daher in der Compose den WP-Port fix mappen (nicht dynamisch "80", das vergibt Docker zufällig):

    ports:
      - "127.0.0.1:8081:80"

Und die Labels auf Service-Ebene (gleiche Einrückung wie environment:/volumes:, nur einmal labels: pro Service!):

    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.abow.rule=Host(`abow.info`)"
      - "traefik.http.routers.abow.entrypoints=websecure"
      - "traefik.http.routers.abow.tls=true"
      - "traefik.http.routers.abow.tls.certresolver=letsencrypt"
      - "traefik.http.services.abow.loadbalancer.server.url=http://127.0.0.1:8081"

YAML-Fallen: labels: darf nicht unter volumes: verschachtelt sein und nicht doppelt vorkommen (mapping key "labels" already defined). Nach jeder Änderung validieren:

docker compose config >/dev/null && echo "YAML OK" || echo "YAML kaputt"

Anwenden und intern testen (ohne auf DNS/Zertifikat zu warten):

docker compose up -d wordpress

curl -s -I http://127.0.0.1:8081/ | head -1            # WordPress direkt: 200/301
curl -s -I -H "Host: abow.info" http://127.0.0.1/ | head -1   # ueber Traefik

HTTP/1.1 308 Permanent Redirect beim zweiten Befehl = Traefik kennt den abow-Router und leitet auf HTTPS um. Routing steht.

Schritt 8: DNS umstellen → Zertifikat kommt automatisch

Das Let’s-Encrypt-Zertifikat (HTTP-Challenge) zieht erst, wenn die Domain öffentlich auf den VPS zeigt. Beim DNS-Anbieter für abow.info:

Vorher testen ohne DNS-Wartezeit: per Windows-hosts-Datei abow.info → VPS-IP (PowerShell-Skript unten). Browser-Zertifikatswarnung ist dabei normal, bis das echte Zert gezogen ist.

Nach Propagation prüfen:

dig +short abow.info                                   # -> 72.61.92.170
curl -sI https://abow.info | head -3                   # -> HTTP/2 200
echo | openssl s_client -connect abow.info:443 -servername abow.info 2>/dev/null \
  | openssl x509 -noout -issuer -subject -dates        # Issuer: Let's Encrypt

HTTP/2 200 ohne TLS-Fehler = live mit gültigem Zertifikat.

Schritt 9: Nacharbeiten & Aufräumen

# In WordPress: Einstellungen -> Permalinks -> ohne Aenderung speichern (Rewrites/.htaccess)

# Backups/Reste entfernen
rm -rf /var/lib/docker/volumes/wordpress-ibr4_wordpress/_data_OLD
rm -f  /var/lib/docker/volumes/wordpress-ibr4_wordpress/_data/wp-config.php.*-bak*
rm -f  /docker/wordpress-ibr4/docker-compose.yml.bak*

• DB-Passwort rotieren, falls es irgendwo im Klartext aufgetaucht ist.
• Strato-Dump nach erfolgreicher Kontrolle sichern/löschen.

PowerShell: Vorab-Test per hosts-Datei

<#
.NOTES
    Name:        PS_Hosts_Preview_VPS
    Author:      Andreas Bowitz
    Version:     0.2
    LastUpdated: 2026-Jun-03

.SYNOPSIS
    Setzt temporär einen hosts-Eintrag, um eine Domain vor der DNS-Umstellung
    auf die neue VPS-IP zeigen zu lassen (lokaler Test vom Windows-Client).
#>

$VpsIP  = "72.61.92.170"
$Domain = "abow.info"

$HostsFile = "$env:WINDIR\System32\drivers\etc\hosts"
$Entry     = "$VpsIP`t$Domain"

if (-not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()
    ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
    Write-Warning "Bitte PowerShell als Administrator starten."; return
}
if ((Get-Content $HostsFile) -match [Regex]::Escape($Domain)) {
    Write-Host "Eintrag fuer '$Domain' existiert bereits." -ForegroundColor Yellow
} else {
    Add-Content -Path $HostsFile -Value $Entry
    Write-Host "Hinzugefuegt: $Entry" -ForegroundColor Green
}
ipconfig /flushdns | Out-Null
Write-Host "Test: https://$Domain  (Zert-Warnung bis echtem DNS normal). Danach Zeile wieder entfernen." -ForegroundColor Cyan

Bash: Import-Helfer (auf dem VPS)

#!/usr/bin/env bash
# .NOTES
#   Name:        migrate_strato_to_docker
#   Author:      Andreas Bowitz
#   Version:     0.2
#   LastUpdated: 2026-Jun-03
#   Zweck:       DB-Dump in den db-Container importieren + Rechte setzen.
#                Im Compose-Projektverzeichnis ausfuehren.
set -euo pipefail

DB_CONTAINER="wordpress-ibr4-db-1"
WP_CONTAINER="wordpress-ibr4-wordpress-1"
DB_NAME="wordpress"
PREFIX="jryy_"
DUMP="${1:?Pfad zum SQL-Dump angeben}"

echo ">> Pruefe, ob Tabellen existieren ..."
COUNT=$(docker exec "$DB_CONTAINER" sh -c \
  "exec mysql -uwordpress -p\"\$MYSQL_PASSWORD\" -N -e \
   'SELECT COUNT(*) FROM information_schema.tables WHERE table_schema=\"$DB_NAME\";'")
if [ "$COUNT" -gt 0 ]; then
  echo "!! $COUNT Tabellen vorhanden. Erst leeren (manuell), dann erneut starten." ; exit 1
fi

echo ">> Importiere '$DUMP' ..."
docker exec -i "$DB_CONTAINER" \
  sh -c 'exec mysql -uwordpress -p"$MYSQL_PASSWORD" '"$DB_NAME" < "$DUMP"

echo ">> Rechte setzen ..."
docker exec "$WP_CONTAINER" chown -R www-data:www-data /var/www/html

echo ">> Kontrolle ..."
docker exec "$DB_CONTAINER" sh -c \
  "exec mysql -uwordpress -p\"\$MYSQL_PASSWORD\" $DB_NAME \
   -e 'SELECT option_value FROM ${PREFIX}options WHERE option_name=\"siteurl\";'"
echo ">> Fertig."

Troubleshooting (gesammelte Stolperfallen)

Fazit: Auf einem Docker-VPS verlagert sich der Umzug komplett in die Shell. Die eigentliche Arbeit sind nicht die Standard-Schritte (Dump rein, Files rein), sondern die Eigenheiten der Umgebung: Named Volume = _data (nie löschen), WORDPRESS_TABLE_PREFIX beim richtigen Service plus --force-recreate, Effektiv-Prüfung mit php -r statt grep, und Traefik im Host-Mode mit festem Port und server.url. Wer diese vier Punkte kennt, zieht beim nächsten Mal in 20 Minuten um – ohne Hilfe.

Ziel

Du sollst nach diesem Beitrag:

• das Handelskalkulationsschema sicher von oben nach unten durchrechnen können,
• Vorwärts-, Rückwärts- und Differenzkalkulation auseinanderhalten,
• Kalkulationszuschlag, Kalkulationsfaktor und Handelsspanne berechnen und unterscheiden,
• und das Ganze einmal als wiederverwendbares PowerShell-Tool in der Hand haben.

Worin unterscheidet sich die Handelskalkulation?

Ein Produktionsbetrieb zerlegt seine Kosten fein in Material- und Fertigungsgemeinkosten, Verwaltung und Vertrieb (klassische Zuschlagskalkulation). Ein Händler produziert nichts – er kauft fertige Ware ein und verkauft sie weiter. Deshalb werden seine Gemeinkosten nicht aufgesplittet, sondern in einem einzigen Satz zusammengefasst: den Handlungskosten (über den Handlungskostenzuschlagssatz).

Der Handlungskostenzuschlag gibt das prozentuale Verhältnis der Handlungskosten zum Wareneinsatz (Bezugspreis) an.

Das macht die Handelskalkulation zu einer schlanken Zuschlagskalkulation – ideal für Handel und E‑Commerce.

Das Handelskalkulationsschema

Das Schema läuft vom Listeneinkaufspreis (was der Lieferant offiziell aufruft) bis zum Listenverkaufspreis (was am Ende auf deinem Preisschild steht). Wichtig: Es wird immer mit Nettopreisen gerechnet – die Mehrwertsteuer bleibt außen vor.

Merke – die Stolperfalle bei Skonto & Rabatt im Verkaufsteil: Kundenskonto, Vertreterprovision und Kundenrabatt werden nicht auf den darunterliegenden Wert aufgeschlagen, sondern sind Prozente vom darüberliegenden Preis (Zielverkaufspreis bzw. Listenverkaufspreis = 100 %). Du rechnest also „im Hundert“ mit vermindertem Grundwert:

Barverkaufspreis = Zielverkaufspreis × (100 % − e %)
  →  Zielverkaufspreis = Barverkaufspreis ÷ (100 % − e %)

Zielverkaufspreis = Listenverkaufspreis × (100 % − f %)
  →  Listenverkaufspreis = Zielverkaufspreis ÷ (100 % − f %)

Die drei Kalkulationsrichtungen

Die Rückwärtskalkulation ist im Handel oft die ehrlichste: Der Markt diktiert den Preis (gerade bei vergleichbaren Produkten), und du rechnest zurück, wie viel du maximal im Einkauf zahlen darfst, ohne dass die Marge kippt.

Durchgerechnetes Beispiel (Vorwärtskalkulation)

Ein Einzelhändler kauft ein Gerät zum Listeneinkaufspreis von 512,64 € (netto). Konditionen: 10 % Lieferrabatt, 2 % Lieferskonto, 5,40 € Bezugskosten, 43 % Handlungskosten, 15 % Gewinn, 2 % Kundenskonto, 10 % Kundenrabatt.

Kleiner Realitäts-Check: Je nachdem, ob du jeden Zwischenschritt rundest oder mit allen Nachkommastellen durchrechnest, weicht der Endwert um ein, zwei Cent ab (hier: 853,12 € bei schrittweiser Rundung). In der Prüfung gilt i. d. R. die schrittweise gerundete Variante.

Die drei Kennzahlen: Zuschlag, Faktor, Spanne

Aus genau diesem Beispiel lassen sich drei Kennzahlen ableiten, die ständig verwechselt werden. Der Rohgewinn ist dabei die Differenz zwischen Bezugspreis und Listenverkaufspreis:

Rohgewinn = Listenverkaufspreis − Bezugspreis
          = 853,12 € − 457,55 € = 395,57 €

Eselsbrücke: Zuschlag und Faktor schauen auf den Einkauf (Nenner = Bezugspreis), die Handelsspanne schaut auf den Verkauf (Nenner = Listenverkaufspreis). Mit dem Faktor sparst du dir das ganze Schema: Einstand × 1,8645 = Listenverkaufspreis (netto).

Bonus: Handelskalkulation als PowerShell-Funktion

Damit du nicht jedes Mal die Tabelle von Hand rechnest, hier eine kleine Vorwärtskalkulation als Funktion. Sie rundet schrittweise (prüfungskonform) und gibt das komplette Schema aus.

<#
.NOTES
    Name:        PS_Handelskalkulation_Vorwaerts
    Author:      Andreas Bowitz
    Version:     0.1
    LastUpdated: 2026-Jun-03

.SYNOPSIS
    Berechnet die Vorwaertskalkulation vom Listeneinkaufspreis bis zum
    Listenverkaufspreis (netto, ohne USt) nach dem Handelskalkulationsschema.

.EXAMPLE
    Get-Handelskalkulation -Listeneinkaufspreis 512.64 -LieferrabattProz 10 `
        -LieferskontoProz 2 -Bezugskosten 5.40 -HandlungskostenProz 43 `
        -GewinnProz 15 -KundenskontoProz 2 -KundenrabattProz 10
#>
function Get-Handelskalkulation {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)] [double] $Listeneinkaufspreis,
        [double] $LieferrabattProz   = 0,
        [double] $LieferskontoProz   = 0,
        [double] $Bezugskosten       = 0,
        [Parameter(Mandatory)] [double] $HandlungskostenProz,
        [Parameter(Mandatory)] [double] $GewinnProz,
        [double] $KundenskontoProz   = 0,
        [double] $KundenrabattProz   = 0
    )

    # Hilfsfunktion: kaufmaennisch auf 2 Nachkommastellen runden
    function r([double]$x) { [math]::Round($x, 2, [MidpointRounding]::AwayFromZero) }

    # --- Einkaufsteil (Aufschlag/Abschlag vom Grundwert) ---
    $lieferrabatt = r($Listeneinkaufspreis * $LieferrabattProz / 100)
    $zieleinkauf  = r($Listeneinkaufspreis - $lieferrabatt)

    $lieferskonto = r($zieleinkauf * $LieferskontoProz / 100)
    $bareinkauf   = r($zieleinkauf - $lieferskonto)

    $bezugspreis  = r($bareinkauf + $Bezugskosten)

    # --- Selbstkosten & Gewinn ---
    $handlungsk   = r($bezugspreis * $HandlungskostenProz / 100)
    $selbstkosten = r($bezugspreis + $handlungsk)

    $gewinn       = r($selbstkosten * $GewinnProz / 100)
    $barverkauf   = r($selbstkosten + $gewinn)

    # --- Verkaufsteil: verminderter Grundwert ("im Hundert") ---
    $zielverkauf  = r($barverkauf / (1 - $KundenskontoProz / 100))
    $kundenskonto = r($zielverkauf - $barverkauf)

    $listenverkauf = r($zielverkauf / (1 - $KundenrabattProz / 100))
    $kundenrabatt  = r($listenverkauf - $zielverkauf)

    # --- Kennzahlen ---
    $rohgewinn = r($listenverkauf - $bezugspreis)
    $zuschlag  = r($rohgewinn / $bezugspreis * 100)
    $faktor    = [math]::Round($listenverkauf / $bezugspreis, 4)
    $spanne    = r($rohgewinn / $listenverkauf * 100)

    [PSCustomObject][ordered]@{
        Listeneinkaufspreis  = $Listeneinkaufspreis
        Lieferrabatt         = $lieferrabatt
        Zieleinkaufspreis    = $zieleinkauf
        Lieferskonto         = $lieferskonto
        Bareinkaufspreis     = $bareinkauf
        Bezugskosten         = $Bezugskosten
        Bezugspreis          = $bezugspreis
        Handlungskosten      = $handlungsk
        Selbstkosten         = $selbstkosten
        Gewinn               = $gewinn
        Barverkaufspreis     = $barverkauf
        Kundenskonto         = $kundenskonto
        Zielverkaufspreis    = $zielverkauf
        Kundenrabatt         = $kundenrabatt
        Listenverkaufspreis  = $listenverkauf
        Kalkulationszuschlag = "$zuschlag %"
        Kalkulationsfaktor   = $faktor
        Handelsspanne        = "$spanne %"
    }
}

Aufruf mit den Beispielwerten von oben:

Get-Handelskalkulation -Listeneinkaufspreis 512.64 -LieferrabattProz 10 `
    -LieferskontoProz 2 -Bezugskosten 5.40 -HandlungskostenProz 43 `
    -GewinnProz 15 -KundenskontoProz 2 -KundenrabattProz 10 | Format-List

→ liefert u. a. Bezugspreis = 457,55, Selbstkosten = 654,30, Listenverkaufspreis = 853,12, Kalkulationsfaktor = 1,8645.

Praxisbezug: Warum das im (Online-)Handel zählt

Wer Ware handelt – ob Drucker, Notebooks oder Sammelkarten – steht vor genau dieser Rechnung. Drei typische Fälle:

• Vorwärts: Booster-Display im Einkauf, du willst deinen Listenpreis bestimmen → Schema von oben nach unten.
• Rückwärts: Der Marktpreis einer Karte steht fest (z. B. aus einer Preisquelle) → du rechnest zurück, was dein maximaler Einstand sein darf, damit Handlungskosten und Wunschmarge noch passen. Genau hier setzt der Kalkulationsfaktor an: Marktpreis ÷ 1,8645 = max. Einstand (bei gleicher Kostenstruktur).
• Differenz: Ware ist eingekauft, Verkaufspreis ist gesetzt → du prüfst, was tatsächlich an Gewinn übrig bleibt.

Nicht vergessen: Die ganze Kalkulation läuft netto. Die Umsatzsteuer kommt erst danach obendrauf bzw. wird im B2B durchgereicht – sie ist kein Bestandteil der Preiskalkulation.

Fazit: Die Handelskalkulation ist eine schlanke Zuschlagskalkulation mit nur einem Gemeinkostensatz – wer das Schema und die drei Kennzahlen (Zuschlag, Faktor, Spanne) sauber trennt, kalkuliert Verkaufspreise in der Prüfung und im echten Lager fehlerfrei.

Inhaltsverzeichnis

• Binäre Logik – worum geht es?
• Die drei Grundfunktionen: NICHT, UND, ODER
• Schaltzeichen im Überblick (IEC vs. US-Norm)
• Die zusammengesetzten Gatter: NAND, NOR, XOR, XNOR
• Zeitablaufdiagramm (Impulsdiagramm)
• Wichtige Rechenregeln & die Sätze von De Morgan
• Normalformen: DNF und KNF
• NAND & NOR – die universellen Gatter
• Bonus: Wahrheitstabelle per PowerShell
• Fazit

Binäre Logik – worum geht es?

Digitaltechnik kennt nur zwei Zustände: 0 und 1 (auch LOW/HIGH, falsch/wahr, aus/ein). Eine logische Funktion bildet einen oder mehrere Eingänge auf genau einen Ausgang ab. Beschreiben kannst du sie auf drei gleichwertige Arten:

• Wahrheitstabelle – listet für jede Eingangskombination den Ausgang auf.
• Boolescher Ausdruck – die Funktion als Formel, z. B. Y = A ∧ B.
• Schaltzeichen / Logikplan – die grafische Darstellung als Gatter.

Bei n Eingängen gibt es immer 2ⁿ mögliche Eingangskombinationen – bei 2 Eingängen also 4 Zeilen, bei 3 Eingängen 8 Zeilen. Das ist später für DNF/KNF wichtig.

Notation: Es gibt mehrere übliche Schreibweisen. Ich nutze hier ∧ (UND), ∨ (ODER), ¬ (NICHT) und ⊕ (XOR). Gleichwertig sind: UND = · oder Zusammenschreiben (A·B bzw. AB), ODER = +, NICHT = Überstrich (Ā).

Die drei Grundfunktionen: NICHT, UND, ODER

Aus diesen drei lässt sich jede beliebige logische Funktion zusammensetzen – sie sind das Fundament.

NICHT (NOT / Negation / Inverter)

Dreht den Eingang um. Ein Eingang, ein Ausgang.

Y = ¬A

UND (AND / Konjunktion)

Der Ausgang ist nur dann 1, wenn alle Eingänge 1 sind. Merksatz: „UND ist geizig“.

Y = A ∧ B

ODER (OR / Disjunktion)

Der Ausgang ist 1, sobald mindestens ein Eingang 1 ist. Merksatz: „ODER ist großzügig“.

Y = A ∨ B

Schaltzeichen im Überblick (IEC vs. US-Norm)

In der Praxis triffst du auf zwei Symbol-Welten:

• IEC 60617 / DIN – rechteckige Symbole mit einem Kennzeichen im Block (& für UND, ≥1 für ODER, 1 für NICHT, =1 für XOR). In deutschen Prüfungen und Normplänen üblich.
• ANSI / US-Norm – die „distinktiven“ geschwungenen Formen, die du aus vielen Datenblättern und internationaler Literatur kennst.

Eine Negation wird in beiden Welten durch einen kleinen Kreis (Bubble) am Ausgang dargestellt – so werden aus UND/ODER die Funktionen NAND/NOR.

Die zusammengesetzten Gatter: NAND, NOR, XOR, XNOR

NAND (NOT-AND)

Negiertes UND – Ausgang ist 0 nur dann, wenn alle Eingänge 1 sind.

Y = ¬(A ∧ B)

NOR (NOT-OR)

Negiertes ODER – Ausgang ist 1 nur dann, wenn alle Eingänge 0 sind.

Y = ¬(A ∨ B)

XOR (Exklusiv-ODER / Antivalenz)

Ausgang ist 1, wenn die Eingänge unterschiedlich sind. Bei mehr als zwei Eingängen gilt: 1, wenn die Anzahl der Einsen ungerade ist (Paritätsfunktion).

Y = A ⊕ B

XNOR (Äquivalenz)

Negiertes XOR – Ausgang ist 1, wenn die Eingänge gleich sind. Praktisch als „Vergleicher“.

Y = ¬(A ⊕ B)

Zeitablaufdiagramm (Impulsdiagramm)

Das Zeitablaufdiagramm (auch Impuls- oder Signal-Zeit-Diagramm) zeigt, wie sich die Ausgänge über die Zeit verhalten, während sich die Eingänge ändern. Hier durchlaufen die Eingänge A und B nacheinander alle vier Kombinationen 00 → 01 → 10 → 11. So siehst du auf einen Blick, wie jedes Gatter reagiert (in idealer Betrachtung ohne Gatterlaufzeit/Schaltverzögerung).

Lies es spaltenweise: In jeder Zeitspalte gilt eine feste Kombination von A und B, und du kannst Zeile für Zeile mit den Wahrheitstabellen oben gegenprüfen.

Wichtige Rechenregeln & die Sätze von De Morgan

Für Vereinfachungen brauchst du die Grundgesetze der Booleschen Algebra:

Besonders prüfungsrelevant sind die Sätze von De Morgan – sie verbinden UND/ODER über die Negation und sind die Grundlage dafür, dass NAND und NOR universell sind:

¬(A ∧ B) = ¬A ∨ ¬B
¬(A ∨ B) = ¬A ∧ ¬B

Merksatz: „Negation rein – aus UND wird ODER (und umgekehrt).“

Normalformen: DNF und KNF

Eine Normalform ist eine standardisierte Schreibweise, in der sich jede logische Funktion direkt aus ihrer Wahrheitstabelle ablesen lässt – ohne Raten.

• DNF – Disjunktive Normalform: eine ODER-Verknüpfung von UND-Termen (sog. Mintermen). Du baust sie aus allen Zeilen, in denen der Ausgang 1 ist.
• KNF – Konjunktive Normalform: eine UND-Verknüpfung von ODER-Termen (sog. Maxtermen). Du baust sie aus allen Zeilen, in denen der Ausgang 0 ist.

So liest du die Terme ab

Minterm (für DNF, Zeile mit Ausgang 1): Alle Eingangsvariablen werden mit UND verknüpft. Eine Variable steht negiert, wenn sie in dieser Zeile 0 ist, und nicht negiert, wenn sie 1 ist.

Maxterm (für KNF, Zeile mit Ausgang 0): Alle Eingangsvariablen werden mit ODER verknüpft. Hier ist es genau umgekehrt: Eine Variable steht negiert, wenn sie in dieser Zeile 1 ist, und nicht negiert, wenn sie 0 ist.

Beispiel: Mehrheitsfunktion (2-aus-3)

Nehmen wir eine typische Funktion mit drei Eingängen: Der Ausgang f ist 1, wenn mindestens zwei der drei Eingänge 1 sind (z. B. eine „2-aus-3″-Mehrheitsentscheidung).

DNF – ODER über alle Minterme (die vier 1-Zeilen):

f = (¬A ∧ B ∧ C) ∨ (A ∧ ¬B ∧ C) ∨ (A ∧ B ∧ ¬C) ∨ (A ∧ B ∧ C)

KNF – UND über alle Maxterme (die vier 0-Zeilen):

f = (A ∨ B ∨ C) ∧ (A ∨ B ∨ ¬C) ∧ (A ∨ ¬B ∨ C) ∧ (¬A ∨ B ∨ C)

Beide Formeln beschreiben dieselbe Funktion – einmal über die 1-Stellen, einmal über die 0-Stellen. Welche Form kürzer ist, hängt davon ab, ob die Funktion mehr Einsen oder mehr Nullen hat: Hat die Funktion wenige Einsen, ist die DNF kürzer; hat sie wenige Nullen, ist die KNF kürzer.

Wichtig: Normalform ≠ minimale Form

DNF und KNF sind vollständig, aber meist nicht minimal. Die Mehrheitsfunktion lässt sich z. B. zu

f = (A ∧ B) ∨ (A ∧ C) ∨ (B ∧ C)

vereinfachen. Solche Minimierungen macht man per Boolescher Algebra (De Morgan, Distributivgesetz) oder grafisch mit dem KV-Diagramm (Karnaugh-Veitch) – das ist aber ein eigenes Thema.

NAND & NOR – die universellen Gatter

Eine Eigenschaft, die in Prüfungen gern abgefragt wird: NAND und NOR sind jeweils funktional vollständig. Das heißt, du kannst mit ausschließlich NAND-Gattern (oder ausschließlich NOR-Gattern) jede beliebige Logik nachbauen. Beispiele mit NAND:

Das ist auch ökonomisch relevant: In der Fertigung ist es günstiger, einen Chip mit nur einem Gattertyp zu bestücken, als mehrere Typen zu mischen.

Bonus: Wahrheitstabelle per PowerShell

Da du vermutlich eh schon eine PowerShell offen hast – damit kannst du dir die Wahrheitstabelle der Grundfunktionen schnell selbst ausgeben lassen. Praktisch zum Gegenprüfen:

<#
.SYNOPSIS
    Gibt die Wahrheitstabelle der logischen Grundfunktionen fuer zwei Eingaenge aus.
.DESCRIPTION
    Durchlaeuft alle vier Kombinationen von A und B und berechnet
    UND, ODER, XOR, NAND, NOR und XNOR ueber die bitweisen Operatoren.
.NOTES
    Name: PS_Wahrheitstabelle_Grundfunktionen
    Author: Andreas Bowitz
    Version: 0.1
    LastUpdated: 2026-Jun-03
#>

$ergebnis = foreach ($A in 0..1) {
    foreach ($B in 0..1) {
        [PSCustomObject]@{
            A    = $A
            B    = $B
            UND  = $A -band $B            # AND
            ODER = $A -bor  $B            # OR
            XOR  = $A -bxor $B            # XOR
            NAND = [int](-not ($A -band $B))
            NOR  = [int](-not ($A -bor  $B))
            XNOR = [int](-not ($A -bxor $B))
        }
    }
}

$ergebnis | Format-Table -AutoSize

Ausgabe:

A B UND ODER XOR NAND NOR XNOR
- - --- ---- --- ---- --- ----
0 0   0    0   0    1   1    1
0 1   0    1   1    1   0    0
1 0   0    1   1    1   0    0
1 1   1    1   0    0   0    1

Vergleiche das Ergebnis ruhig mit den Tabellen weiter oben – es passt Zeile für Zeile.

Fazit: Mit NICHT, UND, ODER hast du das komplette Fundament der Digitaltechnik in der Hand. NAND, NOR, XOR sind nur clevere Kombinationen davon, und über DNF/KNF bekommst du aus jeder Wahrheitstabelle systematisch eine Formel – ganz ohne Raten. Wer das sicher beherrscht, hat in der FISI-Prüfung bei Themen wie Schaltnetzen, KV-Diagrammen und Logikplänen einen klaren Vorteil. Im nächsten Schritt lohnt sich der Blick auf das KV-Diagramm zur Minimierung.

1. Das Fundament: Bit, Byte und das digitale Signal

Ein digitales Signal kennt nur zwei Zustände – im Gegensatz zum analogen, das jeden Zwischenwert annehmen kann:

Diese drei Schritte – Abtasten, Quantisieren, Codieren – tauchen bei allen drei Datentypen wieder auf. Wenn du das Muster einmal verstanden hast, ist der Rest nur noch Variation.

2. Text speichern: ASCII → ISO 8859 → Unicode

Text ist eine Folge von Zeichen. Damit ein Rechner sie speichern kann, bekommt jedes Zeichen über einen Zeichensatz einen festen Binärcode.

Das „A“ hat im ASCII-Code die Nummer 65, binär 01000001. Genau diese Zuordnung leistet ein Zeichensatz.

ASCII

• American Standard Code for Information Interchange, 1963 entwickelt.
• Ursprünglich 7 Bit → 2⁷ = 128 Zeichen (Buchstaben, Ziffern, Steuerzeichen).
• Später erweitert auf 8 Bit → 2⁸ = 256 Zeichen.

ISO 8859 (und der „ANSI“-Mythos)

• Erweiterung des ASCII-Zeichensatzes, jeweils 8 Bit pro Zeichen.
• Die Norm hat mehrere Teile (ISO 8859-1 „Latin-1“, -5 Kyrillisch, -7 Griechisch usw.), um zusätzliche Sprachen abzudecken.
• Achtung: „ANSI“ ist nicht dasselbe wie ISO 8859. ANSI ist die Normungsorganisation (American National Standards Institute). Unter Windows meint „ANSI-Kodierung“ meist die Codepage Windows-1252 – verwandt mit, aber nicht identisch zu ISO 8859-1.

Unicode / UTF

• Ab 1990 eingeführt, später als ISO/IEC 10646 normiert.
• Ziel: ein Zeichensatz für alle bekannten Schriftzeichen weltweit.
• Verbreitete Kodierungen: UTF-8, UTF-16, UTF-32.
• UTF-8 ist heute der De-facto-Standard im Web: Es ist abwärtskompatibel zu ASCII (die ersten 128 Zeichen sind identisch) und nutzt je nach Zeichen 1 bis 4 Byte.

Praxisbezug: Genau hier entstehen die berüchtigten „ä“-Salate. Das passiert, wenn ein UTF-8-codierter Text als ISO 8859-1 interpretiert wird (oder umgekehrt). Wenn du in Logs, CSVs oder DB-Exporten kaputte Umlaute siehst, ist fast immer ein Encoding-Mismatch schuld.

3. Bilder speichern: Raster vs. Vektor

Bei Grafiken gibt es zwei grundverschiedene Welten.

Rastergrafik (Pixelgrafik)

• Besteht aus einer Folge von Bildpunkten (Pixeln) – den Messpunkten eines Kamerasensors.
• Die Pixel sind in einem Raster angeordnet. Die Anzahl der Messpunkte entspricht der Auflösung, angegeben in dpi (dots per inch, 1 inch = 2,54 cm).
• + Jedes Pixel einzeln bearbeitbar, viele gängige Programme.
• − Skalierung (Vergrößern) ist verlustbehaftet → Klötzchen/Treppen.
• Formate: gif, jpg/jpeg, png, psd, tiff.

Vektorgrafik

• Speichert keine einzelnen Pixel, sondern das Bild als geometrische Objekte (Linien, Kreise, Polygone), beschrieben durch Vektoren (mathematisch minimal nötige Infos).
• Beispiel Kreis: Position/Mittelpunkt, Radius, Linienstärke, Farbe.
• + Verlustfrei skalierbar, verlustfreie Kompression.
• − Effekte wie Reflexionen/Schatten schwer darstellbar, spezielle Programme nötig; Anzeigegeräte sind auf Raster ausgelegt → oft Rasterung (Konvertierung) nötig.
• Formate: svg, ai, pdf, eps, wmf.

Farbtiefe – wie viele Bits pro Pixel?

Pro Messpunkt wird der Farbton gemessen und als Bitfolge codiert. Die Anzahl der Bits ist die Farbtiefe.

Wichtig (häufiger Klausurfehler): 8 Bit pro Kanal ergeben 256 Werte je Kanal. Erst alle drei Kanäle zusammen ergeben 256 × 256 × 256 = 16.777.216 Farben insgesamt – nicht „pro Kanal“.

Datenmenge einer Rastergrafik berechnen

Die Formel ist simpel:

Datenmenge [Bit] = Breite [px] × Höhe [px] × Farbtiefe [Bit]
Datenmenge [Byte] = Datenmenge [Bit] / 8

Beispiel (3209 × 2649 px, 24 Bit Farbtiefe):

3209 × 2649 × 24 = 204.015.384 Bit
204.015.384 / 8  = 25.501.923 Byte
25.501.923 / 1024 / 1024 ≈ 24,32 MiB

Würde man dasselbe Bild als reine 1-Bit-Bitmap (Schwarz/Weiß) ablegen, blieben nur die Pixel selbst:

3209 × 2649 × 1 = 8.500.641 Bit  (≈ 8,5 Mbit)
8.500.641 / 8 / 1024 / 1024 ≈ 1,013 MiB

Stolperfalle: 8.500.641 Bit sind ≈ 8,5 Mbit, nicht 0,85 Mbit. Bei MB/MiB außerdem aufpassen: Die Rechnung oben nutzt 1024er-Schritte → korrekt wäre die Einheit MiB (Mebibyte). In Datenblättern wird „MB“ oft als 1.000.000 Byte gemeint – das gibt leicht abweichende Zahlen.

4. Ton speichern: Sampling, Nyquist & Co.

Ein Audiosignal ist in der Natur analog (eine kontinuierliche Welle). Für die digitale Speicherung wird es per Sampling in eine diskrete Treppenfunktion verwandelt.

Beim Sampling wird die Amplitude des Signals in festen Zeitabständen gemessen (abgetastet) und als numerischer Wert gespeichert. Mit T als Periodendauer (Abtastperiode in Sekunden) gilt:

f = 1 / T   [Hz]      (1 Hz = 1 Messung pro Sekunde)

Sampling-Rate (Sampling-Frequenz)

• Anzahl der Messvorgänge/Abtastungen pro Sekunde.
• Audio-CD: 44,1 kHz → 44.100 Abtastungen pro Sekunde.

Nyquist-Shannon-Abtasttheorem

• Um ein analoges Signal verlustfrei rekonstruieren zu können, muss die Abtastrate mehr als das Doppelte der höchsten enthaltenen Frequenz betragen.
• Menschliches Gehör: ca. 20 Hz – 20 kHz.
• → Theoretisch reichen knapp über 40 kHz. Die CD nutzt mit 44,1 kHz bewusst etwas Reserve (für Filter-Spielraum).

Stolperfalle: Im Lernzettel stand „40,1 kHz“. Das ist ein Zahlendreher. Gemeint ist: > 40 kHz nötig, CD-Standard 44,1 kHz.

Sampling-Tiefe (Bit-Tiefe)

• Anzahl der Bits, mit denen ein einzelner Abtastwert gespeichert wird → bestimmt die Wertauflösung (Dynamik).
• Standard: 16 Bit (CD-Qualität). Studio: 24 oder 32 Bit (32 Bit meist als Fließkomma). 64 Bit ist in der Praxis unüblich.

Tonkanäle (für Raumklang)

Mono · Stereo · Dolby Surround · 5.1-Sound.

5. Praxis: kleine PowerShell-Helfer

Für FISI-Azubis (und für mich im Alltag) sind zwei Mini-Skripte hilfreich, um die Theorie anfassbar zu machen.

a) Zeichen → Codepoint → Bitfolge anzeigen

<#
.SYNOPSIS
    Zeigt fuer einen Text je Zeichen den Unicode-Codepoint sowie die ASCII-/UTF-8-Bitfolge.
.NOTES
    Name:        PS_Zeichen_zu_Bitfolge
    Author:      Andreas Bowitz
    Version:     1.0
    LastUpdated: 2026-Jun-03
#>

param(
    [string]$Text = "Andi"
)

foreach ($char in $Text.ToCharArray()) {
    $code = [int][char]$char                              # Unicode-Codepoint (dezimal)
    $bin  = [Convert]::ToString($code, 2).PadLeft(8, '0') # Binaer, auf 8 Bit aufgefuellt
    $hex  = "0x{0:X2}" -f $code                            # Hexadezimal

    [PSCustomObject]@{
        Zeichen   = $char
        Dezimal   = $code
        Hex       = $hex
        Bitfolge  = $bin
    }
}

Für "Andi" liefert das u. a. A → 65 → 0x41 → 01000001. Genau das zeigt auch die Grafik oben.

b) Datenmenge einer Rastergrafik berechnen

<#
.SYNOPSIS
    Berechnet die unkomprimierte Datenmenge einer Rastergrafik aus Breite, Hoehe und Farbtiefe.
.NOTES
    Name:        PS_Bilddatenmenge_berechnen
    Author:      Andreas Bowitz
    Version:     1.0
    LastUpdated: 2026-Jun-03
#>

param(
    [int]$BreitePx   = 3209,
    [int]$HoehePx    = 2649,
    [int]$FarbtiefeBit = 24
)

$bits  = [double]$BreitePx * $HoehePx * $FarbtiefeBit
$bytes = $bits / 8
$mib   = $bytes / 1024 / 1024

[PSCustomObject]@{
    Pixel       = $BreitePx * $HoehePx
    Bit         = $bits
    Byte        = [math]::Round($bytes, 0)
    MiB         = [math]::Round($mib, 2)
} | Format-List

Ausgabe für die Beispielwerte: ≈ 24,32 MiB – passt zur Handrechnung oben.

6. Stolperfallen aus der technischen Prüfung

Damit der Stoff klausurfest sitzt, hier gesammelt die korrigierten Klassiker:

1. Nyquist: Es heißt „mehr als das Doppelte“ der höchsten Frequenz – nicht „40,1 kHz“. Gehör bis 20 kHz → >40 kHz nötig → CD: 44,1 kHz.
2. Farben bei 24 Bit: 256 Werte pro Kanal, aber 16.777.216 Farben insgesamt – nicht „pro Kanal“.
3. ISO 8859: mehrere Teile, jeweils 8 Bit (nicht 18 Bit). Und ANSI ≠ ISO 8859 (ANSI = Organisation; Windows-„ANSI“ = CP-1252).
4. Einheiten: 8.500.641 Bit ≈ 8,5 Mbit. Bei /1024-Rechnungen ist die korrekte Einheit MiB, nicht „MB“.
5. Sampling-Tiefe: Standard 16 Bit, Studio 24/32 Bit. 64 Bit ist praktisch nicht gebräuchlich.

TL;DR

Das gemeinsame Muster bleibt immer gleich: Abtasten → Quantisieren → Codieren.

1. Womit man rechnet: Größen und Einheiten

Eine physikalische Größe ist eine messbare Eigenschaft – z. B. Länge, Temperatur oder Spannung. Sie besteht immer aus einem Zahlenwert und einer Einheit: 230 V, 3,4 m, 36 °C.

In der Technik rechnet man ausschließlich mit SI-Einheiten (oder davon abgeleiteten Einheiten). Die sieben Basisgrößen:

Sehr große oder kleine Werte kürzt man mit Einheitenvorsätzen ab – das spart Nullen und Nerven:

Als ITler kennst du das längst – nur dass k in der Datenwelt manchmal 1024 statt 1000 meint. In der Elektrotechnik ist k immer sauber 1000.

2. Der Sprung aus der Mechanik: Arbeit, Energie, Leistung

Bevor es elektrisch wird, drei mechanische Begriffe, die später 1:1 wiederkommen.

• Gewichtskraft: F_G = m · g mit g = 9,81 m/s². Eine 15-kg-Kiste zieht mit 15 · 9,81 = 147 N nach unten.
• Arbeit: W = F · s – Kraft mal Weg, Einheit Newtonmeter (Nm) bzw. Joule (J).
• Energie ist das Vermögen, Arbeit zu leisten. Sie wird nicht verbraucht, nur umgewandelt (Energieerhaltungssatz). Eine angehobene Last speichert potenzielle Energie, beim Absenken wird daraus kinetische Energie.
• Leistung: P = W / t – verrichtete Arbeit pro Zeit, Einheit Watt (W).

Merke dir das Verhältnis von Arbeit und Leistung – das ist exakt der Unterschied zwischen „wie viel Energie insgesamt“ (kWh auf deiner Stromrechnung) und „wie schnell“ (Watt auf dem Netzteil).

3. Der Stromkreis

Damit Strom fließt, braucht es einen geschlossenen Weg: einen Erzeuger (Spannungsquelle), einen Verbraucher und Hin- und Rückleiter dazwischen. Unterbricht ein Schalter den Weg, ist Schluss.

Zwei Richtungen, die man nicht verwechseln darf:

• Technische Stromrichtung (rot): außerhalb des Erzeugers von Plus nach Minus. Reine Konvention – historisch festgelegt, bevor man das Elektron kannte.
• Elektronenbewegung (blau): die freien Elektronen wandern tatsächlich vom Minuspol weg (Elektronenüberschuss) zum Pluspol – also entgegen der technischen Stromrichtung.

Praxis-Wahrheit: Die Elektronen selbst kriechen nur mit ca. 0,1 – 10 mm/s durch den Leiter (Driftgeschwindigkeit). Trotzdem leuchtet die Lampe sofort, weil sich der elektrische Impuls fast mit Lichtgeschwindigkeit (≈ 300 000 km/s) durch den Leiter fortpflanzt – wie ein voll gefülltes Rohr, bei dem vorne sofort Wasser rauskommt, wenn du hinten drückst.

Leiter, Nichtleiter, Halbleiter

Die Halbleiter sind der Grund, warum du diesen Artikel überhaupt liest: Jeder Transistor, jede CPU, jeder SSD-Flashspeicher basiert auf gezielt „verunreinigtem“ Silizium.

4. Elektrische Ladung Q – die Wurzel von allem

Reibt man einen Kunststoffstab an Wolle, zieht er Papierschnipsel an. Ursache ist die elektrische Ladung Q. Es gibt zwei Sorten:

• Gleichartige Ladungen stoßen sich ab.
• Ungleichartige Ladungen ziehen sich an.

Woher die Ladung kommt, zeigt der Atomaufbau (bohrsches Modell): Ein Atom hat einen Kern (Protonen +, Neutronen neutral) und eine Hülle aus Elektronen −. Werden Elektronen verschoben, entsteht ein Ladungsunterschied.

Die kleinste mögliche Ladung ist die Elementarladung:

e = 1,602 · 10⁻¹⁹ C        (Einheit: Coulomb, C)

Jede Ladung ist ein Vielfaches davon:

Q = n · e

Eine Ladung von 1 Coulomb entspricht also rund 6,242 · 10¹⁸ Elektronen – das ist die Zahl 1 / e. Sechs Trillionen Elektronen für eine einzige Sekunde 1-A-Strom. Elektronen sind verdammt klein.

5. Elektrische Spannung U

In einer Spannungsquelle werden Ladungen getrennt: ein Pol bekommt Elektronenüberschuss (Minus), der andere Elektronenmangel (Plus). Diese Trennung kostet Arbeit – und die steckt als Energie in den getrennten Ladungen.

U = W / Q        (Einheit: Volt, V)

Spannung ist also Arbeit pro Ladung. Anschaulich wie ein gespanntes Gummiband: Je weiter (= mehr Arbeit) du die Ladungen auseinanderziehst, desto höher die Spannung.

Spannung ist immer eine Differenz zwischen zwei Punkten (Potenzialen). Liegt Punkt A auf φ_A = 9 V und Punkt B auf φ_B = 6 V, beträgt die Spannung dazwischen U = 9 V − 6 V = 3 V.

Sicherheit: Das Berühren von Spannungen über 50 V (AC) kann lebensgefährlich sein. Das ist kein „kann mal pieksen“ – respektiere das, auch im Serverraum hinter der USV.

Wie Spannung erzeugt wird

6. Elektrischer Strom I

Fließen die getrennten Ladungen über einen Verbraucher wieder zusammen, ist das der elektrische Strom: die gerichtete Bewegung freier Elektronen.

I = Q / t        (Einheit: Ampere, A)

Stromstärke ist also Ladung pro Zeit. 1 A bedeutet: pro Sekunde wandert 1 C (also ~6,242 · 10¹⁸ Elektronen) durch den Leiterquerschnitt.

Was Strom alles anrichtet (die fünf Wirkungen)

Die drei Stromarten

• Gleichstrom (DC): fließt nur in eine Richtung, gleichbleibende Stärke → gerade Linie. (Batterie, Netzteil-Ausgang, USB)
• Wechselstrom (AC): Richtung und Stärke wechseln ständig → Sinuskurve. (Steckdose mit 230 V / 50 Hz)
• Mischstrom (UC): Gleichstrom mit überlagertem Wechselanteil → pulsierender Gleichstrom. (z. B. hinter einem Gleichrichter vor der Glättung)

7. Stromdichte J – warum dünne Kabel heiß werden

Durch jeden Querschnitt fließen pro Sekunde gleich viele Elektronen – egal ob dick oder dünn. Im dünnen Leiter müssen sie sich aber schneller durchquetschen → mehr Reibung → mehr Wärme.

J = I / A        (Einheit: A/mm²)

Deshalb gibt es höchstzulässige Stromstärken je Querschnitt (DIN VDE 0298-4). Ein paar Werte für fest verlegte, PVC-isolierte Kupferleitungen (Verlegeart B2, 30 °C):

Genau deshalb riecht ein überlastetes, unterdimensioniertes Verlängerungskabel im Serverschrank irgendwann verschmort. Stromdichte ist kein Theorie-Kram.

8. Alles auf einen Blick

9. Bonus: kleiner Elektro-Rechner in PowerShell

Weil’s hier um IT geht – und weil man Grundlagen am besten behält, wenn man damit spielt: eine kleine Funktion, die dir die wichtigsten Grundgrößen ausrechnet. Kein Programmier-Hexenwerk, reines PowerShell.

<#
.SYNOPSIS
    Berechnet elektrische Grundgroessen (Ladung, Strom, Leistung, Arbeit,
    Anzahl Elektronen) aus den jeweils bekannten Werten.

.DESCRIPTION
    Lernhilfe zu den Grundbegriffen der Elektrotechnik. Es werden nur die
    Parameter angegeben, die bekannt sind - die Funktion leitet daraus die
    abhaengigen Groessen ab.

.PARAMETER Spannung   Spannung U in Volt (V)
.PARAMETER Strom      Stromstaerke I in Ampere (A)
.PARAMETER Zeit       Zeit t in Sekunden (s)
.PARAMETER Ladung     Ladung Q in Coulomb (C)

.EXAMPLE
    Get-ElektroGrundgroessen -Spannung 230 -Strom 2 -Zeit 3600

.NOTES
    Name:        Get-ElektroGrundgroessen
    Author:      Andreas Bowitz
    Version:     0.1
    LastUpdated: 2026-Jun-03
#>
function Get-ElektroGrundgroessen {
    [CmdletBinding()]
    param(
        [double]$Spannung,   # U in Volt
        [double]$Strom,      # I in Ampere
        [double]$Zeit,       # t in Sekunden
        [double]$Ladung      # Q in Coulomb
    )

    # Elementarladung (Coulomb)
    $e = 1.602176634e-19

    $result = [ordered]@{}

    # Ladung aus Strom * Zeit  (Q = I * t)
    if ($Strom -and $Zeit -and -not $Ladung) {
        $Ladung = $Strom * $Zeit
    }
    # Strom aus Ladung / Zeit  (I = Q / t)
    elseif ($Ladung -and $Zeit -and -not $Strom) {
        $Strom = $Ladung / $Zeit
    }

    if ($Ladung)  { $result['Ladung Q (C)']          = [math]::Round($Ladung, 4) }
    if ($Strom)   { $result['Strom I (A)']           = [math]::Round($Strom, 4) }
    if ($Ladung)  { $result['Anzahl Elektronen n']   = "{0:E3}" -f ($Ladung / $e) }

    # Leistung  (P = U * I)
    if ($Spannung -and $Strom) {
        $leistung = $Spannung * $Strom
        $result['Leistung P (W)'] = [math]::Round($leistung, 3)

        # Arbeit  (W = P * t)
        if ($Zeit) {
            $arbeit = $leistung * $Zeit
            $result['Arbeit W (Ws)']  = [math]::Round($arbeit, 1)
            $result['Arbeit W (kWh)'] = [math]::Round($arbeit / 3.6e6, 4)
        }
    }

    [pscustomobject]$result
}

# Beispielaufruf: 230 V, 2 A, eine Stunde
Get-ElektroGrundgroessen -Spannung 230 -Strom 2 -Zeit 3600

Erwartete Ausgabe:

Ladung Q (C)         : 7200
Strom I (A)          : 2
Anzahl Elektronen n  : 4.494E+022
Leistung P (W)       : 460
Arbeit W (Ws)        : 1656000
Arbeit W (kWh)       : 0,46

460 W über eine Stunde sind also 0,46 kWh – das passt sauber zur Logik deiner Stromrechnung.

10. Faktencheck (IT-Agent-Review)

Damit hier nichts Halbgares stehen bleibt, zwei Punkte, die in vielen älteren Lehrunterlagen schlampig sind:

1. Definition des Ampere. Ältere Quellen definieren 1 A über die Kraft zwischen zwei parallelen Leitern: bei 1 m Abstand und 1 A wirkt je Meter eine Kraft von 2 · 10⁻⁷ N/m (nicht 2 · 10⁷ – das ist ein verbreiteter Tipp-/OCR-Fehler um 14 Zehnerpotenzen daneben). Seit der SI-Reform 2019 ist diese Krafdefinition überholt: Das Ampere wird heute über die fest definierte Elementarladung e = 1,602176634 · 10⁻¹⁹ C festgelegt. Fürs Grundverständnis bleibt I = Q / t aber völlig richtig.
2. Rechenwerte geprüft: F_G = 15 kg · 9,81 m/s² = 147 N · 1 C ≙ 6,242 · 10¹⁸ Elektronen · P = 230 V · 2 A = 460 W · 460 W · 1 h = 0,46 kWh .

SEO / Marketing-Agent (Meta für Yoast/RankMath): Title: RAID-Level einfach erklärt: Vor- & Nachteile + NetApp | abow.info Description: RAID 0, 1, 5, 6, 10 verständlich erklärt – Kapazität, Ausfallsicherheit, Vor- und Nachteile. Plus: Warum RAID kein Backup ist und wie NetApp mit RAID-DP/RAID-TEC arbeitet.

Inhaltsverzeichnis

1. Worum geht’s?
2. JBOD – der ehrliche Haufen Platten
3. Was bedeutet RAID eigentlich?
4. Die wichtigsten RAID-Level im Überblick
5. RAID-Level im direkten Vergleich (Tabelle)
6. Vor- und Nachteile – wann nimmst du was?
7. Warum RAID kein Backup ist
8. Der NetApp-Blick: RAID 4, RAID-DP & RAID-TEC
9. PowerShell: Storage-Health auslesen
10. Fazit

Worum geht’s?

Du hast mehrere Festplatten und willst entweder mehr Speed, mehr Kapazität, mehr Ausfallsicherheit – oder eine Mischung daraus. Genau das löst RAID. In diesem Beitrag gehe ich die gängigen RAID-Level durch, zeige dir Kapazität und Ausfalltoleranz, die ehrlichen Vor- und Nachteile, und am Ende werfe ich einen Blick darauf, wie ein Enterprise-Storage-Hersteller wie NetApp das Thema angeht.

IT-Agent (Faktencheck vorab): RAID stand ursprünglich für Redundant Array of Inexpensive Disks (Patterson, Gibson & Katz, Berkeley 1987). Erst das Marketing machte später Independent daraus, weil „billig“ im Enterprise-Vertrieb schlecht klang. Beide Schreibweisen sind heute geläufig – „Independent“ ist die offizielle.

JBOD – der ehrliche Haufen Platten

JBOD = Just a Bunch Of Disks. Hier arbeiten die Platten nicht zusammen – sie werden einfach als einzelne Laufwerke (oder linear aneinandergehängt = „Spanning“) präsentiert. Keine Redundanz, kein Performance-Gewinn durch Verteilung, keine Magie. JBOD ist genau das, was draufsteht: ein Bündel Platten.

Was bedeutet RAID eigentlich?

RAID = Redundant Array of Independent Disks. Mehrere Datenträger arbeiten zusammen, um eines oder mehrere dieser Ziele zu erreichen:

• Ausfallsicherheit – eine (oder mehrere) Platte(n) dürfen sterben, ohne dass Daten verloren gehen.
• Performance – Lese-/Schreibzugriffe werden auf mehrere Spindeln/SSDs verteilt.
• Kapazität – mehrere Platten bilden ein großes logisches Volume.

Erreicht wird das über drei Grundtechniken, die je nach Level kombiniert werden:

Die wichtigsten RAID-Level im Überblick

Im Folgenden ist n = Anzahl der Platten, S = Kapazität pro Platte (gleich große Platten vorausgesetzt).

RAID 0 – Striping

Daten werden über alle Platten gestriped. Maximale Kapazität und Geschwindigkeit, aber null Redundanz.

• Kapazität: n × S
• Mindestens: 2 Platten
• Ausfalltoleranz: 0 – fällt eine Platte aus, sind alle Daten weg.

RAID 1 – Mirroring

Jede Platte ist die identische Kopie der anderen.

• Kapazität: S (bei 2 Platten); allgemein (n × S) / 2 bei Spiegelpaaren
• Mindestens: 2 Platten
• Ausfalltoleranz: 1 Platte pro Spiegel

RAID 10 (1+0) – Mirror + Stripe

Erst spiegeln, dann über die Spiegelpaare stripen. Kombiniert Speed und Sicherheit.

• Kapazität: (n × S) / 2
• Mindestens: 4 Platten
• Ausfalltoleranz: pro Spiegelpaar darf 1 Platte ausfallen

IT-Agent (Korrektur zu deinen Notizen): In den handschriftlichen Notizen stand bei RAID 10 „mind. 2 Festplatten“. Das ist nicht korrekt – RAID 10 braucht mindestens 4 Platten, weil es ein Stripe über gespiegelte Paare ist. Mit 2 Platten hättest du nur ein RAID 1.

RAID 3 – Striping + dedizierte Parität

Byte-weises Striping mit einer eigenen, festen Paritätsplatte. Heute praktisch ausgestorben: Die einzelne Paritätsplatte ist ein Flaschenhals, RAID 5 hat es abgelöst. Gut zu kennen für die Prüfung, in der Praxis kaum noch anzutreffen.

RAID 5 – Striping + verteilte Parität

Daten und Parität werden über alle Platten verteilt (keine dedizierte Paritätsplatte mehr).

• Kapazität: (n − 1) × S
• Mindestens: 3 Platten
• Ausfalltoleranz: 1 Platte – fällt eine zweite aus, bevor die erste rekonstruiert ist → vollständiger Datenverlust.

RAID 6 – Striping + doppelte Parität

Wie RAID 5, aber mit zwei unabhängigen Paritätsblöcken (P und Q).

• Kapazität: (n − 2) × S
• Mindestens: 4 Platten
• Ausfalltoleranz: 2 Platten gleichzeitig

RAID-Level im direkten Vergleich

Level	Technik	Min. Platten	Nutzkapazität	Ausfalltoleranz	Lesen	Schreiben
RAID 0	Striping	2	n × S	0
RAID 1	Mirroring	2	(n × S)/2	1 / Spiegel
RAID 5	Striping + Parität	3	(n − 1) × S	1		(Write-Penalty)
RAID 6	Striping + 2× Parität	4	(n − 2) × S	2		(2× Write-Penalty)
RAID 10	Mirror + Stripe	4	(n × S)/2	≥ 1 (je Spiegel)

IT-Agent (Stichwort Write-Penalty): Bei RAID 5/6 muss für jeden kleinen Schreibvorgang erst gelesen, dann neu berechnet und wieder geschrieben werden (Read-Modify-Write). Das kostet IOPS. RAID 5 hat die „Write-Penalty 4″, RAID 6 sogar „6″. Merk dir das – es erklärt, warum datenbanklastige Systeme oft RAID 10 fahren.

Vor- und Nachteile – wann nimmst du was?

RAID 0

• Maximale Kapazität & Speed, kein Verschnitt
• Keinerlei Sicherheit – nur für Wegwerf-Daten (Scratch, Cache, Videoschnitt-Puffer)

RAID 1

• Simpel, schnelle Reads, sofort einsatzbereit nach Plattentausch
• 50 % Kapazitätsverlust, Schreibrate ≈ einer Einzelplatte

RAID 5

• Guter Kompromiss aus Kapazität und Sicherheit, nur 1 Platte „Verlust“
• Schwache Schreibperformance, riskant bei großen Platten (siehe Rebuild-Problem unten)

RAID 6

• Übersteht zwei gleichzeitige Ausfälle – ideal für große SATA-Platten
• Noch langsamere Schreibvorgänge, 2 Platten „Verlust“

RAID 10

• Bester Allrounder für Performance + Sicherheit, schnelle Rebuilds
• Teuer – 50 % der Rohkapazität gehen für Spiegel drauf

IT-Agent (Rebuild-Falle bei RAID 5): Je größer die Platten, desto länger dauert ein Rebuild – und während des stundenlangen Rebuilds werden alle übrigen Platten voll belastet. Steigt dabei eine zweite aus (oder taucht ein Lesefehler / URE auf), ist bei RAID 5 alles weg. Genau deshalb gilt RAID 5 bei großen Kapazitäten als überholt und man greift zu RAID 6 oder RAID 10.

Warum RAID kein Backup ist

Der wichtigste Satz des ganzen Beitrags:

RAID schützt vor Hardware-Ausfall – nicht vor Datenverlust.

RAID hilft dir nicht bei:

• versehentlich gelöschten Dateien (der Löschvorgang wird brav auf alle Platten gespiegelt),
• Ransomware / Verschlüsselung,
• defektem Dateisystem oder Controller-Fehlern,
• Feuer, Diebstahl, Überspannung (lokaler Totalverlust).

RAID = Verfügbarkeit. Backup = Wiederherstellbarkeit. Du brauchst beides. Stichwort 3-2-1-Regel: 3 Kopien, 2 verschiedene Medien, 1 Kopie außer Haus.

Der NetApp-Blick: RAID 4, RAID-DP & RAID-TEC

Im Enterprise-Storage sieht die RAID-Welt etwas anders aus. NetApp setzt in seinem Betriebssystem ONTAP nicht primär auf RAID 5/6, sondern auf drei eigene Verfahren:

• RAID 4 – Striping mit dedizierter Paritätsplatte (eigentlich der „alte“ Ansatz, der unter RAID 5 ausgemustert wurde).
• RAID-DP (Double Parity) – RAID 4 erweitert um eine zweite, diagonale Paritätsplatte. Übersteht zwei gleichzeitige Ausfälle und erfüllt damit die SNIA-Definition von RAID 6. Eingeführt 2003 mit Data ONTAP 6.5.
• RAID-TEC (Triple Erasure Coding) – dritte Parität, übersteht drei gleichzeitige Ausfälle. Default-Policy für große Kapazitäts-HDDs (ab ca. 6 TB).

Warum tut NetApp das mit einer dedizierten Paritätsplatte überhaupt?

Normalerweise wäre eine feste Paritätsplatte ein Flaschenhals. NetApp umgeht das über das Dateisystem WAFL (Write Anywhere File Layout): Schreibvorgänge werden im RAM zu kompletten Stripes zusammengefasst und am Stück geschrieben – inklusive vorab berechneter Parität. Dadurch entfällt das teure Read-Modify-Write und die Write-Penalty fällt praktisch weg.

IT-Agent (Begriffs-Hierarchie bei NetApp): Die Reihenfolge ist Platten → RAID-Gruppen → Aggregat → Volumes. Mehrere Platten bilden eine RAID-Gruppe (RAID 4 / DP / TEC), mehrere RAID-Gruppen bilden ein Aggregat, darauf liegen die FlexVols. Das ist ein beliebter Stolperstein, wenn man von „klassischem“ Hardware-RAID kommt.

Marketing-Agent (Merksatz für den Leser): „RAID-DP gibt dir RAID-6-Sicherheit zum RAID-4-Preis.“ Genau so hat NetApp das damals beworben – und für die Prüfung ist es ein guter Anker: DP = doppelt, TEC = dreifach.

PowerShell: Storage-Health auslesen

Unter Windows (Server 2012+ / Win 8+) kannst du den Zustand deiner physischen Platten, Storage Pools und virtuellen Datenträger (Storage Spaces) mit dem nativen Storage-Modul auslesen. Hier ein kleines Skript, das dir alles kompakt auf einen Blick gibt – lokal oder per Remoting über mehrere Hosts:

<#
.NOTES
    Name: Get-StorageHealth
    Author: Andreas Bowitz
    Version: 0.1
    LastUpdated: 2026-Jun-03
#>

[CmdletBinding()]
param(
    [string[]]$ComputerName = $env:COMPUTERNAME
)

function Get-LocalStorageHealth {

    Write-Host "`n=== Physische Datenträger ===" -ForegroundColor Cyan
    Get-PhysicalDisk |
        Sort-Object DeviceId |
        Select-Object DeviceId, FriendlyName, MediaType,
            @{N = 'Size(GB)'; E = { [math]::Round($_.Size / 1GB, 1) } },
            HealthStatus, OperationalStatus |
        Format-Table -AutoSize

    Write-Host "=== Storage Pools ===" -ForegroundColor Cyan
    $pools = Get-StoragePool -IsPrimordial $false -ErrorAction SilentlyContinue
    if ($pools) {
        $pools |
            Select-Object FriendlyName,
                @{N = 'Size(GB)';      E = { [math]::Round($_.Size / 1GB, 1) } },
                @{N = 'Allocated(GB)'; E = { [math]::Round($_.AllocatedSize / 1GB, 1) } },
                HealthStatus, OperationalStatus |
            Format-Table -AutoSize
    }
    else {
        Write-Host "  Keine (nicht-primordialen) Storage Pools gefunden." -ForegroundColor DarkGray
    }

    Write-Host "=== Virtuelle Datenträger (Storage Spaces) ===" -ForegroundColor Cyan
    $vdisks = Get-VirtualDisk -ErrorAction SilentlyContinue
    if ($vdisks) {
        $vdisks |
            Select-Object FriendlyName, ResiliencySettingName,
                @{N = 'Size(GB)'; E = { [math]::Round($_.Size / 1GB, 1) } },
                HealthStatus, OperationalStatus |
            Format-Table -AutoSize
    }
    else {
        Write-Host "  Keine virtuellen Datenträger gefunden." -ForegroundColor DarkGray
    }
}

foreach ($computer in $ComputerName) {
    Write-Host "`n############################################" -ForegroundColor Yellow
    Write-Host "  Host: $computer" -ForegroundColor Yellow
    Write-Host "############################################" -ForegroundColor Yellow

    if ($computer -eq $env:COMPUTERNAME) {
        Get-LocalStorageHealth
    }
    else {
        if (Test-Connection -ComputerName $computer -Count 1 -Quiet) {
            try {
                Invoke-Command -ComputerName $computer `
                    -ScriptBlock ${function:Get-LocalStorageHealth} -ErrorAction Stop
            }
            catch {
                Write-Warning "  $computer : $($_.Exception.Message)"
            }
        }
        else {
            Write-Warning "  $computer ist nicht erreichbar (Ping fehlgeschlagen)."
        }
    }
}

IT-Agent (wichtige Einschränkung): Get-PhysicalDisk & Co. zeigen dir Software-RAID / Storage Spaces und den SMART-Status einzelner Disks. Steckt dein RAID hinter einem Hardware-Controller (Dell PERC, HPE Smart Array) oder einem NetApp-Filer, siehst du dort oft nur ein einziges logisches Volume. Für den echten RAID-Status brauchst du dann die Vendor-Tools: StorCLI / ssacli bzw. den NetApp System Manager oder die ONTAP CLI (storage aggregate show, storage disk show).

<a name=“fazit“></a>

Fazit

• RAID 0 = Speed/Kapazität, null Sicherheit.
• RAID 1 = simpel & sicher, halbe Kapazität.
• RAID 5 = guter Kompromiss, aber bei großen Platten riskant (Rebuild-Falle).
• RAID 6 = zwei Platten dürfen sterben – die vernünftige Wahl für große Arrays.
• RAID 10 = der Performance-Sicherheits-King, aber teuer.
• NetApp kocht mit RAID 4 / RAID-DP / RAID-TEC sein eigenes Süppchen – clever gelöst über WAFL.

Und nie vergessen: RAID ist kein Backup.

Wie immer berichte ich hier nur von meinen persönlichen Erfahrungen und Ergebnissen. Dies ist keine offizielle Anleitung von Microsoft oder NetApp. Das Nutzen von Skripten geschieht auf eigene Gefahr.

Diese Dokumentation basiert auf der Installation eines CU auf dem eigenständigen Exchange-Server exch01.domain.tld, der vorab mit allen aktuellen Windows-Updates versorgt wurde. Die zugrunde liegende Umgebung ist ein Multi-AD-Forest mit Child-Domain – also deutlich komplexer als eine Single-Forest-/Single-Domain-Struktur.

Wichtig vorab (Stand: Juni 2026): Exchange 2016/2019 sind End of Support

Exchange Server 2016 und 2019 haben am 14. Oktober 2025 das Support-Ende erreicht. Es gibt seitdem keine regulären Sicherheitsupdates, Bugfixes oder technischen Support mehr. Wer noch im Programm der Extended Security Updates (ESU) ist, erhält Updates nur noch bis April 2026 – das ist ausdrücklich nur ein Übergang, keine Dauerlösung.

Die einzige weiterhin unterstützte On-Prem-Variante ist Exchange Server Subscription Edition (SE). Exchange SE RTM ist code-identisch mit Exchange 2019 CU15; SE CU1 kam in H1/2026, SE CU2 folgt in H2/2026 und blockt dann die Koexistenz mit 2016/2019.

Konsequenz für dieses Thema: Reine CU-Installationen auf 2016/2019 sind heute fast nur noch im Rahmen einer In-Place-Migration nach SE relevant (2019 CU14/CU15 → SE) oder mit aktivem ESU. Der hier beschriebene Ablauf gilt aber technisch unverändert auch für Exchange Server SE – Modern Servicing bedeutet lediglich: Es ist immer nur das aktuellste CU supported (kein „N-1″ mehr).

Voraussetzungen

Passende Berechtigungen

Für das Update wird ein Benutzerkonto benötigt, das Mitglied in folgenden Gruppen ist:

• Organization Management
• Organisations-Admins (Enterprise Admins)
• Schema-Admins

Nur damit ist sichergestellt, dass alle Änderungen am Active-Directory-Schema und an der Exchange-Organisation durchgeführt werden können. Fehlen die Rechte, schlägt die Installation fehl – und die Ursache lässt sich oft nur mit gezielter Log-Recherche nachvollziehen.

In seltenen Konstellationen (wie z. B. bei domain.tld) ist die Gruppe Organisations-Admins nicht automatisch Mitglied der Domänen-Admins jeder betroffenen Domäne. Dann muss PrepareDomain zwingend mit einem Benutzer aus der Domänen-Admins-Gruppe der jeweiligen Domäne ausgeführt werden.

Vorbereitung der Arbeiten

Je nach Umgebung unterscheiden sich die Vorbereitungsschritte. Vieles lässt sich aber schon im Vorfeld erledigen.

Übersicht der Exchange-Server erfassen

Erstelle vorab eine Übersicht aller Exchange-Server inklusive Dienstestatus, Build-Versionen und ggf. Rollenverteilung. Das dokumentiert den IST-Zustand sauber und hilft im Fehlerfall enorm.

Tipp: Microsoft empfiehlt offiziell den Exchange Server Health Checker (PowerShell-Skript), um vorab zu sehen, welche CUs/SUs/manuellen Schritte ausstehen. Den IST-Zustand kannst du außerdem mit dem unten verlinkten Pre-Flight-Skript einsammeln.

Beginn der Arbeiten kommunizieren

Vor dem Start der Wartung den Kunden/Service Owner rechtzeitig informieren, damit Einschränkungen bekannt und eingeplant sind.

Exchange-Version ermitteln

Zuerst feststellen, welche Version aktuell läuft – per Exchange Management Shell oder EAC.

Get-ExchangeServer | Select-Object Name, AdminDisplayVersion | Format-Table

Beispielausgabe:

Name    AdminDisplayVersion
----    -------------------
EXCH01  Version 15.1 (Build 2044.4)
EXCH02  Version 15.1 (Build 2044.4)

Die Build-Nummer ordnest du über die Microsoft-Liste der konkreten CU-Version zu: Exchange Build Numbers and Release Dates (Microsoft Learn)

Build-Logik kurz erklärt: 15.0.x = Exchange 2013, 15.1.x = Exchange 2016, 15.2.x = Exchange 2019 / Exchange SE. Im Beispiel entspricht 15.1.2044.4 dem Exchange 2016 CU17.

CU-Version der Setup-Datei prüfen

Welche Version ein vorhandenes Setup-Paket enthält:

Get-Command Exsetup.exe | ForEach-Object { $_.FileVersionInfo }

Download der aktuellen CU/SE-Version

Aktuelle Pakete (Exchange SE bzw. die letzten ESU-fähigen SUs für 2016/2019) gibt es bei Microsoft. Nutze zur Pfadbestimmung den Exchange Update Wizard, der dir abhängig von Quell- und Ziel-CU die genauen Schritte ausgibt.

Besonderheit: UM Language Pack

Hinweis: Unified Messaging (UM) wurde mit Exchange 2019 entfernt und ist in Exchange SE nicht mehr vorhanden. Dieser Abschnitt ist daher nur noch für Exchange 2016 relevant.

Falls UM eingesetzt wird, ist ggf. ein UM Language Pack installiert (z. B. für Voicemail-Ansagen). Es muss nach dem CU-Update in passender Version neu installiert werden und erscheint in der Systemsteuerung unter Programme und Features.

Prüfen, ob ein Language Pack aktiv ist:

Get-UMService | Select-Object Name, Languages

Wird nur {en-US} ausgegeben, ist kein zusätzliches Sprachpaket installiert.

.NET Framework-Version ermitteln

Am einfachsten per PowerShell (als Administrator):

(Get-ItemProperty "HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full").Release

Beispielausgabe:

528049

Der Release-Wert lässt sich der Microsoft-Tabelle zuordnen – 528049 = .NET 4.8: How to determine which .NET Framework versions are installed

Kurzreferenz Release-Werte: 528040/528049/528449 = .NET 4.8 · 533320/533325 = .NET 4.8.1. Exchange SE benötigt .NET 4.8 (auf Windows Server 2025 ist 4.8.1 systemseitig dabei).

Kompatibilität von CU und .NET Framework

Mit diesen Infos prüfst du anhand der Supportability Matrix, ob die installierte .NET-Version zum geplanten CU passt. Ist das nicht der Fall, muss .NET vor dem CU aktualisiert werden.

Exchange Server Supportability Matrix (Microsoft Learn)

In unserem Beispiel: .NET 4.8 wird bereits ab Exchange 2016 CU13 unterstützt – ein .NET-Update ist hier nicht erforderlich.

Active Directory Schema-Version prüfen

Vor dem CU prüfen, ob das AD-Schema bereits die erforderliche Version hat.

Exchange Schema Version:

$sc = (Get-ADRootDSE).SchemaNamingContext
$ob = "CN=ms-Exch-Schema-Version-Pt," + $sc
Write-Output "RangeUpper: $((Get-ADObject $ob -Properties rangeUpper).rangeUpper)"

Exchange Object Version (Domain):

$dc = (Get-ADRootDSE).DefaultNamingContext
$ob = "CN=Microsoft Exchange System Objects," + $dc
Write-Output "ObjectVersion (Default): $((Get-ADObject $ob -Properties objectVersion).objectVersion)"

Exchange Object Version (Forest):

$cc = (Get-ADRootDSE).ConfigurationNamingContext
$fl = "(objectClass=msExchOrganizationContainer)"
Write-Output "ObjectVersion (Configuration): $((Get-ADObject -LDAPFilter $fl -SearchBase $cc -Properties objectVersion).objectVersion)"

Hinweis: Die ObjectVersion (Configuration) wird in manchen Umgebungen erst nach dem erfolgreichen Update des ersten Exchange-Servers erhöht.

Beispielausgabe:

RangeUpper: 15332
ObjectVersion (Default): 13237
ObjectVersion (Configuration): 16217

Die jeweils erforderlichen Soll-Werte je CU stehen hier:

• Exchange 2016 – AD- und Domain-Vorbereitung
• Exchange 2019 – AD- und Domain-Vorbereitung

In unserem Fall muss das Schema erweitert werden, da das neue CU eine höhere Schema-Version voraussetzt.

Tipp: Alle obigen Abfragen plus Dienstestatus, FSMO, .NET und Transport Agents erledigt das verlinkte Pre-Flight-Skript in einem Rutsch (read-only).

Schema Master ermitteln

Für das Schema-Upgrade muss bekannt sein, welcher DC die Schema-Master-Rolle hält. Das Upgrade sollte im Vorfeld des CU erfolgen.

Variante 1 – CMD:

netdom query fsmo

Variante 2 – PowerShell:

Get-ADForest | Select-Object SchemaMaster

Schema-Erweiterung des Active Directory

Die Installations-ISO des CUs wird auf dem DC mit der Schema-Master-Rolle eingebunden (im Beispiel rootdc01.domain.tld).

Alternativ auf einem anderen DC in der gleichen AD-Site wie der Exchange-Server. Bei Bedarf die FSMO-Rolle temporär verschieben:

1. mmc öffnen → Snap-In „Active Directory-Schema“ hinzufügen
2. Rechtsklick auf Active Directory-Schema → Change Domain Controller
3. Ziel-DC wählen → Operation Master → Change

Durchführung

1. PowerShell als Administrator auf dem Schema-Master öffnen
2. Auf das ISO-Laufwerk wechseln (z. B. D:):

D:

3. Befehle nacheinander ausführen:

.\setup.exe /PrepareSchema /IAcceptExchangeServerLicenseTerms_DiagnosticDataON
.\setup.exe /PrepareAD /IAcceptExchangeServerLicenseTerms_DiagnosticDataON

Zum Lizenz-Schalter: Microsoft akzeptiert zwei Varianten – _DiagnosticDataON oder _DiagnosticDataOFF. Der Unterschied ist ausschließlich, ob optionale Diagnosedaten an Microsoft gesendet werden. Funktional ist die Installation identisch. Tipp: Innerhalb einer Wartung konsistent denselben Schalter verwenden, um Verwirrung in den Logs zu vermeiden.

Komplexe Umgebungen mit mehreren Domänen

Gibt es Exchange-Server in weiteren Domänen:

.\setup.exe /PrepareAllDomains /IAcceptExchangeServerLicenseTerms_DiagnosticDataON

Schlägt PrepareAllDomains mangels Domain-Adminrechten fehl, jede Domäne einzeln vorbereiten:

.\setup.exe /PrepareDomain:<domain.tld> /IAcceptExchangeServerLicenseTerms_DiagnosticDataON

Abschluss der AD-Vorbereitung

Danach ist das AD auf dem aktuellen Stand. Die ISO kann vom DC wieder ausgehängt werden.

Hinweis: Vor dem Start der Exchange-Installation die AD-Replikation abwarten – meist reichen ca. 15 Minuten, je nach Umgebung mehr. Mit repadmin /replsummary lässt sich der Replikationsstand prüfen.

Problem: „Ein Neustart einer vorangegangenen Installation steht noch aus“

Vor dem Setup kann diese Meldung kommen:

Ein Neustart einer vorangegangenen Installation steht noch aus. Starten Sie das System neu, und führen Sie Setup erneut aus.

Das Setup wird abgebrochen. Details im Log:

<SystemDrive>:\ExchangeSetupLogs\ExchangeSetup.log

Lösungsmöglichkeiten

• Variante 1 (empfohlen): Server einmal neu starten, Setup erneut ausführen.
• Variante 2 (nur wenn Reboot nicht hilft): Den Registry-Wert prüfen:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager → PendingFileRenameOperations

Korrektur/Warnung (wichtig!): Diesen Wert nicht blind löschen. PendingFileRenameOperations kann mehrere legitime ausstehende Umbenennungen enthalten, die Windows beim nächsten Boot erledigen will. Werden die gelöscht, können laufende Updates inkonsistent werden.

Besser: Erst den Inhalt ansehen (Get-ItemProperty ... -Name PendingFileRenameOperations), den Wert exportieren/sichern, und nur wenn dort ausschließlich irrelevante Reste stehen, gezielt entfernen. In 95 % der Fälle löst ein simpler Reboot das Problem sauber.

Weitere Infos: FrankysWeb – „Ein Neustart steht noch aus“

Sonderanpassungen an der Konfiguration

Individuelle Konfigurationsänderungen (z. B. an web.config) können durch ein CU überschrieben werden. Diese vorab dokumentieren/exportieren und nach dem Update prüfen und ggf. erneut setzen.

Abhängige Drittherstellersoftware

In produktiven Umgebungen ist oft Drittsoftware aktiv (Signaturen, Archivierung, Security). Solche Komponenten können durch ein CU beeinträchtigt werden, vor allem wenn Exchange-DLLs ersetzt werden.

Prüfen, ob sich Software in den Mailflow einklinkt:

Get-TransportAgent

Beispielausgabe:

Name                              Enabled  Priority
----                              -------  --------
Exclaimer Auto Responder Agent    True     1

Hier ist der Exclaimer Auto Responder Routing Agent aktiv (laut Hersteller keine Maßnahmen nach CU nötig). Anders z. B. bei CI-Mail Policy – die muss nach jedem CU neu installiert werden.

Empfehlung: Vor dem Update die Dritthersteller-Doku prüfen oder beim Hersteller anfragen, ob nach einem CU Maßnahmen nötig sind.

Vorbereitung vor dem Update

Kundenkommunikation

Falls noch nicht erfolgt: Kunde vor Beginn informieren, besonders bei Produktivsystemen.

Kein Snapshot!

Ein Snapshot (Hyper-V/VMware) ist nicht sinnvoll – das CU ändert nicht nur Exchange, sondern auch das AD-Schema. Ein Snapshot-Rollback führt zu inkonsistenten Zuständen. Es gibt kein Rollback – nur den Weg nach vorn.

Technische Vorbereitung

Status der Exchange-Dienste dokumentieren

IST-Zustand festhalten:

• Dienste (Screenshot oder PowerShell): Test-ServiceHealth
• Komponentenstatus: Get-ServerComponentState <Servername>

Hintergrund: CU-/Hotfix-Installationen setzen Dienste/Komponenten oft auf „Deaktiviert“. Eine saubere Rückdokumentation ist entscheidend.

Zugriffe reduzieren

• Benutzersitzungen abmelden (alle außer Admin).
• Offene PowerShell-Sitzungen beenden:

Get-Process *powershell* | Stop-Process -Id <Prozess-ID>

Virenscanner deaktivieren

• AV (z. B. Bitdefender) deaktivieren (bei Bitdefender: Shift + Rechtsklick > Poweruser).
• Andere Lösungen nach Herstelleranleitung.
• Geht keine Deaktivierung: dokumentieren und fortfahren.

Backup pausieren

• Laufende Backup-Jobs pausieren/deaktivieren – das CU beinhaltet mehrere Neustarts; Sicherungen können den Prozess stören oder beschädigte Backups erzeugen.

Installation des .NET Framework Updates (falls erforderlich)

Im Beispiel nicht nötig – der Vollständigkeit halber:

1. Offline-Installer herunterladen (z. B. .NET 4.8)
2. Als Administrator ausführen, Lizenz akzeptieren, installieren
3. Laufzeit bis zu 60 Minuten, wirkt teils eingefroren
4. Neustart zwingend
5. Danach über Windows Update verfügbare .NET-Sicherheitsupdates nachziehen

IIS URL Rewrite Module (bei bestimmten CUs)

Seit dem CU vom September 2021 gibt es einen sicherheitsrelevanten „Not-Aus-Schalter“. Dafür ist vorab das IIS URL Rewrite Module nötig:

Microsoft URL Rewrite Module

Installation dauert nur wenige Minuten und sollte vor dem CU erfolgen, falls das CU diese Abhängigkeit mitbringt.

Installation des Cumulative Updates (CU)

Vor der Installation den Exchange Server einmal neu starten, um sauber zu starten.

ISO-Datei einbinden

Die CU-ISO per Doppelklick einbinden – sie erscheint als virtuelles Laufwerk.

Wichtiger Hinweis: Extended Protection

Mit aktuellen CUs wird Extended Protection (EP) automatisch aktiviert. Exchange Extended Protection (Microsoft Learn)

Soll EP nicht aktiviert werden:

.\Setup.exe /Update /DoNotEnableEP /IAcceptExchangeServerLicenseTerms_DiagnosticDataON

EP ist eine Sicherheitsfunktion und sollte im Normalfall aktiviert bleiben. /DoNotEnableEP nur nutzen, wenn dokumentierte Kompatibilitätsgründe vorliegen (z. B. bestimmte Loadbalancer-/Hybrid-Szenarien).

CU-Installation starten

1. Administrative PowerShell öffnen
2. Zum ISO-Laufwerk navigieren
3. Installation starten:

.\Setup.exe /Mode:Upgrade /IAcceptExchangeServerLicenseTerms_DiagnosticDataON

Wichtig: setup.exe muss als Administrator laufen, sonst drohen inkonsistentes Verhalten oder ein defekter Exchange-Server.

Während der Installation

• Die Installation kann mehrfach längere Zeit „hängen“ – das ist normal.
• Alle Exchange-Dienste sind gestoppt – das Monitoring sollte das erkennen (ggf. Wartungsfenster setzen).
• Häufige Fehlerursache: Backup-Software startet automatisch → Backup-Jobs vorab stoppen!

Neustart nach dem CU-Update

Nach der Installation ist ein Neustart zwingend. Er kann ungewöhnlich lange dauern – teils bis zu einer Stunde, bis alle Dienste laufen.

Nacharbeiten nach dem CU-Update

Sonderanpassungen prüfen und ggf. erneut setzen

web.config-Anpassungen u. Ä. jetzt prüfen und bei Bedarf erneut vornehmen – CUs überschreiben solche Änderungen.

Arbeiten nach dem Neustart

1. Dienste & Konfiguration

Exchange-Dienste gestartet und in erwarteter Konfiguration? → Abgleich mit Vorher-Screenshot.

2. Komponentenstatus

Get-ServerComponentState <Servername>

→ Abgleich mit dokumentiertem Zustand.

3. Datenbankstatus

Im EAC → Servers → Databases prüfen, ob alle Datenbanken eingebunden/bereitgestellt sind. (PowerShell: Get-MailboxDatabaseCopyStatus.)

4. Mailflow testen

Test eingehend und ausgehend (z. B. Admin sendet an Techniker, erhält Antwort).

5. OWA / Outlook-Zugriff prüfen

OWA mit Testnutzer testen, wenn möglich Outlook-Konnektivität prüfen.

6. Monitoring prüfen

Alles wieder „grün“? CPU-Last direkt nach Neustart erhöht ist normal – nach 30–60 Minuten sollte sie sich stabilisieren.

7. Ereignisprotokolle prüfen

Anwendungs-/System-Eventlogs filtern (Kritisch/Fehler/Warnung). Kurz nach dem Neustart sind manche Fehler normal und verschwinden wieder.

Letzte Schritte nach dem CU-Update

Prüfung mit Test-ServiceHealth

Test-ServiceHealth

Alle erforderlichen Dienste sollten „Running“ zeigen.

Microsoft empfiehlt, nach dem Update erneut den Exchange Health Checker laufen zu lassen, um offene Folgeaktionen zu erkennen.

Reaktivierung des Virenscanners

Falls manuell deaktiviert und nicht automatisch zurück: AV wieder aktivieren.

Backup fortsetzen

Pausierten Backup-Job fortsetzen (Rechtsklick → Fortsetzen).

Prüfung der erfolgreichen Installation

Get-ExchangeServer | Select-Object Name, AdminDisplayVersion | Format-Table

Beispielausgabe:

Name    AdminDisplayVersion
----    -------------------
EXCH04  Version 15.1 (Build 2044.4)
EXCH05  Version 15.1 (Build 2176.2)

Die Build-Nummer muss der Zielversion entsprechen (siehe Microsoft Build-Liste).

Abschluss

• Information kommunizieren (intern an Service Owner, extern an Kunde/Ansprechpartner).
• Installationsdateien bereinigen (ISO und extrahierte Dateien löschen, Papierkorb leeren).

Bonus: Pre-Flight-Skript

Das begleitende PowerShell-Skript PS_Exchange_CU_PreFlight_Check.ps1 sammelt den kompletten IST-Zustand (Versionen, Dienste, ComponentState, AD-Schema, FSMO, .NET, Transport Agents, Pending-Reboot) read-only in eine Textdatei – ideal für die Vorher-/Nachher-Dokumentation.

Wer war von Neumann – und warum reden wir 80 Jahre später noch darüber?

John von Neumann beschrieb 1945 im „First Draft of a Report on the EDVAC“ ein Rechnermodell, bei dem Programm und Daten im selben Speicher liegen. Das klingt heute selbstverständlich, war damals aber der Durchbruch: Vorher musste man Rechner für jede neue Aufgabe quasi neu verdrahten. Seitdem gilt: gleiche Hardware, beliebige Programme – einfach in den Speicher laden, fertig.

Die 5 Funktionseinheiten

Das Herzstück der Architektur sind fünf logische Einheiten, die über ein gemeinsames Bus-System miteinander reden:

1. Steuerwerk (CU – Control Unit): der Dirigent. Es holt die Befehle in der richtigen Reihenfolge und versorgt alle anderen Einheiten mit Steuersignalen.
2. Rechenwerk (ALU – Arithmetic Logic Unit): führt die eigentliche Arbeit aus – arithmetisch (Addition, Subtraktion …) und logisch (UND, ODER, NICHT, Vergleiche).
3. Speicher: bewahrt Programm, Eingaben und Zwischenergebnisse auf.
4. Eingabeeinheit: bringt Daten in den Rechner (Tastatur, Netzwerkkarte …).
5. Ausgabeeinheit: gibt Daten wieder aus (Bildschirm, Drucker …).

Merke: Steuerwerk + Rechenwerk = Prozessor (CPU). Ein-/Ausgabe wird oft als eine I/O-Einheit zusammengefasst – deshalb sprechen manche von vier Einheiten. Beide Zählweisen sind korrekt, je nachdem ob man E und A trennt.

Das Bus-System: drei Leitungen, eine Aufgabe

Die Einheiten sind über den Systembus verbunden – physikalisch nichts anderes als ein Bündel elektrischer Leitungen. Er besteht aus drei Teilen:

Die Breite des Datenbusses (z. B. 64 Bit) bestimmt mit, wie viele Bit gleichzeitig übertragen werden können – ein direkter Hebel für die Performance.

Wie der Speicher organisiert ist

Der Speicher besteht aus vielen gleich großen, fortlaufend nummerierten Speicherzellen. Jede Zelle hat eine eindeutige Adresse – stell es dir wie Hausnummern in einer Straße vor.

• Bit = binary digit, die kleinste Informationseinheit (0 oder 1).
• Ein einzelnes Bit anzusteuern wäre viel zu aufwendig. Deshalb fasst man mehrere Speicherelemente zu einer Zelle zusammen – die kleinste adressierbare Einheit ist meist 1 Byte = 8 Bit.
• Alle Daten – Programm, Eingaben, Zwischenergebnisse – landen im selben Speicher und werden binär codiert.

Der Befehlszyklus: Befehlsregister & Befehlszählregister

Damit die CPU weiß, was als Nächstes dran ist, hat das Steuerwerk zwei wichtige Register:

• Befehlsregister: enthält den aktuell bearbeiteten Befehl. Ein Befehl besteht aus einem Operationsteil (was tun?) und einem Adressteil (mit welchen Daten?).
• Befehlszählregister (Program Counter): enthält die Adresse des nächsten Befehls. Nach jedem Befehl wird der Inhalt um 1 erhöht.

Bei Sprungbefehlen wird der Zähler stattdessen auf einen anderen Wert gesetzt (GoTo). Besonders mächtig sind die bedingten Sprünge: Hier entscheidet die ALU per logischem Vergleich, ob gesprungen wird oder nicht – das ist die Grundlage für jedes if und jede Schleife in jedem Programm.

Die Prinzipien der Von-Neumann-Architektur (Prüfungsklassiker)

1. Es gibt fünf Funktionseinheiten.
2. Die Rechnerstruktur ist unabhängig vom Problem – mit derselben Hardware löst man beliebige Aufgaben, indem man das passende Programm lädt.
3. Programm, Daten und Zwischenergebnisse liegen im gleichen Speicher.
4. Der Speicher ist in gleich große, fortlaufend nummerierte Zellen unterteilt.
5. Befehle werden der Reihe nach abgearbeitet (Sprungbefehle erlauben Abweichungen).
6. Der Befehlsvorrat umfasst mindestens: arithmetische Befehle, logische Befehle, Transportbefehle und bedingte Sprünge.
7. Alle Daten werden binär codiert.

Der Haken: der Von-Neumann-Flaschenhals

Genau das Prinzip, das die Architektur so flexibel macht – ein gemeinsamer Speicher und ein gemeinsamer Bus für Befehle und Daten – ist auch ihre größte Schwäche. Der Prozessor kann in einem Takt entweder einen Befehl oder ein Datum über den Bus holen, nicht beides gleichzeitig. Dieser Engpass heißt Von-Neumann-Flaschenhals (geprägt von John Backus, 1977).

Die ganze moderne Hardware-Trickkiste ist im Grunde eine Antwort darauf:

• Caches (schneller SRAM-Zwischenspeicher direkt an der CPU), um den langsamen Hauptspeicher seltener zu bemühen.
• Harvard-Architektur in Caches, die Befehle und Daten doch wieder physisch trennt.
• Pipelining, Prefetching und breitere Busse.

Wenn du also wissen willst, warum es überhaupt L1/L2/L3-Cache, Dual-Channel-RAM und immer schnellere Speicheranbindung gibt: Die Antwort steckt in diesem 80 Jahre alten Bauplan.

Fazit

Die Von-Neumann-Architektur ist simpel genug, um sie sich in fünf Minuten zu merken, und gleichzeitig fundamental genug, um den Aufbau jedes heutigen Rechners zu erklären. Fünf Einheiten, drei Busse, ein gemeinsamer Speicher – und ein Flaschenhals, gegen den die gesamte Computertechnik seit Jahrzehnten anrennt.

Im nächsten Teil dieser Reihe gehe ich tiefer in den Speicher: SRAM vs. DRAM, SDRAM, die DDR-Generationen und wie man aus „PC3-12800“ die echte Taktrate ausrechnet.

Diese Reihe: Teil 1 – Darstellen & Umrechnen · Teil 2 – Wertebereiche & Rechnen wie ein Computer (dieser Beitrag)

Wertebereiche: Was passt in n Bit?

Mit n Bits lassen sich immer genau 2ⁿ verschiedene Zahlen darstellen. Wie viele das sind, ändert sich also nicht – nur welche Zahlen, je nach Interpretation:

Bei 3 Bit sind es in beiden Fällen 8 darstellbare Zahlen – einmal 0…7, einmal −4…3. Beim Zweierkomplement „kostet“ das VZ-Bit die Hälfte des positiven Bereichs, dafür gibt’s negative Zahlen. Der negative Bereich reicht eine Zahl weiter als der positive (−4 vs. +3), weil die 0 keinen eigenen Vorzeichen-Slot braucht.

Merksatz: Normal [0 ; 2ⁿ−1], Zweierkomplement [−2ⁿ⁻¹ ; 2ⁿ⁻¹−1].

Rechnen wie ein Computer: Subtraktion = Addition

Hier wird’s spannend: Eine CPU kann eigentlich gar nicht subtrahieren. Sie kann nur addieren. Der Trick: Statt a − b rechnet sie a + (−b), wobei −b im Zweierkomplement vorliegt. Ein eventueller Übertrag aus dem höchsten Bit wird einfach verworfen – und das Ergebnis stimmt automatisch.

Genau deshalb ist 2K im Computer so beliebt: Addition und Subtraktion laufen über dieselbe Hardware-Schaltung.

Beispiel a) 7 + (−5) = 2 (4 Bit)

Beispiel b) 13 − 8 = 5 (5 Bit) → gerechnet als 13 + (−8)

Beispiel c) 23 − 16 = 7 (6 Bit) → 23 + (−16)

Beispiel d) −3 + (−5) = −8 (4 Bit) – zwei negative Zahlen

In allen Fällen: addieren, den Übertrag links wegwerfen, fertig. Kein Sonderfall fürs Minus.

Überlauf (Overflow) – wenn das Ergebnis nicht mehr passt

Was passiert, wenn das Ergebnis den Wertebereich sprengt? Beispiel in 3 Bit (WB [−4 ; 3]):

−4 + (−4) = −8 — aber −8 liegt außerhalb von [−4 ; 3].

Operand	Bits
−4	100₂ₖ
−4	100₂ₖ
Summe	(1)000 → 000 = 0 (erwartet: −8)

Das Ergebnis 0 ist schlicht falsch – ein klassischer Integer Overflow. Die Faustregel zur Erkennung:

Haben beide Summanden dasselbe Vorzeichen, das Ergebnis aber ein anderes, ist ein Überlauf passiert.

Hier: beide Operanden negativ (MSB 1), Ergebnis positiv (MSB 0) → Overflow. Genau solche Fehler stecken hinter realen Bugs (vom „Gangnam-Style-Zähler“ bei YouTube bis zu sicherheitskritischen int-Overflows). Wer den Wertebereich im Kopf hat, sieht sie kommen.

Zum Selbst-Ausprobieren: PowerShell-Demo

Dieses Skript berechnet Wertebereiche und addiert zwei Zahlen wie eine CPU – inklusive automatischer Overflow-Erkennung:

<#
.SYNOPSIS
    Demonstriert Wertebereiche und Addition im Zweierkomplement (wie eine CPU).
.DESCRIPTION
    Funktionen:
      ConvertTo-TwosComplement   -> Dezimalzahl in 2K-Bitstring (feste Bitbreite)
      Get-TwosComplementRange    -> Wertebereich fuer n Bit
      Add-TwosComplement         -> Addition zweier Zahlen mit Overflow-Erkennung
.NOTES
    Name: PS_Zweierkomplement_Arithmetik
    Author: Andreas Bowitz
    Version: 0.1
    LastUpdated: 2026-Jun-02
#>

function ConvertTo-TwosComplement {
    param(
        [Parameter(Mandatory)][int]$Value,
        [int]$Bits = 8
    )
    $mask = [int]([math]::Pow(2, $Bits) - 1)
    $tc   = $Value -band $mask
    return [Convert]::ToString($tc, 2).PadLeft($Bits, '0')
}

function Get-TwosComplementRange {
    param([int]$Bits = 8)
    [PSCustomObject]@{
        Bits  = $Bits
        Min   = -[int][math]::Pow(2, $Bits - 1)
        Max   =  [int][math]::Pow(2, $Bits - 1) - 1
        Count = [int][math]::Pow(2, $Bits)
    }
}

function Add-TwosComplement {
    param(
        [Parameter(Mandatory)][int]$A,
        [Parameter(Mandatory)][int]$B,
        [int]$Bits = 4
    )
    $range = Get-TwosComplementRange -Bits $Bits
    $sum   = $A + $B
    # Overflow: Ergebnis liegt ausserhalb des Wertebereichs
    $overflow = ($sum -lt $range.Min) -or ($sum -gt $range.Max)
    [PSCustomObject]@{
        Rechnung = "$A + ($B)"
        Bits     = "$(ConvertTo-TwosComplement $A $Bits) + $(ConvertTo-TwosComplement $B $Bits)"
        Ergebnis = $sum
        Overflow = $overflow
    }
}

# --- Test anhand der Beispiele aus dem Artikel ---
Get-TwosComplementRange -Bits 3                     # Min -4, Max 3, Count 8
Get-TwosComplementRange -Bits 8                     # Min -128, Max 127, Count 256

Add-TwosComplement -A 7  -B -5 -Bits 4              # 2,  Overflow = False
Add-TwosComplement -A -3 -B -5 -Bits 4              # -8, Overflow = False
Add-TwosComplement -A -4 -B -4 -Bits 3              # -8, Overflow = True  (!)

Zusammenfassung

• Mit n Bits sind immer 2ⁿ Zahlen darstellbar.
• Wertebereich: normal [0 ; 2ⁿ−1], Zweierkomplement [−2ⁿ⁻¹ ; 2ⁿ⁻¹−1].
• Ein Computer subtrahiert durch Addition des Zweierkomplements – der Übertrag links wird verworfen.
• Überlauf droht, sobald das Ergebnis den Wertebereich verlässt (gleiches Vorzeichen rein, anderes raus).

Zurück zu Teil 1: negative Zahlen darstellen & umrechnen, falls du die Grundlagen der 2K-Darstellung auffrischen willst.

Hinweis: Der rechtliche Teil ist nach bestem Wissen recherchiert (Stand 2026), aber keine Rechtsberatung. Im Ernstfall fragst du eine:n Anwält:in oder die IHK.

1. Was bei der Warenannahme anfällt – die Checkliste

Die Warenannahme ist die erste Verteidigungslinie. Arbeite sie stur ab, bevor du irgendetwas unterschreibst:

• [ ] Anschrift prüfen – Absender und Empfänger korrekt? (Bin ich überhaupt der richtige Empfänger?)
• [ ] Lieferschein Bestellung abgleichen – stimmt die bestellte mit der gelieferten Ware überein?
• [ ] Lieferschein tatsächliche Ware abgleichen – Menge, Anzahl, Gewicht, Artikelnummern
• [ ] Verpackung auf äußere Schäden prüfen – Dellen, Nässe, aufgerissene Kartons
• [ ] Tatbestandsaufnahme / Schadensprotokoll bei sichtbaren Schäden sofort erstellen
• [ ] Empfang auf dem Lieferschein bestätigen – aber mit Vorbehalt, wenn etwas auffällt
• [ ] Unterschrift erst nach der Sichtprüfung – nicht blind quittieren
• [ ] Unverzügliche Probe / Stichprobe der Ware – v. a. bei verderblicher oder empfindlicher Ware
• [ ] Erfassung im Warenwirtschaftssystem (Scanner / Barcode)

Praxis-Tipp: Bei versiegelten Booster-Displays und Cases ist die „unverzügliche Probe“ heikel – ein geöffnetes Display ist nicht mehr verkäuflich. Sinnvoll ist hier eine Gewichts- und Mengenprüfung auf Kartonebene sowie das Fotografieren des ungeöffneten Wareneingangs (Zeitstempel!). So hast du Beweise, ohne die Versiegelung zu brechen.

2. Mängel erkennen und richtig einordnen

Nicht jeder Mangel ist gleich. Die Unterscheidung ist wichtig, weil sie über Fristen und Ansprüche entscheidet.

Sachmangel (§ 434 BGB)

Die Ware ist nicht so beschaffen wie vereinbart. Typische Fälle:

• Quantitativer Mangel: zu wenig geliefert (Mengenabweichung)
• Falsche Ware: komplett anderer Artikel als bestellt
• Kaputte / unbrauchbare Ware: Transport- oder Produktionsschaden
• Qualitativer Mangel: Ware entspricht nicht der zugesicherten Eigenschaft
• Montagemängel bzw. Mängel durch eine fehlerhafte Montageanleitung – die sogenannte „IKEA-Klausel“ (§ 434 Abs. 4 BGB): Eine falsche Anleitung kann die Ware selbst mangelhaft machen.

Rechtsmangel (§ 435 BGB)

Die Sache ist durch Rechte Dritter belastet – z. B. ein Eigentumsvorbehalt oder eine Lizenz, die du nicht kennst.

Zusätzlich gilt: Der Verkäufer haftet auch für öffentliche Aussagen des Herstellers (Werbung, Produktangaben). Was in der Werbung versprochen wird, ist Teil der geschuldeten Beschaffenheit.

3. Die Rügepflicht – der Teil, an dem es im Streit hängt

Hier ist der wichtigste rechtliche Punkt, und hier hatte das ursprüngliche Lernmaterial ein paar Stolperfallen (siehe Korrektur-Box unten).

Zweiseitiger Handelskauf (beide sind Kaufleute) → § 377 HGB

Wenn du als Händler beim Lieferanten/Großhändler kaufst, seid ihr beide Kaufleute. Dann gilt die Untersuchungs- und Rügepflicht nach § 377 HGB:

• Offene (erkennbare) Mängel: unverzüglich nach Ablieferung untersuchen und rügen.
• Versteckte Mängel: unverzüglich nach Entdeckung rügen.
• Folge bei Versäumnis: Die Ware gilt als genehmigt (§ 377 Abs. 2 HGB) – du verlierst deine Gewährleistungsrechte gegen den Lieferanten.
• Arglistig verschwiegene Mängel: Hier kann sich der Verkäufer nicht auf eine versäumte Rüge berufen (§ 377 Abs. 5 HGB).

„Unverzüglich“ heißt juristisch: ohne schuldhaftes Zögern (§ 121 BGB) – nicht „sofort“, aber so schnell wie zumutbar.

Einseitiger Handelskauf (du verkaufst an Endkunden)

Verkaufst du an Verbraucher (z. B. dein Shop), ist nur eine Seite Kaufmann. Dann gilt § 377 HGB nicht für den Kunden: Der Kunde ist nicht verpflichtet, unverzüglich zu rügen. Für ihn greift die normale Gewährleistung.

Form der Mängelrüge

Mängelrügen sind formfrei (mündlich oder schriftlich möglich) – aber: schriftlich (E-Mail, Brief) ist immer besser, weil du dann eine Beweisgrundlage hast.

Und: Mangelhafte Ware musst du auf Kosten des Lieferanten sorgfältig aufbewahren, bis die Sache geklärt ist (§ 379 HGB).

4. Fristen – korrigiert auf die aktuelle Rechtslage

Korrektur-Box (Plausibilitätsprüfung): Im ursprünglichen Lernmaterial standen u. a. „7 Jahre“ und „6 Monate Beweislastumkehr“. Beides ist nicht (mehr) korrekt. Hier die aktuelle Fassung:

Beweislastumkehr heißt: Zeigt sich der Mangel innerhalb der ersten 12 Monate nach Übergabe, wird vermutet, dass er schon bei Übergabe vorhanden war – der Verkäufer muss das Gegenteil beweisen. Danach kehrt sich die Last um: Der Käufer muss beweisen, dass der Mangel von Anfang an bestand (ggf. per Sachverständigem).

5. Mangelfreie Ware einlagern – systematisch vs. chaotisch

Hat die Ware die Prüfung bestanden, geht sie ins Lager. Zwei Grundprinzipien der Lagerplatzzuordnung:

Systematische (feste) Lagerplatzzuordnung

Jeder Artikel hat einen festen Platz.

• Vorteile: Ware ohne System/Scanner auffindbar, gute Übersicht, eingespielte Wege
• Nachteile: schlechte Platzausnutzung (reservierte Plätze bleiben leer), unflexibel bei Sortimentswechsel

Chaotische (dynamische) Lagerplatzzuordnung

Ware kommt dorthin, wo gerade Platz frei ist – das System merkt sich den Ort.

• Vorteile: optimale Platzausnutzung, flexibel, kurze Einlagerwege
• Nachteile: funktioniert nur mit IT (WaWi/Scanner), ohne System praktisch nicht auffindbar

Allgemeine Einlagerungsregeln

• Sortieren nach Gewicht, Volumen, Marke und Zugriffshäufigkeit
• Schwere Geräte unten, leichtere oben ins Regal
• Teure Geräte übersichtlich & gesichert lagern
• Zusammenhängende Produkte am gleichen Ort lagern
• FiFo (First in – First out): zuerst eingelagerte Ware zuerst raus – Pflicht bei verderblicher Ware, sinnvoll bei allem mit „Verfallsdatum“ im weiteren Sinne (bei TCGs: ältere Auflagen/Drucke zuerst).

6. IT-Praxis: Wareneingang protokollieren mit PowerShell

Damit die Prüfung nicht im Zettelchaos endet, hier ein kleiner Helfer: Er fragt die Eckdaten ab und schreibt einen sauberen, revisionssicheren (append-only) Eintrag in eine CSV. Perfekt für ein kleines Lager – und passt zum Prinzip „keine Daten überschreiben“.

<#
.SYNOPSIS
    Erfasst einen Wareneingang interaktiv und haengt ihn append-only an ein CSV-Protokoll an.

.NOTES
    Name: PS_Wareneingangskontrolle_Protokoll
    Author: Andreas Bowitz
    Version: 0.1
    LastUpdated: 2026-Jun-02
#>

param(
    [string]$ProtokollPfad = "$PSScriptRoot\Wareneingang_Protokoll.csv"
)

# --- Eingaben abfragen ---
$lieferant      = Read-Host "Lieferant"
$lieferschein   = Read-Host "Lieferschein-Nr"
$bestellung     = Read-Host "Bestell-Nr"
$artikel        = Read-Host "Artikel / Set"
$mengeSoll      = Read-Host "Menge SOLL"
$mengeIst       = Read-Host "Menge IST"
$mangel         = Read-Host "Maengel? (leer = keine)"
$pruefer        = Read-Host "Pruefer"

# --- Status automatisch ableiten (kleine Plausi-Pruefung) ---
if ($mengeSoll -ne $mengeIst) {
    $status = "ABWEICHUNG-MENGE"
} elseif (-not [string]::IsNullOrWhiteSpace($mangel)) {
    $status = "MANGEL"
} else {
    $status = "OK"
}

# --- Datensatz bauen ---
$eintrag = [PSCustomObject]@{
    Zeitstempel  = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
    Lieferant    = $lieferant
    LieferscheinNr = $lieferschein
    BestellNr    = $bestellung
    Artikel      = $artikel
    MengeSoll    = $mengeSoll
    MengeIst     = $mengeIst
    Mangel       = $mangel
    Status       = $status
    Pruefer      = $pruefer
}

# --- Append-only schreiben (Header nur einmalig anlegen) ---
$writeHeader = -not (Test-Path $ProtokollPfad)
$eintrag | Export-Csv -Path $ProtokollPfad -Append -NoTypeInformation `
    -Encoding UTF8 -Delimiter ";" -Force:$false

Write-Host ""
Write-Host "Eintrag gespeichert -> Status: $status" -ForegroundColor Cyan
Write-Host "Protokoll: $ProtokollPfad"

Was der Helfer macht:

• fragt die Pflichtfelder der Prüfung ab,
• leitet den Status automatisch ab (Mengenabweichung schlägt vor „MANGEL“),
• schreibt append-only (kein Überschreiben, kein Datenverlust),
• nutzt ; als Trennzeichen und UTF-8 → öffnet sich sauber in Excel (DE).

Ausbaustufe: Den Zeitstempel + ein Foto des Wareneingangs koppeln (Dateiname = Lieferschein-Nr) – dann hast du im Streitfall sofort Beweis und Protokoll beieinander.

Fazit

Wareneingangskontrolle ist kein Bürokratie-Selbstzweck, sondern dein Rechtsschutz an der Rampe. Die Reihenfolge ist immer gleich: erst prüfen, dann quittieren – und im B2B-Einkauf unverzüglich rügen, sonst gilt die Ware als genehmigt. Wer dann noch sauber protokolliert (gern digital, append-only) und systematisch einlagert, spart sich später Diskussionen, Geld und Nerven.