Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Postgres und die Deletion Policy

Ziel: Jede NotesApp bekommt ihre eigene Postgres-Datenbank mit erzeugtem Passwort. Das Volume überlebt das Löschen der Instanz, und eine neue Instanz findet ihre Daten wieder. · Dauer: ca. 60 min · Voraussetzung: Tag 5

Briefing

  • Vier neue Objekte: ein Secret mit Passwort, ein PersistentVolumeClaim, ein StatefulSet mit Postgres und ein Service davor.
  • Das Passwort erzeugt kro mit random.seededString(länge, seed). Gleicher Seed, gleiches Passwort, bei jedem Abgleich und auch nach einem Neuanlegen.
  • Abhängigkeiten entstehen nur über Verweise. notes-api soll erst starten, wenn Postgres bereit ist. Deshalb liest das Deployment den Namen des DB-Service, und der Service hängt am StatefulSet mit seinem readyWhen.
  • Die Annotation kro.run/deletion-policy: Orphaned sagt kro: Dieses Objekt beim Aufräumen stehen lassen. Sie ist Alpha und braucht das Feature Gate DeletionPolicy.
 secret ─────────────────────────────┐
 dbSecret ──► database (readyWhen) ──► dbService ──► deployment (readyWhen) ──► service
 dbData ────►┘                                     ▲
                                        dbSecret ──┘

Drill 1: Schema und Status erweitern

mkdir -p ~/kro-lab/tag06
cd ~/kro-lab/tag06
cp ../tag05/notesapp-rgd.yaml .

Ergänze im Editor unter nodePort: … ein Objekt database und unter port: ${service…} zwei Status-Felder:

      nodePort: integer | required=true minimum=30000 maximum=32767
      database:
        storage: string | default="1Gi"
    status:
      availableReplicas: ${deployment.status.?availableReplicas.orValue(0)}
      image: ${deployment.spec.template.spec.containers[0].image}
      port: ${service.spec.ports[0].nodePort}
      database: ${dbService.metadata.name}
      storage: ${dbData.spec.resources.requests.storage}

Fortschritt speichern? Kostenlos registrieren

Drill 2: Vier neue Objekte

Füge direkt hinter das Objekt secret (vor - id: deployment) diesen Block ein:

    - id: dbSecret
      template:
        apiVersion: v1
        kind: Secret
        metadata:
          name: ${schema.metadata.name}-db
        stringData:
          password: ${random.seededString(24, schema.metadata.namespace + "/" + schema.metadata.name)}
    - id: dbData
      template:
        apiVersion: v1
        kind: PersistentVolumeClaim
        metadata:
          name: ${schema.metadata.name}-db-data
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: ${schema.spec.database.storage}
    - id: database
      template:
        apiVersion: apps/v1
        kind: StatefulSet
        metadata:
          name: ${schema.metadata.name}-db
        spec:
          serviceName: ${schema.metadata.name}-db
          replicas: 1
          selector:
            matchLabels:
              app: ${schema.metadata.name}-db
          template:
            metadata:
              labels:
                app: ${schema.metadata.name}-db
            spec:
              containers:
                - name: postgres
                  image: postgres:18.6-alpine
                  env:
                    - name: POSTGRES_USER
                      value: notes
                    - name: POSTGRES_DB
                      value: notes
                    - name: POSTGRES_PASSWORD
                      valueFrom:
                        secretKeyRef:
                          name: ${dbSecret.metadata.name}
                          key: password
                    - name: PGDATA
                      value: /var/lib/postgresql/data/pgdata
                  ports:
                    - containerPort: 5432
                  readinessProbe:
                    exec:
                      command: ["pg_isready", "-U", "notes", "-d", "notes"]
                  volumeMounts:
                    - name: data
                      mountPath: /var/lib/postgresql/data
              volumes:
                - name: data
                  persistentVolumeClaim:
                    claimName: ${dbData.metadata.name}
      readyWhen:
        - ${database.status.?readyReplicas.orValue(0) == 1}
    - id: dbService
      template:
        apiVersion: v1
        kind: Service
        metadata:
          name: ${database.metadata.name}
        spec:
          selector: ${database.spec.selector.matchLabels}
          ports:
            - port: 5432
  • Der Seed namespace/name ist für jede Instanz eindeutig und bleibt gleich, wenn du die Instanz löschst und neu anlegst. Warum das wichtig ist, siehst du in Drill 6.
  • Das Volume ist ein eigenes Objekt dbData und nicht Teil des StatefulSets (volumeClaimTemplates). Nur so kann kro es verwalten und später stehen lassen.
  • PGDATA zeigt auf einen Unterordner. Postgres will ein leeres Verzeichnis, und im Wurzelverzeichnis des Volumes liegt bei manchen Speicherklassen lost+found.

