SQL Server unter Linux tunen: Was Microsoft empfiehlt und was davon wirkt

#!/usr/bin/env bash
# PSG Stack · SQL Server unter Linux und Docker · Host-Check
# Vergleicht Linux-Einstellungen eines SQL-Server-Hosts mit den Empfehlungen von Microsoft
# (Learn: „Performance best practices: Storage, kernel, CPU, and network“, Stand 05/2026).
#
# !!! WARNUNG — bitte vor dem Ausführen lesen !!!
# - Nur lesend. Das Skript ändert keine Einstellung und schreibt keine Datei.
# - Aufruf: bash host-check-de.sh [Datenverzeichnis] [Logverzeichnis]
#   Standard: /var/opt/mssql/data für beides. Ohne root fehlen evtl. einzelne Werte (dann „?“).
# - Kernel-Werte gelten für den ganzen Host. In einem Container zeigt das Skript die Werte des Hosts;
#   ändern lassen sie sich nur auf dem Host, nicht im Container.
# - „prüfen“ heißt: abweichend von Microsofts Empfehlung. Ob die Abweichung bei Ihnen etwas kostet,
#   sagt das Skript nicht; Empfehlungen gelten für dedizierte SQL-Server-Hosts.
# - Geprüft im PSG-Lab auf Ubuntu 24.04 (Host) und in den Containern von SQL Server 2017 bis 2025
#   (13.11.2026); auf Red Hat und SUSE nicht geprüft.
set -u
DATA=${1:-/var/opt/mssql/data}
LOG=${2:-$DATA}
lies() { cat "$1" 2>/dev/null | tr -d '\n' || true; }
zeile() { printf '%-34s %-28s %-30s %s\n' "$1" "$2" "$3" "$4"; }
pruef() { if [ "$1" = "$2" ]; then echo ok; elif [ -z "$1" ] || [ "$1" = "?" ]; then echo "?"; else echo prüfen; fi; }

echo "Host-Check SQL Server unter Linux · $(date '+%Y-%m-%d %H:%M') · $(hostname)"
. /etc/os-release 2>/dev/null; echo "System: ${PRETTY_NAME:-?} · Kernel $(uname -r)"
if [ -f /.dockerenv ] || grep -qa docker /proc/1/cgroup 2>/dev/null; then echo "Hinweis: läuft in einem Container; Kernel-Werte sind die des Hosts."; fi
echo
zeile "Einstellung" "Ist" "Empfehlung (Microsoft)" "Bewertung"
zeile "-----------" "---" "----------------------" "---------"

