SaaS-Angebote entwerfen und bereitstellen

Mit Application Design Center und App Lifecycle Manager können Sie die Bereitstellung von mehrmandantenfähigen SaaS-Anwendungen standardisieren und skalieren, ohne die Infrastruktur für jeden Kunden manuell konfigurieren zu müssen. Sie stellen wiederverwendbare Terraform-Module im App Design Center zu zusammengesetzten Anwendungsvorlagen zusammen und verpacken diese Vorlagen dann im App Lifecycle Manager in verwaltete SaaS-Angebote.

In dieser Anleitung stellen Sie isolierte Mandantenumgebungen bereit und automatisieren progressive Updates und Roll-outs. Dieser Workflow ist für Plattform-Entwickler, Unternehmensarchitekten und DevOps-Operatoren gedacht.

Ziele

  • Bereiten Sie ein GitHub-Repository mit Cloud Run- und Cloud Storage-Terraform-Modulen vor.
  • Verknüpfen Sie Ihr GitHub-Repository mit Google Cloud über Developer Connect.
  • Importieren Sie die Terraform-Module, um Komponentenvorlagen in App Design Center zu erstellen und zu katalogisieren.
  • Entwerfen Sie eine zusammengesetzte Anwendungsvorlage, die Ihre Komponentenvorlagen enthält.
  • Vorlage verpacken und eine Kundenumgebung in App Lifecycle Manager bereitstellen
  • Automatisieren Sie progressive Roll-outs in Ihren Kundenumgebungen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

  1. Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Developer Connect, Secret Manager, App Lifecycle Manager, Infrastructure Manager, and Cloud Run APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Developer Connect, Secret Manager, App Lifecycle Manager, Infrastructure Manager, and Cloud Run APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  8. Prüfen Sie, ob Sie die folgenden IAM-Rollen (Identity and Access Management) für Ihr Projekt haben:
    • Application Design Center Admin (roles/designcenter.admin) und Service Usage Admin (roles/serviceusage.serviceUsageAdmin), um die Einrichtung durchzuführen.
    • SaaS Service Management Admin (roles/saasservicemgmt.admin)
    • Developer Connect-Administrator (roles/developerconnect.admin)
    • Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin) oder Sicherheitsadministrator (roles/iam.securityAdmin), um Dienstkonten zu erstellen und IAM-Rollen zuzuweisen.
    • Cloud Run-Administrator (roles/run.admin)
    • Storage-Administrator (roles/storage.admin)
    • Service Account Admin (roles/iam.serviceAccountAdmin)
  9. Installieren Sie die Google Cloud CLI und initialisieren Sie sie:
    gcloud init
    Prüfen Sie, ob die beta-Komponenten installiert sind:
    gcloud components install beta
  10. Schließen Sie die Einrichtung des Application Design Center für Ihr Projekt mit einer Anwendungsverwaltungsgrenze für ein einzelnes Projekt ab. Bei der Einrichtung wird die Anwendungsverwaltung aktiviert, ein Storage-Bucket für Terraform bereitgestellt und der Space default-space sowie der Katalog default-catalog erstellt.
  11. Installieren Sie Git auf Ihrem lokalen Computer.
  12. Sie benötigen ein GitHub-Konto mit Berechtigungen zum Erstellen von Repositories und Generieren von persönlichen Zugriffstokens.

Umgebung und Quell-Repository einrichten

Um Ihre Umgebung für diese Anleitung einzurichten, geben Sie Variablenwerte an und konfigurieren Sie Ihr GitHub-Repository.

Variablen für die Anleitung angeben

