flowchart LR
    user["Du / Team"] --> intent["Gewünschter Zustand"]
    intent --> manifest["YAML, Helm, Kustomize oder GitOps"]
    manifest --> api["Kubernetes API Server"]
    api --> etcd["etcd: Cluster-Zustand"]
    api --> controllers["Controller"]
    api --> scheduler["Scheduler"]
    scheduler --> node["Worker Node"]
    controllers --> node
    node --> kubelet["kubelet"]
    kubelet --> runtime["Container Runtime"]
    runtime --> pods["Pods und Container"]
    pods --> service["Service Discovery und Netzwerk"]
    pods --> storage["Volumes und Storage"]
    pods --> signals["Logs, Metriken, Events"]
    signals --> user

flowchart TD
    subgraph cp["Control Plane"]
        api["kube-apiserver"]
        etcd["etcd"]
        sched["kube-scheduler"]
        cm["kube-controller-manager"]
        ccm["cloud-controller-manager"]
    end

    subgraph n1["Worker Node A"]
        kubelet1["kubelet"]
        proxy1["kube-proxy oder eBPF-Dataplane"]
        cni1["CNI Plugin"]
        rt1["containerd oder CRI-O"]
        pods1["Pods"]
    end

    subgraph n2["Worker Node B"]
        kubelet2["kubelet"]
        proxy2["kube-proxy oder eBPF-Dataplane"]
        cni2["CNI Plugin"]
        rt2["containerd oder CRI-O"]
        pods2["Pods"]
    end

    api --> etcd
    api --> sched
    api --> cm
    api --> ccm
    api --> kubelet1
    api --> kubelet2
    kubelet1 --> rt1 --> pods1
    kubelet2 --> rt2 --> pods2
    cni1 --> pods1
    cni2 --> pods2
    proxy1 --> pods1
    proxy2 --> pods2

flowchart TD
    client["kubectl, Controller, CI/CD, GitOps"] --> lb["Load Balancer für API Server"]

    lb --> api1["API Server 1"]
    lb --> api2["API Server 2"]
    lb --> api3["API Server 3"]

    api1 --> e1["etcd Member 1"]
    api2 --> e2["etcd Member 2"]
    api3 --> e3["etcd Member 3"]

    e1 <--> e2
    e2 <--> e3
    e1 <--> e3

    api1 --> sched["Scheduler mit Leader Election"]
    api2 --> cm["Controller Manager mit Leader Election"]
    api3 --> ccm["Cloud Controller Manager"]

flowchart LR
    subgraph stacked["Stacked Control Plane"]
        cp1["Control Plane Node 1\nAPI + etcd"]
        cp2["Control Plane Node 2\nAPI + etcd"]
        cp3["Control Plane Node 3\nAPI + etcd"]
        cp1 <--> cp2
        cp2 <--> cp3
        cp1 <--> cp3
    end

    subgraph external["Externe etcd-Topologie"]
        apiA["Control Plane Nodes\nAPI, Scheduler, Controller"]
        etcdA["dedizierter etcd Node 1"]
        etcdB["dedizierter etcd Node 2"]
        etcdC["dedizierter etcd Node 3"]
        apiA --> etcdA
        apiA --> etcdB
        apiA --> etcdC
        etcdA <--> etcdB
        etcdB <--> etcdC
        etcdA <--> etcdC
    end

flowchart TD
    api["API Server"] --> kubelet["kubelet"]

    subgraph node["Worker Node"]
        kubelet --> cri["CRI Schnittstelle"]
        cri --> runtime["containerd oder CRI-O"]
        runtime --> sandbox["Pod Sandbox"]
        sandbox --> c1["Container app"]
        sandbox --> c2["Container sidecar"]
        kubelet --> volumes["Volume Mounts"]
        kubelet --> probes["Liveness, Readiness, Startup Probes"]
        kubelet --> logs["Container Logs"]
        proxy["kube-proxy oder eBPF"] --> dataplane["Service-Dataplane"]
        cni["CNI Plugin"] --> podnet["Pod-Netzwerk"]
        ds["DaemonSet Pods"] --> nodeagents["Monitoring, Logging, Security, CNI"]
    end

flowchart LR
    api["API Server"] -->|Pod-Status lesen| kubelet["kubelet"]
    api -->|Logs, exec, port-forward, debug| kubelet
    kubelet -->|Node- und Pod-Status melden| api
    api -->|Proxy-Pfad| target["Node, Pod oder Service"]
    target --> response["Antwort an API Client"]
    response --> user["kubectl"]

flowchart TD
    platform["Plattform"] --> api["API und Zustand"]
    platform --> scheduling["Scheduling"]
    platform --> runtime["Laufzeit"]
    platform --> network["Netzwerk"]
    platform --> storage["Storage"]
    platform --> security["Security"]
    platform --> observe["Beobachtbarkeit"]

    api --> apiserver["kube-apiserver"]
    api --> etcd["etcd"]
    scheduling --> scheduler["kube-scheduler"]
    scheduling --> autoscaler["Cluster Autoscaler"]
    runtime --> kubelet["kubelet"]
    runtime --> crio["CRI Runtime"]
    network --> cni["CNI"]
    network --> service["Service-Dataplane"]
    storage --> csi["CSI"]
    storage --> pv["PV, PVC, StorageClass"]
    security --> rbac["RBAC"]
    security --> admission["Admission"]
    security --> pss["Pod Security"]
    observe --> metrics["Metriken"]
    observe --> logs["Logs"]
    observe --> traces["Traces"]