thp=$(lies /sys/kernel/mm/transparent_hugepage/enabled | sed -n 's/.*\[\(.*\)\].*/\1/p'); thp=${thp:-?}
zeile "Transparent Huge Pages" "$thp" "always (mehrere Instanzen: madvise)" "$(pruef "$thp" always)"
sw=$(lies /proc/sys/vm/swappiness); sw=${sw:-?}
zeile "vm.swappiness" "$sw" "1" "$(pruef "$sw" 1)"
mm=$(lies /proc/sys/vm/max_map_count); mm=${mm:-?}
if [ "$mm" != "?" ] && [ "$mm" -ge 262144 ] 2>/dev/null; then b=ok; [ "$mm" -lt 1600000 ] && b="ok (Profil: 1600000)"; else b=$(pruef "$mm" 1600000); fi
zeile "vm.max_map_count" "$mm" "1600000 (mindestens 262144)" "$b"
dr=$(lies /proc/sys/vm/dirty_ratio); dbr=$(lies /proc/sys/vm/dirty_background_ratio)
zeile "vm.dirty_ratio / background" "${dr:-?} / ${dbr:-?}" "80 / 3 (TuneD-Profil mssql)" "$( [ "${dr:-}" = 80 ] && [ "${dbr:-}" = 3 ] && echo ok || echo prüfen )"
numa=$(ls -d /sys/devices/system/node/node* 2>/dev/null | wc -l)
nb=$(lies /proc/sys/kernel/numa_balancing); nb=${nb:-?}
if [ "$numa" -gt 1 ]; then b=$(pruef "$nb" 0); else b="ok (1 NUMA-Knoten)"; fi
zeile "kernel.numa_balancing" "$nb ($numa NUMA-Knoten)" "0 bei mehreren NUMA-Knoten" "$b"
if command -v tuned-adm >/dev/null 2>&1; then t=$(tuned-adm active 2>/dev/null | sed -n 's/.*: //p'); else t="kein TuneD"; fi
zeile "TuneD-Profil" "${t:-?}" "mssql" "$( [ "${t:-}" = mssql ] && echo ok || echo prüfen )"
gov=$(lies /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor); gov=${gov:-"n/a (VM?)"}
zeile "CPU-Governor" "$gov" "performance" "$( [ "$gov" = performance ] && echo ok || { [ "${gov#n/a}" != "$gov" ] && echo info || echo prüfen; } )"
sw_on=$(awk 'NR>1' /proc/swaps 2>/dev/null | wc -l)
zeile "Swap eingerichtet" "$( [ "$sw_on" -gt 0 ] && echo ja || echo nein )" "ja (Sicherheitsnetz, keine Kapazität)" "$( [ "$sw_on" -gt 0 ] && echo ok || echo prüfen )"

for pfad in $(printf "%s\n%s\n" "$DATA" "$LOG" | awk '!s[$0]++'); do
  [ -d "$pfad" ] || { zeile "Verzeichnis $pfad" "fehlt" "" "?"; continue; }
  read -r dev fs opts < <(awk -v p="$(df -P "$pfad" 2>/dev/null | awk 'NR==2{print $6}')" '$2==p{print $1, $3, $4}' /proc/mounts | tail -1)
  if [ "${fs:-}" = overlay ]; then
    zeile "Dateisystem $pfad" "overlay" "Volume oder Bind-Mount" "prüfen (Container-Schreibschicht)"; continue; fi
  zeile "Dateisystem $pfad" "${fs:-?}" "xfs (ext4 unterstützt)" "$( [ "${fs:-}" = xfs ] && echo ok || { [ "${fs:-}" = ext4 ] && echo ok || echo prüfen; } )"
  zeile "  Mount-Option atime" "$(echo "${opts:-?}" | grep -o 'noatime\|relatime\|strictatime' | head -1)" "noatime" "$(echo "${opts:-}" | grep -q noatime && echo ok || echo prüfen)"
  blk=$(basename "$(readlink -f "${dev:-x}" 2>/dev/null)" | sed 's/[0-9]*$//; s/p$//')
  if [ -n "$blk" ] && [ -d "/sys/block/$blk/queue" ]; then
    ra=$(lies /sys/block/$blk/queue/read_ahead_kb); sch=$(lies /sys/block/$blk/queue/scheduler | sed -n 's/.*\[\(.*\)\].*/\1/p')
    fua=$(lies /sys/block/$blk/queue/fua); wc=$(lies /sys/block/$blk/queue/write_cache)
    zeile "  Read-ahead ($blk)" "${ra:-?} KB" "4096 (blockdev --setra, Sektoren)" "info"
    zeile "  I/O-Scheduler ($blk)" "${sch:-?}" "keine Vorgabe (Multiqueue)" "info"
    zeile "  FUA / Write-Cache ($blk)" "${fua:-?} / ${wc:-?}" "FUA=1 nur dann TF 3979" "info"
  else
    zeile "  Blockgerät" "nicht ermittelbar" "" "?"
  fi
done

CONF=/var/opt/mssql/mssql.conf
echo
if [ -r "$CONF" ]; then
  echo "mssql.conf ($CONF), Einträge mit Leistungsbezug:"
  grep -E '^\s*(writethrough|alternatewritethrough|memorylimitmb|traceflag[0-9]*)\s*=' "$CONF" | sed 's/^/  /' || echo "  (keine; es gelten die Standardwerte)"
else
  echo "mssql.conf nicht lesbar oder nicht vorhanden (Standardwerte; im Container ggf. MSSQL_*-Variablen)."
fi
echo "Standard unter Linux: Forced Flush (Trace Flag 3982), control.writethrough = 1, control.alternatewritethrough = 1."
echo "Nie writethrough = 0 setzen, solange nicht belegt ist, dass der Speicher O_DIRECT-sicher ist."

Host-Check SQL Server unter Linux · 2026-11-13 10:33 · psg-sql-lab01
System: Ubuntu 24.04.5 LTS · Kernel 6.8.0-147-generic

Einstellung                        Ist                          Empfehlung (Microsoft)         Bewertung
-----------                        ---                          ----------------------         ---------
Transparent Huge Pages             madvise                      always (mehrere Instanzen: madvise) prüfen
vm.swappiness                      60                           1                              prüfen
vm.max_map_count                   1048576                      1600000 (mindestens 262144)    ok (Profil: 1600000)
vm.dirty_ratio / background        20 / 10                      80 / 3 (TuneD-Profil mssql)    prüfen
kernel.numa_balancing              1 (2 NUMA-Knoten)            0 bei mehreren NUMA-Knoten     prüfen
TuneD-Profil                       kein TuneD                   mssql                          prüfen
CPU-Governor                       n/a (VM?)                    performance                    info
Swap eingerichtet                  nein                         ja (Sicherheitsnetz, keine Kapazität) prüfen
Dateisystem /srv/sql/data          ext4                         xfs (ext4 unterstützt)        ok
  Mount-Option atime               relatime                     noatime                        prüfen
  Read-ahead (sdc)                 128 KB                       4096 (blockdev --setra, Sektoren) info
  I/O-Scheduler (sdc)              none                         keine Vorgabe (Multiqueue)     info
  FUA / Write-Cache (sdc)          0 / write back               FUA=1 nur dann TF 3979         info
Dateisystem /srv/sql/log           ext4                         xfs (ext4 unterstützt)        ok
  Mount-Option atime               relatime                     noatime                        prüfen
  Read-ahead (sdd)                 128 KB                       4096 (blockdev --setra, Sektoren) info
  I/O-Scheduler (sdd)              none                         keine Vorgabe (Multiqueue)     info
  FUA / Write-Cache (sdd)          0 / write back               FUA=1 nur dann TF 3979         info

mssql.conf nicht lesbar oder nicht vorhanden (Standardwerte; im Container ggf. MSSQL_*-Variablen).
Standard unter Linux: Forced Flush (Trace Flag 3982), control.writethrough = 1, control.alternatewritethrough = 1.
Nie writethrough = 0 setzen, solange nicht belegt ist, dass der Speicher O_DIRECT-sicher ist.

/* PSG Stack · SQL Server unter Linux und Docker · Abfrage 4 „Betriebs-Check“   Prüft Einstellungen und Wartezeiten, die unter Linux für Leistung und stabilen Betrieb zählen:   Flush-Trace-Flags, Speichergrenzen und Speicherdruck, CPUs und Scheduler, MAXDOP, tempdb,   Wartezeiten beim Schreiben des Transaktionsprotokolls. Eine Zeile je Prüfpunkt mit Bewertung.    !!! WARNUNG — bitte vor dem Ausführen lesen !!!   - Nur lesend. Die Abfrage ändert keine Daten und keine Einstellung.   - Rechte: VIEW SERVER STATE (ab 2022 genügt für die meisten Punkte VIEW SERVER PERFORMANCE STATE);     ohne VIEW ANY DEFINITION meldet der tempdb-Punkt „nicht geprüft“.   - MAXDOP 1: Jede Teilabfrage läuft seriell und belegt keine weiteren Kerne.   - Wartezeiten zählen seit dem letzten Start oder seit dem letzten Leeren der Statistik.   - Bewertung „prüfen“ heißt: genauer hinsehen, nicht automatisch ändern. Richtwerte nach Microsoft     Learn (Linux-Performance-Seiten, Stand 05/2026) und PSG-Lab; sie ersetzen keine Analyse.   - Ab SQL Server 2017. Geprüft im PSG-Lab auf 2017, 2019, 2022 und 2025 in Linux-Containern,     als sa und ohne sysadmin (13.11.2026); unter Windows nicht geprüft (Linux-Punkte zeigen dort n/a).*/SET NOCOUNT ON; DECLARE @r TABLE (nr int, bereich nvarchar(20), pruefpunkt nvarchar(80), wert nvarchar(200),                  richtwert nvarchar(200), bewertung nvarchar(10), hinweis nvarchar(400));DECLARE @linux bit = 0, @cpu int, @sched int, @mem_mb bigint, @ziel_mb bigint, @modell nvarchar(60),        @maxmem bigint, @maxdop int, @ctp int, @sql nvarchar(max), @container nvarchar(60) = N'n/a'; IF OBJECT_ID(N'sys.dm_os_host_info') IS NOT NULL    SELECT @linux = CASE WHEN host_platform = N'Linux' THEN 1 ELSE 0 END FROM sys.dm_os_host_info OPTION (MAXDOP 1); SELECT @cpu = cpu_count, @mem_mb = physical_memory_kb / 1024, @ziel_mb = committed_target_kb / 1024,       @modell = sql_memory_model_descFROM sys.dm_os_sys_info OPTION (MAXDOP 1);IF EXISTS (SELECT 1 FROM sys.all_columns WHERE object_id = OBJECT_ID(N'sys.dm_os_sys_info') AND name = N'container_type_desc')    EXEC sys.sp_executesql N'SELECT @c = container_type_desc FROM sys.dm_os_sys_info OPTION (MAXDOP 1);', N'@c nvarchar(60) OUTPUT', @c = @container OUTPUT;SELECT @sched = COUNT(*) FROM sys.dm_os_schedulers WHERE status = N'VISIBLE ONLINE' OPTION (MAXDOP 1);SELECT @maxmem = CONVERT(bigint, value_in_use) FROM sys.configurations WHERE name = N'max server memory (MB)' OPTION (MAXDOP 1);SELECT @maxdop = CONVERT(int, value_in_use) FROM sys.configurations WHERE name = N'max degree of parallelism' OPTION (MAXDOP 1);SELECT @ctp = CONVERT(int, value_in_use) FROM sys.configurations WHERE name = N'cost threshold for parallelism' OPTION (MAXDOP 1); /* 1 · Schreiben und Flushen (nur Linux) */DECLARE @tf TABLE (TraceFlag int, Status int, Global int, Session int);BEGIN TRY    INSERT @tf EXEC (N'DBCC TRACESTATUS(3979, 3982, 8002, -1) WITH NO_INFOMSGS');END TRYBEGIN CATCHEND CATCH;INSERT @r SELECT 1, N'Flushen', N'Flush-Modus (Trace Flag 3979)',    CASE WHEN @linux = 0 THEN N'n/a (Windows)' WHEN NOT EXISTS (SELECT 1 FROM @tf) THEN N'nicht lesbar'         WHEN EXISTS (SELECT 1 FROM @tf WHERE TraceFlag = 3979 AND Global = 1) THEN N'FUA-Schreiben (3979 an)'         ELSE N'Forced Flush (Standard, 3979 aus)' END,    N'Forced Flush, außer der Speicher kann nachweislich FUA', N'info',    N'Forced Flush ist der Linux-Standard, auch wenn DBCC TRACESTATUS 3982 nicht als aktiv zeigt (PSG-Lab). 3979 nur mit FUA-fähigem Speicher und alternatewritethrough = 0.';INSERT @r SELECT 2, N'Flushen', N'writethrough / alternatewritethrough', N'in mssql.conf (SQL Server zeigt sie nicht)',    N'1 / 1 (Standard) oder 1 / 0 mit Trace Flag 3979', N'info',    N'Mit cat /var/opt/mssql/mssql.conf prüfen, Abschnitt [control]; fehlt er, gelten die Standardwerte. writethrough = 0 kann Daten kosten.'; /* 2 · Wartezeiten beim Schreiben (seit Start) */DECLARE @gesamt bigint, @flush bigint, @wl_ms bigint, @wl_n bigint;SELECT @gesamt = SUM(wait_time_ms) FROM sys.dm_os_wait_statsWHERE wait_type NOT LIKE N'SLEEP%' AND wait_type NOT LIKE N'BROKER%' AND wait_type NOT LIKE N'XE%'  AND wait_type NOT LIKE N'%QUEUE%' AND wait_type NOT LIKE N'HADR%' AND wait_type NOT LIKE N'SQLTRACE%'  AND wait_type NOT LIKE N'CLR%' AND wait_type NOT LIKE N'FT_%' AND wait_type NOT LIKE N'%IDLE%'  AND wait_type NOT IN (N'WAITFOR', N'CHECKPOINT_QUEUE', N'DIRTY_PAGE_POLL', N'DISPATCHER_QUEUE_SEMAPHORE',      N'LOGMGR_QUEUE', N'REQUEST_FOR_DEADLOCK_SEARCH', N'SP_SERVER_DIAGNOSTICS_SLEEP', N'QDS_ASYNC_QUEUE',      N'QDS_PERSIST_TASK_MAIN_LOOP_SLEEP', N'QDS_CLEANUP_STALE_QUERIES_TASK_MAIN_LOOP_SLEEP', N'PWAIT_EXTENSIBILITY_CLEANUP_TASK',      N'SOS_WORK_DISPATCHER', N'PVS_PREALLOCATE', N'PREEMPTIVE_XE_DISPATCHER', N'PREEMPTIVE_OS_FLUSHFILEBUFFERS_IDLE')OPTION (MAXDOP 1);SELECT @flush = SUM(CASE WHEN wait_type = N'PREEMPTIVE_OS_FLUSHFILEBUFFERS' THEN wait_time_ms ELSE 0 END),       @wl_ms = SUM(CASE WHEN wait_type = N'WRITELOG' THEN wait_time_ms ELSE 0 END),       @wl_n  = SUM(CASE WHEN wait_type = N'WRITELOG' THEN waiting_tasks_count ELSE 0 END)FROM sys.dm_os_wait_stats OPTION (MAXDOP 1);INSERT @r SELECT 3, N'Flushen', N'Anteil PREEMPTIVE_OS_FLUSHFILEBUFFERS an den Wartezeiten',    CASE WHEN ISNULL(@gesamt, 0) = 0 THEN N'keine Wartezeiten'         ELSE REPLACE(CONVERT(nvarchar(20), CONVERT(decimal(5, 1), 100.0 * @flush / @gesamt)), N'.', N',') + N' %' END,    N'unter Linux oft weit oben, für sich allein kein Befund', N'info',    N'Entspricht dem fdatasync-Aufruf von SQL Server unter Linux (Paul Randal, Bob Dorr). Erst zusammen mit hohen WRITELOG-Zeiten ein Thema.';INSERT @r SELECT 4, N'Flushen', N'WRITELOG, mittlere Wartezeit je Commit-Warten',    CASE WHEN ISNULL(@wl_n, 0) = 0 THEN N'keine' ELSE REPLACE(CONVERT(nvarchar(20), CONVERT(decimal(9, 2), 1.0 * @wl_ms / @wl_n)), N'.', N',') + N' ms' END,    N'wenige Millisekunden', CASE WHEN @wl_n > 0 AND 1.0 * @wl_ms / @wl_n > 5 THEN N'prüfen' ELSE N'ok' END,    N'Hohe Werte: Log-Datenträger langsam, Log in der Container-Schreibschicht (overlayfs) oder sehr viele kleine Transaktionen.'; /* 3 · Speicher */INSERT @r SELECT 5, N'Speicher', N'max server memory gegen sichtbaren Speicher',    CONVERT(nvarchar(20), @maxmem) + N' MB von ' + CONVERT(nvarchar(20), @mem_mb) + N' MB',    N'gesetzt, unter dem sichtbaren Speicher, mit Kopfraum',    CASE WHEN @maxmem >= 2147483647 OR @maxmem > @mem_mb THEN N'prüfen' ELSE N'ok' END,    N'Unter Linux begrenzt memory.memorylimitmb (bzw. MSSQL_MEMORY_LIMIT_MB) den ganzen Prozess, max server memory nur den Puffer-Pool. Im Container 10–20 % Kopfraum zum Container-Limit lassen.';INSERT @r SELECT 6, N'Speicher', N'Speicherziel (committed_target)',    CONVERT(nvarchar(20), @ziel_mb) + N' MB', N'unter dem Container- oder Host-Limit', N'info',    N'2017 und 2019 sehen das cgroup-v2-Limit eines Containers nicht und planen mit dem Host-Speicher (PSG-Lab, Teil 3).';INSERT @r SELECT 7, N'Speicher', N'Speichermodell', @modell, N'CONVENTIONAL ist unter Linux normal', N'info',    N'Für „Lock Pages in Memory“ gibt es unter Linux keine dokumentierte Entsprechung.';DECLARE @tief int, @proz int;SELECT @tief = CONVERT(int, system_low_memory_signal_state) FROM sys.dm_os_sys_memory OPTION (MAXDOP 1);SELECT @proz = CONVERT(int, process_physical_memory_low) FROM sys.dm_os_process_memory OPTION (MAXDOP 1);INSERT @r SELECT 8, N'Speicher', N'Speicherdruck jetzt (System / Prozess)',    CONVERT(nvarchar(5), @tief) + N' / ' + CONVERT(nvarchar(5), @proz), N'0 / 0',    CASE WHEN @tief = 1 OR @proz = 1 THEN N'prüfen' ELSE N'ok' END,    N'1 heißt: SQL Server meldet gerade zu wenig Speicher. Bleibt es dauerhaft 1, Grenzen und speicherhungrige Abfragen prüfen.'; /* 4 · CPU, Scheduler, Parallelität */INSERT @r SELECT 9, N'CPU', N'CPUs und sichtbare Scheduler',    CONVERT(nvarchar(10), @cpu) + N' CPUs, ' + CONVERT(nvarchar(10), @sched) + N' Scheduler'      + CASE WHEN @container <> N'n/a' AND @container <> N'NONE' THEN N' · ' + @container ELSE N'' END,    N'so viele Scheduler, wie CPUs tatsächlich zur Verfügung stehen', N'info',    N'Eine CPU-Quote (docker --cpus) sieht SQL Server nicht. Gegenmittel laut Microsoft: PROCESS AFFINITY und unter cgroup v2 Trace Flag 8002.';INSERT @r SELECT 10, N'CPU', N'Trace Flag 8002 (weiche Prozessoraffinität)',    CASE WHEN @linux = 0 THEN N'n/a (Windows)' WHEN NOT EXISTS (SELECT 1 FROM @tf) THEN N'nicht lesbar'         WHEN EXISTS (SELECT 1 FROM @tf WHERE TraceFlag = 8002 AND Global = 1) THEN N'an' ELSE N'aus' END,    N'Microsoft: unter cgroup v2 zusammen mit PROCESS AFFINITY; vorher messen', N'info',    N'Ohne 8002 bindet PROCESS AFFINITY die Scheduler fest an einzelne CPUs. Im PSG-Lab (2019–2025, Quote 4 CPUs) brachte 8002 zur Affinität keinen messbaren Gewinn.';INSERT @r SELECT 11, N'CPU', N'max degree of parallelism', CONVERT(nvarchar(10), @maxdop),    N'höchstens 8 je NUMA-Knoten, nicht 0 bei mehr als 8 Schedulern',    CASE WHEN @maxdop = 0 AND @sched > 8 THEN N'prüfen' ELSE N'ok' END,    N'MAXDOP 0 nutzt so viele Threads, wie Scheduler sichtbar sind, auch wenn der Container weniger CPU bekommt.';INSERT @r SELECT 12, N'CPU', N'cost threshold for parallelism', CONVERT(nvarchar(10), @ctp),    N'nicht die Voreinstellung 5', CASE WHEN @ctp = 5 THEN N'prüfen' ELSE N'ok' END,    N'Die Voreinstellung 5 lässt schon sehr kleine Abfragen parallel laufen.'; /* 5 · tempdb */IF HAS_PERMS_BY_NAME(NULL, NULL, N'VIEW ANY DEFINITION') = 1BEGIN    DECLARE @n int, @gleich bit, @prozent int;    SELECT @n = COUNT(*), @gleich = CASE WHEN MIN(size) = MAX(size) AND MIN(growth) = MAX(growth) THEN 1 ELSE 0 END,           @prozent = MAX(CONVERT(int, is_percent_growth))    FROM sys.master_files WHERE database_id = 2 AND type = 0 OPTION (MAXDOP 1);    INSERT @r SELECT 13, N'tempdb', N'Datendateien',        CONVERT(nvarchar(10), @n) + N' Dateien, ' + CASE WHEN @gleich = 1 THEN N'gleich groß' ELSE N'unterschiedlich' END          + CASE WHEN @prozent = 1 THEN N', Wachstum in Prozent' ELSE N'' END,        N'so viele wie Scheduler, höchstens 8, gleich groß, festes Wachstum',        CASE WHEN @n < CASE WHEN @sched > 8 THEN 8 ELSE @sched END OR @gleich = 0 OR @prozent = 1 THEN N'prüfen' ELSE N'ok' END,        N'Ab 2019 legt eine Linux-Installation bis zu acht Dateien an (Microsoft); die Container-Images legen beim ersten Start eine je CPU an, höchstens acht (PSG-Lab; 2017: eine). Nicht bei einem In-place-Upgrade.';ENDELSE    INSERT @r SELECT 13, N'tempdb', N'Datendateien', N'nicht geprüft', N'', N'info', N'VIEW ANY DEFINITION fehlt (sys.master_files).'; SELECT nr, bereich, pruefpunkt, wert, richtwert, bewertung, hinweis FROM @r ORDER BY nr OPTION (MAXDOP 1);

nr|bereich|pruefpunkt|wert|richtwert|bewertung|hinweis
--|-------|----------|----|---------|---------|-------
1|Flushen|Flush-Modus (Trace Flag 3979)|Forced Flush (Standard, 3979 aus)|Forced Flush, außer der Speicher kann nachweislich FUA|info|Forced Flush ist der Linux-Standard, auch wenn DBCC TRACESTATUS 3982 nicht als aktiv zeigt (PSG-Lab). 3979 nur mit FUA-fähigem Speicher und alternatewritethrough = 0.
2|Flushen|writethrough / alternatewritethrough|in mssql.conf (SQL Server zeigt sie nicht)|1 / 1 (Standard) oder 1 / 0 mit Trace Flag 3979|info|Mit cat /var/opt/mssql/mssql.conf prüfen, Abschnitt [control]; fehlt er, gelten die Standardwerte. writethrough = 0 kann Daten kosten.
3|Flushen|Anteil PREEMPTIVE_OS_FLUSHFILEBUFFERS an den Wartezeiten|22,9 %|unter Linux oft weit oben, für sich allein kein Befund|info|Entspricht dem fdatasync-Aufruf von SQL Server unter Linux (Paul Randal, Bob Dorr). Erst zusammen mit hohen WRITELOG-Zeiten ein Thema.
4|Flushen|WRITELOG, mittlere Wartezeit je Commit-Warten|0,56 ms|wenige Millisekunden|ok|Hohe Werte: Log-Datenträger langsam, Log in der Container-Schreibschicht (overlayfs) oder sehr viele kleine Transaktionen.
5|Speicher|max server memory gegen sichtbaren Speicher|2147483647 MB von 4916 MB|gesetzt, unter dem sichtbaren Speicher, mit Kopfraum|prüfen|Unter Linux begrenzt memory.memorylimitmb (bzw. MSSQL_MEMORY_LIMIT_MB) den ganzen Prozess, max server memory nur den Puffer-Pool. Im Container 10–20 % Kopfraum zum Container-Limit lassen.
6|Speicher|Speicherziel (committed_target)|4267 MB|unter dem Container- oder Host-Limit|info|2017 und 2019 sehen das cgroup-v2-Limit eines Containers nicht und planen mit dem Host-Speicher (PSG-Lab, Teil 3).
7|Speicher|Speichermodell|CONVENTIONAL|CONVENTIONAL ist unter Linux normal|info|Für „Lock Pages in Memory“ gibt es unter Linux keine dokumentierte Entsprechung.
8|Speicher|Speicherdruck jetzt (System / Prozess)|0 / 0|0 / 0|ok|1 heißt: SQL Server meldet gerade zu wenig Speicher. Bleibt es dauerhaft 1, Grenzen und speicherhungrige Abfragen prüfen.
9|CPU|CPUs und sichtbare Scheduler|6 CPUs, 6 Scheduler · LINUX CONTAINER|so viele Scheduler, wie CPUs tatsächlich zur Verfügung stehen|info|Eine CPU-Quote (docker --cpus) sieht SQL Server nicht. Gegenmittel laut Microsoft: PROCESS AFFINITY und unter cgroup v2 Trace Flag 8002.
10|CPU|Trace Flag 8002 (weiche Prozessoraffinität)|aus|Microsoft: unter cgroup v2 zusammen mit PROCESS AFFINITY; vorher messen|info|Ohne 8002 bindet PROCESS AFFINITY die Scheduler fest an einzelne CPUs. Im PSG-Lab (2019–2025, Quote 4 CPUs) brachte 8002 zur Affinität keinen messbaren Gewinn.
11|CPU|max degree of parallelism|0|höchstens 8 je NUMA-Knoten, nicht 0 bei mehr als 8 Schedulern|ok|MAXDOP 0 nutzt so viele Threads, wie Scheduler sichtbar sind, auch wenn der Container weniger CPU bekommt.
12|CPU|cost threshold for parallelism|5|nicht die Voreinstellung 5|prüfen|Die Voreinstellung 5 lässt schon sehr kleine Abfragen parallel laufen.
13|tempdb|Datendateien|6 Dateien, gleich groß|so viele wie Scheduler, höchstens 8, gleich groß, festes Wachstum|ok|Ab 2019 legt eine Linux-Installation bis zu acht Dateien an (Microsoft); die Container-Images legen beim ersten Start eine je CPU an, höchstens acht (PSG-Lab; 2017: eine). Nicht bei einem In-place-Upgrade.