Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Helm-Provider – Postgres und notes als Chart

Ziel: Helm-Charts mit OpenTofu installieren: den Postgres-Operator CloudNativePG, eine Datenbank als Cluster und notes als eigenes Chart – verbunden über das Secret, das der Operator anlegt. · Dauer: ca. 90 min · Voraussetzung: Tag 6

Briefing

  • Der Helm-Provider installiert Charts wie helm install, aber mit Plan und State: helm_release mit Repository, Chart, Version und Werten.
  • Werte übergibst du am besten als values = [yamlencode({ … })]: HCL-Maps werden zu YAML, Variablen und Referenzen gehen direkt hinein.
  • CloudNativePG ist ein Operator für Postgres in Kubernetes. Eine Ressource Cluster beschreibt die Datenbank; der Operator legt Pods, Volumes, Dienste und ein Secret mit der fertigen Verbindungs-URL an.
  • Der Operator bringt eigene Ressourcentypen (CRDs) mit. Was einen solchen Typ benutzt, hängt am Operator – depends_on macht das sichtbar.
 helm_release.cnpg  (Operator, Namespace cnpg-system)
   └─► helm_release.db    (Chart „cluster" → Cluster notes-db-cluster, Secret …-app)
         └─► helm_release.notes (eigenes Chart, NOTES_DB_URL aus Secret …-app/uri)
                └─► http://notes-helm.<VM_IP>.sslip.io

Drill 1: Der Operator

mkdir -p ~/tf-lab/tag07 && cd ~/tf-lab/tag07
cat > versions.tf <<'EOF'
terraform {
  required_version = ">= 1.13.0"
  required_providers {
    helm = {
      source  = "hashicorp/helm"
      version = "~> 3.3"
    }
  }
}

provider "helm" {
  kubernetes = {
    config_path = "/etc/rancher/k3s/k3s.yaml"
  }
}
EOF
cat > operator.tf <<'EOF'
resource "helm_release" "cnpg" {
  name             = "cnpg"
  repository       = "https://cloudnative-pg.github.io/charts"
  chart            = "cloudnative-pg"
  version          = "0.29.1"
  namespace        = "cnpg-system"
  create_namespace = true
  wait             = true
}
EOF
tofu init -no-color | grep -E 'Installed|initialized'
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
kubectl -n cnpg-system get deployments
kubectl get crd -o name | grep -c 'postgresql.cnpg.io'

Erwartet (Alter weicht ab):

- Installed hashicorp/helm v3.3.0 (signed, key ID 0C0AF313E5FD9F80)
OpenTofu has been successfully initialized!
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
cnpg-cloudnative-pg   1/1     1            1           40s
11
  • In Version 3 des Helm-Providers ist kubernetes ein Attribut mit =, kein Block – ältere Beispiele im Netz zeigen noch kubernetes { … }.
  • wait = true wartet, bis alle Pods des Charts bereit sind. Danach gibt es die elf neuen Ressourcentypen, darunter clusters.postgresql.cnpg.io.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eine Datenbank

cat > db.tf <<'EOF'
resource "helm_release" "db" {
  name             = "notes-db"
  repository       = "https://cloudnative-pg.github.io/charts"
  chart            = "cluster"
  version          = "0.9.0"
  namespace        = "notes-helm"
  create_namespace = true
  values = [yamlencode({
    type = "postgresql"
    cluster = {
      instances = 1
      storage   = { size = "1Gi" }
    }
  })]
  depends_on = [helm_release.cnpg]
}

locals {
  db_secret = "${helm_release.db.name}-cluster-app"
}
EOF
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
kubectl -n notes-helm wait cluster/notes-db-cluster --for=condition=Ready --timeout=300s
kubectl -n notes-helm get secret notes-db-cluster-app -o jsonpath='{.data.uri}' \
  | base64 -d; echo

Erwartet (nach ein bis zwei Minuten; das Passwort ist zufällig und länger):

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
cluster.postgresql.cnpg.io/notes-db-cluster condition met
postgresql://app:kbdPex8sZQv5…@notes-db-cluster-rw.notes-helm:5432/app
  • Das Chart cluster legt nur die Ressource Cluster an und ist sofort fertig; die eigentliche Arbeit macht danach der Operator. kubectl wait wartet darauf.
  • Das Secret notes-db-cluster-app enthält Benutzer, Passwort und unter uri die fertige Verbindungs-URL. Das Passwort hat der Operator erzeugt – es steht nirgends im Code und nicht im State von OpenTofu.
  • local.db_secret leitet den Namen aus dem Release ab. Ändert jemand den Namen des Releases, zieht das Secret mit.

Fortschritt speichern? Kostenlos registrieren

Drill 3: notes als eigenes Chart

Im Begleitcode liegt ein kleines Chart für notes:

ls ~/tf-lab/code/charts/notes ~/tf-lab/code/charts/notes/templates
grep -A3 'secretKeyRef' ~/tf-lab/code/charts/notes/templates/deployment.yaml | head -4

Erwartet:

/home/ubuntu/tf-lab/code/charts/notes:
Chart.yaml
templates
values.yaml

/home/ubuntu/tf-lab/code/charts/notes/templates:
deployment.yaml
ingress.yaml
secret.yaml
service.yaml
                secretKeyRef:
                  name: {{ .Values.db.secretName }}
                  key: uri
      {{- end }}

Ein Init-Container führt vor jedem Start notes-api migrate aus; beide lesen die URL aus dem Secret, dessen Name als Wert hereinkommt.

cat > notes.tf <<'EOF'
variable "vm_ip" {
  type = string
}

resource "helm_release" "notes" {
  name      = "notes"
  chart     = "${pathexpand("~")}/tf-lab/code/charts/notes"
  namespace = "notes-helm"
  values = [yamlencode({
    replicas = 1
    db       = { secretName = local.db_secret }
    host     = "notes-helm.${var.vm_ip}.sslip.io"
  })]
}

output "url" {
  value = "http://notes-helm.${var.vm_ip}.sslip.io"
}
EOF
export TF_VAR_vm_ip=$VM_IP
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
U=$(tofu output -raw url)
curl -s -X POST -H "X-API-Key: $NOTES_API_KEY" -H 'Content-Type: application/json' \
  -d '{"text":"in Postgres auf k3s"}' "$U/notes" | jq -r .text
kubectl -n notes-helm get pods

Erwartet (Pod-Namen und Alter weichen ab):

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
in Postgres auf k3s
NAME                     READY   STATUS    RESTARTS   AGE
notes-5fbc5f7cf9-65kvp   1/1     Running   0          20s
notes-5fbc5f7cf9-fhs9z   1/1     Running   0          20s
notes-db-cluster-1       1/1     Running   0          2m

Ein Chart aus einem lokalen Ordner braucht kein Repository. pathexpand("~") macht aus ~ das Home-Verzeichnis – OpenTofu selbst kennt ~ nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Werte ändern

sed -i 's/^    replicas = 1$/    replicas = 2/' notes.tf
tofu plan -no-color | grep -E '[-+] +"replicas"|Plan:'
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
kubectl -n notes-helm get deployment notes -o jsonpath='{.status.readyReplicas}'; echo
kubectl -n notes-helm get secrets -l owner=helm,name=notes --no-headers | wc -l

Erwartet:

              - "replicas": 1
              + "replicas": 2
Plan: 0 to add, 1 to change, 0 to destroy.
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
2
2

Der Plan zeigt den Unterschied im YAML, das yamlencode erzeugt – mit Anführungszeichen um jeden Schlüssel. Helm merkt sich jede Version eines Releases in einem Secret – nach dem Upgrade gibt es zwei. Ein Rollback mit helm rollback ginge an OpenTofu vorbei; der richtige Weg zurück ist der alte Wert im Code und ein neues apply.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Neue Chart-Version

Die Chart-Version im Code ändert sich – OpenTofu sieht es am Inhalt des Ordners:

sed -i 's/^version: 1.0.0$/version: 1.1.0/' ~/tf-lab/code/charts/notes/Chart.yaml
tofu plan -no-color | grep -E '^      ~ version|Plan:'
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
tofu state show helm_release.notes | grep -E '^ +(version|status) +='

Erwartet:

      ~ version                    = "1.0.0" -> "1.1.0"
Plan: 0 to add, 1 to change, 0 to destroy.
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
    status                     = "deployed"
    version                    = "1.1.0"

Bei einem Chart aus einem Repository steht die Version als version = "…" im Code; ein neues Chart kommt dann nur, wenn du sie änderst.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

curl -s "$(tofu output -raw url)/notes" | jq -r '.[].text'

Erwartet:

in Postgres auf k3s
tofu state list

Erwartet:

helm_release.cnpg
helm_release.db
helm_release.notes
kubectl -n notes-helm get cluster notes-db-cluster -o jsonpath='{.status.phase}'; echo

Erwartet:

Cluster in healthy state

Challenge

Die Werte für notes sollen aus einer Datei notes-values.yaml.tftpl kommen, damit sie auch jemand ohne HCL-Kenntnisse lesen kann. Der Plan darf danach keine Änderung zeigen.

Hinweis: values = [templatefile("…", { … })].

Lösung

cat > notes-values.yaml.tftpl <<'EOF'
replicas: 2
db:
  secretName: ${db_secret}
host: notes-helm.${vm_ip}.sslip.io
EOF
python3 - <<'PY'
import re
s = open("notes.tf").read()
s = re.sub(r"values = \[yamlencode\(\{.*?\}\)\]",
           'values = [templatefile("${path.module}/notes-values.yaml.tftpl", {\n'
           '    db_secret = local.db_secret\n    vm_ip     = var.vm_ip\n  })]',
           s, flags=re.S)
open("notes.tf", "w").write(s)
PY
tofu fmt >/dev/null
gen=$(kubectl -n notes-helm get deployment notes -o jsonpath='{.metadata.generation}')
tofu plan -no-color | grep -E 'Plan:|No changes'
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
neu=$(kubectl -n notes-helm get deployment notes -o jsonpath='{.metadata.generation}')
[[ $gen == "$neu" ]] && echo "Deployment unverändert"

Erwartet:

Plan: 0 to add, 1 to change, 0 to destroy.
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
Deployment unverändert

OpenTofu vergleicht den Text der Werte: yamlencode schreibt "replicas": 2, die Vorlage replicas: 2. Deshalb plant es eine Änderung. Helm rendert aus beiden dieselben Manifeste – das Deployment bleibt unberührt, nur eine neue Release-Version entsteht. Achte bei Vorlagen auf Einrückung: YAML verzeiht keinen falschen Abstand.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Versionen pinnen: Charts ohne version installieren die jeweils neueste – ein apply nach Wochen kann dann ein Major-Upgrade bringen.
  • CRDs und Operatoren gehören in eine eigene Konfiguration, die vor den Anwendungen läuft. Ressourcen über kubernetes_manifest brauchen die CRDs schon beim Plan; in derselben Konfiguration wie der Operator scheitert der erste Lauf.
  • OpenTofu oder GitOps? Viele Teams installieren Plattform-Komponenten (Operatoren, Ingress, Monitoring) mit OpenTofu und Anwendungen mit Argo CD oder Flux.