14 Min. Lesezeit

Lernziele

Am Ende dieses Moduls werden Sie in der Lage sein:

  • Einen Managed Kubernetes-Cluster und einen Node Pool mit `ionoscloud_k8s_cluster` und `ionoscloud_k8s_node_pool` bereitstellen und die kubeconfig abrufen
  • Die API, das Frontend und den Worker von TaskBoard mit Deployments, Services, ConfigMaps und Secrets bereitstellen, die aus der Private Container Registry ziehen
  • Ingress für TaskBoard mit einem NodePort-Ingress-Controller hinter einem separat bereitgestellten Application Load Balancer konfigurieren
  • Node Pools ohne Ausfallzeit skalieren und aktualisieren, wobei mehrere Pools zur Isolierung von Workloads verwendet werden
  • Fehlende Pods mit `kubectl` debuggen und wissen, wo Cluster-Protokolle in IONOS CLOUD gespeichert werden

Einheit 3.2: Kubernetes-Bereitstellung und Betrieb

Einführung

Die Images von TaskBoard befinden sich im Registry aus Einheit 3.1. Jetzt benötigen sie einen Ort, an dem sie ausgeführt werden können. Managed Kubernetes betreibt die Steuerungsebene; Sie verwalten Node Pools und Workloads mit Code.

Einige Komponenten funktionieren anders als bei anderen Kubernetes-Plattformen. Ein Service vom Typ LoadBalancer weist einem einzelnen Node eine statische IP zu, anstatt einen Load Balancer zu erstellen, und Nodes werden während der Wartung ersetzt.

In dieser Einheit provisionieren Sie den Cluster mit Terraform, verbinden kubectl, deployen die Workloads von TaskBoard, setzen den ALB aus Einheit 2.3 vor einen Ingress Controller und betreiben Node Pools. Im Code Lab führen Sie TaskBoard von terraform apply zu einem funktionierenden Endpoint hinter dem ALB.

1. Provisionierung von MKS mit Terraform

1.1 Der Cluster

resource "ionoscloud_k8s_cluster" "taskboard" {
  name        = "taskboard-dev"
  k8s_version = var.k8s_version

  maintenance_window {
    day_of_the_week = "Sunday"
    time            = "02:00:00Z"
  }

  api_subnet_allow_list = ["203.0.113.0/24"]

  s3_buckets {
    name = "taskboard-k8s-audit-7f3a"
  }
}

Nur name ist erforderlich. api_subnet_allow_list beschränkt den Zugriff auf den Kubernetes API Server auf diese CIDRs; der clusterinterne Verkehr wird nicht beeinflusst, und ohne eine Liste ist der Zugriff nicht eingeschränkt. s3_buckets benennt einen bestehenden IONOS Cloud Object Storage Bucket für die Audit-Logs der Kubernetes API. Das Wartungsfenster öffnet sich zum von Ihnen festgelegten Zeitpunkt und bleibt vier Stunden geöffnet.

Lesen Sie die aktuelle Standardversion aus der API und übergeben Sie diese, anstatt eine alte Version aus einem Beispiel zu kopieren:

curl --silent "https://api.ionos.com/cloudapi/v6/k8s/versions/default" \
  --header "Authorization: Bearer $IONOS_TOKEN"
export TF_VAR_k8s_version="<version from the response>"

Die unterstützten Minor-Versionen sind 1.32, 1.33, 1.34 und 1.35. Version 1.32 erreicht am 1. Dezember 2026 das IONOS CLOUD End of Life, und für ein Cluster mit einer EOL-Version können keine neuen Node Pools erstellt werden. Downgrades werden nicht unterstützt.

1.2 Der Node Pool

# In the existing ionoscloud_lan.app and ionoscloud_lan.db from Unit 2.2, add:
# lifecycle {
#   create_before_destroy = true
# }

resource "ionoscloud_k8s_node_pool" "general" {
  datacenter_id     = ionoscloud_datacenter.taskboard.id
  k8s_cluster_id    = ionoscloud_k8s_cluster.taskboard.id
  name              = "general"
  k8s_version       = ionoscloud_k8s_cluster.taskboard.k8s_version
  server_type       = "VCPU"
  availability_zone = "AUTO"
  storage_type      = "SSD"
  node_count        = 2
  cores_count       = 2
  ram_size          = 4096
  storage_size      = 20

  lans {
    id   = ionoscloud_lan.app.id
    dhcp = true
  }

  lans {
    id   = ionoscloud_lan.db.id
    dhcp = true
  }

  maintenance_window {
    day_of_the_week = "Sunday"
    time            = "03:00:00Z"
  }
}