Legen Sie Variablen in dieser Anleitung und in Ihrem Befehlsterminal fest.

  1. Legen Sie die folgenden Variablen fest, um die Befehle in dieser Anleitung zu aktualisieren:

    Variable Beschreibung Wert
    PROJECT_ID Ihre Projekt-ID in Google Cloud PROJECT_ID
    REGION Bereitstellungsregion für App Design Center-Ressourcen, Developer Connect, App Lifecycle Manager-Angebote und Mandanteninfrastruktur us-central1
  2. Konfigurieren Sie im Befehlsterminal das aktive Google Cloud Projekt:

    gcloud config set project PROJECT_ID
    
  3. Rufen Sie Ihre Google Cloud -Projektnummer ab und speichern Sie sie in einer Umgebungsvariablen:

    PROJECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
    

Terraform-Konfigurationsdateien erstellen

Modulare Terraform-Definitionen für Cloud Run und Cloud Storage erstellen Diese Module importieren Sie später in App Design Center, um sie in wiederverwendbare Architekturkomponenten zu verpacken.

  1. Erstellen Sie eine lokale Verzeichnisstruktur für Ihre Terraform-Module:

    mkdir -p adc-alm-starter/infra/cloud-run
    mkdir -p adc-alm-starter/infra/cloud-storage
    cd adc-alm-starter
    
  2. Erstellen Sie in infra/cloud-run/main.tf die Cloud Run-Moduldefinition:

    terraform {
      required_version = ">= 1.5.0"
      required_providers {
        google = {
          source  = "hashicorp/google"
          version = ">= 5.0.0"
        }
      }
    }
    
    variable "project_id" {
      type        = string
      description = "The Google Cloud project ID."
    }
    
    variable "region" {
      type        = string
      description = "The deployment region."
      default     = "us-central1"
    }
    
    variable "service_name" {
      type        = string
      description = "Name of the Cloud Run service."
      default     = "sample-app"
    }
    
    variable "bucket_name" {
      type        = string
      description = "Name of the Cloud Storage bucket to connect."
      default     = ""
    }
    
    resource "google_service_account" "app_sa" {
      account_id   = "${var.service_name}-sa"
      display_name = "Service Account for ${var.service_name}"
      project      = var.project_id
    }
    
    resource "google_cloud_run_v2_service" "app_service" {
      name                = var.service_name
      location            = var.region
      project             = var.project_id
      deletion_protection = false
    
      template {
        service_account = google_service_account.app_sa.email
        containers {
          image = "us-docker.pkg.dev/cloudrun/container/hello"
          env {
            name  = "STORAGE_BUCKET"
            value = var.bucket_name
          }
          resources {
            limits = {
              cpu    = "1"
              memory = "512Mi"
            }
          }
        }
      }
    }
    
    output "service_url" {
      description = "URL of the deployed Cloud Run service."
      value       = google_cloud_run_v2_service.app_service.uri
    }
    
    output "service_account_email" {
      description = "Email of the Cloud Run service account."
      value       = google_service_account.app_sa.email
    }
    
  3. Erstellen Sie in infra/cloud-run/metadata.yaml die Metadatendefinition des Moduls:

    apiVersion: blueprints.cloud.google.com/v1alpha1
    kind: BlueprintMetadata
    metadata:
      name: cloud-run-component
    spec:
      info:
        title: Cloud Run Component
        version: 0.1.0
        actuationTool:
          flavor: Terraform
          version: ">= 1.5.0"
      interfaces:
        variables:
          - name: project_id
            description: The Google Cloud project ID.
            varType: string
            required: true
          - name: region
            description: The deployment region.
            varType: string
            defaultValue: us-central1
          - name: service_name
            description: Name of the Cloud Run service.
            varType: string
            defaultValue: sample-app
          - name: bucket_name
            description: Name of the Cloud Storage bucket to connect.
            varType: string
            defaultValue: ""
        outputs:
          - name: service_url
            description: URL of the deployed Cloud Run service.
          - name: service_account_email
            description: Email of the Cloud Run service account.
    
  4. Erstellen Sie in infra/cloud-storage/main.tf die Cloud Storage-Moduldefinition:

    terraform {
      required_version = ">= 1.5.0"
      required_providers {
        google = {
          source  = "hashicorp/google"
          version = ">= 5.0.0"
        }
        random = {
          source  = "hashicorp/random"
          version = ">= 3.5.0"
        }
      }
    }
    
    variable "project_id" {
      type        = string
      description = "The Google Cloud project ID."
    }
    
    variable "region" {
      type        = string
      description = "The deployment region."
      default     = "us-central1"
    }
    
    variable "bucket_name_prefix" {
      type        = string
      description = "Prefix for the Cloud Storage bucket."
      default     = "app-data"
    }
    
    variable "writer_service_account" {
      type        = string
      description = "Service account email granted objectAdmin permissions."
      default     = ""
    }
    
    resource "random_id" "bucket_suffix" {
      byte_length = 4
    }
    
    resource "google_storage_bucket" "bucket" {
      name                        = "${var.bucket_name_prefix}-${random_id.bucket_suffix.hex}"
      location                    = var.region
      project                     = var.project_id
      uniform_bucket_level_access = true
      force_destroy               = true
    }
    
    resource "google_storage_bucket_iam_member" "writer_grant" {
      count  = var.writer_service_account != "" ? 1 : 0
      bucket = google_storage_bucket.bucket.name
      role   = "roles/storage.objectAdmin"
      member = "serviceAccount:${var.writer_service_account}"
    }
    
    output "bucket_name" {
      description = "Name of the created storage bucket."
      value       = google_storage_bucket.bucket.name
    }
    
  5. Erstellen Sie in infra/cloud-storage/metadata.yaml die Metadatendefinition des Moduls:

    apiVersion: blueprints.cloud.google.com/v1alpha1
    kind: BlueprintMetadata
    metadata:
      name: cloud-storage-component
    spec:
      info:
        title: Cloud Storage Component
        version: 0.1.0
        actuationTool:
          flavor: Terraform
          version: ">= 1.5.0"
      interfaces:
        variables:
          - name: project_id
            description: The Google Cloud project ID.
            varType: string
            required: true
          - name: region
            description: The deployment region.
            varType: string
            defaultValue: us-central1
          - name: bucket_name_prefix
            description: Prefix for the Cloud Storage bucket.
            varType: string
            defaultValue: app-data
          - name: writer_service_account
            description: Service account email granted objectAdmin permissions.
            varType: string
            defaultValue: ""
        outputs:
          - name: bucket_name
            description: Name of the created storage bucket.
    