Fortschritt speichern? Kostenlos registrieren

Drill 3: notes-api an die Datenbank

Ersetze im Objekt deployment alles ab spec: unter template: (also die Pod-Spezifikation) durch diese Fassung:

            spec:
              initContainers:
                - name: migrate
                  image: ${schema.spec.image}
                  args: ["migrate"]
                  env:
                    - name: DB_PASSWORD
                      valueFrom:
                        secretKeyRef:
                          name: ${dbSecret.metadata.name}
                          key: password
                    - name: NOTES_DB_URL
                      value: postgres://notes:$(DB_PASSWORD)@${dbService.metadata.name}:5432/notes?sslmode=disable
              containers:
                - name: api
                  image: ${schema.spec.image}
                  ports:
                    - containerPort: 8080
                  env:
                    - name: NOTES_API_KEY
                      valueFrom:
                        secretKeyRef:
                          name: ${secret.metadata.name}
                          key: apiKey
                    - name: DB_PASSWORD
                      valueFrom:
                        secretKeyRef:
                          name: ${dbSecret.metadata.name}
                          key: password
                    - name: NOTES_DB_URL
                      value: postgres://notes:$(DB_PASSWORD)@${dbService.metadata.name}:5432/notes?sslmode=disable
                  readinessProbe:
                    httpGet:
                      path: /healthz
                      port: 8080
  • notes-api migrate legt die Tabelle an und endet. Als Init-Container läuft es vor jedem Start.
  • $(DB_PASSWORD) ist keine kro-Syntax, sondern Kubernetes: Eine Variable darf auf eine weiter oben definierte Variable verweisen. kro fasst nur ${…} an.
  • ${dbService.metadata.name} ist die Kante, die notes-api hinter die Datenbank stellt.
kubectl apply -f notesapp-rgd.yaml
kubectl get rgd notesapp
kubectl get rgd notesapp -o jsonpath='{.status.topologicalOrder}{"\n"}'

Erwartet:

resourcegraphdefinition.kro.run/notesapp configured
NAME       APIVERSION   KIND       STATE    READY   AGE
notesapp   v1alpha1     NotesApp   Active   True    3m36s
["secret","dbSecret","dbData","database","dbService","deployment","service"]

Sieben Objekte, und die Reihenfolge stimmt mit dem Bild im Briefing überein.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Wenn die Instanz auf ERROR springt

kubectl -n app get notesapp

Bei dir steht hier entweder IN_PROGRESS und nach einer Minute ACTIVE, oder:

NAME    REPLICAS   AVAILABLE   PORT    STATE
notes   1          1           30080   ERROR
kubectl -n app get notesapp notes \
  -o jsonpath='{.status.conditions[?(@.type=="Ready")].message}{"\n"}'

Erwartet bei ERROR:

graph-engine build failed: rgdadapter: compile: build node "instance": parse patch
payload: error getting field schema for path status.database: schema not found for
field database

Das ist eine Eigenheit von kro 0.10.0: Bekommt eine RGD neue Status-Felder, während schon Instanzen existieren, arbeitet der Controller manchmal mit dem alten Schema der CRD weiter. Die CRD selbst ist richtig, nur kro hat die alte Fassung im Speicher. Ein Neustart des Controllers lädt sie neu:

