App Lifecycle Manager overview

App Lifecycle Manager (previously known as SaaS Runtime) lets you store, host, manage, and monitor software as a service (SaaS) applications on Google Cloud. App Lifecycle Manager manages Terraform deployments at scale, allowing you to manage both your SaaS application and the infrastructure that it runs on.

App Lifecycle Manager can be used in many ways by a variety of stakeholders within the SaaS pipeline. If your work aligns with any of the following roles, you can use App Lifecycle Manager to streamline your multi-tenant operations:

  • Platform administrator

  • Application developer

  • Architect

  • Compliance administrator

  • Platform engineer

  • Finance operations

App Lifecycle Manager provides the following benefits:

  • Simplify service management at scale: Automate lifecycle tasks such as tenant provisioning, staged rollouts, and feature flag management across your SaaS tenants.

  • Expand observability and control: Fine-tune updates and releases across configurable units to manage your app offering with precision at scale.

  • Build consistency across Google Cloud: Manage services across Google Cloud, Google Distributed Cloud, Billing, Observability, and Resource Manager.

  • Promote modularity and reuse: Use a flexible, template-driven architecture that supports unit-based group updates, inter-unit dependencies, and repeatable deployments.

How App Lifecycle Manager works

App Lifecycle Manager deploys infrastructure and application artifacts that define your app offering. Each component of your offering is defined by a Terraform configuration and modeled as a unit kind. You provision units (instances of a unit kind) for your tenants and update those units over time using versioned releases and configurable rollouts.

The App Lifecycle Manager architecture is built around the following core concepts:

  • App offering (Saas): The top-level resource that represents your SaaS product and defines the available regions where your resources and units reside.

  • Composite templates and blueprints: The Terraform configurations that specify the Google Cloud resources for your offering. You can design and connect composite templates from Application Design Center, or package Terraform configurations directly into Open Container Initiative (OCI) blueprints stored in Artifact Registry.

  • Unit kinds (UnitKind): Templates that define distinct, independently managed components of your app offering (for example, a database tier or an application cluster). Unit kinds can declare dependencies and variable mappings so outputs from one unit automatically pass as inputs to dependent units.

  • Units (Unit) and tenants (Tenant): A unit is a deployed instance of a unit kind. Units are typically grouped by tenant and provisioned into dedicated tenant projects using Infrastructure Manager and a user-managed actuation service account.

  • Releases (Release): Immutable snapshots of a unit kind that reference a specific blueprint version and default input variables.

  • Rollout kinds (RolloutKind) and rollouts (Rollout): A rollout applies a new release across a fleet of units. Each rollout follows the rollout strategy, error budget, and unit filters defined in its rollout kind.

  • Feature flags: Runtime configuration controls that let you toggle feature availability and behavior across units and tenants without redeploying infrastructure. For more information, see the Feature flags overview.

For full definitions of App Lifecycle Manager terminology, see the App Lifecycle Manager glossary.

Prepare your workload for App Lifecycle Manager

Before you deploy your app offering, determine how to partition your application and infrastructure within the App Lifecycle Manager ecosystem.

Organize components of your app offering that should be updated or scaled together into distinct Terraform configurations, and model each grouping as a separate unit kind. For example, you might model a shared network or database in one unit kind and your stateless application tier in a dependent unit kind.

Use composite templates with App Lifecycle Manager

To define the architecture of your App Lifecycle Manager offerings, use composite templates through Application Design Center.

When you attach a composite template to your app offering, App Lifecycle Manager automatically populates the unit kinds, blueprints, and releases defined in your template. When you update the composite template in App Design Center, you can import the new template revision into your app offering to deploy updates across your units.

For more information about authoring composite templates, see Design composite templates. For instructions on connecting a composite template to an offering, see Model and package units of deployment.

End-to-end workflow

Deploying and operating a multi-tenant application with App Lifecycle Manager follows four main stages:

  1. Design and package your application: Author modular Terraform components and assemble a composite application template in Application Design Center, or package your Terraform configurations into OCI blueprints.

  2. Configure projects and service accounts: Set up your producer and tenant projects and grant the required IAM roles to your App Lifecycle Manager service accounts.

  3. Create and model your app offering: Create an app offering with your target regions, connect your composite template or define unit kinds in Model and package units of deployment, and configure variables and dependencies.

  4. Provision units and deploy releases: Deploy unit instances for each tenant, and deploy subsequent updates across locations using rollout strategies as described in Update a SaaS offering.

To walk through this workflow step by step:

  • Follow the end-to-end tutorial, Design and deploy SaaS offerings, to build a multi-component composite template in App Design Center and deploy it across tenants with App Lifecycle Manager.

  • Try the quickstart to deploy a Cloud Run and Cloud Storage composite application template with App Lifecycle Manager.

Key operational concepts

As you plan your production architecture in App Lifecycle Manager, review the following standalone guides:

  • Service accounts: Learn about the Google-managed App Lifecycle Manager service agent, user-managed actuation service accounts (actuation_sa), and optional artifact creation service accounts, along with the required IAM roles for each.

  • Rollout strategies: Compare single-location, all-at-once, and progressive rollout strategies, and learn how rollout kinds use error budgets and unit filters to safeguard production updates.

  • Regionalization: Understand how available regions on an app offering govern unit placement, rollout locations, automated resource replication, and location requirements for Artifact Registry and Developer Connect.

What's next