Concevoir et déployer des offres SaaS

Application Design Center et App Lifecycle Manager vous permettent de standardiser et de faire évoluer la distribution SaaS mutualisée sans configurer manuellement l'infrastructure pour chaque client. Vous assemblez des modules Terraform réutilisables dans des modèles d'application composites dans App Design Center, puis vous empaquetez ces modèles dans des offres SaaS gérées dans App Lifecycle Manager.

Dans ce tutoriel, vous allez provisionner des environnements de locataires isolés et automatiser les mises à jour et les déploiements progressifs. Ce workflow est conçu pour les ingénieurs de plate-forme, les architectes d'entreprise et les opérateurs DevOps.

Objectifs

  • Préparez un dépôt GitHub contenant des modules Terraform Cloud Run et Cloud Storage.
  • Associez votre dépôt GitHub à Google Cloud à l'aide de Developer Connect.
  • Importez les modules Terraform pour créer et cataloguer des modèles de composants dans App Design Center.
  • Concevez un modèle d'application composite qui inclut vos modèles de composants.
  • Empaquetez votre modèle et déployez un environnement client dans App Lifecycle Manager.
  • Automatisez les déploiements progressifs dans les environnements de vos clients.

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. 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

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

  3. 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

  4. Assurez-vous de disposer des rôles IAM (Identity and Access Management) suivants sur votre projet :
    • Administrateur Application Design Center (roles/designcenter.admin) et Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin) pour effectuer la configuration.
    • Administrateur de la gestion des services SaaS (roles/saasservicemgmt.admin)
    • Administrateur Developer Connect (roles/developerconnect.admin)
    • Administrateur IAM du projet (roles/resourcemanager.projectIamAdmin) ou Administrateur de sécurité (roles/iam.securityAdmin) pour créer des comptes de service et accorder des rôles IAM.
    • Administrateur Cloud Run (roles/run.admin)
    • Administrateur de l'espace de stockage (roles/storage.admin)
    • Administrateur de compte de service (roles/iam.serviceAccountAdmin)
  5. Installez la Google Cloud CLI, puis initialisez-la :
    gcloud init
    Assurez-vous que les composants beta sont installés :
    gcloud components install beta
  6. Terminez la configuration d'Application Design Center sur votre projet à l'aide d'un périmètre de gestion des applications à projet unique. La configuration active la gestion des applications, provisionne un bucket de stockage pour Terraform, et crée l'espace default-space et le catalogue default-catalog.
  7. Installez Git sur votre machine locale.
  8. Assurez-vous de disposer d'un compte GitHub avec les autorisations nécessaires pour créer des dépôts et générer des jetons d'accès personnels.

Configurer l'environnement et le dépôt source

Pour configurer votre environnement pour ce tutoriel, spécifiez des valeurs de variables et configurez votre dépôt GitHub.

Spécifier les variables du tutoriel

Définissez des variables dans ce tutoriel et dans votre terminal de commande.

  1. Définissez les variables suivantes pour mettre à jour les commandes de ce tutoriel :

    Variable Description Valeur
    PROJECT_ID ID de votre projet Google Cloud PROJECT_ID
    REGION Région de déploiement pour les ressources App Design Center, Developer Connect, les offres App Lifecycle Manager et l'infrastructure de locataire us-central1
  2. Dans votre terminal de commande, configurez le projet Google Cloud actif :

    gcloud config set project PROJECT_ID
    
  3. Récupérez le numéro de votre projet Google Cloud et stockez-le dans une variable d'environnement :

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

Créer des fichiers de configuration Terraform

Créer des définitions Terraform modulaires pour Cloud Run et Cloud Storage Vous importerez ensuite ces modules dans App Design Center pour les empaqueter dans des composants architecturaux réutilisables.

  1. Créez une structure de répertoires locale pour vos modules Terraform :

    mkdir -p adc-alm-starter/infra/cloud-run
    mkdir -p adc-alm-starter/infra/cloud-storage
    cd adc-alm-starter
    
  2. Dans infra/cloud-run/main.tf, créez la définition du module 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. Dans infra/cloud-run/metadata.yaml, créez la définition des métadonnées du module :

    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. Dans infra/cloud-storage/main.tf, créez la définition du module 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. Dans infra/cloud-storage/metadata.yaml, créez la définition des métadonnées du module :

    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.
    

Déployer Terraform sur GitHub