Die lans-Blöcke verbinden jeden Knoten mit dem privaten App-LAN aus Einheit 2.2, wo der ALB sie in Abschnitt 4 erreicht, und mit dem DB-LAN, wo die Pods PostgreSQL, In-Memory DB und Kafka erreichen (Einheit 2.5). Knotenpools erhalten ihre IP-Adressen in einem privaten LAN über DHCP. Der Anbieter empfiehlt create_before_destroy in den LANs, damit der Knotenpool aktualisiert wird, bevor ein LAN zerstört wird.

Diese Argumente sind unveränderlich: name, cpu_family, availability_zone, cores_count, ram_size, storage_size und storage_type. allow_replace = true ändert sie, indem er den Pool zerstört und neu erstellt, was zu einer Ausfallzeit für alle Pods auf dem Pool führt. server_type akzeptiert DedicatedCore oder VCPU, und Sie können einen vorhandenen Pool zwischen ihnen umschalten. Ein provisionierter Kern entspricht 2 Managed Kubernetes CPUs.

1.3 Abrufen der Kubeconfig

data "ionoscloud_k8s_cluster" "taskboard" {
  id         = ionoscloud_k8s_cluster.taskboard.id
  depends_on = [ionoscloud_k8s_node_pool.general]
}

resource "local_file" "kubeconfig" {
  sensitive_content = yamlencode(jsondecode(data.ionoscloud_k8s_cluster.taskboard.kube_config))
  filename          = "kubeconfig.yaml"
}

Die Datenquelle gibt kube_config zurück, und der gesamte config-Knoten ist als sensibel markiert. Das Schreiben der kubeconfig in eine Datei ist ein Sicherheitsrisiko: Halten Sie sie aus Git heraus. Außerhalb von Terraform erhalten Sie dieselbe Datei über die API oder die CLI:

curl --silent "https://api.ionos.com/cloudapi/v6/k8s/$CLUSTER_ID/kubeconfig" \
  --header "Authorization: Bearer $IONOS_TOKEN" > kubeconfig.yaml
ionosctl k8s kubeconfig get --cluster-id "$CLUSTER_ID"

Die API gibt standardmäßig YAML zurück, oder JSON, wenn der Accept-Header dies anfordert. Nur Administratoren können die kubeconfig eines Clusters ohne Node Pool abrufen; alle anderen Benutzer müssen zuerst einen Node Pool erstellen.

2. Verbindung zum Cluster herstellen

export KUBECONFIG="$PWD/kubeconfig.yaml"
kubectl config get-contexts
kubectl get nodes -o wide
kubectl create namespace taskboard
kubectl config set-context --current --namespace=taskboard

Verwenden Sie die heruntergeladene kubeconfig-Datei für die Einrichtung, nicht für tägliche Bereitstellungen.

2.1 RBAC für Bereitstellungen

Erstellen Sie für die CI-Pipeline in Einheit 3.3 ein Service-Konto, das nur den Namespace von TaskBoard verwalten kann:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: taskboard-deployer
  namespace: taskboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: taskboard-deployer-edit
  namespace: taskboard
subjects:
  - kind: ServiceAccount
    name: taskboard-deployer
    namespace: taskboard
roleRef:
  kind: ClusterRole
  name: edit
  apiGroup: rbac.authorization.k8s.io

Die eingebaute edit ClusterRole, die über ein RoleBinding zugewiesen wird, gewährt Berechtigungen nur innerhalb von taskboard. Wer überhaupt Cluster erstellen darf, ist ein IONOS CLOUD Privileg: Eine Gruppe benötigt createK8sCluster (Kubernetes Cluster im DCD erstellen).

3. TaskBoard-Workloads

3.1 Abrufen aus der Private Container Registry

kubectl create secret docker-registry taskboard-registry \
  --docker-server="$CR_HOST" \
  --docker-username=taskboard-k8s-pull \
  --docker-password="$(cat k8s-pull.pass)" \
  --namespace taskboard

