Terraform-Kubernetes-Apps über Cloud Marketplace anbieten

Mit Terraform-Kubernetes-Apps in Google Cloud Marketplace können Ihre Kunden Terraform verwenden, um Ihre containerisierten Apps in Google Kubernetes Engine bereitzustellen. Ihre Nutzer zahlen nicht für die Nutzung Ihrer Terraform-Kubernetes-Apps, sondern für die Nutzung von Google Cloud -Ressourcen. Sie können Terraform-Kubernetes-Apps öffentlich für alle Cloud Marketplace-Nutzer oder privat über Private Offers anbieten.

Für Terraform-Kubernetes-Apps, die Sie über Cloud Marketplace anbieten, werden die Konfigurationen mit Helm-Diagrammen definiert, die Sie in Artifact Registry hosten. Danach können Sie Ihre App über das Producer Portal in Cloud Marketplace einbinden.

Übersicht über das Onboarding einer Terraform-Kubernetes-Anwendung

Das Anbieten einer Terraform-Kubernetes-App über Cloud Marketplace umfasst die folgenden Schritte:

1. Terraform-Kubernetes-Anwendung für Cloud Marketplace vorbereiten Dazu gehört das Einrichten von Artifact Registry und das Übertragen der Images Ihrer App per Push an Artifact Registry.

2. Fügen Sie Preisinformationen für Ihre App im Producer Portal hinzu.

3. Bereitstellung Ihrer App konfigurieren: Konfigurieren Sie im Producer Portal das Terraform-Modul, das Helm-Diagramm und die Container-Images Ihrer App.

4. Veröffentlichen Sie Ihr Produkt im Cloud Marketplace. Während Sie Ihr Produkt einrichten, reichen Sie verschiedene Teile des Produkts zur Überprüfung ein. Das Cloud Marketplace-Team prüft jede Einreichung und arbeitet mit Ihnen zusammen, um alle Probleme zu lösen, bevor die Einreichung genehmigt wird. Wenn alle Einreichungen genehmigt wurden, können Sie das Produkt innerhalb weniger Minuten veröffentlichen und starten.

Anforderungen für Terraform-Kubernetes-Anwendungen

Alle Produkte, die Sie über Cloud Marketplace anbieten, müssen den Anforderungen für Einträge im Cloud Marketplace entsprechen.

Ihre Terraform-Kubernetes-App muss die folgenden zusätzlichen Anforderungen erfüllen:

• Ihre Anwendung muss auf GKE-Knoten mit x86-Prozessoren ausgeführt werden.
• Alle Helm-Charts und Container-Images Ihrer App müssen in Ihre Artifact Registry-Registry hochgeladen werden, in dasselbe Repository und Projekt, das Sie für Ihre Terraform Kubernetes-App verwenden.
• Ihre Artifact Registry-Registrierung muss ein Helm-Diagramm enthalten.
• Das Terraform-Modul muss als ZIP-Datei in einem Cloud Storage-Bucket gehostet werden, der sich in demselben Projekt befindet, das Sie für Ihre Terraform Kubernetes-App verwenden.
• Sie müssen die Versionsverwaltung für den Cloud Storage-Bucket aktivieren, den Sie zum Hosten Ihres Terraform-Moduls verwenden.
• Sie müssen ein Nutzerhandbuch mit Schritten zum Bereitstellen Ihrer App über die Befehlszeile, zum Konfigurieren der App und zum Verwenden der App hinzufügen. Weitere Informationen finden Sie in diesem Dokument unter Anforderungen an Ihr Nutzerhandbuch.
• Es werden nur Betaressourcen oder allgemein verfügbare Kubernetes-Ressourcen verwendet, um Nutzer vor instabilen APIs zu schützen.

Anforderungen an Ihre App-Bilder

Ihre App-Bilder müssen die folgenden Anforderungen erfüllen:

• Alle Images Ihrer App müssen mit dem Release-Track und der aktuellen Version versehen sein. Wenn Sie beispielsweise die Version 2.0.5 auf dem Release-Track 2.0 veröffentlichen, müssen alle entsprechenden Images mit 2.0 und 2.0.5 gekennzeichnet sein. Weitere Informationen finden Sie unter Releases verwalten.