Terraform an GitHub übertragen

Übertragen Sie Ihre Terraform-Konfigurationen in ein GitHub-Repository und verbinden Sie das Repository über Developer Connect mit Google Cloud . Über die Verbindung erhält das App Design Center sicheren Zugriff, um Infrastrukturüberarbeitungen direkt aus der Versionsverwaltung zu importieren.

  1. Erstellen Sie in einem Webbrowser ein neues GitHub-Repository mit dem Namen adc-alm-starter.

  2. Erstellen Sie in GitHub ein detailliertes persönliches Zugriffstoken, um Ihren git push-Befehl zu authentifizieren. Wählen Sie das Repository adc-alm-starter aus und gewähren Sie die Berechtigungen Inhalte: Lesen und Schreiben.

  3. Initialisieren Sie Git im Verzeichnis adc-alm-starter, führen Sie einen Commit für die Dateien durch und übertragen Sie sie per Push an GitHub:

    cd adc-alm-starter
    git init
    git add infra/
    git commit -m "feat: initialize Cloud Run and Cloud Storage modules"
    git branch -M main
    git remote add origin https://github.com/GITHUB_USER_OR_ORG/adc-alm-starter.git
    git push -u origin main
    

    Wenn Sie zur Authentifizierung aufgefordert werden, geben Sie Ihren GitHub-Nutzernamen und Ihr persönliches Zugriffstoken ein.

  4. Rufen Sie in der Google Cloud Console die Seite Developer Connect auf:

    Zu Developer Connect

  5. Erstellen Sie in der Region us-central1 eine Verbindung für Ihr GitHub-Konto und verknüpfen Sie Ihr Repository. Eine ausführliche Anleitung finden Sie unter Verbindung zu GitHub herstellen.

  6. Ermitteln Sie die Verbindungs-ID und die Git-Repository-Link-ID für das verknüpfte Repository und aktualisieren Sie die folgenden Variablen:

    • CONNECTION_ID: Die Developer Connect-Verbindungskennung.
    • GIT_REPO_LINK_ID: Die Kennung des verknüpften Git-Repositorys.