kubectl -n kro-system rollout restart deploy/kro
kubectl -n kro-system rollout status deploy/kro
kubectl -n app get notesapp -w

Erwartet (mit Strg+C beenden):

deployment.apps/kro restarted
deployment "kro" successfully rolled out
NAME    REPLICAS   AVAILABLE   PORT    STATE
notes   1                              IN_PROGRESS
notes   1          1           30080   ACTIVE

Merke dir das Muster: neue Status-Felder, Instanzen auf ERROR, Meldung schema not found for field, dann den Controller neu starten. Es kommt im Wettkampf wieder.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die Datenbank prüfen

kubectl -n app get pods,pvc

Erwartet:

NAME                        READY   STATUS    RESTARTS   AGE
pod/notes-6874dfb8c-snnjf   1/1     Running   0          28s
pod/notes-db-0              1/1     Running   0          71s

NAME                                  STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS
persistentvolumeclaim/notes-db-data   Bound    pvc-ea46db97-7ea6-44ea-979a-0cecbef22a32   1Gi        RWO            local-path

Erst die Datenbank, 43 Sekunden später notes-api, genau wie im Graphen.

curl -s -H "X-API-Key: lab-api-key-123" -d '{"text":"bleibt erhalten"}' \
  localhost:30080/notes
kubectl -n app rollout restart deploy/notes
kubectl -n app rollout status deploy/notes
curl -s localhost:30080/notes

Erwartet (die ID weicht ab):

{"id":"5953a797-216a-45be-a2f9-fe1e5782a1f4","text":"bleibt erhalten"}
deployment.apps/notes restarted
deployment "notes" successfully rolled out
[{"id":"5953a797-216a-45be-a2f9-fe1e5782a1f4","text":"bleibt erhalten"}]

Die Notiz liegt in Postgres und überlebt den Neustart von notes-api. Die Notiz „erste Notiz“ von Tag 4 ist weg, die lag nur im Speicher.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Das Volume stehen lassen

Was passiert, wenn jemand die Instanz löscht? Ohne weitere Angaben löscht kro alles, auch das Volume mit allen Notizen. Ergänze bei dbData die Annotation:

        metadata:
          name: ${schema.metadata.name}-db-data
          annotations:
            kro.run/deletion-policy: Orphaned
kubectl apply -f notesapp-rgd.yaml
kubectl get rgd notesapp \
  -o jsonpath='{.status.state}: {.status.conditions[?(@.type=="GraphAccepted")].message}{"\n"}'

Erwartet:

Inactive: failed to build resource "dbData": resource "dbData": annotation
"kro.run/deletion-policy" requires the DeletionPolicy feature gate to be enabled

Das Feature Gate schaltest du über eine Werte-Datei für das Chart ein:

cat > ~/kro-lab/kro-values.yaml <<'EOF'
config:
  featureGates:
    DeletionPolicy: true
EOF
helm upgrade kro oci://registry.k8s.io/kro/charts/kro -n kro-system \
  --version 0.10.0 -f ~/kro-lab/kro-values.yaml
kubectl -n kro-system rollout status deploy/kro

Erwartet (gekürzt):

Pulled: registry.k8s.io/kro/charts/kro:0.10.0
Release "kro" has been upgraded. Happy Helming!
NAMESPACE: kro-system
STATUS: deployed
REVISION: 2
deployment "kro" successfully rolled out
kubectl get rgd notesapp
kubectl -n app get pvc notes-db-data \
  -o jsonpath='{.metadata.annotations.kro\.run/deletion-policy}{"\n"}'

Erwartet:

NAME       APIVERSION   KIND       STATE    READY   AGE
notesapp   v1alpha1     NotesApp   Active   True    14m
Orphaned

Die Annotation steht jetzt am lebenden Objekt. kro liest sie beim Löschen genau dort nach. Deshalb gilt: Erst die Policy setzen und abwarten, dann löschen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Löschen und wiederfinden

