תכנון ופריסה של מוצרי SaaS

בעזרת Application Design Center ו-App Lifecycle Manager אתם יכולים ליצור סטנדרטיזציה ולהרחיב את ההפצה של SaaS עם כמה דיירים, בלי להגדיר ידנית את התשתית לכל לקוח. אתם יכולים לאסוף מודולים של Terraform לשימוש חוזר בתבניות של אפליקציות מורכבות ב-App Design Center, ואז לארוז את התבניות האלה בהצעות SaaS מנוהלות ב-App Lifecycle Manager.

במדריך הזה תלמדו איך להקצות סביבות מבודדות לדיירים, ואיך להפוך את העדכונים וההשקות ההדרגתיים לאוטומטיים. תהליך העבודה הזה מיועד למהנדסי פלטפורמות, לאדריכלים ארגוניים ולמפעילי DevOps.

מטרות

  • מכינים מאגר ב-GitHub שמכיל מודולים של Terraform ל-Cloud Run ול-Cloud Storage.
  • מקשרים את המאגר ב-GitHub אל Google Cloud באמצעות Developer Connect.
  • מייבאים את המודולים של Terraform כדי ליצור ולקטלג תבניות של רכיבים ב-App Design Center.
  • מעצבים תבנית של אפליקציה מורכבת שכוללת את תבניות הרכיבים.
  • אורזים את התבנית ופורסים סביבת לקוח ב-App Lifecycle Manager.
  • אוטומציה של השקות הדרגתיות בסביבות הלקוחות.

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

בעזרת מחשבון העלויות אתם יכולים להעריך את העלויות בהתאם לשימוש הצפוי.

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

כשמסיימים את המשימות שמתוארות במסמך הזה אפשר למחוק את המשאבים שיצרתם כדי להימנע מחיובים נוספים. מידע נוסף זמין בקטע הסרת המשאבים.

לפני שמתחילים

  1. נכנסים לחשבון Google Cloud . אנחנו ממליצים למשתמשים חדשים ב- Google Cloudליצור חשבון כדי שיוכלו להעריך את הביצועים של המוצרים שלנו בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300$ להרצה, לבדיקה ולפריסה של עומסי העבודה.
  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. מוודאים שיש לכם את התפקידים הבאים של ניהול זהויות והרשאות גישה (IAM) בפרויקט:
    • אדמין של Application Design Center (roles/designcenter.admin) ואדמין של שימוש בשירות (roles/serviceusage.serviceUsageAdmin) כדי לבצע את ההגדרה.
    • אדמין של ניהול שירות SaaS ‏(roles/saasservicemgmt.admin)
    • אדמין ב-Developer Connect ‏(roles/developerconnect.admin)
    • אדמין IAM בפרויקט (roles/resourcemanager.projectIamAdmin) או אדמין אבטחה (roles/iam.securityAdmin) כדי ליצור חשבונות שירות ולהקצות תפקידי IAM.
    • אדמין ב-Cloud Run‏ (roles/run.admin)
    • אדמין באחסון (roles/storage.admin)
    • אדמין בחשבון שירות (roles/iam.serviceAccountAdmin)
  9. מתקינים את Google Cloud CLI ומפעילים אותו:
    gcloud init
    מוודאים שהרכיבים של beta מותקנים:
    gcloud components install beta
  10. מגדירים את Application Design Center בפרויקט באמצעות תחום לניהול אפליקציות בפרויקט יחיד. ההגדרה מאפשרת ניהול אפליקציות, מקצה קטגוריית אחסון ל-Terraform ויוצרת את המרחב של default-space ואת הקטלוג של default-catalog.
  11. מתקינים את Git במחשב המקומי.
  12. מוודאים שיש לכם חשבון GitHub עם הרשאות ליצור מאגרים וליצור טוקני גישה אישיים.

הגדרת הסביבה ומאגר המקור

כדי להגדיר את הסביבה למדריך הזה, צריך לציין ערכי משתנים ולהגדיר את המאגר ב-GitHub.

הגדרת משתני המדריך