sequenceDiagram
    participant U as Du oder Tool
    participant API as API Server
    participant AUTHN as Authentifizierung
    participant AUTHZ as Autorisierung
    participant ADM as Admission Control
    participant ETCD as etcd
    participant CTRL as Controller

    U->>API: apply, create, patch oder delete
    API->>AUTHN: Wer stellt die Anfrage?
    AUTHN-->>API: Identität
    API->>AUTHZ: Darf diese Identität das tun?
    AUTHZ-->>API: erlaubt oder verweigert
    API->>ADM: Validierung und Mutation
    ADM-->>API: akzeptiert oder abgelehnt
    API->>ETCD: Zustand speichern
    ETCD-->>API: gespeichert
    API-->>U: API-Antwort
    CTRL->>API: Änderung beobachten
    CTRL->>API: tatsächlichen Zustand anpassen

flowchart TD
    obj["Kubernetes Objekt"] --> apiVersion["apiVersion"]
    obj --> kind["kind"]
    obj --> metadata["metadata"]
    obj --> spec["spec"]
    obj --> status["status"]

    metadata --> name["name"]
    metadata --> namespace["namespace"]
    metadata --> labels["labels"]
    metadata --> annotations["annotations"]
    metadata --> owner["ownerReferences"]
    metadata --> finalizers["finalizers"]

    spec --> desired["gewünschter Zustand"]
    status --> actual["beobachteter Zustand"]
    status --> conditions["Conditions"]
    status --> observed["observedGeneration"]

flowchart LR
    desired["Desired State\nim API-Objekt"] --> compare["Controller vergleicht"]
    actual["Actual State\nim Cluster"] --> compare
    compare -->|Abweichung| act["Aktion ausführen"]
    act --> actual
    compare -->|keine Abweichung| steady["stabiler Zustand"]
    act --> status["Status aktualisieren"]
    status --> desired

flowchart TD
    watch["Watch auf API-Ressourcen"] --> queue["Work Queue"]
    queue --> reconcile["Reconcile-Funktion"]
    reconcile --> read["aktuellen Zustand lesen"]
    read --> decide{Ist-Zustand korrekt?}
    decide -->|ja| status["Status prüfen oder aktualisieren"]
    decide -->|nein| change["Ressourcen erstellen, ändern oder löschen"]
    change --> requeue["erneut einreihen bei Bedarf"]
    status --> wait["auf nächste Änderung warten"]
    requeue --> queue
    wait --> watch

flowchart TD
    dep["Deployment"] -->|ownerReference| rs1["ReplicaSet alte Version"]
    dep -->|ownerReference| rs2["ReplicaSet neue Version"]
    rs2 -->|ownerReference| pod1["Pod 1"]
    rs2 -->|ownerReference| pod2["Pod 2"]
    rs1 --> oldpod["alter Pod"]
    delete["Deployment wird gelöscht"] --> gc["Garbage Collector"]
    gc --> rs1
    gc --> rs2
    gc --> pod1
    gc --> pod2

sequenceDiagram
    participant U as Du
    participant API as API Server
    participant OBJ as Objekt mit Finalizer
    participant C as Controller
    participant EXT as Externe Ressource

    U->>API: delete objekt
    API->>OBJ: deletionTimestamp setzen
    API-->>U: Objekt ist im Löschzustand
    C->>API: Objekt mit deletionTimestamp sehen
    C->>EXT: externe Ressource aufräumen
    EXT-->>C: aufgeräumt
    C->>API: Finalizer entfernen
    API->>API: Objekt endgültig löschen

flowchart LR
    obj["Ressource"] --> status["status"]
    obj --> events["Events"]
    status --> conditions["Conditions"]
    conditions --> ready["Ready"]
    conditions --> available["Available"]
    conditions --> progressing["Progressing"]
    conditions --> degraded["Degraded oder Failed"]
    events --> schedule["Scheduling Events"]
    events --> image["Image Pull Events"]
    events --> volume["Volume Events"]
    events --> probe["Probe Events"]

flowchart TD
    deploy["Deployment\napp=web"] --> rs["ReplicaSet\nreplicas=3"]
    rs --> pod1["Pod web-1"]
    rs --> pod2["Pod web-2"]
    rs --> pod3["Pod web-3"]

    svc["Service\nselector app=web"] --> pod1
    svc --> pod2
    svc --> pod3

sequenceDiagram
    participant U as Du
    participant API as API Server
    participant D as Deployment Controller
    participant OLD as Altes ReplicaSet
    participant NEW as Neues ReplicaSet
    participant SVC as Service

    U->>API: neues Image per apply oder set image
    API-->>D: Deployment geändert
    D->>NEW: neues ReplicaSet erstellen
    D->>NEW: neue Pods hochskalieren
    NEW-->>SVC: readiness erreicht
    D->>OLD: alte Pods herunterskalieren
    D->>API: Rollout-Status aktualisieren

flowchart LR
    bad["Release v3 fehlerhaft"] --> detect["Fehler erkannt"]
    detect --> undo["kubectl rollout undo"]
    undo --> previous["ReplicaSet v2 wieder hochskalieren"]
    previous --> down["ReplicaSet v3 herunterskalieren"]
    down --> verify["Service, Logs und Metriken prüfen"]

stateDiagram-v2
    [*] --> Pending
    Pending --> Running: Node zugewiesen und Container gestartet
    Pending --> Failed: Scheduling, Image oder Volume scheitert
    Running --> Succeeded: alle Container erfolgreich beendet
    Running --> Failed: Container oder Pod scheitert dauerhaft
    Running --> Terminating: Löschung oder Eviction
    Terminating --> [*]
    Succeeded --> [*]
    Failed --> [*]

flowchart TD
    start["Pod wird gestartet"] --> init1["Init Container 1"]
    init1 --> init2["Init Container 2"]
    init2 --> app["App Container"]
    init2 --> sidecar["Sidecar Container"]
    app <--> sharednet["gemeinsamer Netzwerk-Namespace"]
    sidecar <--> sharednet
    app <--> volume["gemeinsame Volumes"]
    sidecar <--> volume

flowchart TD
    pod["Pod"] --> startup["Startup Probe"]
    startup -->|erfolgreich| live["Liveness Probe aktiv"]
    startup -->|fehlschlägt zu oft| restart1["Container Neustart"]
    live -->|ok| ready["Readiness Probe"]
    live -->|fehlschlägt zu oft| restart2["Container Neustart"]
    ready -->|ready| endpoints["EndpointSlice enthält Pod"]
    ready -->|not ready| noTraffic["kein Service-Traffic"]