kubectl -n app delete notesapp notes
kubectl -n app get all,pvc,secret

Erwartet:

notesapp.lab.example.com "notes" deleted from app namespace
NAME                                  STATUS   VOLUME
persistentvolumeclaim/notes-db-data   Bound    pvc-ea46db97-7ea6-44ea-979a-0cecbef22a32

Alles ist weg, nur das Volume nicht. Seine kro-Labels hat kro entfernt:

kubectl -n app get pvc notes-db-data --show-labels

Erwartet:

NAME            STATUS   VOLUME                                     ...   LABELS
notes-db-data   Bound    pvc-ea46db97-7ea6-44ea-979a-0cecbef22a32   ...   <none>

Für kro ist das PVC jetzt ein fremdes Objekt. Lege die Instanz neu an:

kubectl apply -f ../tag04/notes.yaml
kubectl -n app wait notesapp/notes --for=condition=Ready --timeout=120s
curl -s localhost:30080/notes

Erwartet:

notesapp.lab.example.com/notes created
notesapp.lab.example.com/notes condition met
[{"id":"5953a797-216a-45be-a2f9-fe1e5782a1f4","text":"bleibt erhalten"}]

Die neue Instanz hat das vorhandene PVC übernommen, denn Name und Namespace passen. Und weil der Seed des Passworts aus Namespace und Name besteht, passt auch das Passwort zu den alten Daten. Mit schema.metadata.uid als Seed hätte die neue Instanz ein neues Passwort bekommen, und Postgres hätte sie abgewiesen.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n app get notesapp notes

Erwartet:

NAME    REPLICAS   AVAILABLE   PORT    STATE
notes   1          1           30080   ACTIVE
kubectl -n app get notesapp notes -o jsonpath='{.status.database} {.status.storage}{"\n"}'

Erwartet: notes-db 1Gi.

kubectl -n app get pvc notes-db-data \
  -o jsonpath='{.metadata.labels.kro\.run/instance-name}{"\n"}'

Erwartet: notes. Das PVC gehört wieder zur Instanz.

diff notesapp-rgd.yaml ~/kro-lab/code/loesung/tag06/notesapp-rgd.yaml

Erwartet: keine Ausgabe.

Challenge

Lies das Passwort der Datenbank aus dem Secret und melde dich damit per psql im Pod notes-db-0 an. Wie viele Zeilen hat die Tabelle notes?

Hinweis: kubectl get secret … -o jsonpath und base64 -d. Im Pod reicht psql -U notes, denn lokal vertraut Postgres dem Benutzer.

Lösung

kubectl -n app get secret notes-db -o jsonpath='{.data.password}' | base64 -d; echo
kubectl -n app exec notes-db-0 -- psql -U notes -tc 'select count(*) from notes'

Erwartet (das Passwort weicht ab):

1v4yxk7a1v4yxk7a1v4yxk7a
     1

Sieh dir das Passwort genau an: 24 Zeichen, aber nur acht verschiedene, die sich dreimal wiederholen. random.seededString taugt für Namen und Suffixe, für ein Passwort ist das zu wenig Zufall.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Datenbanken als Dienst: Eine Postgres-Instanz pro App im selben Namespace ist für das Lab gut. Im Betrieb übernimmt ein Operator wie CloudNativePG Backups, Failover und Upgrades. Die RGD legt dann statt eines StatefulSets ein Cluster-Objekt des Operators an.
  • Passwörter erzeugen: random.seededString ist deterministisch. Wer Seed und Funktion kennt, kann das Passwort ausrechnen, und in kro 0.10.0 wiederholt es sich nach acht Zeichen. Für echte Geheimnisse nimm einen Secret-Manager oder einen Generator wie den External Secrets Operator.
  • Alpha heißt Alpha: Die Deletion Policy und ihr Feature Gate können sich noch ändern (KREP-014). Schaltest du das Gate wieder ab, ignoriert kro die Annotation und löscht auch Orphaned-Objekte.