In many cloud environments, infrastructure teams are responsible for monitoring maintenance activities across hundreds of resources. They receive notifications about planned updates, identify affected systems, contact application teams, and coordinate the required actions.
This approach becomes difficult as an organization grows.
Consider an organization running several applications on Google Cloud. One application uses Cloud Run and Cloud SQL, another depends on Google Kubernetes Engine, and a third uses Compute Engine instances and managed databases.
When Google Cloud schedules maintenance for these resources, the infrastructure team needs to determine which applications might be affected. That requires understanding resource dependencies, identifying application owners, and communicating the maintenance schedule to the right people.
The problem is not simply receiving maintenance notifications. It is connecting infrastructure-level maintenance events to the applications that depend on those resources.
Google Cloud addresses this challenge through Unified Maintenance and its integration with App Hub and Cloud Hub. Instead of looking at maintenance only from an individual resource or project perspective, organizations can get an application-oriented view of maintenance activities.
This makes it easier for application teams to understand which maintenance events affect their services and prepare accordingly.
Why Infrastructure-Centric Maintenance Becomes Difficult
Traditional cloud maintenance processes often separate infrastructure ownership from application ownership.
Infrastructure teams manage resources such as virtual machines, databases, networks, and Kubernetes clusters. Application teams focus on business functionality, application performance, and customer experience.
Both teams need maintenance information, but they usually look at it from different perspectives.
An infrastructure engineer might receive a notification that a Cloud SQL instance has scheduled maintenance. The application owner, however, wants to know which application uses that database, whether a customer-facing workflow could be affected, and what actions are required before the maintenance begins.
Without a clear relationship between infrastructure resources and applications, someone must manually connect these details.
A typical process looks like this:
Google Cloud Maintenance Event
|
v
Infrastructure Team
|
v
Identify Affected Resources
|
v
Find Dependent Applications
|
v
Contact Application Owners
|
v
Plan and Coordinate Actions
This process introduces unnecessary coordination work.
It can also create delays when resource ownership information is outdated or when different teams maintain separate spreadsheets and documentation.
An application-centric maintenance model changes the way teams approach this problem.
Instead of starting with an individual infrastructure resource, teams can start with the application and understand the maintenance activities affecting its registered components.
Understanding Unified Maintenance
Unified Maintenance is a Google Cloud service that provides centralized visibility into planned maintenance activities across supported Google Cloud products.
It brings maintenance information into a common experience and integrates with Cloud Logging.
Teams can use it to:
View upcoming and ongoing maintenance activities.
Review completed and canceled maintenance events.
Understand which resources are affected.
Identify available maintenance controls.
Configure notifications for scheduled maintenance.
Integrate maintenance events with existing operational workflows.
For example, if a Cloud SQL instance has a scheduled maintenance event, the team can inspect its maintenance details, including the scheduled start time, expected end time, affected resource, and available controls.
Some maintenance activities can be rescheduled or performed on demand. Others are managed entirely by Google and cannot be changed by customers.
This distinction is important. Unified Maintenance provides visibility and access to supported controls; it does not give application owners unrestricted control over every Google Cloud maintenance operation.
Moving From Individual Resources to Applications
The important part of application-centric maintenance is connecting infrastructure resources to the applications that use them.
Google Cloud provides App Hub for organizing related services and workloads into logical applications.
An application in App Hub represents a group of resources that work together to provide business functionality.
For example, consider an e-commerce application:
E-Commerce Application
|
+---- Frontend
| |
| +---- Cloud Run
|
+---- Backend API
| |
| +---- Cloud Run
|
+---- Database
| |
| +---- Cloud SQL
|
+---- Background Processing
|
+---- Google Kubernetes Engine
Each component can be registered with the application in App Hub.
Once the resources are organized this way, application-centric maintenance visibility can associate supported maintenance events with the relevant application.
Instead of asking which project contains a database instance, an application owner can start by examining the maintenance activities associated with the e-commerce application.
This makes maintenance information more useful to the people responsible for application reliability.
Preparing Google Cloud for Application-Centric Maintenance
Before using application-level maintenance visibility, organizations need to establish an application management structure.
Google Cloud supports application management through an app-enabled folder.
An app-enabled folder provides a boundary within the resource hierarchy where applications can be organized and managed.
It also uses a management project to store application metadata and configuration.
The management project contains information about applications, services, workloads, ownership, and other application attributes.
A simplified structure looks like this:
Google Cloud Organization
|
v
App-Enabled Folder
|
+---- Management Project
| |
| +---- App Hub Metadata
| +---- Application Configuration
| +---- Observability Configuration
|
+---- Project A
| |
| +---- Cloud Run
| +---- Cloud SQL
|
+---- Project B
|
+---- GKE
+---- Compute Engine
An application can include resources from multiple projects within the application management boundary.
This is useful for organizations where application components are distributed across different projects for security, billing, or operational reasons.
To enable application management, an administrator can use the Google Cloud console:
Open the Manage resources page.
Select the folder that should become the application management boundary.
Open the folder's settings.
Locate the Application management section.
Create the management project and enable the required APIs.
Google Cloud also recommends testing application management in a dedicated folder before introducing it into an existing critical resource hierarchy.
The management project is important because it stores the logical application model. Deleting it permanently removes the application metadata and groupings, although the underlying resources in other projects remain intact.
Registering Application Resources in App Hub
After configuring the application management boundary, the next step is to organize the existing resources into applications.
Suppose an organization has a customer portal consisting of a Cloud Run frontend, a Cloud Run API, and a Cloud SQL database.
The team should register the relevant services and workloads with the customer portal application.
The application should also contain useful metadata, such as:
Ownership information is particularly important.
If an application has no clearly identified owner, the organization may still struggle to determine who should respond when maintenance affects that application.
A useful ownership model could look like this:
Application | Owner | Criticality | Environment |
|---|
Customer Portal | Customer Experience Team | High | Production |
Payment Service | Payments Team | Critical | Production |
Reporting Platform | Data Engineering Team | Medium | Production |
App Hub provides the application structure and metadata. It does not automatically transfer every infrastructure responsibility to the application owner.
Platform and infrastructure teams can continue managing shared infrastructure, while application teams gain a clearer view of the resources associated with their services.
Viewing Maintenance Activities in Cloud Hub
Once the application resources are registered, teams can use Cloud Hub to review maintenance activities.
Cloud Hub provides a centralized experience for viewing operational information across Google Cloud resources and registered applications.
The Maintenance page displays supported scheduled, started, completed, and canceled maintenance activities.
For an application-oriented workflow, select the relevant management project and review the available maintenance information.
The page provides filters for:
Maintenance category.
Resource location.
Resource type.
When an application-level maintenance view is available, the team can use the registered application context to understand which maintenance activities affect its components.
A maintenance detail page provides useful information, including:
This gives application owners more context than a notification containing only a resource name.
For example, if a scheduled update affects the Cloud SQL instance used by the payment service, the team can identify the affected application and review its operational requirements before the maintenance begins.
Application support in the Cloud Hub Maintenance experience is a Preview capability, so organizations should verify its availability and suitability for their environment before depending on it for production processes.
Enabling Unified Maintenance
To use Unified Maintenance, organizations need to enable the Maintenance API in the appropriate project.
For application-level visibility, the API should be enabled in the management project associated with the app-enabled folder.
The following command enables the API:
gcloud services enable maintenance.googleapis.com \
--project=my-management-project
Replace my-management-project with the actual management project ID.
The account enabling the API needs the serviceusage.services.enable permission. The Service Usage Admin role provides this permission.
Unified Maintenance also sends maintenance activity logs to Cloud Logging.
These logs provide another way to inspect scheduled and completed maintenance events, even when teams use their own dashboards or notification systems.
One important detail is that enabling the API does not populate historical events that were scheduled before the API was enabled. Teams should account for this when introducing the feature into an existing environment.
Configuring Maintenance Notifications
Viewing maintenance activities in a dashboard is useful, but application owners should not have to remember to check the dashboard every day.
Cloud Logging allows teams to create log-based alerting policies for maintenance events.
For example, a team may want to receive a notification whenever a new maintenance event is scheduled for a Cloud SQL instance.
The following Logging query filters scheduled maintenance events for Cloud SQL:
log_id("maintenance.googleapis.com/maintenance_events")
AND jsonPayload.resource.type = "sqladmin.googleapis.com/Instance"
AND jsonPayload.state = "SCHEDULED"
This filter can be used when creating a log-based alert policy.
Teams can also create alerts for changes in maintenance state or updates to scheduled maintenance times.
For example, the organization may want notifications when:
A new maintenance event is scheduled.
An event changes from SCHEDULED to STARTED.
The scheduled start or end time changes.
Maintenance affects resources in a particular location.
Cloud Logging notification channels support several integration options, including email, Pub/Sub, PagerDuty, Slack, SMS, and webhooks.
This makes it possible to connect maintenance notifications to existing incident-management and communication workflows.
For example, a webhook can send a maintenance event to an internal operations platform, where the event can be associated with an application owner and a corresponding maintenance task.
Giving Application Owners the Right Responsibilities
Application-centric maintenance is not about removing infrastructure teams from the maintenance process.
It is about making responsibilities clearer.
Infrastructure teams understand the underlying cloud platform, shared resources, networking, and infrastructure-level reliability requirements.
Application teams understand application dependencies, business impact, customer workflows, and application-specific recovery procedures.
Both perspectives are necessary.
A practical responsibility model could look like this:
Responsibility | Infrastructure or Platform Team | Application Team |
|---|
Configure application management boundaries | Responsible | Consulted |
Maintain shared infrastructure | Responsible | Informed |
Register application resources | Support | Responsible |
Maintain application ownership metadata | Support | Responsible |
Review application maintenance impact | Support | Responsible |
Configure platform-wide alerts | Responsible | Consulted |
Prepare application recovery plans | Support | Responsible |
Coordinate application testing | Consulted | Responsible |
The exact division depends on the organization's operating model.
The important point is that infrastructure teams should not need to manually interpret every maintenance event for every application.
Application teams should have enough visibility and context to understand the impact on their own services.
Understanding IAM Permissions
Application-centric maintenance requires appropriate access to the management project and the projects containing the relevant resources.
For viewing maintenance activities in Cloud Hub, users need the Logs Viewer role on the relevant project or management project.
The role is:
roles/logging.viewer
The Cloud Hub Operator role also includes Logs Viewer permissions.
For App Hub operations, different roles control application management:
IAM role | Responsibility |
|---|
App Hub Admin | Full access to App Hub resources |
App Hub Editor | Create and manage applications, services, and workloads |
App Hub Viewer | View applications, services, workloads, and their attributes |
These permissions should be assigned according to each team's responsibilities.
For example, application owners who only need to inspect application information should not automatically receive administrative permissions over the entire application management boundary.
Similarly, infrastructure administrators should retain the permissions required to manage shared platform resources.
Using role-based access control helps organizations delegate application-level responsibilities without granting unnecessary infrastructure access.
Practical Example: Preparing a Payment Service for Database Maintenance
Consider a payment platform that uses a Cloud SQL database and a Cloud Run API.
The infrastructure team receives information about planned maintenance for the database.
In a traditional process, the infrastructure team might need to identify the application using the database, find its owner, and send a notification explaining the maintenance window.
With application-centric visibility, the payment service can already be registered in App Hub with its associated resources and ownership information.
The workflow becomes more direct:
Cloud SQL Maintenance Scheduled
|
v
Unified Maintenance Event
|
v
Application Maintenance Context
|
v
Payment Service Identified
|
v
Payment Team Reviews Impact
|
v
Validate Application Readiness
|
v
Monitor Maintenance and Recovery
The payment team can review the maintenance schedule and prepare its application-specific response.
For example, it can verify that database connections are handled correctly, retry logic is configured appropriately, and the application can recover from temporary connection interruptions.
The infrastructure team remains responsible for the underlying platform, while the application team takes responsibility for understanding and preparing for the impact on its service.
This reduces manual coordination and gives both teams a clearer operational picture.
Best Practices for Application-Centric Maintenance
Introducing application-centric maintenance is more effective when it is supported by a consistent resource ownership model.
First, keep App Hub application registrations accurate. An application view is only useful when its registered resources reflect the actual architecture.
Second, maintain ownership metadata. Every production application should have a clearly identified team responsible for reviewing maintenance impact.
Third, create alerts based on business impact. Sending every infrastructure event to every developer creates notification fatigue. Filter events by resource type, location, application, and maintenance state wherever possible.
Fourth, define application-specific readiness procedures. A maintenance notification should lead to an actionable checklist rather than simply being acknowledged.
Fifth, understand which maintenance activities are controllable. Some services allow maintenance windows or rescheduling, while others are fully managed by Google.
Finally, do not treat maintenance visibility as a substitute for high availability. Applications should still use appropriate redundancy, retries, health checks, monitoring, and recovery strategies.
Summary
Managing cloud maintenance only at the infrastructure level creates additional coordination work as organizations grow. Infrastructure teams must identify affected resources, discover dependent applications, and communicate maintenance details to the teams responsible for those applications.
Google Cloud's Unified Maintenance, App Hub, and Cloud Hub provide a more application-oriented approach.
App Hub organizes related services and workloads into logical applications. Unified Maintenance provides centralized information about planned maintenance, while Cloud Hub brings maintenance details into an operational view.
With application ownership metadata and Cloud Logging alerts, teams can connect maintenance events to the applications they affect and prepare the appropriate response.
The goal is not to move all infrastructure responsibilities away from platform teams. It is to give application owners the visibility and context they need to manage application reliability while infrastructure teams continue to operate the underlying cloud platform.
Join the conversation! Your thoughts help the community grow.