• Alle Images Ihrer App müssen die folgende Annotation in ihrem Image-Manifest enthalten:

  com.googleapis.cloudmarketplace.product.service.name=services/SERVICE_NAME
  

  Ersetzen Sie SERVICE_NAME durch den Namen Ihres Dienstes. Den Namen Ihres Dienstes finden Sie in der Produkttabelle auf der Seite Übersicht im Producer Portal. Weitere Informationen zu Anmerkungen finden Sie in der Dokumentation der Open Container Initiative zu Anmerkungen auf GitHub.

Anforderungen an Ihr Artifact Registry-Repository

Das Helm-Diagramm und die Container-Images Ihrer App müssen Teil eines einzelnen Artifact Registry-Repositorys sein.

Wenn Ihr Artifact Registry-Repository beispielsweise us-docker.pkg.dev/exampleproject ist, sollten das Helm-Diagramm und die Container-Images Ihrer App so aussehen:

• us-docker.pkg.dev/exampleproject/exampleapp/chart
• us-docker.pkg.dev/exampleproject/exampleapp/image1
• us-docker.pkg.dev/exampleproject/exampleapp/image2

Anforderungen an das Terraform-Modul

Kunden verwenden das Terraform-Modul, um Ihr Produkt über Infrastructure Manager aus Cloud Marketplace bereitzustellen. Das Terraform-Modul enthält die Kubernetes-Konfiguration Ihrer Anwendung.

Verwenden Sie das Beispielmodul als Ausgangspunkt und folgen Sie der Partneranleitung, um ein Terraform-Modul zu erstellen, das mit Ihrer App kompatibel ist.

An Ihre Anwendung übergebene Parameter

Ihr Terraform-Modul muss Parameter deklarieren, die von Kunden bei der Auswahl Ihrer Anwendung erfasst werden müssen. Diese Parameter werden dann an den Helm-Diagramm-Container übergeben, wenn Nutzer die Anwendung bereitstellen.

Damit diese Parameter konfiguriert werden können, muss Ihr Terraform-Modul eine schema.yaml-Datei enthalten.

Informationen zum Erstellen eines schema.yaml finden Sie in der Anleitung zum Erstellen eines Schemas auf GitHub.

GPU-Clusteranfragen

Wenn Ihre Anwendung bestimmte GPU-Anforderungen hat oder GPU-intensiv ist, können Sie den Typ und die Anzahl der GPUs im Cluster mit Ihrem Deployer-Schema angeben. Wenn Sie Ihre GPU-Anforderungen angeben, deaktivieren Sie die unterstützte Clustererstellung.

Ihre Anwendung kann eine generische Nvidia-GPU oder eine bestimmte Nvidia-Plattform anfordern.

Anforderungen an das Nutzerhandbuch Ihrer App

Das Nutzerhandbuch Ihrer App muss die folgenden Informationen enthalten:

• Übersicht: Eine allgemeine Übersicht über Ihre App mit ihren grundlegenden Funktionen und Konfigurationsoptionen. Der Abschnitt muss auch einen Link zu Ihrer veröffentlichten App auf Cloud Marketplace enthalten.
• Einmalige Einrichtung: Dazu gehören Schritte zum Konfigurieren von Helm und zum Installieren der Anwendungs-CustomResourceDefinition (CRD), damit Ihr Cluster die Anwendungsressource verwalten kann.
• Installation: Dazu gehören die folgenden Schritte:
  • Befehle zum Bereitstellen Ihrer App
  • In der UI-Konfiguration verfügbare Parameter übergeben
  • Image-Referenzen an unveränderliche Digests anheften
  • Informationen zu benutzerdefinierten Eingabefeldern, die Sie Ihrem Terraform-Modul hinzugefügt haben, sofern zutreffend. Weitere Informationen finden Sie in der Anleitung zum Hinzufügen von Eingabefeldern zu Ihrem Terraform-Modul.
• Grundlegende Nutzung: Anleitungen für die folgenden Aufgaben:
  • Nutzernamen und Passwörter ändern
  • Verbindung zu einer Admin-Konsole herstellen (falls zutreffend)
  • Verbindung zu einem Clienttool herstellen und gegebenenfalls Beispielbefehl ausführen
  • Eingehenden Traffic aktivieren und gegebenenfalls TLS-Zertifikate installieren
• Sichern und Wiederherstellen: Informationen zum Sichern des App-Status und zum Wiederherstellen des App-Status aus einer Sicherung.
• Image-Updates: Informationen zum Aktualisieren der App-Bilder für Patches oder kleinere Updates.
• Skalierung: Informationen zur Skalierung der App, falls zutreffend.
• Löschen: Anleitungen zum Löschen der App und zum Bereinigen aller verbleibenden Ressourcen, z. B. PersistentVolumeClaims.

