Ein europäischer Cloud-Anbieter auf Herz und Nieren geprüft - StackIT

In diesem Blog zeige ich Ihnen, wie Sie mit StackIT loslegen können, indem Sie auf offenen Standards basierende Tools wie Container-Images, Terraform und Kubernetes verwenden.

Mit den folgenden Schritten können Sie die berüchtigte paas-monitor-Anwendung einsetzen:

• ein StackIT-Projekt erstellen
• einen Kubernetes-Cluster erstellen
• die Anwendung bereitstellen
• dem Internet aussetzen

Sobald die Anwendung ausgeführt wird, können Sie:

• eine laufende Aktualisierung der Anwendung durchführen
• die Anwendung automatisch skalieren
• ein Knoten-Upgrade durchführen

Und das alles bequem von Ihrem Terraform-Quellcode aus!

ein StackIT-Projekt erstellen

Um das Projekt zu starten, erstellen Sie über die StackIT-Konsole ein StackIT-Projekt, ein Dienstkonto und einen Dienstkontoschlüssel. Laden Sie den Schlüssel für das Dienstkonto herunter und speichern Sie ihn sicher auf Ihrem Computer.

einen Kubernetes-Cluster erstellen

Mit der Projekt-ID und dem Schlüssel für das Dienstkonto können Sie einen Kubernetes-Cluster mit der folgenden Terraform-Vorlage erstellen:

resource "stackit_ske_cluster" "paas-monitor" {
  project_id             = var.project_id
  name                   = "ps-mntr" // only 11 characters allowed
  Kubernetes_version_min = "1.31"
  extensions = {
    acl = {
      allowed_cidrs = var.allowed_cidrs
      enabled       = true
    }
  }

  node_pools = [
    {
      name               = "paas-monitor"
      machine_type       = "g1.3"
      minimum            = 1
      maximum            = 6
      max_surge          = 3
      max_unavailable    = 3
      availability_zones = ["eu01-1", "eu01-2", "eu01-3"]
      os_version_min     = "4152.2.0"
      os_name            = "flatcar"
      volume_size        = 32
      volume_type        = "storage_premium_perf6"
    }
  ]
}

resource "stackit_ske_kubeconfig" "paas-monitor" {
  project_id   = var.project_id
  cluster_name = stackit_ske_cluster.paas-monitor.name
  refresh      = true
}

resource "local_file" "kubeconfig" {
  content  = stackit_ske_kubeconfig.paas-monitor.kube_config
  filename = "./.stackit/kubeconfig"
  
  directory_permission = "0700"
  file_permission      = "0600"
}

Nachdem der Cluster erstellt wurde, können Sie in der StackIT-Konsole sowohl die k8s-Kontrollebene als auch die Arbeiterknoten-VMs sehen.

Stellen Sie sicher, dass Sie die ACL-Erweiterung auf dem Cluster aktivieren und eine IP-Zulassungsliste angeben. Damit verhindern Sie unberechtigte Zugriffsversuche durch Dritte.

Der Einfachheit halber ist die kubeconfig für den Zugriff auf den Cluster in ./.stackit/kubeconfig gespeichert.

die Anwendung bereitstellen

Um die berüchtigte paas-monitor-Anwendung einzusetzen, verwenden Sie die folgende Terraform-Definition:

resource "Kubernetes_namespace" "paas-monitor" {  
  metadata {  
    name = "paas-monitor"  
  }  
}  

resource "Kubernetes_service_account" "paas-monitor" {  
  metadata {  
    name      = "paas-monitor"  
    namespace = Kubernetes_namespace.paas-monitor.metadata[0].name  
  }  
}

resource "Kubernetes_deployment" "paas-monitor" {  
  metadata {  
    name      = "paas-monitor"  
    namespace = Kubernetes_namespace.paas-monitor.metadata[0].name  
    labels = {  
      app = "paas-monitor"  
    }  
  }  

  spec {  
    selector {  
      match_labels = {  
        app = "paas-monitor"  
      }  
    }  

    template {  
      metadata {  
        labels = {  
          app = "paas-monitor"  
        }  
      }  

      spec {  
        service_account_name = Kubernetes_service_account.paas-monitor.metadata[0].name  
        container {  
          image = "gcr.io/binx-io-public/paas-monitor:latest"  
          name  = "paas-monitor"  

          env {  
            name = "MESSAGE"  
            value = "Hallo Werld"  
          }  
          port {  
            container_port = 1337  
            protocol       = "TCP"  
          }  

          readiness_probe {  
            http_get {  
              path = "/health"  
              port = 1337  
            }  
            initial_delay_seconds = 10  
            period_seconds        = 10  
            timeout_seconds       = 3  
            success_threshold     = 1  
            failure_threshold     = 3  
          }  

          liveness_probe {  
            http_get {  
              path = "/health"  
              port = 1337  
            }  
            initial_delay_seconds = 10  
            period_seconds        = 10  
            timeout_seconds       = 3  
            success_threshold     = 1  
            failure_threshold     = 3  
          }  
          resources {  
            limits = {  
              cpu    = "0.5"  
              memory = "32Mi"  
            }  
            requests = {  
              cpu    = "0.5"  
              memory = "32Mi"  
            }  
          }  
        }  
      }  
    }  
  }  
}  