sequenceDiagram
    participant API as API Server
    participant EP as EndpointSlice Controller
    participant K as kubelet
    participant APP as App Container
    participant SVC as Service Traffic

    API->>EP: Pod bekommt deletionTimestamp
    EP->>SVC: Endpoint aus Routing entfernen
    API->>K: Pod beenden
    K->>APP: preStop Hook ausführen, falls vorhanden
    K->>APP: SIGTERM senden
    APP->>APP: laufende Requests abschließen
    K->>APP: nach Grace Period SIGKILL, falls nötig

flowchart TD
    sts["StatefulSet db"] --> pod0["db-0"]
    sts --> pod1["db-1"]
    sts --> pod2["db-2"]
    pod0 --> pvc0["data-db-0"]
    pod1 --> pvc1["data-db-1"]
    pod2 --> pvc2["data-db-2"]
    svc["Headless Service db"] --> pod0
    svc --> pod1
    svc --> pod2
    dns0["db-0.db.namespace.svc"] --> pod0
    dns1["db-1.db.namespace.svc"] --> pod1
    dns2["db-2.db.namespace.svc"] --> pod2

flowchart LR
    ds["DaemonSet"] --> node1["Node A"]
    ds --> node2["Node B"]
    ds --> node3["Node C"]
    node1 --> agent1["Agent Pod"]
    node2 --> agent2["Agent Pod"]
    node3 --> agent3["Agent Pod"]
    agent1 --> use1["Logs, Metriken, CNI oder Security"]
    agent2 --> use2["Logs, Metriken, CNI oder Security"]
    agent3 --> use3["Logs, Metriken, CNI oder Security"]

flowchart TD
    cron["CronJob\nZeitplan"] --> job1["Job 2026-06-13 01:00"]
    cron --> job2["Job 2026-06-14 01:00"]
    job1 --> pod1["Pod Versuch 1"]
    job1 --> pod2["Pod Retry, falls nötig"]
    pod1 --> success["Succeeded"]
    pod2 --> fail["Failed oder Succeeded"]
    job2 --> pod3["Pod nächste Ausführung"]

flowchart LR
    metrics["Metrics API\nCPU, Memory oder Custom Metrics"] --> hpa["Horizontal Pod Autoscaler"]
    hpa --> decision{Skalieren nötig?}
    decision -->|mehr Last| up["replicas erhöhen"]
    decision -->|weniger Last| down["replicas senken"]
    up --> deploy["Deployment oder StatefulSet scale subresource"]
    down --> deploy
    deploy --> pods["mehr oder weniger Pods"]

flowchart LR
    subgraph nodeA["Node A"]
        podA1["Pod A1\n10.244.1.10"]
        podA2["Pod A2\n10.244.1.11"]
        cniA["CNI"]
    end
    subgraph nodeB["Node B"]
        podB1["Pod B1\n10.244.2.10"]
        podB2["Pod B2\n10.244.2.11"]
        cniB["CNI"]
    end
    podA1 --> cniA
    cniA <--> cniB
    cniB --> podB1
    podA2 --> cniA
    cniB --> podB2

flowchart TD
    svc["Service\nselector app=shop"] --> selector["Label Selector"]
    selector --> pod1["Pod 1\napp=shop\nReady"]
    selector --> pod2["Pod 2\napp=shop\nReady"]
    selector --> pod3["Pod 3\napp=shop\nNotReady"]
    pod1 --> eps["EndpointSlice"]
    pod2 --> eps
    pod3 -. nicht ready .-> eps
    eps --> dataplane["kube-proxy oder eBPF-Dataplane"]
    dataplane --> client["Clusterinterner Client"]

flowchart TD
    svc["Service"] --> clusterip["ClusterIP\nintern im Cluster"]
    svc --> nodeport["NodePort\nPort auf jedem Node"]
    svc --> lb["LoadBalancer\nexterner Load Balancer"]
    svc --> external["ExternalName\nDNS-Alias"]

    clusterip --> internal["Pod-zu-Service Traffic"]
    nodeport --> node["Client erreicht Node-IP und Port"]
    lb --> cloud["Cloud oder MetalLB stellt externe Adresse bereit"]
    external --> dns["CNAME-artige Namensauflösung"]

sequenceDiagram
    participant APP as App Pod
    participant DNS as CoreDNS
    participant API as API Server
    participant SVC as Service
    participant EP as EndpointSlice

    APP->>DNS: shop.demo.svc.cluster.local auflösen
    DNS->>API: Service- und Endpoint-Daten aus Cache/API
    API-->>DNS: Service-IP oder Endpoint-Informationen
    DNS-->>APP: DNS-Antwort
    APP->>SVC: Verbindung zur Service-IP
    SVC->>EP: Routing zu passendem Pod

flowchart LR
    client["Browser oder API Client"] --> dns["DNS"]
    dns --> lb["Load Balancer"]
    lb --> controller["Ingress Controller"]
    controller --> ingress["Ingress-Regeln\nHost und Path"]
    ingress --> service["Service"]
    service --> endpoints["EndpointSlices"]
    endpoints --> pod1["Pod A"]
    endpoints --> pod2["Pod B"]
    cert["TLS Secret oder cert-manager"] --> controller

flowchart TD
    infra["Plattformteam"] --> gatewayClass["GatewayClass"]
    infra --> gateway["Gateway\nListener, Adresse, TLS"]
    appteam["Anwendungsteam"] --> route["HTTPRoute, GRPCRoute oder TCPRoute"]
    route --> service["Service"]
    service --> pods["Pods"]
    gatewayClass --> controller["Gateway Controller"]
    gateway --> controller
    route --> controller
    controller --> dataplane["Proxy oder Load Balancer"]
    dataplane --> service