Validez vos configurations Terraform dans un dépôt GitHub et connectez le dépôt à Google Cloud via Developer Connect. La connexion permet à App Design Center d'accéder de manière sécurisée aux révisions d'infrastructure pour les importer directement depuis le système de contrôle des sources.

  1. Dans un navigateur Web, créez un dépôt GitHub nommé adc-alm-starter.

  2. Créez un jeton d'accès personnel précis dans GitHub pour authentifier votre commande git push. Sélectionnez le dépôt adc-alm-starter et accordez les autorisations Contenu : lecture et écriture.

  3. Dans votre terminal de commande, initialisez Git dans le répertoire adc-alm-starter, effectuez un commit des fichiers et transmettez-les à 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
    

    Lorsque vous êtes invité à vous authentifier, saisissez votre nom d'utilisateur GitHub et votre jeton d'accès personnel.

  4. Dans la console Google Cloud , accédez à la page Developer Connect :

    Accéder à Developer Connect

  5. Créez une connexion dans la région us-central1 pour votre compte GitHub et associez votre dépôt. Pour obtenir des instructions détaillées, consultez Se connecter à GitHub.

  6. Identifiez l'ID de connexion et l'ID de lien du dépôt Git pour le dépôt associé, puis mettez à jour les variables suivantes :

    • CONNECTION_ID : identifiant de la connexion Developer Connect.
    • GIT_REPO_LINK_ID : identifiant du dépôt Git associé.

Créer des modèles dans App Design Center

Pour concevoir votre infrastructure Google Cloud , importez des modules Terraform dans App Design Center en tant que modèles de composants. Créez ensuite un modèle d'application composite incluant les composants.

Vérifier votre espace et votre catalogue

Si vous avez terminé la configuration d'App Design Center dans la console Google Cloud , votre espace et votre catalogue par défaut ont été créés automatiquement.

Si vous avez effectué la configuration avec la gcloud CLI, procédez comme suit :

  1. Vérifiez que default-space existe dans votre région :

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

    Remplacez default-space par l'ID de votre espace App Design Center.

  2. Si l'espace n'existe pas, créez l'espace et le catalogue :

    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"
    

    Remplacez default-catalog par l'ID de votre catalogue.

Créer des modèles de composants

Les modèles de composants transforment les modules Terraform individuels en blocs de base que vous pouvez ajouter à des modèles d'applications multiservices.

Créez des modèles de composants basés sur les modules Terraform de votre dépôt Git :

  1. Créez un modèle de catalogue pour 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
    

    Remplacez cloud-run-component par l'identifiant du modèle de composant Cloud Run.

  2. Créez un modèle de catalogue pour 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
    

    Remplacez cloud-storage-component par l'identifiant du modèle de composant Cloud Storage.

  3. Créez une révision de modèle en important le module Terraform Cloud Run depuis votre dépôt 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"
    

    Remplacez les éléments suivants :

    • CONNECTION_ID : ID de votre connexion Developer Connect.
    • GIT_REPO_LINK_ID : ID de votre lien de dépôt Git associé.
  4. Créez une révision de modèle en important le module Terraform Cloud Storage depuis votre dépôt 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"
    

    Remplacez les éléments suivants :

    • CONNECTION_ID : ID de votre connexion Developer Connect.
    • GIT_REPO_LINK_ID : ID de votre lien de dépôt Git associé.
  5. Répertoriez les modèles partagés dans votre espace pour récupérer leurs ID de modèle partagé :

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

    Dans le résultat de la commande, notez le segment SHARED_TEMPLATE_ID du champ name (projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/SHARED_TEMPLATE_ID) pour cloud-run-component et cloud-storage-component.

Créer un modèle d'application composite

Combinez vos modèles de composants dans un modèle d'application composite et configurez les connexions de paramètres. App Lifecycle Manager utilise des modèles composites pour gérer la topologie de votre application en tant qu'offre SaaS. Vous spécifiez des sorties et des entrées pour vous assurer que le service Cloud Run reçoit automatiquement le nom du bucket et les autorisations IAM nécessaires pour accéder à Cloud Storage.

  1. Créez un modèle d'application composite :

    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
    

    Remplacez run-storage-app par l'identifiant de votre modèle d'application composite.

  2. Ajoutez le composant Cloud Run au modèle d'application :

    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"
    

    Remplacez RUN_SHARED_TEMPLATE_ID par l'ID du modèle partagé cloud-run-component que vous avez récupéré.

  3. Ajoutez le composant Cloud Storage au modèle d'application :

    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"
    

    Remplacez STORAGE_SHARED_TEMPLATE_ID par l'ID du modèle partagé cloud-storage-component que vous avez récupéré.

  4. Créez une connexion entre le service Cloud Run et le bucket Cloud Storage. Cette commande associe la sortie du bucket à la variable d'environnement du service et accorde l'accès IAM au compte de service :

    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. Validez le modèle d'application pour générer une révision de modèle immuable :

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

    Le résultat de la commande confirme l'identifiant de révision généré (par exemple, r-1), que vous référencerez lorsque vous créerez votre offre SaaS dans App Lifecycle Manager.