Vorlagen in App Design Center erstellen

Wenn Sie Ihre Google Cloud -Infrastruktur entwerfen möchten, importieren Sie Terraform-Module als Komponentenvorlagen in das App Design Center. Erstellen Sie dann eine zusammengesetzte Anwendungsvorlage, die die Komponenten enthält.

Space und Katalog bestätigen

Wenn Sie die Einrichtung des App Design Centers in der Google Cloud Console abgeschlossen haben, wurden Ihr Standard-Space und Ihr Standardkatalog automatisch erstellt.

Wenn Sie die Einrichtung mit der gcloud CLI abgeschlossen haben, gehen Sie so vor:

  1. Prüfen Sie, ob default-space in Ihrer Region vorhanden ist:

    gcloud design-center spaces describe "default-space" \
        --location="us-central1"
    

    Ersetzen Sie default-space durch die ID Ihres App Design Center-Space.

  2. Wenn der Space nicht vorhanden ist, erstellen Sie ihn und den Katalog:

    gcloud design-center spaces create "default-space" \
        --location="us-central1" \
        --display-name="Default Space"
    
    gcloud design-center spaces catalogs create "default-catalog" \
        --space="default-space" \
        --location="us-central1" \
        --display-name="Default Catalog"
    

    Ersetzen Sie default-catalog durch Ihre Katalog-ID.

Komponentenvorlagen erstellen

Mit Komponentenvorlagen werden einzelne Terraform-Module in Bausteine umgewandelt, die Sie Anwendungsvorlagen mit mehreren Diensten hinzufügen können.

Erstellen Sie Komponentenvorlagen basierend auf den Terraform-Modulen in Ihrem Git-Repository:

  1. Erstellen Sie eine Katalogvorlage für Cloud Run:

    gcloud design-center spaces catalogs templates create "cloud-run-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --display-name="Cloud Run Component" \
        --template-category=component-template
    

    Ersetzen Sie cloud-run-component durch die Kennung für die Cloud Run-Komponentenvorlage.

  2. Erstellen Sie eine Katalogvorlage für Cloud Storage:

    gcloud design-center spaces catalogs templates create "cloud-storage-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --display-name="Cloud Storage Component" \
        --template-category=component-template
    

    Ersetzen Sie cloud-storage-component durch die Kennung der Cloud Storage-Komponentenvorlage.

  3. Erstellen Sie eine Vorlagenversion, indem Sie das Cloud Run-Terraform-Modul aus Ihrem Git-Repository importieren:

    gcloud design-center spaces catalogs templates revisions create r-1 \
        --template="cloud-run-component" \
        --catalog="default-catalog" \
        --space="default-space" \
        --location="us-central1" \
        --developer-connect-repo="projects/PROJECT_ID/locations/us-central1/connections/CONNECTION_ID/gitRepositoryLinks/GIT_REPO_LINK_ID" \
        --developer-connect-repo-dir="infra/cloud-run" \
        --developer-connect-repo-ref="refs/heads/main"
    

    Ersetzen Sie Folgendes:

    • CONNECTION_ID: Ihre Developer Connect-Verbindungs-ID.
    • GIT_REPO_LINK_ID: die Verknüpfungs-ID Ihres verknüpften Git-Repositorys.
  4. Erstellen Sie eine Vorlagenversion, indem Sie das Cloud Storage-Terraform-Modul aus Ihrem Git-Repository importieren:

    gcloud design-center spaces catalogs templates revisions create r-1 \
        --template="cloud-storage-component" \
        --catalog="default-catalog" \
        --space="default-space" \
        --location="us-central1" \
        --developer-connect-repo="projects/PROJECT_ID/locations/us-central1/connections/CONNECTION_ID/gitRepositoryLinks/GIT_REPO_LINK_ID" \
        --developer-connect-repo-dir="infra/cloud-storage" \
        --developer-connect-repo-ref="refs/heads/main"
    

    Ersetzen Sie Folgendes:

    • CONNECTION_ID: Ihre Developer Connect-Verbindungs-ID.
    • GIT_REPO_LINK_ID: die Verknüpfungs-ID Ihres verknüpften Git-Repositorys.
  5. Listen Sie die geteilten Vorlagen in Ihrem Gruppenbereich auf, um die IDs der geteilten Vorlagen abzurufen:

    gcloud design-center spaces shared-templates list \
        --space="default-space" \
        --location="us-central1"
    

    Notieren Sie sich in der Befehlsausgabe das Segment SHARED_TEMPLATE_ID aus dem Feld name (projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/SHARED_TEMPLATE_ID) für cloud-run-component und cloud-storage-component.