flowchart TD
    ns["Namespace demo"] --> defaultDeny["Default Deny Policy"]
    defaultDeny --> pod["Pod app=api"]
    client["Pod app=frontend"] -->|erlaubt TCP 8080| pod
    db["Pod app=db"] -. nicht erlaubt .-> pod
    internet["externer Traffic"] -. nicht erlaubt .-> pod
    policy["NetworkPolicy\nPodSelector app=api"] --> ingress["Ingress-Regeln"]
    ingress --> client

flowchart LR
    pod["App Pod"] --> policy["Egress NetworkPolicy"]
    policy -->|erlaubt| dns["CoreDNS TCP/UDP 53"]
    policy -->|erlaubt| api["interner API Service"]
    policy -. blockiert .-> internet["beliebiges Internet"]
    policy -. blockiert .-> metadata["Cloud Metadata Service"]

flowchart TD
    client["Client Pod"] --> sidecarA["Sidecar Proxy A"]
    sidecarA --> mesh["Mesh Control Plane"]
    sidecarA --> sidecarB["Sidecar Proxy B"]
    sidecarB --> server["Server Pod"]
    mesh --> certs["Zertifikate und Identitäten"]
    mesh --> routing["Traffic-Regeln"]
    mesh --> telemetry["Metriken und Traces"]
    k8s["Kubernetes API"] --> mesh

flowchart TD
    cm["ConfigMap"] --> env["Environment Variables"]
    cm --> volume["Volume Mount als Datei"]
    deploy["Deployment"] --> pod["Pod"]
    pod --> env
    pod --> volume
    image["Container Image"] --> pod
    change["ConfigMap geändert"] --> effect{Wie eingebunden?}
    effect -->|Env| restart["Pod-Neustart nötig"]
    effect -->|Volume| refresh["Datei kann aktualisiert werden"]

flowchart TD
    user["berechtigte Identität oder Controller"] --> api["API Server"]
    api --> rbac["RBAC Prüfung"]
    rbac --> secret["Secret Objekt"]
    secret --> etcd["etcd\noptional Encryption at Rest"]
    secret --> kubelet["kubelet auf Zielnode"]
    kubelet --> pod["Pod Volume oder Env"]
    pod --> app["App liest Secret"]
    attacker["zu breite Rechte"] -. get/list/watch secrets .-> secret

flowchart LR
    source["Externe Secret-Quelle\nVault, Cloud Secret Manager oder SOPS"] --> controller["External Secrets Controller oder GitOps"]
    controller --> api["Kubernetes API"]
    api --> k8ssecret["Kubernetes Secret"]
    k8ssecret --> pod["Pod"]
    rotate["Rotation"] --> source
    source --> audit["Audit und Zugriffskontrolle"]

sequenceDiagram
    participant K as kubelet
    participant R as Container Runtime
    participant REG as Registry
    participant P as Pod

    K->>R: Image ziehen
    R->>REG: Manifest und Layer anfordern
    REG-->>R: erlaubt oder verweigert
    R-->>K: Image vorhanden oder Fehler
    K->>P: Container starten
    P-->>K: Status melden

flowchart LR
    code["Quellcode"] --> build["Build Pipeline"]
    build --> test["Tests"]
    test --> scan["Image- und Dependency-Scan"]
    scan --> sbom["SBOM"]
    sbom --> sign["Signatur"]
    sign --> registry["Registry"]
    registry --> admission["Admission Policy"]
    admission --> cluster["Cluster Deployment"]

flowchart TD
    pod["Pod"] --> volume["Volume Mount"]
    volume --> pvc["PersistentVolumeClaim"]
    pvc --> pv["PersistentVolume"]
    pv --> backend["Storage Backend"]
    sc["StorageClass"] --> pvc
    csi["CSI Driver"] --> pv
    csi --> backend

sequenceDiagram
    participant U as Du
    participant API as API Server
    participant PVC as PVC Controller
    participant CSI as CSI Provisioner
    participant BE as Storage Backend
    participant POD as Pod

    U->>API: PVC erstellen
    API-->>PVC: neuer Claim
    PVC->>CSI: Volume anfordern
    CSI->>BE: Storage Volume erzeugen
    BE-->>CSI: Volume bereitgestellt
    CSI->>API: PV erstellen und binden
    POD->>API: Pod mit PVC starten
    API-->>POD: PVC ist gebunden

flowchart TD
    pvc["PVC"] --> mode{volumeBindingMode}
    mode --> immediate["Immediate"]
    mode --> wait["WaitForFirstConsumer"]
    immediate --> pv1["PV wird sofort erzeugt"]
    pv1 --> risk["mögliche Zone passt nicht zum späteren Node"]
    wait --> pod["Pod wird erstellt"]
    pod --> scheduler["Scheduler wählt Node und Zone"]
    scheduler --> pv2["PV passend zur Zone"]

flowchart TD
    sts["StatefulSet postgres"] --> template["volumeClaimTemplates"]
    template --> pvc0["data-postgres-0"]
    template --> pvc1["data-postgres-1"]
    template --> pvc2["data-postgres-2"]
    pvc0 --> pv0["PV 0"]
    pvc1 --> pv1["PV 1"]
    pvc2 --> pv2["PV 2"]
    pod0["postgres-0"] --> pvc0
    pod1["postgres-1"] --> pvc1
    pod2["postgres-2"] --> pvc2

flowchart TD
    subgraph control["CSI Controller Ebene"]
        provisioner["external-provisioner"]
        attacher["external-attacher"]
        resizer["external-resizer"]
        snapshotter["external-snapshotter"]
        csiController["CSI Controller Plugin"]
    end

    subgraph node["CSI Node Ebene"]
        kubelet["kubelet"]
        registrar["node-driver-registrar"]
        csiNode["CSI Node Plugin"]
        mount["Mount in Pod"]
    end

    provisioner --> csiController
    attacher --> csiController
    resizer --> csiController
    snapshotter --> csiController
    csiController --> backend["Storage Backend"]
    kubelet --> registrar
    kubelet --> csiNode
    csiNode --> mount
    mount --> pod["Pod"]

flowchart LR
    manifests["Manifeste und Helm Values"] --> git["Git oder Artefakt-Repository"]
    pvdata["Persistente Daten"] --> backup["Backup oder Snapshot"]
    etcd["Clusterzustand"] --> etcdbackup["etcd Backup"]
    git --> restore["Restore-Prozess"]
    backup --> restore
    etcdbackup --> restore
    restore --> validation["Validierung\nDaten, App, Service, Rechte"]

sequenceDiagram
    participant API as API Server
    participant S as Scheduler
    participant N as Nodes
    participant K as kubelet

    API-->>S: Pod ohne nodeName sichtbar
    S->>N: Nodes filtern
    S->>N: Nodes bewerten
    S->>API: Pod an Node binden
    API-->>K: kubelet auf Zielnode sieht Pod
    K->>K: Container vorbereiten und starten
    K->>API: Pod-Status melden

flowchart TD
    container["Container Ressourcen"] --> requests["Requests"]
    container --> limits["Limits"]
    requests --> scheduling["Scheduler plant Kapazität"]
    limits --> runtime["Runtime begrenzt Verbrauch"]
    requests --> qos{QoS-Klasse}
    limits --> qos
    qos --> guaranteed["Guaranteed"]
    qos --> burstable["Burstable"]
    qos --> besteffort["BestEffort"]
    besteffort --> eviction["höheres Eviction-Risiko"]

flowchart TD
    pod["Pod"] --> required["requiredDuringScheduling"]
    pod --> preferred["preferredDuringScheduling"]
    required --> nodeA["nur Nodes mit label disk=ssd"]
    preferred --> nodeB["bevorzugt zone=eu-central-1a"]
    anti["Pod Anti-Affinity"] --> spread["nicht neben gleichem App-Pod"]
    spread --> nodes["Verteilung über Nodes oder Zonen"]

flowchart LR
    node["Node mit Taint\ndedicated=gpu:NoSchedule"] --> barrier["Abweisung"]
    podA["Pod ohne Toleration"] -. wird nicht geplant .-> barrier
    podB["Pod mit passender Toleration"] --> barrier
    barrier --> scheduler["Scheduler darf Node berücksichtigen"]
    scheduler --> node

flowchart TD
    deploy["Deployment replicas=6"] --> tsc["Topology Spread Constraint\ntopologyKey=zone"]
    tsc --> zoneA["Zone A\n2 Pods"]
    tsc --> zoneB["Zone B\n2 Pods"]
    tsc --> zoneC["Zone C\n2 Pods"]
    zoneA --> nodeA1["Node A1"]
    zoneB --> nodeB1["Node B1"]
    zoneC --> nodeC1["Node C1"]

flowchart LR
    deploy["Deployment replicas=3"] --> pdb["PDB minAvailable=2"]
    drain["kubectl drain node-a"] --> eviction1["Eviction Pod 1"]
    eviction1 --> allowed{Bleiben mindestens 2 verfügbar?}
    allowed -->|ja| evict["Eviction erlaubt"]
    allowed -->|nein| block["Eviction blockiert"]
    pdb --> allowed

flowchart TD
    pod["Pod Pending"] --> reason{Warum Pending?}
    reason -->|zu wenig CPU oder Memory| ca["Cluster Autoscaler prüft Node-Gruppe"]
    reason -->|unerfüllbare Affinity| fix1["Manifest oder Labels korrigieren"]
    reason -->|fehlende Toleration| fix2["Toleration oder Taint-Design prüfen"]
    reason -->|Storage-Zonenkonflikt| fix3["StorageClass und Binding prüfen"]
    ca --> scale["neuen Node hinzufügen"]
    scale --> scheduler["Scheduler plant Pod"]

flowchart TD
    ns["Namespace team-a"] --> quota["ResourceQuota"]
    ns --> limitrange["LimitRange"]
    quota --> max["maximale Summe\nCPU, Memory, Pods, PVCs"]
    limitrange --> defaults["Default Requests und Limits"]
    deploy["neuer Workload"] --> admission["Admission Prüfung"]
    max --> admission
    defaults --> admission
    admission -->|ok| create["Ressource wird erstellt"]
    admission -->|verletzt Grenze| reject["Request wird abgelehnt"]

flowchart LR
    request["API Request"] --> authn["Authentifizierung"]
    authn --> authz["Autorisierung\nRBAC oder Webhook"]
    authz --> admission["Admission\nvalidierend und mutierend"]
    admission --> etcd["Persistenz in etcd"]
    etcd --> kubelet["Ausführung durch kubelet"]
    kubelet --> runtime["Runtime-Isolation"]
    runtime --> network["NetworkPolicy"]
    network --> observe["Audit, Logs, Runtime Detection"]

flowchart TD
    subject["Subject\nUser, Group oder ServiceAccount"] --> binding["RoleBinding oder ClusterRoleBinding"]
    binding --> role["Role oder ClusterRole"]
    role --> rule1["apiGroups"]
    role --> rule2["resources"]
    role --> rule3["verbs"]
    rule3 --> examples["get, list, watch, create, update, patch, delete"]
    binding --> scope{Scope}
    scope --> ns["Namespace"]
    scope --> cluster["Clusterweit"]

flowchart LR
    pod["Pod"] --> sa["ServiceAccount"]
    sa --> token["Bound ServiceAccount Token"]
    token --> api["API Server"]
    api --> rbac["RBAC"]
    rbac --> allowed["erlaubte API-Aktionen"]
    rbac --> denied["verweigerte API-Aktionen"]

sequenceDiagram
    participant U as Du oder CI/CD
    participant API as API Server
    participant M as Mutating Admission
    participant V as Validating Admission
    participant P as Policy Engine
    participant E as etcd

    U->>API: Pod erstellen
    API->>M: Defaults oder Sidecars ergänzen
    M-->>API: mutiertes Objekt
    API->>V: Objekt validieren
    V->>P: Policy prüfen
    P-->>V: erlaubt oder verweigert
    V-->>API: Ergebnis
    API->>E: speichern, wenn erlaubt

flowchart TD
    ns["Namespace"] --> labels["pod-security.kubernetes.io Labels"]
    labels --> privileged["Privileged\nsehr offen"]
    labels --> baseline["Baseline\ngrundlegende Einschränkungen"]
    labels --> restricted["Restricted\nstärker gehärtet"]
    pod["neuer Pod"] --> admission["Pod Security Admission"]
    labels --> admission
    admission -->|konform| allowed["Pod wird zugelassen"]
    admission -->|verletzt Policy| denied["Pod wird abgelehnt oder gewarnt"]

flowchart TD
    pod["Pod spec"] --> podctx["Pod SecurityContext"]
    pod --> containers["Container"]
    containers --> cctx["Container SecurityContext"]
    podctx --> fs["fsGroup, runAsUser, runAsNonRoot"]
    cctx --> caps["Capabilities drop/add"]
    cctx --> priv["privileged"]
    cctx --> ro["readOnlyRootFilesystem"]
    cctx --> seccomp["seccompProfile"]
    cctx --> allow["allowPrivilegeEscalation"]

flowchart TD
    cluster["Cluster"] --> nsA["Namespace team-a"]
    cluster --> nsB["Namespace team-b"]
    nsA --> rbacA["RBAC team-a"]
    nsA --> quotaA["Quota und LimitRange"]
    nsA --> netA["NetworkPolicies"]
    nsA --> pssA["Pod Security"]
    nsB --> rbacB["RBAC team-b"]
    nsB --> quotaB["Quota und LimitRange"]
    nsB --> netB["NetworkPolicies"]
    nsB --> pssB["Pod Security"]
    admission["Clusterweite Admission Policies"] --> nsA
    admission --> nsB

flowchart LR
    actor["User, CI/CD oder Workload"] --> api["API Server"]
    api --> audit["Audit Log"]
    pod["laufender Pod"] --> runtime["Runtime Events"]
    node["Node"] --> syscall["System Calls und Prozessverhalten"]
    runtime --> detection["Falco, Tetragon oder EDR"]
    syscall --> detection
    audit --> siem["SIEM oder Log-Plattform"]
    detection --> siem
    siem --> alert["Security Alert"]

flowchart TD
    workload["Workload"] --> metrics["Metriken"]
    workload --> logs["Logs"]
    workload --> traces["Traces"]
    k8s["Kubernetes API"] --> status["Status und Conditions"]
    k8s --> events["Events"]
    metrics --> dash["Dashboards und Alerts"]
    logs --> search["Logsuche"]
    traces --> flow["Request-Flüsse"]
    status --> triage["Triage"]
    events --> triage

flowchart TD
    prom["Prometheus"] --> sd["Kubernetes Service Discovery"]
    sd --> pods["App Pods mit /metrics"]
    sd --> nodes["Node Exporter"]
    sd --> kubelet["kubelet / cAdvisor"]
    sd --> ksm["kube-state-metrics"]
    prom --> rules["Alert Rules"]
    rules --> alertmanager["Alertmanager"]
    prom --> grafana["Grafana Dashboards"]

flowchart LR
    app["App Container"] --> stdout["stdout und stderr"]
    stdout --> nodefiles["Node Logdateien"]
    nodefiles --> agent["Log Agent als DaemonSet"]
    agent --> buffer["Puffer und Parsing"]
    buffer --> backend["Loki, Elasticsearch oder Cloud Logging"]
    backend --> query["Suche und Dashboards"]

sequenceDiagram
    participant C as Client
    participant FE as Frontend
    participant API as Backend API
    participant DB as Datenbank
    participant OTEL as OpenTelemetry Collector

    C->>FE: Request mit Trace Context
    FE->>OTEL: Span senden
    FE->>API: Request weitergeben
    API->>OTEL: Span senden
    API->>DB: Query
    DB-->>API: Ergebnis
    API-->>FE: Antwort
    FE-->>C: Antwort
    OTEL->>OTEL: Trace zusammensetzen

flowchart TD
    problem["Problem sichtbar"] --> events["kubectl get events --sort-by=.lastTimestamp"]
    events --> scheduling["FailedScheduling"]
    events --> image["FailedPull oder BackOff"]
    events --> volume["FailedMount oder FailedAttachVolume"]
    events --> probe["Unhealthy Probe"]
    events --> eviction["Evicted oder NodePressure"]
    scheduling --> next1["Ressourcen und Constraints prüfen"]
    image --> next2["Registry und Pull Secret prüfen"]
    volume --> next3["PVC, PV, CSI prüfen"]
    probe --> next4["App Health und Probe-Config prüfen"]
    eviction --> next5["Node-Ressourcen prüfen"]

sequenceDiagram
    participant A as Admin
    participant K as kubeadm
    participant CP as Control Plane Node
    participant API as API Server
    participant W as Worker Node

    A->>K: kubeadm init
    K->>CP: Zertifikate und Konfiguration erzeugen
    K->>CP: statische Pods für Control Plane schreiben
    CP->>API: API Server wird verfügbar
    A->>K: CNI installieren
    A->>W: kubeadm join mit Token
    W->>API: Node registrieren
    API-->>A: Cluster zeigt Node Ready nach CNI und kubelet

flowchart TD
    plan["Upgrade planen"] --> backup["etcd Backup und Restore-Pfad prüfen"]
    backup --> cp["Control Plane upgraden"]
    cp --> node1["Node cordon"]
    node1 --> drain["Node drain"]
    drain --> upgrade["kubelet und Runtime upgraden"]
    upgrade --> uncordon["Node uncordon"]
    uncordon --> validate["Workloads und SLOs prüfen"]
    validate --> next["nächster Node"]

flowchart LR
    dev["Du änderst Manifest oder Values"] --> pr["Pull Request"]
    pr --> review["Review und Checks"]
    review --> merge["Merge in Zielbranch"]
    merge --> repo["Git Repository"]
    repo --> gitops["Argo CD oder Flux"]
    gitops --> diff["Diff gegen Cluster"]
    diff --> sync["Synchronisation"]
    sync --> api["Kubernetes API"]
    api --> status["Health und Sync Status"]

flowchart TD
    chart["Helm Chart"] --> render["helm template"]
    values["values.yaml"] --> render
    render --> manifests["gerenderte Manifeste"]
    manifests --> lint["lint und policy checks"]
    lint --> upgrade["helm upgrade --install"]
    upgrade --> api["Kubernetes API"]
    api --> release["Helm Release Secret"]
    api --> resources["Kubernetes Ressourcen"]

flowchart TD
    base["base\nDeployment, Service, Config"] --> dev["overlay dev"]
    base --> stage["overlay stage"]
    base --> prod["overlay prod"]
    dev --> patchDev["Patches und Images dev"]
    stage --> patchStage["Patches und Images stage"]
    prod --> patchProd["Patches und Images prod"]
    patchProd --> output["kubectl apply -k overlays/prod"]

flowchart TD
    cni["CNI"] --> pods["Pods erhalten Netzwerk"]
    coredns["CoreDNS"] --> discovery["Service Discovery"]
    metrics["Metrics Server"] --> hpa["HPA und kubectl top"]
    ingress["Ingress oder Gateway Controller"] --> external["externer Traffic"]
    csi["CSI"] --> volumes["Persistente Volumes"]
    cert["cert-manager"] --> tls["TLS Zertifikate"]
    externaldns["ExternalDNS"] --> dns["DNS Records"]
    observability["Monitoring und Logging"] --> ops["Betrieb und Triage"]

flowchart TD
    start["Problem melden"] --> scope["Scope klären\nNamespace, Workload, Zeitpunkt"]
    scope --> get["kubectl get relevante Ressourcen"]
    get --> describe["kubectl describe"]
    describe --> events["Events sortieren"]
    events --> status{Ressourcenstatus?}
    status -->|Pending| pending["Scheduling, Ressourcen, PVC, Taints"]
    status -->|CrashLoop| crash["Logs previous, Exit Code, Probes"]
    status -->|Running aber nicht erreichbar| network["Service, EndpointSlice, DNS, Ingress"]
    status -->|Forbidden| rbac["RBAC und ServiceAccount"]
    status -->|Node betroffen| node["Node, kubelet, Runtime, CNI"]
    pending --> fix["Korrektur und Validierung"]
    crash --> fix
    network --> fix
    rbac --> fix
    node --> fix

flowchart TD
    pending["Pod Pending"] --> events["Events prüfen"]
    events --> scheduling{FailedScheduling?}
    scheduling -->|ja| resources["CPU, Memory, Pod-Quota"]
    scheduling -->|ja| constraints["Affinity, Taints, Topology"]
    scheduling -->|nein| image["Image Pull noch nicht abgeschlossen?"]
    events --> volume{Volume Events?}
    volume -->|ja| pvc["PVC, PV, StorageClass, CSI"]
    resources --> fix["Requests oder Kapazität korrigieren"]
    constraints --> fix
    pvc --> fix
    image --> fix

flowchart TD
    crash["CrashLoopBackOff"] --> previous["kubectl logs --previous"]
    previous --> exit["Exit Code prüfen"]
    exit --> config["ConfigMap, Secret, Env prüfen"]
    exit --> deps["Abhängigkeiten prüfen\nDB, API, DNS"]
    exit --> probe["Probe-Konfiguration prüfen"]
    exit --> resources["OOMKilled oder CPU-Starvation prüfen"]
    config --> fix["Fix deployen"]
    deps --> fix
    probe --> fix
    resources --> fix
    fix --> rollout["Rollout überwachen"]

flowchart TD
    img["ImagePullBackOff"] --> name["Image-Name und Tag prüfen"]
    name --> registry["Registry erreichbar?"]
    registry --> auth["Pull Secret korrekt?"]
    auth --> tls["TLS und Zertifikate ok?"]
    tls --> arch["Architektur passend? amd64, arm64"]
    arch --> quota["Rate Limit oder Registry Quota?"]
    quota --> fix["Manifest, Secret oder Registry korrigieren"]

flowchart TD
    svc["Service antwortet nicht"] --> eps["EndpointSlices prüfen"]
    eps --> empty{Keine Endpoints?}
    empty -->|ja| selector["Service Selector prüfen"]
    selector --> labels["Pod Labels prüfen"]
    labels --> readiness["Pod Readiness prüfen"]
    readiness --> ports["targetPort und containerPort prüfen"]
    empty -->|nein| dataplane["kube-proxy, eBPF oder NetworkPolicy prüfen"]
    ports --> fix["Labels, Readiness oder Ports korrigieren"]
    dataplane --> fix

flowchart TD
    dnsfail["DNS-Auflösung scheitert"] --> debugpod["Debug-Pod im Namespace starten"]
    debugpod --> fqdn["Kurzname und FQDN testen"]
    fqdn --> coredns["CoreDNS Pods und Logs prüfen"]
    coredns --> svc["kube-dns Service prüfen"]
    svc --> netpol["NetworkPolicy erlaubt DNS?"]
    netpol --> node["Node-Netzwerk und CNI prüfen"]
    node --> fix["Ursache korrigieren und erneut testen"]

flowchart TD
    fail["Externer Request scheitert"] --> dns["DNS Record korrekt?"]
    dns --> lb["Load Balancer erreichbar?"]
    lb --> controller["Ingress oder Gateway Controller läuft?"]
    controller --> routeClass["IngressClass oder GatewayClass korrekt?"]
    routeClass --> rule["Host, Path, Listener, Route korrekt?"]
    rule --> svc["Service korrekt?"]
    svc --> eps["EndpointSlices vorhanden?"]
    eps --> pod["Pods ready und App antwortet?"]