resource "Kubernetes_horizontal_pod_autoscaler" "paas_monitor" {  
  metadata {  
    name = "paas-monitor"  
    namespace = Kubernetes_namespace.paas-monitor.metadata[0].name  
  }  

  spec {  
    min_replicas = 2  
    max_replicas = 10  
    target_cpu_utilization_percentage = 15  

    scale_target_ref {  
      kind = "Deployment"  
      name = "paas-monitor"  
      api_version = "apps/v1"  
    }  
  }  
}

Wie Sie sehen können, stellen wir die Anwendung mit Zustands- und Bereitschaftsprüfungen bereit und fügen einen horizontalen Pod-Autoscaler hinzu, um auf bis zu 10 Instanzen zu skalieren.

Beachten Sie, dass der Pod eine irrsinnige Menge an CPU verbraucht und die Ziel-CPU-Auslastung niedrig ist. Dies dient nur zu Demonstrationszwecken.

dem Internet aussetzen

Um den Dienst dem Internet zugänglich zu machen, müssen Sie eine öffentliche IP-Adresse von StackIT zuweisen und sie in einer DNS-Zone speichern, wie im folgenden Ausschnitt gezeigt:

resource "stackit_public_ip" "paas-monitor" {
  project_id = var.project_id
  labels = {
    "name" = "paas-monitor"
  }
}

resource "stackit_dns_zone" "paas-monitor" {
  project_id    = var.project_id
  name          = "paas-monitor"
  dns_name      = format("%s.runs.onstackit.cloud", data.stackit_resourcemanager_project.current.name)
}

resource "stackit_dns_record_set" "app" {
  project_id = var.project_id
  zone_id    = stackit_dns_zone.paas-monitor.zone_id
  name       = "app"
  type       = "A"

  records    = [stackit_public_ip.paas-monitor.ip]
}

Als nächstes fügen Sie einen Verweis auf die zugewiesene IP-Adresse in die Kubernetes-Dienstdefinition ein:

resource "Kubernetes_service" "paas_monitor" {  
  metadata {  
    name = "paas-monitor"  
    namespace = Kubernetes_namespace.paas-monitor.metadata[0].name  
    labels = {  
      app = Kubernetes_deployment.paas-monitor.metadata[0].labels.app  
    }  

    annotations = {  
      "yawol.stackit.cloud/existingFloatingIP": stackit_public_ip.paas-monitor.ip  
    }  
  }  

  spec {  
    selector = {  
      app = Kubernetes_deployment.paas-monitor.metadata[0].labels.app  
    }  
    port {  
      port        = 80  
      target_port = 1337  
      protocol    = "TCP"  
    }  
    type = "LoadBalancer"  
  }  
}

Jetzt können Sie über die URL http://app auf die Anwendung zugreifen.<ihr-projektname>.runs.onstackit.cloud

rollierende Aktualisierung der Bereitstellung

Um ein rollierendes Update zu erzwingen, ändern Sie die Umgebungsvariable MESSAGE der Anwendung in der Terraform-Vorlage in 'Hello Werld' und wenden Sie die Änderung an.

Autoskalierung bei der Arbeit

Um die automatische Skalierung der Pods zu erzwingen, klicken Sie ein paar Mal auf die Schaltfläche 'CPU erhöhen' und Sie werden sehen, dass sich die Anzahl der Instanzen erhöht.

rollierende Knoten-Updates

Um eine Aktualisierung der Clusterknoten zu erzwingen, aktualisieren Sie die min_os_version in der Terraform-Vorlage auf die empfohlene neueste Version und wenden Sie sie an. Sie können die Auswirkungen auf die Anwendung weiterhin beobachten.

In diesem Fall gab es 26 Fehler in kurzer Folge, aber ich habe Knotenaktualisierungen ohne Fehler beobachtet.

Fazit

Es war großartig zu sehen, wie einfach es war, eine Standard-Webanwendung auf StackIT zum Laufen zu bringen, die auf Open-Source-Dienstprogrammen und -Frameworks basiert.

Alles in allem habe ich etwa 2,5 Stunden gebraucht, um die Anwendung auf StackIT zum Laufen zu bringen, und das ohne jegliche Vorkenntnisse oder Schulungen zu StackIT.

Offene, auf Standards basierende Dienstprogramme und Frameworks sind eindeutig ein Schritt zur Verbesserung Ihrer Portabilität und tragen zu Ihrer digitalen Souveränität bei.

---

Die vollständige Terraform-Einrichtung finden Sie im Repository https://github.com/xebia/blog-kicking-the-tires-of-an-european-cloud-provider-stackit.git

Das Bild wurde vom Autor unter Verwendung eines Screenshots von der Startseite von https://stackit.de erstellt.