Zusammengesetzte Anwendungsvorlage erstellen

Kombinieren Sie Ihre Komponentenvorlagen zu einer zusammengesetzten Anwendungsvorlage und konfigurieren Sie Parameterverbindungen. App Lifecycle Manager verwendet zusammengesetzte Vorlagen, um Ihre Anwendungstopologie als SaaS-Angebot zu verwalten. Sie geben Ausgaben und Eingaben an, damit der Cloud Run-Dienst automatisch den Bucket-Namen und die erforderlichen IAM-Berechtigungen für den Zugriff auf Cloud Storage erhält.

  1. Zusammengesetzte Anwendungsvorlage erstellen:

    gcloud design-center spaces application-templates create "run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --display-name="Cloud Run and Storage Multi-Tenant Application" \
        --composition-type=composite
    

    Ersetzen Sie run-storage-app durch die Kennung Ihrer zusammengesetzten Anwendungsvorlage.

  2. Fügen Sie die Cloud Run-Komponente zur Anwendungsvorlage hinzu:

    gcloud design-center spaces application-templates components create cloud-run-comp \
        --application-template="run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --shared-template-revision-uri="projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/RUN_SHARED_TEMPLATE_ID/revisions/r-1"
    

    Ersetzen Sie RUN_SHARED_TEMPLATE_ID durch die abgerufene ID der geteilten Vorlage cloud-run-component.

  3. Fügen Sie der Anwendungsvorlage die Cloud Storage-Komponente hinzu:

    gcloud design-center spaces application-templates components create cloud-storage-comp \
        --application-template="run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --shared-template-revision-uri="projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/STORAGE_SHARED_TEMPLATE_ID/revisions/r-1"
    

    Ersetzen Sie STORAGE_SHARED_TEMPLATE_ID durch die abgerufene ID der geteilten Vorlage cloud-storage-component.

  4. Erstellen Sie eine Verbindung vom Cloud Run-Dienst zum Cloud Storage-Bucket. Dadurch wird die Bucket-Ausgabe mit der Dienstumgebungsvariablen verknüpft und dem Dienstkonto IAM-Zugriff gewährt:

    gcloud design-center spaces application-templates components connections create run-to-storage \
        --component=cloud-run-comp \
        --application-template="run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --destination-component-uri="projects/PROJECT_ID/locations/us-central1/spaces/default-space/applicationTemplates/run-storage-app/components/cloud-storage-comp" \
        --source-component-parameters='[{"key": "bucket_name", "value": "module.cloud-storage-comp.bucket_name"}]' \
        --destination-component-parameters='[{"key": "writer_service_account", "value": "module.cloud-run-comp.service_account_email"}]'
    
  5. Übernehmen Sie die Anwendungsvorlage, um eine unveränderliche Vorlagenversion zu generieren:

    gcloud design-center spaces application-templates commit "run-storage-app" \
        --space="default-space" \
        --location="us-central1"
    

    Die Befehlsausgabe bestätigt die generierte Versions-ID (z. B. r-1), auf die Sie beim Erstellen Ihres SaaS-Angebots im App Lifecycle Manager verweisen.


Kundenumgebungen mit App Lifecycle Manager bereitstellen

Mit App Lifecycle Manager können Sie Ihre Anwendungsvorlage in ein bereitstellbares Produkt umwandeln und dedizierte Umgebungen für jeden Kunden bereitstellen.

Anwendungsvorlage verpacken

Registrieren Sie Ihre Vorlagenversion bei App Lifecycle Manager, um ein bereitstellbares SaaS-Angebot zu erstellen:

  1. Erstellen Sie das SaaS-Angebot in us-central1:

    gcloud beta app-lifecycle-manager saas create "saas-run-storage" \
        --location="us-central1" \
        --locations=name="us-central1" \
        --application-template="projects/PROJECT_ID/locations/us-central1/spaces/default-space/applicationTemplates/run-storage-app" \
        --application-template-revision="projects/PROJECT_ID/locations/us-central1/spaces/default-space/applicationTemplates/run-storage-app/revisions/r-1"
    

    Ersetzen Sie saas-run-storage durch die Kennung Ihres SaaS-Angebots.

  2. Listen Sie die generierten Releases auf, um die Veröffentlichungs-ID, die Art der Einheit und die Eingabevariablen abzurufen:

    gcloud beta app-lifecycle-manager releases list \
        --location="us-central1"
    

    App Lifecycle Manager erstellt und verpackt den Blueprint der zusammengesetzten Vorlage asynchron. Wenn die Liste leer ist, warten Sie einige Minuten und führen Sie den Befehl noch einmal aus.

    Der Befehl gibt die folgenden Informationen aus:

    • Das Feld name (z. B. projects/PROJECT_ID/locations/us-central1/releases/r-r-1-06c6a0). Das letzte Segment ist Ihre RELEASE_ID (z. B. r-r-1-06c6a0).
    • Das Feld unitKind (z. B. projects/PROJECT_ID/locations/us-central1/unitKinds/u-native-components-e97e0c). Das letzte Segment ist Ihre UNIT_KIND_ID (z. B. u-native-components-e97e0c).

Dienstkonto für die Bereitstellung erstellen

Erstellen Sie ein Dienstkonto, das App Lifecycle Manager die Berechtigung erteilt, Ressourcen in Ihrem Namen bereitzustellen:

  1. Erstellen Sie das Dienstkonto für die Benutzerinteraktion:

    gcloud iam service-accounts create "tenant-actuation-sa" \
        --display-name="Tenant Actuation Service Account"
    

    Ersetzen Sie tenant-actuation-sa durch den Namen Ihres Dienstkontos für die simulierte Benutzerinteraktion.

  2. Erstellen Sie die E‑Mail-Adresse des Dienstkontos und rufen Sie die Identität des App Lifecycle Manager-Dienst-Agents ab:

    ACTUATION_SA="tenant-actuation-sa@PROJECT_ID.iam.gserviceaccount.com"
    ALM_P4SA="service-${PROJECT_NUM}@gcp-sa-saasservicemgmt.iam.gserviceaccount.com"
    INFRA_MANAGER_P4SA="service-${PROJECT_NUM}@gcp-sa-config.iam.gserviceaccount.com"
    
  3. Weisen Sie dem Dienstkonto für die simulierte Benutzerinteraktion die erforderlichen Rollen zum Erstellen und Verwalten der Mandanteninfrastruktur zu:

    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/run.admin" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/storage.admin" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/iam.serviceAccountAdmin" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/iam.serviceAccountUser" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/config.admin" \
        --condition=None
    
  4. Gewähren Sie den Dienst-Agents von App Lifecycle Manager und Infra Manager die Berechtigung, die Identität des Dienstkontos für die simulierte Benutzerinteraktion zu übernehmen:

    gcloud iam service-accounts add-iam-policy-binding "${ACTUATION_SA}" \
        --member="serviceAccount:${ALM_P4SA}" \
        --role="roles/iam.serviceAccountUser" \
        --condition=None
    
    gcloud iam service-accounts add-iam-policy-binding "${ACTUATION_SA}" \
        --member="serviceAccount:${ALM_P4SA}" \
        --role="roles/iam.serviceAccountTokenCreator" \
        --condition=None
    
    gcloud iam service-accounts add-iam-policy-binding "${ACTUATION_SA}" \
        --member="serviceAccount:${INFRA_MANAGER_P4SA}" \
        --role="roles/iam.serviceAccountUser" \
        --condition=None
    

Umgebung für einen Kunden bereitstellen

Erstellen Sie eine Kundenumgebung und lösen Sie die Bereitstellung der dedizierten Infrastruktur aus:

  1. Erstellen Sie mit der generierten Art der Einheit eine Umgebung Unit, die einen isolierten Kundenmandanten darstellt:

    gcloud beta app-lifecycle-manager units create "tenant-1" \
        --location="us-central1" \
        --unit-kind="UNIT_KIND_ID"
    

    Ersetzen Sie tenant-1 durch die Kennung Ihrer Mandanteneinheit.

  2. Lösen Sie einen Einheitenvorgang aus, um die Mandanteninfrastruktur bereitzustellen:

    gcloud beta app-lifecycle-manager unit-operations create provision-tenant-1 \
        --location="us-central1" \
        --unit="projects/PROJECT_ID/locations/us-central1/units/tenant-1" \
        --provision \
        --provision-release="RELEASE_ID" \
        --provision-input-variables=variable=project_id,value="PROJECT_ID",type=string \
        --provision-input-variables=variable=project_number,value="${PROJECT_NUM}",type=string \
        --provision-input-variables=variable=actuation_sa,value="${ACTUATION_SA}",type=string \
        --provision-input-variables=variable=cloud-run-comp_project_id,value="PROJECT_ID",type=string \
        --provision-input-variables=variable=cloud-run-comp_region,value="us-central1",type=string \
        --provision-input-variables=variable=cloud-storage-comp_project_id,value="PROJECT_ID",type=string \
        --provision-input-variables=variable=cloud-storage-comp_region,value="us-central1",type=string
    
  3. Beschreiben Sie den Einheitenvorgang, um den Bereitstellungsstatus zu überwachen, bis er SUCCEEDED erreicht:

    gcloud beta app-lifecycle-manager unit-operations describe provision-tenant-1 \
        --location="us-central1"
    

Updates in Kundenumgebungen automatisieren

Mit Roll-outs können Sie Anwendungsupdates sicher in allen Kundenumgebungen bereitstellen.

Aktualisierungsstrategie auswählen

Legen Sie fest, wie Updates an Kundenumgebungen bereitgestellt werden, z. B. alle auf einmal oder in Phasen:

  1. Erstellen Sie eine RolloutKind, um die Orchestrierungsstrategie für Ihre Einheiten zu definieren:

    gcloud beta app-lifecycle-manager rollout-kinds create "progressive-rollout" \
        --location="us-central1" \
        --unit-kind="projects/PROJECT_ID/locations/us-central1/unitKinds/UNIT_KIND_ID" \
        --rollout-orchestration-strategy="Google.Cloud.Simple.AllAtOnce"
    

    Ersetzen Sie progressive-rollout durch die Kennung der Roll-out-Art.