flowchart TD
    pvc["PVC Pending"] --> sc["StorageClass existiert?"]
    sc --> provisioner["Provisioner verfügbar?"]
    provisioner --> quota["StorageQuota oder Backend-Kapazität?"]
    quota --> binding["volumeBindingMode und Zone?"]
    binding --> access["AccessMode passend?"]
    access --> events["PVC- und CSI-Events prüfen"]
    events --> logs["CSI Controller Logs prüfen"]

flowchart TD
    node["Node NotReady"] --> cond["Node Conditions prüfen"]
    cond --> kubelet["kubelet Status und Logs"]
    cond --> runtime["Container Runtime erreichbar?"]
    cond --> cni["CNI bereit?"]
    cond --> pressure["DiskPressure, MemoryPressure, PIDPressure"]
    cond --> cert["Zertifikate und API-Verbindung"]
    kubelet --> fix["Service oder Konfiguration korrigieren"]
    runtime --> fix
    cni --> fix
    pressure --> cleanup["Kapazität freigeben oder Node ersetzen"]
    cert --> fix

flowchart TD
    forbidden["API meldet Forbidden"] --> identity["Identität prüfen\nUser, Group, ServiceAccount"]
    identity --> verb["Verb prüfen\nget, list, create, patch"]
    verb --> resource["Resource und API Group prüfen"]
    resource --> scope["Namespace oder Cluster-Scope?"]
    scope --> binding["RoleBinding oder ClusterRoleBinding prüfen"]
    binding --> cani["kubectl auth can-i testen"]
    cani --> fix["minimale passende Rechte vergeben"]

flowchart TD
    oom["OOMKilled"] --> limits["Memory Limit prüfen"]
    limits --> usage["tatsächliche Memory-Nutzung prüfen"]
    usage --> leak["Memory Leak oder Lastspitze?"]
    usage --> request["Request realistisch?"]
    request --> qos["QoS-Klasse prüfen"]
    qos --> node["Node MemoryPressure prüfen"]
    leak --> fix["App oder Limit korrigieren"]
    request --> fix
    node --> fix

flowchart TD
    rollout["Rollout hängt"] --> status["kubectl rollout status"]
    status --> rs["ReplicaSets vergleichen"]
    rs --> newpods["neue Pods prüfen"]
    newpods --> pending["Pending?"]
    newpods --> crash["CrashLoop oder Probe Fail?"]
    newpods --> readiness["Readiness wird nie true?"]
    rs --> pdb["PDB blockiert alte Pod-Eviction?"]
    pending --> fix["Scheduling oder Storage fixen"]
    crash --> fix
    readiness --> fix
    pdb --> fix

stateDiagram-v2
    [*] --> Erkennen
    Erkennen --> Eingrenzen: betroffene Ressourcen bestimmen
    Eingrenzen --> Eindämmen: Netzwerk, Rechte oder Node isolieren
    Eindämmen --> BeweiseSichern: Logs, Events, Images, Manifeste sichern
    BeweiseSichern --> ZugangEntziehen: Tokens, Secrets, Rollen rotieren
    ZugangEntziehen --> Bereinigen: Ursache entfernen
    Bereinigen --> Wiederherstellen: kontrollierter Restore oder Rollout
    Wiederherstellen --> Verbessern: Policies und Monitoring schärfen
    Verbessern --> [*]

flowchart LR
    task["Deployment ausrollen"] --> observe1["kubectl get deploy,rs,pod"]
    observe1 --> labels["Labels und Selector prüfen"]
    labels --> service["Service hinzufügen"]
    service --> endpoints["EndpointSlices beobachten"]
    endpoints --> rollout["Image ändern und Rollout verfolgen"]
    rollout --> explain["Diagramm mit realen Namen beschriften"]

flowchart TD
    frontend["frontend Pod"] --> api["api Pod"]
    api --> db["db Pod"]
    debug["debug Pod"] -. blockiert .-> db
    internet["Internet"] -. blockiert .-> api
    policy1["Policy frontend zu api"] --> frontend
    policy1 --> api
    policy2["Policy api zu db"] --> api
    policy2 --> db

flowchart LR
    create["PVC erstellen"] --> pending["PVC Pending erzeugen"]
    pending --> inspect["describe pvc und events"]
    inspect --> sc["StorageClass korrigieren"]
    sc --> bind["PVC Bound"]
    bind --> pod["Pod mit Mount starten"]
    pod --> verify["Datei schreiben und Pod neu erstellen"]

flowchart TD
    sa["ServiceAccount mit minimalen Rechten"] --> cani["kubectl auth can-i"]
    cani --> pod["Pod mit SecurityContext"]
    pod --> admission["Pod Security Admission testen"]
    admission --> secret["Secret-Zugriff prüfen"]
    secret --> netpol["NetworkPolicy anwenden"]
    netpol --> audit["Audit- oder Event-Spuren ansehen"]

flowchart LR
    good["gute Beschriftung\nService wählt Pods über Labels"] --> better["besser erklärbar im Workshop"]
    bad["svc1"] -. zu kryptisch .-> unclear["unklare Aussage"]

flowchart TD
    topic["Ein Thema"] --> diag1["Diagramm 1\nArchitektur"]
    topic --> diag2["Diagramm 2\nAblauf"]
    topic --> diag3["Diagramm 3\nTroubleshooting"]

flowchart LR
    beginner["Fundamentals"] --> simple["Pods, Services, Deployments"]
    intermediate["Intermediate"] --> flow["Rollouts, Probes, Storage, Netzwerk"]
    professional["Professional"] --> ops["HA, Upgrades, Add-ons, Observability"]
    security["Security"] --> controls["RBAC, Admission, Policies, Incident Response"]