Déployer des environnements client avec App Lifecycle Manager

Utilisez App Lifecycle Manager pour transformer votre modèle d'application en produit déployable et provisionner des environnements dédiés pour chaque client.

Empaqueter votre modèle d'application

Enregistrez la révision de votre modèle auprès d'App Lifecycle Manager pour créer une offre SaaS déployable :

  1. Créez l'offre SaaS dans 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"
    

    Remplacez saas-run-storage par l'identifiant de votre offre SaaS.

  2. Répertoriez les versions générées pour récupérer l'ID de version, le genre d'unité et les variables d'entrée :

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

    App Lifecycle Manager compile et empaquette le plan du modèle composite de manière asynchrone. Si la liste est vide, patientez quelques minutes, puis réexécutez la commande.

    La commande affiche les informations suivantes :

    • Le champ name (par exemple, projects/PROJECT_ID/locations/us-central1/releases/r-r-1-06c6a0). Le segment de fin est votre RELEASE_ID (par exemple, r-r-1-06c6a0).
    • Le champ unitKind (par exemple, projects/PROJECT_ID/locations/us-central1/unitKinds/u-native-components-e97e0c). Le segment de fin est votre UNIT_KIND_ID (par exemple, u-native-components-e97e0c).

Créer un compte de service de déploiement

Créez un compte de service qui autorise App Lifecycle Manager à provisionner des ressources en votre nom :

  1. Créez le compte de service d'activation :

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

    Remplacez tenant-actuation-sa par le nom de votre compte de service d'activation.

  2. Créez l'adresse e-mail du compte de service et récupérez l'identité de l'agent de service App Lifecycle Manager :

    ACTUATION_SA="tenant-actuation-sa@PROJECT_ID."
    ALM_P4SA="service-${PROJECT_NUM}@gcp-sa-saasservicemgmt."
    INFRA_MANAGER_P4SA="service-${PROJECT_NUM}@gcp-sa-config."
    
  3. Attribuez au compte de service d'activation les rôles nécessaires pour créer et gérer l'infrastructure du locataire :

    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. Accordez aux agents de service App Lifecycle Manager et Infra Manager l'autorisation d'emprunter l'identité du compte de service d'activation :

    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
    

Déployer un environnement pour un client

Créez un environnement client et déclenchez le déploiement de son infrastructure dédiée :

  1. Créez un environnement Unit représentant un locataire client isolé à l'aide du genre d'unité généré :

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

    Remplacez tenant-1 par l'identifiant de votre unité de locataire.

  2. Déclenchez une opération d'unité pour provisionner l'infrastructure du locataire :

    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. Décrivez l'opération de l'unité pour surveiller l'état du provisionnement jusqu'à ce qu'il atteigne SUCCEEDED :

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

Automatiser les mises à jour dans les environnements client

Utilisez les déploiements pour déployer en toute sécurité les mises à jour d'applications dans tous vos environnements client.

Choisir une stratégie de mise à jour

Définissez la manière dont les mises à jour sont transmises aux environnements client, par exemple en les déployant toutes en même temps ou par phases :

  1. Créez un RolloutKind pour définir la stratégie d'orchestration de vos unités :

    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"
    

    Remplacez progressive-rollout par l'identifiant du type de déploiement.

Déployer et suivre la mise à jour

Lancez le déploiement et surveillez sa progression jusqu'à ce qu'il soit terminé :

  1. Déclenchez le déploiement pour déployer votre version sur les unités de locataire éligibles :

    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"
    

    Remplacez rollout-v1 par l'identifiant de votre déploiement.

  2. Décrivez le déploiement pour inspecter l'exécution active et vérifier que l'état atteint SUCCEEDED :

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

    Le résultat du déploiement confirme que vos unités de locataire ont été mises à jour vers la révision du modèle cible.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Supprimer un projet Google Cloud  :

gcloud projects delete PROJECT_ID

Supprimer des ressources individuelles

Si vous avez déployé les ressources du tutoriel dans un projet existant, supprimez les ressources individuelles dans l'ordre inverse de leur dépendance pour éviter une facturation inattendue :

  1. Déprovisionnez l'infrastructure de l'environnement client et attendez la fin de l'opération :

    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. Supprimez l'environnement client App Lifecycle Manager :

    gcloud beta app-lifecycle-manager units delete "tenant-1" \
        --location="us-central1" \
        --quiet
    
  3. Supprimez les ressources de déploiement et de version d'App Lifecycle Manager dans l'ordre inverse de leur dépendance :

    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. Supprimez le modèle d'application, les entrées de catalogue et l'espace 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. Supprimez le lien et la connexion au dépôt 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. Supprimez le compte de service d'activation :

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

Étapes suivantes