Preismodelle für Terraform-Kubernetes-Anwendungen

Sie können eines der folgenden Preismodelle für Ihre App auswählen:

• Kostenlos: Kunden zahlen nur für die Google Cloud Ressourcen, die sie nutzen.
• Nutzungsbasiert: Kunden zahlen für Ihre App auf Grundlage der von Ihnen ausgewählten Messwerte, z. B. der Anzahl der Container oder der Speicherzeit. Wenn Sie ein nutzungsbasiertes Preismodell wählen, muss Ihre Anwendung Nutzungsinformationen erfassen und an Google melden.

Nachdem Sie eine Terraform Kubernetes-App mit nutzungsbasierter Preisgestaltung veröffentlicht haben, können Sie die Preise der App aktualisieren. Wenn Sie den Preis Ihrer App aktualisieren möchten, muss die Veröffentlichung Ihrer App oder die letzte Preisaktualisierung mindestens 30 Tage zurückliegen.

Achtung :Sie können eine kostenlose Terraform Kubernetes-App nicht so aktualisieren, dass sie nutzungsbasierte Preise verwendet. Wenn Sie das Preismodell Ihrer App von „kostenlos“ zu „nutzungsbasiert“ ändern möchten, müssen Sie einen neuen Produkteintrag für Ihre App mit nutzungsbasierter Preisgestaltung erstellen.

Nutzungsbasierte Preise

Google Cloud Marketplace verwendet Kubernetes-Pod-Annotationen, um die Nutzung zu erfassen und Kunden für die Bereitstellungen Ihrer Cloud Marketplace-Apps in Rechnung zu stellen. In Cloud Marketplace werden Abrechnung und Messung auf Pod-Ebene erfasst und auf Ebene des Produkteintrags zusammengefasst.

Wenn Sie mehrere Pods auf derselben Maschine (vCPU, GPU, TPU oder Arbeitsspeicher) bereitstellen, weist das System jedem der Pods die kumulative Nutzung zu, die über alle auf der Maschine bereitgestellten Pods hinweg auftritt. Wenn Sie beispielsweise drei Pods haben, die dieselbe GPU verwenden, zählt Cloud Marketplace dies als drei GPUs.

Im Cloud Marketplace werden verschiedene GKE-SKUs innerhalb jeder vCPU-, TPU-, GPU- oder Arbeitsspeicherfamilie von SKUs als identisch behandelt. Wenn beispielsweise GPU als Messwert festgelegt ist, gilt der konfigurierte Preis unabhängig davon, ob Ihr Kunde GKE Autopilot T4 GPU Premium, GKE Autopilot L4, GKE Autopilot H100 GPU Premium, GKE Autopilot A100 40 GiB GPU, GKE Autopilot A100 80 GiB GPU oder GKE Autopilot H100 GPU Premium verwendet.

Wir empfehlen dringend, in Ihre Cloud Marketplace-Apps eine Geschäftslogik für eine genaue Kundenabrechnung zu integrieren. Um die Auswirkungen eines versehentlichen Entfernens von Labelanmerkungen zu minimieren, empfehlen wir, Ihre App so zu gestalten, dass regelmäßig geprüft wird, ob die Labelanmerkungen noch vorhanden sind. Wenn eine Annotation fehlt, sollte die Funktionalität Ihrer App eingeschränkt werden, bis das Label wiederhergestellt wurde. Ein Beispiel dafür in Python finden Sie unten:

pod_name = os.environ.get("HOSTNAME")
namespace = open(
      "/var/run/secrets/kubernetes.io/serviceaccount/namespace"
).read()
# Load in-cluster config
config.load_incluster_config()
v1 = client.CoreV1Api()
# Get the Pod object
pod = v1.read_namespaced_pod(name=pod_name, namespace=namespace)
annotations = pod.metadata.annotations
if annotations:
print("Annotations for this pod:")
for key, value in annotations.items():
      print(f"  {key}: {value}")
else:
print("No annotations found on this pod.")

Nächste Schritte

• Lesen Sie die Anforderungen für Einträge im Cloud Marketplace.
• Terraform-Kubernetes-Anwendung für Cloud Marketplace vorbereiten
• Fügen Sie Ihre Terraform-Kubernetes-Anwendung über das Producer Portal dem Cloud Marketplace hinzu.