Das Secret enthält den nur für Abrufe bestimmten Token aus Einheit 3.1. Verweisen Sie in jeder Pod-Spezifikation darauf über imagePullSecrets. Ohne diesen Token verbleiben Pods im Zustand ImagePullBackOff, da die Registry niemals nicht authentifizierte Abrufe zulässt.

3.2 Deployment, Service, ConfigMap und Secret

apiVersion: v1
kind: ConfigMap
metadata:
  name: taskboard-config
data:
  LOG_LEVEL: "info"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: taskboard-api
spec:
  replicas: 2
  selector:
    matchLabels: { app: taskboard-api }
  template:
    metadata:
      labels: { app: taskboard-api }
    spec:
      imagePullSecrets:
        - name: taskboard-registry
      containers:
        - name: api
          image: <registry-hostname>/taskboard/api:<git-sha>
          ports:
            - containerPort: 8000
          envFrom:
            - configMapRef: { name: taskboard-config }
            - secretRef: { name: taskboard-db }
          resources:
            requests: { cpu: 250m, memory: 256Mi }
            limits: { memory: 512Mi }
          readinessProbe:
            httpGet: { path: /api/health, port: 8000 }
---
apiVersion: v1
kind: Service
metadata:
  name: taskboard-api
spec:
  selector: { app: taskboard-api }
  ports:
    - port: 80
      targetPort: 8000

Das taskboard-db Secret enthält die PostgreSQL-Verbindungswerte aus Einheit 2.5. Erstellen Sie es aus Ihrem Secret Store, niemals aus einer Datei in Git. Das Web-Deployment verwendet den Port 8080, und das Worker-Deployment hat keinen Service. Setzen Sie requests und limits: Ein Knoten, dem der RAM ausgeht, kann am Ende NotReady sein und sich mit Disk-I/O beschäftigen.

4. Ingress: Controller auf Nodes, Load Balancer werden separat provisioniert

4.1 Was ein LoadBalancer-Service auf MKS bewirkt

apiVersion: v1
kind: Service
metadata:
  name: demo
spec:
  type: LoadBalancer
  loadBalancerIP: 198.51.100.20   # an IP you reserved in IP Management
  selector: { app: demo }
  ports:
    - port: 80

In einem öffentlichen Node-Pool werden auf diese Weise weder ein ALB noch ein NLB erstellt. IONOS CLOUD weist eine vorab reservierte statische IP zu oder reserviert eine neue und hängt sie als sekundäre IP an einen Worker-Node. Dieser Node fungiert als Ingress-Node; kube-proxy leitet den Verkehr an Pods auf anderen Nodes weiter, und dieser NAT-Schritt ersetzt die Client-IP. Jeder Node bietet an der öffentlichen Schnittstelle bis zu 2 Gbit/s. Ohne loadBalancerIP wird die Adresse freigegeben, wenn Sie den Service löschen. Private Node-Pools unterstützen den Typ LoadBalancer nicht.

4.2 TaskBoard: Ingress Controller hinter dem ALB

TaskBoard verwendet den Managed ALB aus Einheit 2.3, der mit Terraform provisioniert wurde und nicht aus einem Manifest stammt. Der Ingress-Controller läuft auf den Worker-Nodes und wird als NodePort bereitgestellt; der ALB leitet den Verkehr an die Nodes im App-LAN weiter.

helm repo add traefik https://traefik.github.io/charts
helm install traefik traefik/traefik --namespace ingress --create-namespace \
  --set service.type=NodePort --set ports.web.nodePort=30080
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: taskboard
spec:
  ingressClassName: traefik
  rules:
    - http:
        paths:
          - path: /api
            pathType: Prefix
            backend: { service: { name: taskboard-api, port: { number: 80 } } }
          - path: /
            pathType: Prefix
            backend: { service: { name: taskboard-web, port: { number: 80 } } }

Die Zielgruppe verweist nun auf die Adressen der Knoten im App-LAN, auf dem NodePort:

variable "ingress_node_ips" {
  type = list(string)
}