מגדירים משתנים במדריך הזה ובטרמינל הפקודות.

  1. מגדירים את המשתנים הבאים כדי לעדכן את הפקודות במדריך הזה:

    משתנה תיאור ערך
    PROJECT_ID מזהה הפרויקט ב- Google Cloud PROJECT_ID
    REGION אזור הפריסה של משאבי App Design Center,‏ Developer Connect,‏ App Lifecycle Manager ותשתית הדייר (tenant) us-central1
  2. במסוף הפקודות, מגדירים את הפרויקט הפעיל ב- Google Cloud :

    gcloud config set project PROJECT_ID
    
  3. מאחזרים את Google Cloud מספר הפרויקט ושומרים אותו במשתנה סביבה:

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

יצירת קובצי תצורה של Terraform

יצירת הגדרות מודולריות של Terraform ל-Cloud Run ול-Cloud Storage. בהמשך תייבאו את המודולים האלה ל-App Design Center כדי לארוז אותם לרכיבים ארכיטקטוניים שאפשר לעשות בהם שימוש חוזר.

  1. יוצרים מבנה של ספרייה מקומית למודולים של Terraform:

    mkdir -p adc-alm-starter/infra/cloud-run
    mkdir -p adc-alm-starter/infra/cloud-storage
    cd adc-alm-starter
    
  2. ב-infra/cloud-run/main.tf, יוצרים את הגדרת המודול של Cloud Run:

    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. ב-infra/cloud-run/metadata.yaml, יוצרים את הגדרת המטא-נתונים של המודול:

    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. ב-infra/cloud-storage/main.tf, יוצרים את הגדרת המודול של Cloud Storage:

    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. ב-infra/cloud-storage/metadata.yaml, יוצרים את הגדרת המטא-נתונים של המודול:

    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 ל-GitHub

שולחים את הגדרות Terraform למאגר ב-GitHub ומחברים את המאגר ל- Google Cloud באמצעות Developer Connect. החיבור מאפשר ל-App Design Center גישה מאובטחת לייבוא גרסאות תשתית ישירות מבקרת המקור.

  1. בדפדפן אינטרנט, יוצרים מאגר חדש ב-GitHub בשם adc-alm-starter.

  2. יוצרים טוקן גישה אישי מפורט ב-GitHub כדי לאמת את הפקודה git push. בוחרים את המאגר adc-alm-starter ונותנים הרשאות Contents: Read and write.

  3. בטרמינל הפקודות, מפעילים את Git בספרייה adc-alm-starter, מבצעים commit לקבצים ודוחפים אותם ל-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
    

    כשמופיעה בקשה לאימות, מזינים את שם המשתמש ב-GitHub ואת טוקן הגישה האישי.

  4. נכנסים לדף Developer Connect במסוף Google Cloud :

    כניסה ל-Developer Connect

  5. יוצרים חיבור באזור us-central1 לחשבון ב-GitHub ומקשרים את המאגר. להוראות מפורטות, קראו את המאמר התחברות ל-GitHub.

  6. מזהים את מזהה החיבור ואת מזהה הקישור למאגר Git של המאגר המקושר, ומעדכנים את המשתנים הבאים:

    • ‫CONNECTION_ID: המזהה של חיבור Developer Connect.
    • ‫GIT_REPO_LINK_ID: המזהה של מאגר Git המקושר.

יצירת תבניות ב-App Design Center

כדי לתכנן את התשתית של Google Cloud , מייבאים מודולים של Terraform ל-App Design Center כתבניות של רכיבים. לאחר מכן יוצרים תבנית אפליקציה מורכבת שכוללת את הרכיבים.

אימות המרחב והקטלוג

אם השלמתם את ההגדרה של App Design Center במסוף Google Cloud , המרחב והקטלוג שמוגדרים כברירת מחדל נוצרו באופן אוטומטי.

אם השלמתם את ההגדרה באמצעות ה-CLI של gcloud, בצעו את הפעולות הבאות:

  1. מוודאים שהשירות default-space זמין באזור שלכם:

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

    מחליפים את default-space במזהה המרחב ב-App Design Center.

  2. אם המרחב לא קיים, יוצרים את המרחב ואת הקטלוג:

    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"
    

    מחליפים את default-catalog במזהה הקטלוג.

יצירת תבניות של רכיבים

תבניות של רכיבים הופכות מודולים נפרדים של Terraform לאבני בניין שאפשר להוסיף לתבניות של אפליקציות עם כמה שירותים.