Update bereitstellen und verfolgen

Starten Sie den Roll-out und beobachten Sie den Fortschritt, bis die Bereitstellung abgeschlossen ist:

  1. Lösen Sie den Roll-out aus, um Ihren Release auf berechtigte Mandanteneinheiten bereitzustellen:

    gcloud beta app-lifecycle-manager rollouts create "rollout-v1" \
        --location="us-central1" \
        --rollout-kind="projects/PROJECT_ID/locations/us-central1/rolloutKinds/progressive-rollout" \
        --release="projects/PROJECT_ID/locations/us-central1/releases/RELEASE_ID"
    

    Ersetzen Sie rollout-v1 durch die Kennung für Ihren Roll-out.

  2. Beschreiben Sie den Roll-out, um die aktive Ausführung zu prüfen und zu bestätigen, dass der Status SUCCEEDED erreicht:

    gcloud beta app-lifecycle-manager rollouts describe "rollout-v1" \
        --location="us-central1"
    

    Die Roll-out-Ausgabe bestätigt, dass Ihre Mandanteneinheiten auf die Zielvorlagenversion aktualisiert wurden.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

Google Cloud -Projekt löschen:

gcloud projects delete PROJECT_ID

Einzelne Ressourcen löschen

Wenn Sie die Ressourcen der Anleitung in einem vorhandenen Projekt bereitgestellt haben, löschen Sie die einzelnen Ressourcen in umgekehrter Abhängigkeitsreihenfolge, um unerwartete Abrechnungen zu vermeiden:

  1. Heben Sie die Bereitstellung der Infrastruktur der Kundenumgebung auf und warten Sie, bis der Vorgang abgeschlossen ist:

    gcloud beta app-lifecycle-manager unit-operations create deprovision-tenant-1 \
        --location="us-central1" \
        --unit="projects/PROJECT_ID/locations/us-central1/units/tenant-1" \
        --deprovision
    
    gcloud beta app-lifecycle-manager unit-operations describe deprovision-tenant-1 \
        --location="us-central1"
    
  2. Löschen Sie die App Lifecycle Manager-Kundenumgebung:

    gcloud beta app-lifecycle-manager units delete "tenant-1" \
        --location="us-central1" \
        --quiet
    
  3. Löschen Sie den App Lifecycle Manager-Roll-out und die Release-Ressourcen in umgekehrter Abhängigkeitsreihenfolge:

    gcloud beta app-lifecycle-manager rollouts delete "rollout-v1" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager rollout-kinds delete "progressive-rollout" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager releases delete "RELEASE_ID" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager unit-kinds delete "UNIT_KIND_ID" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager saas delete "saas-run-storage" \
        --location="us-central1" \
        --quiet
    
  4. Löschen Sie die Anwendungsvorlage, die Katalogeinträge und den Bereich des App Design Centers:

    gcloud design-center spaces application-templates delete "run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --force \
        --quiet
    
    gcloud design-center spaces catalogs templates delete "cloud-run-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --force \
        --quiet
    
    gcloud design-center spaces catalogs templates delete "cloud-storage-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --force \
        --quiet
    
    gcloud design-center spaces delete "default-space" \
        --location="us-central1" \
        --force \
        --quiet
    
  5. Löschen Sie den Git-Repository-Link und die Verbindung von Developer Connect:

    gcloud developer-connect connections git-repository-links delete "GIT_REPO_LINK_ID" \
        --connection="CONNECTION_ID" \
        --location="us-central1" \
        --quiet
    
    gcloud developer-connect connections delete "CONNECTION_ID" \
        --location="us-central1" \
        --quiet
    
  6. Löschen Sie das Dienstkonto für die Benutzerinteraktion:

    gcloud iam service-accounts delete "${ACTUATION_SA}" \
        --quiet
    

Nächste Schritte