resource "ionoscloud_target_group" "ingress" {
  name             = "taskboard-ingress"
  algorithm        = "ROUND_ROBIN"
  protocol         = "HTTP"
  protocol_version = "HTTP1"

  dynamic "targets" {
    for_each = var.ingress_node_ips
    content {
      ip     = targets.value
      port   = 30080
      weight = 100
    }
  }

  http_health_check {
    path       = "/api/health"
    method     = "GET"
    match_type = "STATUS_CODE"
    response   = "200"
  }
}

Richten Sie die Weiterleitungsregel aus Einheit 2.3 auf ionoscloud_target_group.ingress.id aus. Lesen Sie die Knotenadressen, die in 10.10.1.0/24 liegen, aus kubectl get nodes -o wide oder von innerhalb eines Knotens. Knoten werden während der Wartung (Abschnitt 5) ersetzt, daher die Zielliste nach jeder Änderung des Knotenpools prüfen.

5. Knotenpool-Operationen und Fehlerdiagnose

5.1 Skalierung und mehrere Pools

resource "ionoscloud_k8s_node_pool" "workers" {
  # ... same required arguments as Section 1.2, name = "workers"
  node_count = 1
  auto_scaling {
    min_node_count = 1
    max_node_count = 4
  }
  labels = { pool = "workers" }
  taints {
    key    = "dedicated"
    value  = "worker"
    effect = "NoSchedule"
  }
  lifecycle {
    ignore_changes = [node_count]
  }
}

Ein zweiter Pool isoliert den Hintergrundworker von TaskBoard: der Taint hält andere Pods fern, und das Worker-Deployment erhält eine passende Toleration sowie einen nodeSelector von pool: workers. Mit auto_scaling ändert der Autoscaler die Knotenanzahl, sodass ignore_changes verhindert, dass Terraform dagegen arbeitet. Der Autoscaler bleibt zwischen Ihrem Minimum und Maximum, kann die Vertragsquote nicht überschreiten und kann nicht auf 0 skaliert werden.

Grenze Wert
Knoten pro Knotenpool 100 maximal, 20 empfohlen
Knotenpools pro Cluster 500
Knoten pro Cluster 5000
Pods pro Knoten 110

5.2 Upgrades und Wartung

Während der Wartung eines Knotenpools werden alle Knoten des Pools nacheinander ersetzt, beginnend mit dem ältesten Knoten. Zuerst tritt ein neuer Knoten bei, dann wird der alte Knoten geleert und entfernt. Knoten sind unveränderlich, daher kommen auch Softwareupdates als neue Knoten. Die Wartung berücksichtigt das vierstündige Zeitfenster; Knoten, die nicht rechtzeitig ersetzt werden, werden bei der nächsten Wartung ersetzt.

Knotenpools können eine ältere Kubernetes-Version als die Steuerungsebene ausführen, niemals eine neuere, und die Minor-Versionen dürfen sich um höchstens 1 unterscheiden. Zum Upgrade erhöhen Sie zuerst k8s_version auf dem Cluster, dann auf jedem Pool. Bereiten Sie Ihre Workloads darauf vor, jederzeit evakuiert zu werden: Führen Sie mindestens zwei Replikate aus und verwenden Sie PodDisruptionBudgets, die es einem Pod erlauben, zu gehen.

5.3 Fehlersuche

kubectl get pods -o wide
kubectl describe pod <pod>                 # events: ImagePullBackOff, scheduling, probes
kubectl logs deploy/taskboard-api --since=15m
kubectl exec -it deploy/taskboard-api -- sh
kubectl get events --sort-by=.lastTimestamp

kubectl ist Ihr primäres Werkzeug für Workload-Probleme. Der Logging Service empfängt, was ein Fluent Bit-Agent übermittelt oder was Sie im OTLP-Format senden, sodass Anwendungsprotokolle ihn erst erreichen, nachdem Sie einen Agenten bereitgestellt oder sie über OTLP gesendet haben (Einheit 5.1). Die API-Audit-Protokolle des Clusters werden in den Object Storage-Bucket in s3_buckets gesendet. Wenn ein Knoten nicht mehr reagiert, ersetzen Sie ihn über die API mit POST /k8s/{k8sClusterId}/nodepools/{nodePoolId}/nodes/{nodeId}/replace.

Schnellreferenz für die API

Wichtige API-Endpunkte für das Thema dieser Einheit:

Methode Endpunkt Beschreibung
GET /k8s/versions/default Standardversion für neue Cluster und Node Pools
POST /k8s Ein Cluster erstellen
POST /k8s/{k8sClusterId}/nodepools Einen Node Pool erstellen
GET /k8s/{k8sClusterId}/kubeconfig Die kubeconfig herunterladen (standardmäßig YAML)
POST /k8s/{k8sClusterId}/nodepools/{nodePoolId}/nodes/{nodeId}/replace Einen nicht reagierenden Knoten ersetzen

Basis-URL: https://api.ionos.com/cloudapi/v6 Authentifizierung: Authorization: Bearer <token>

Code Lab

Ziel: Deploy von TaskBoard auf Managed Kubernetes: Erstellen des Clusters und des Node Pools mit Terraform, Deployment der Manifests mit einem Registry-Pull-Secret und Verifizierung des Endpunkts über den ALB.

Voraussetzungen:

  • IONOS CLOUD Konto mit einem API-Token in IONOS_TOKEN
  • Terraform, kubectl und Helm lokal installiert
  • Die Registry, die Images und k8s-pull.pass aus Einheit 3.1
  • Die Konfiguration für das Rechenzentrum, das App-LAN und den ALB aus den Einheiten 2.2 und 2.3

Schritt 1: Cluster und Node Pool hinzufügen

Fügen Sie den Cluster (Abschnitt 1.1, ohne s3_buckets, sofern Sie keinen Bucket haben), den Node Pool (Abschnitt 1.2) und die kubeconfig-Datei (Abschnitt 1.3) zu Ihrer Konfiguration hinzu.

export TF_VAR_k8s_version="<default version from /k8s/versions/default>"
terraform apply -target=ionoscloud_k8s_node_pool.general -target=local_file.kubeconfig

Erwartete Ausgabe:

ionoscloud_k8s_cluster.taskboard: Creation complete after ...
ionoscloud_k8s_node_pool.general: Creation complete after ...
local_file.kubeconfig: Creation complete after ...

Schritt 2: Verbinden

export KUBECONFIG="$PWD/kubeconfig.yaml"
kubectl get nodes

Erwartete Ausgabe:

NAME        STATUS   ROLES    AGE   VERSION
<node-1>    Ready    <none>   ...   v<version>
<node-2>    Ready    <none>   ...   v<version>

Schritt 3: Namespace und Secrets erstellen

kubectl create namespace taskboard
kubectl -n taskboard create secret docker-registry taskboard-registry \
  --docker-server="$CR_HOST" --docker-username=taskboard-k8s-pull \
  --docker-password="$(cat k8s-pull.pass)"
kubectl -n taskboard create secret generic taskboard-db --from-literal=DATABASE_URL="$DATABASE_URL"

Erwartete Ausgabe:

namespace/taskboard created
secret/taskboard-registry created
secret/taskboard-db created

Schritt 4: Workloads bereitstellen

kubectl -n taskboard apply -f k8s/
kubectl -n taskboard rollout status deploy/taskboard-api

Erwartete Ausgabe:

deployment "taskboard-api" successfully rolled out

Schritt 5: Ingress-Controller und Ingress installieren

helm install traefik traefik/traefik --namespace ingress --create-namespace \
  --set service.type=NodePort --set ports.web.nodePort=30080
kubectl -n taskboard apply -f k8s/ingress.yaml

Erwartete Ausgabe:

STATUS: deployed
ingress.networking.k8s.io/taskboard created

Schritt 6: Den ALB auf die Knoten zeigen

kubectl get nodes -o wide        # note each node's address in 10.10.1.0/24
export TF_VAR_ingress_node_ips='["10.10.1.x","10.10.1.y"]'
terraform apply

Erwartete Ausgabe:

ionoscloud_target_group.ingress: Creation complete after ...
ionoscloud_application_loadbalancer_forwardingrule.http: Modifications complete after ...

Schritt 7: Endpunkt überprüfen

curl --silent "http://$(terraform output -raw alb_ip)/api/health"

Erwartete Ausgabe:

{"status": "ok"}

Prüfliste:

  • [ ] Beide Knoten sind Ready
  • [ ] Alle TaskBoard-Pods sind Running, ohne ImagePullBackOff
  • [ ] Der Health Check des ALB meldet die Ziele als gesund
  • [ ] /api/health antwortet über die ALB-IP