יוצרים תבניות של רכיבים על סמך המודולים של Terraform במאגר Git:

  1. יצירת תבנית קטלוג ל-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
    

    מחליפים את cloud-run-component במזהה של תבנית הרכיב של Cloud Run.

  2. יצירת תבנית קטלוג ל-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
    

    מחליפים את cloud-storage-component במזהה של תבנית הרכיב של Cloud Storage.

  3. יוצרים גרסה של תבנית על ידי ייבוא המודול של Cloud Run Terraform ממאגר Git:

    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"
    

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫CONNECTION_ID: מזהה החיבור של Developer Connect.
    • ‫GIT_REPO_LINK_ID: מזהה הקישור של מאגר Git המקושר.
  4. יוצרים גרסה של התבנית על ידי ייבוא המודול של Cloud Storage Terraform ממאגר Git:

    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"
    

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫CONNECTION_ID: מזהה החיבור של Developer Connect.
    • ‫GIT_REPO_LINK_ID: מזהה הקישור של מאגר Git המקושר.
  5. מציגים את רשימת התבניות המשותפות במרחב המשותף כדי לאחזר את המזהים שלהן:

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

    בפלט הפקודה, מאתרים את הקטע SHARED_TEMPLATE_ID מהשדה name (projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/SHARED_TEMPLATE_ID) גם ל-cloud-run-component וגם ל-cloud-storage-component.

יצירת תבנית של אפליקציה מורכבת

משלבים את תבניות הרכיבים בתבנית אפליקציה מורכבת ומגדירים את החיבורים של הפרמטרים. ‫App Lifecycle Manager משתמש בתבניות מורכבות כדי לנהל את הטופולוגיה של האפליקציה כהצעת SaaS. מציינים פלט וקלט כדי לוודא ששירות Cloud Run יקבל באופן אוטומטי את שם הקטגוריה ואת הרשאות ה-IAM הנדרשות כדי לגשת ל-Cloud Storage.

  1. יצירת תבנית של אפליקציה מורכבת:

    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
    

    מחליפים את run-storage-app במזהה של תבנית האפליקציה המשולבת.

  2. מוסיפים את רכיב Cloud Run לתבנית האפליקציה:

    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"
    

    מחליפים את RUN_SHARED_TEMPLATE_ID במזהה התבנית המשותפת של cloud-run-component שאחזרתם.

  3. מוסיפים את הרכיב של Cloud Storage לתבנית של האפליקציה:

    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"
    

    מחליפים את STORAGE_SHARED_TEMPLATE_ID במזהה התבנית המשותפת של cloud-storage-component שאחזרתם.

  4. יוצרים חיבור משירות Cloud Run לקטגוריה של Cloud Storage. הפעולה הזו מקשרת את הפלט של הקטגוריה למשתנה הסביבה של השירות, ומעניקה לחשבון השירות גישה ל-IAM:

    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. מבצעים commit לתבנית האפליקציה כדי ליצור גרסה של תבנית שלא ניתנת לשינוי:

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

    פלט הפקודה מאשר את מזהה הגרסה שנוצר (למשל r-1), שאליו תתייחסו כשתצרו את מוצר ה-SaaS ב-App Lifecycle Manager.


פריסת סביבות של לקוחות באמצעות App Lifecycle Manager

אתם יכולים להשתמש ב-App Lifecycle Manager כדי להפוך את תבנית האפליקציה למוצר שניתן לפריסה, ולהקצות סביבות ייעודיות לכל לקוח.

אריזת תבנית האפליקציה

כדי ליצור מוצר SaaS שניתן לפרוס, צריך לרשום את גרסת התבנית ב-App Lifecycle Manager:

  1. יוצרים את מוצר ה-SaaS ב-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"
    

    מחליפים את saas-run-storage במזהה של מוצר ה-SaaS.

  2. מציגים את הגרסאות שנוצרו כדי לאחזר את מזהה פריט התוכן, סוג היחידה ומשתני הקלט:

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

    ‫App Lifecycle Manager יוצר ומאגד את תוכנית התבנית המורכבת באופן אסינכרוני. אם הרשימה ריקה, מחכים כמה דקות ומריצים שוב את הפקודה.

    הפקודה מפיקה את המידע הבא:

    • השדה name (לדוגמה, projects/PROJECT_ID/locations/us-central1/releases/r-r-1-06c6a0). הקטע בסוף הוא RELEASE_ID (למשל r-r-1-06c6a0).
    • השדה unitKind (לדוגמה, projects/PROJECT_ID/locations/us-central1/unitKinds/u-native-components-e97e0c). הקטע בסוף הוא UNIT_KIND_ID (למשל u-native-components-e97e0c).

יצירת חשבון שירות לפריסה

יוצרים חשבון שירות שנותן ל-App Lifecycle Manager הרשאה להקצות משאבים בשמכם:

  1. יוצרים את חשבון השירות לסימולציה:

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

    מחליפים את tenant-actuation-sa בשם של חשבון השירות לסימולציה.

  2. יוצרים את כתובת האימייל של חשבון השירות ומאחזרים את הזהות של סוכן השירות של App Lifecycle Manager:

    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. מקצים לחשבון השירות של ההפעלה את התפקידים הנדרשים כדי ליצור ולנהל את התשתית של הדייר:

    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. נותנים לסוכני השירות של App Lifecycle Manager ו-Infra Manager הרשאה להתחזות לחשבון השירות לסימולציה:

    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
    

פריסת סביבה ללקוח

יוצרים סביבת לקוח ומפעילים פריסה של התשתית הייעודית:

  1. יוצרים סביבה Unit שמייצגת דייר לקוח מבודד באמצעות סוג היחידה שנוצר:

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

    מחליפים את tenant-1 במזהה היחידה הייעודית לדייר בענן.

  2. מפעילים פעולה של יחידה כדי להקצות את התשתית של הדייר:

    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. מתארים את הפעולה של היחידה כדי לעקוב אחרי סטטוס ההקצאה עד שהוא מגיע לערך SUCCEEDED:

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

עדכונים אוטומטיים בסביבות של הלקוחות

אתם יכולים להשתמש בהשקות כדי לפרוס עדכונים לאפליקציה בצורה בטוחה בכל סביבות הלקוחות.

בחירת אסטרטגיית עדכון

הגדירו איך העדכונים יועברו לסביבות של הלקוחות, למשל פריסה של כל העדכונים בבת אחת או בשלבים:

  1. יוצרים RolloutKind כדי להגדיר את אסטרטגיית התיאום של היחידות:

    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"
    

    מחליפים את progressive-rollout במזהה של סוג ההשקה.

פריסה ומעקב אחרי העדכון

מתחילים את ההשקה ועוקבים אחרי ההתקדמות שלה עד לסיום הפריסה:

  1. מפעילים את ההשקה כדי לפרוס את הגרסה ביחידות הייעודיות לדיירים בענן שעומדות בדרישות:

    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"
    

    מחליפים את rollout-v1 במזהה של ההשקה.

  2. מתארים את ההשקה כדי לבדוק את ההפעלה הפעילה ולוודא שהסטטוס מגיע ל-SUCCEEDED:

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

    הפלט של ההשקה מאשר שהיחידות הייעודיות לדייר בענן עודכנו לגרסת היעד של התבנית.

הסרת המשאבים

כדי להימנע מחיובים בחשבון Google Cloud בגלל השימוש במשאבים שנעשה במסגרת המדריך הזה, אפשר למחוק את הפרויקט שמכיל את המשאבים, או להשאיר את הפרויקט ולמחוק את המשאבים הנפרדים.

מחיקת הפרויקט

כדי למחוק פרויקט ב- Google Cloud :

gcloud projects delete PROJECT_ID

מחיקת משאבים ספציפיים

אם פרסתם את המשאבים של המדריך בפרויקט קיים, מחקו את המשאבים הנפרדים בסדר הפוך של תלות כדי למנוע חיובים לא צפויים:

  1. מבטלים את ניהול ההקצאות של תשתית סביבת הלקוח וממתינים לסיום:

    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. מוחקים את סביבת הלקוח ב-App Lifecycle Manager:

    gcloud beta app-lifecycle-manager units delete "tenant-1" \
        --location="us-central1" \
        --quiet
    
  3. מוחקים את משאבי ההשקה והגרסה של App Lifecycle Manager בסדר הפוך של תלות:

    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. מוחקים את תבנית האפליקציה, את הרשומות בקטלוג ואת המרחב של App Design Center:

    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. מוחקים את הקישור למאגר Git ב-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. מוחקים את חשבון השירות של ההפעלה:

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

המאמרים הבאים