Aufräumarbeiten:

helm uninstall traefik --namespace ingress
terraform destroy -auto-approve
rm -f kubeconfig.yaml

Häufige Fehler

Fehler von Entwicklerinnen und Entwicklern, die bei dem Thema dieser Einheit zu vermeiden sind:

  1. Erwartung eines Load Balancers aus einem Manifest

    • Problem: Sie wenden einen type: LoadBalancer Service an und suchen nach einem neuen ALB, aber der gesamte Traffic trifft auf einem einzigen Knoten ein, und Ihre Protokolle zeigen interne Knoten-IPs anstelle von Client-IPs.
    • Ursache: Auf MKS erhält der Service eine statische IP auf einem Ingress-Knoten, und kube-proxy NAT ersetzt die Client-Adresse.
    • Lösung: Stellen Sie den ALB oder NLB separat mit Terraform bereit (Abschnitt 4.2) oder verwenden Sie externalTrafficPolicy: Local mit der an den Knoten gebundenen IP, auf dem der Ingress-Controller ausgeführt wird.
  2. ImagePullBackOff auf jedem Pod

    • Problem: kubectl describe pod zeigt einen Autorisierungsfehler an, wenn aus der Registry abgerufen wird.
    • Ursache: Die Pod-Spezifikation enthält kein imagePullSecrets, das Secret befindet sich in einem anderen Namespace, oder das Token ist abgelaufen und wurde gelöscht.
    • Lösung: Erstellen Sie das docker-registry Secret im Namespace der Workload, verweisen Sie darauf in der Pod-Spezifikation und vergeben Sie dem Abruf-Token keine Ablaufzeit oder rotieren Sie es vor dem Ablaufdatum.
  3. Ändern eines unveränderlichen Arguments des Knotenpools

    • Problem: Sie erhöhen ram_size und der Plan zeigt eine Zerstörung und Neuerschaffung des Pools an.
    • Ursache: cores_count, ram_size, storage_size und die anderen Template-Argumente sind unveränderlich.
    • Lösung: Erstellen Sie einen neuen Pool mit der neuen Größe, verlegen Sie Workloads über Labels oder durch Drainage und löschen Sie anschließend den alten Pool.

Zusammenfassung

Sie können TaskBoard jetzt von Code aus auf Managed Kubernetes ausführen. Terraform erstellt den Cluster, die Node Pools und die kubeconfig; Workloads ziehen aus der Private Container Registry mit einem Pull-Secret; und ein Ingress-Controller auf den Nodes befindet sich hinter einem separat bereitgestellten ALB. Sie wissen, wie Wartung Nodes ersetzt und wo Sie bei einem Pod-Fehler nachschauen müssen.

Wichtige Punkte:

  • Lesen Sie die Standardversion aus /k8s/versions/default; Node Pools können der Steuerungsebene um höchstens eine Minor-Version hinterhinken
  • Die Argumente der Node-Vorlage sind unveränderlich; allow_replace erstellt den Pool mit Ausfallzeit neu
  • Ein LoadBalancer Service auf MKS ist eine statische IP auf einem Node, kein ALB oder NLB
  • Jeder Pod, der aus dem Registry zieht, benötigt einen imagePullSecrets Eintrag
  • Die Wartung von Node Pools ersetzt Nodes einzeln innerhalb eines vierstündigen Zeitfensters; halten Sie Pools auf 20 Nodes oder weniger

Wichtige Begriffe:

  • Node pool: Eine Gruppe von Nodes mit demselben Servertyp, CPU, RAM und Speicher, verwaltet als ionoscloud_k8s_node_pool
  • Kubeconfig: Die Datei mit der API-Server-Adresse und den Anmeldedaten, die kubectl verwendet
  • Ingress node: Der Worker-Node, der die statische IP eines LoadBalancer Service hält
  • NodePort: Ein Service-Typ, der einen festen Port auf jedem Node öffnet, hier als Zielport des ALB verwendet
  • imagePullSecrets: Das Feld in der Pod-Spezifikation, das auf Registry-Anmeldedaten für private Images verweist

Nächste Schritte

Weiter lernen: Einheit 3.3: CI/CD-Pipelines für IONOS CLOUD

Verwandte Themen: