Study guide
13.2 Cloud Monitoring: Alerts, Custom Metrics & Dashboards
Google Cloud Associate Cloud Engineer ACE
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Introduction & Exam Overview
1.1 About the GCP Associate Cloud Engineer Exam 1.2 How to Use This Study Guide & Build a Study Plan
2 Chapter 2: Resource Hierarchy, IAM Basics & Cloud Identity
2.1 The GCP Resource Hierarchy: Organizations, Folders & Projects 2.2 Organization Policies & Granting IAM Roles 2.3 Cloud Identity: Managing Users and Groups
3 Chapter 3: APIs, Quotas & Billing Configuration
3.1 Enabling APIs and Provisioning Cloud Operations Suite 3.2 Assessing and Requesting Quota Increases 3.3 Billing Accounts, Project Linking & Billing Exports 3.4 Billing Budgets and Alerts
4 Chapter 4: Planning Compute & Storage Resources
4.1 Choosing the Right Compute Option: GCE vs. GKE vs. Cloud Run vs. Cloud Functions 4.2 Spot VMs, Custom Machine Types & Cost-Optimized Compute Planning 4.3 Choosing a Data Storage Product: Cloud SQL, BigQuery, Firestore, Spanner & Bigtable 4.4 Cloud Storage Classes & Persistent Disk Types
5 Chapter 5: Planning Network Resources
5.1 Load Balancing Options and Use Cases 5.2 Regional Resource Placement & High Availability Planning 5.3 Network Service Tiers: Premium vs. Standard
6 Chapter 6: Deploying Compute Engine Workloads
6.1 Launching Compute Engine Instances: Disks, SSH Keys & Availability Policies 6.2 Managed Instance Groups, Instance Templates & Autoscaling 6.3 OS Login and VM Manager for Fleet Configuration
7 Chapter 7: Deploying Google Kubernetes Engine Workloads
7.1 Installing and Configuring kubectl 7.2 Deploying GKE Clusters: Autopilot, Regional, Private & GKE Enterprise 7.3 Deploying Containerized Applications to GKE
8 Chapter 8: Deploying Serverless & Event-Driven Applications
8.1 Deploying Applications to Cloud Run and Cloud Functions 8.2 Event-Driven Architectures: Pub/Sub, Cloud Storage Triggers & Eventarc
9 Chapter 9: Deploying Data Solutions
9.1 Deploying Data Products: Cloud SQL, Firestore, Spanner, BigQuery & AlloyDB 9.2 Deploying Pub/Sub, Dataflow & Loading Data into Google Cloud
10 Chapter 10: Deploying Networking Resources & Infrastructure as Code
10.1 Creating VPCs, Subnets & Shared VPC 10.2 Firewall Rules, Cloud VPN & VPC Network Peering 10.3 Infrastructure as Code: Terraform, Config Connector, Cloud Foundation Toolkit & Helm
11 Chapter 11: Managing Compute Engine & GKE in Production
11.1 Connecting to and Managing Running Compute Engine Instances 11.2 Working with Snapshots and Custom Images 11.3 Managing GKE Clusters: Node Pools, Workloads & Artifact Registry Access 11.4 Horizontal and Vertical Pod Autoscaling in GKE
12 Chapter 12: Managing Cloud Run, Storage & Database Operations
12.1 Managing Cloud Run Revisions, Traffic Splitting & Scaling 12.2 Managing and Securing Cloud Storage Objects & Lifecycle Policies 12.3 Querying, Estimating Costs, Backup & Job Monitoring for Databases (Cloud SQL, BigQuery, Spanner, Dataflow)
13 Chapter 13: Networking Operations, Monitoring & Logging
13.1 Networking Operations: Subnets, Static IPs, Cloud DNS & Cloud NAT 13.2 Cloud Monitoring: Alerts, Custom Metrics & Dashboards 13.3 Cloud Logging: Buckets, Log Analytics, Routers & Filtering 13.4 Diagnostics, Ops Agent, Managed Service for Prometheus & Audit Logs
14 Chapter 14: IAM Policies & Role Types
14.1 IAM Policies: Structure, Bindings & Policy Hierarchy 14.2 IAM Role Types: Basic, Predefined & Custom Roles
15 Chapter 15: Service Accounts & Security Configuration
15.1 Creating Service Accounts & Assigning Least-Privilege Permissions 15.2 Assigning Service Accounts to Resources & Managing SA IAM Policies 15.3 Service Account Impersonation & Short-Lived Credentials
16 Chapter 16: Exam Readiness — Scenarios & Test-Day Strategy
16.1 Common ACE Exam Scenarios & Decision Frameworks 16.2 Test-Day Logistics, Time Management & Final Review Checklist
13.2 Cloud Monitoring: Alerts, Custom Metrics & Dashboards
Key Takeaways Explain This Topic AI
An alerting policy consists of one or more conditions plus one or more notification channels; Cloud Monitoring auto-creates a timestamped incident when a condition is met and auto-closes it when the condition clears.
The five alerting condition families are metric threshold, metric absence, forecasted metric-value, PromQL, and log-based — each maps to a different exam scenario phrase.
Log-based metrics derive counter or distribution data straight from Cloud Logging entries with no application code changes; user-defined custom metrics require writing to the Cloud Monitoring API and use the custom.googleapis.com/ prefix.
Uptime checks are black-box external reachability probes run from multiple global locations and are distinct from internal metric-threshold alerting.
Dashboards come prebuilt automatically per resource type or can be custom-built via Console, API, or Terraform, queried with MQL or PromQL.
Last updated: July 2026
Why This Topic Matters on the Exam
The official exam guide lists "creating Cloud Monitoring alerts" and "creating/ingesting custom metrics" as explicit, testable bullets under Domain 4. In practice, ACE questions rarely ask you to define "monitoring" in the abstract — they describe an operational requirement ("notify the on-call team only when latency crosses a threshold for five straight minutes") and ask which Cloud Monitoring construct to configure. Knowing the pieces of an alerting policy and the two ways to get non-default data into Cloud Monitoring is the difference between guessing and answering confidently.
Cloud Monitoring Building Blocks
Cloud Monitoring (the modern name for what used to be called Stackdriver Monitoring) collects metrics, uptime data, and events across Google Cloud, AWS, on-premises systems, and third-party applications, then lets you visualize, alert on, and analyze them.
A metrics scope (formerly called a "Workspace") is what ties one host project to one or more monitored projects, letting a single Cloud Monitoring view span multiple GCP projects — common in organizations that separate projects by environment (dev/staging/prod) but want unified dashboards and alerting.
Alerting Policies
An alerting policy is the core object that watches for a condition and fires a notification. It has three parts:
Condition(s) — what to watch and when it counts as "bad."
Notification channel(s) — where the alert goes.
Documentation — optional Markdown notes attached to the alert so the on-call responder has context (runbook link, owning team, etc.).
Condition type Triggers when Typical use
Metric threshold A metric value crosses above/below a value for a sustained duration "CPU utilization > 90% for 5 minutes"
Metric absence A monitored time series stops reporting data for a defined window (up to 24 hours) Detect a crashed or stalled process that stops emitting metrics entirely
Forecasted metric-value Extrapolation predicts a threshold breach 1-7 days ahead Proactively catch a disk that will fill up before it actually does
PromQL A Prometheus Query Language expression evaluates true Complex, multi-metric conditions, especially for GKE workloads emitting Prometheus-format metrics
Log-based A Cloud Logging entry matches a filter Alert the moment a specific error string appears in logs, with no code changes
Aggregation matters: each condition specifies an alignment period (the time bucket, e.g., 1 minute) and a reducer (mean, max, sum, count, percentile) applied within that bucket, plus an optional group by on resource labels (e.g., alert per-region rather than on the aggregate across all regions).
Notification channels are project-level resources — email, SMS, Pub/Sub, Slack, PagerDuty, or a generic webhook — created once and then attached to any number of policies. Incidents are the timestamped records Cloud Monitoring creates each time a policy's condition is met; Monitoring auto-closes an incident once the condition clears.
Policies can be built in the Console, via the Cloud Monitoring API, gcloud , or Terraform ( google_monitoring_alert_policy ) — the exam expects you to recognize that alerting is fully automatable via API/Terraform, not just console-only.
Uptime checks are a distinct, simpler mechanism: black-box HTTP(S)/TCP probes sent from multiple global locations to test whether a public endpoint is reachable at all. An uptime check's failure can itself feed an alerting policy — this is "external reachability," as opposed to a metric-threshold condition on internal telemetry.
Custom Metrics: Two Paths
Cloud Monitoring ships with thousands of built-in ("system") metrics for GCP resources, but the exam guide specifically calls out creating/ingesting custom metrics — meaning data Google does not collect for you automatically. There are two supported paths:
Log-based metrics — Cloud Logging can automatically derive a counter metric (how many matching entries occurred) or a distribution metric (a numeric value extracted from each entry, e.g., response size) from any log filter, with no application code changes . Example: a counter metric counting severity=ERROR log entries containing "PaymentDeclined" , which you then alert on directly.
User-defined custom metrics — application code (or the Ops Agent, or an OpenTelemetry exporter) writes data points directly to the Cloud Monitoring API ( projects.timeSeries.create ). Custom metric types use the custom.googleapis.com/ or external.googleapis.com/prometheus/ prefix so Cloud Monitoring can distinguish them from built-in system metrics.
Exam trap: a scenario describing "we want a metric based on how often a specific error message appears in our logs, and we don't want to modify application code" is asking for a log-based metric , not a custom API-ingested metric — the "no code change" phrase is the tell.
Dashboards
Dashboards visualize metrics as widgets (line charts, scorecards, alerting charts, log panels). Google auto-generates prebuilt dashboards per resource type (Compute Engine, GKE, Cloud SQL, and more) the moment you use that resource — no configuration needed. You can also build custom dashboards through the Console, the Monitoring Dashboards API, or Terraform ( google_monitoring_dashboard ), querying data with MQL (Monitoring Query Language) or PromQL widgets.
Applying It: A Worked Scenario
"You need to page the on-call engineer via PagerDuty only when the 95th-percentile request latency for a Cloud Run service exceeds 500ms for five consecutive minutes."
To configure this: create an alerting policy with a metric threshold condition on the Cloud Run request-latency metric, set the aggregation to a 95th-percentile reducer over a 1-minute alignment period, require the condition to hold for a 5-minute duration , and attach a PagerDuty notification channel . No custom metric is needed here — Cloud Run's built-in latency metric already exists; you are only configuring the alerting policy around it.
Section Takeaways
An alerting policy = condition(s) + notification channel(s), evaluated continuously, producing auto-closing incidents.
Metric-threshold, metric-absence, forecasted, PromQL, and log-based are the five condition families the exam expects you to distinguish.
Log-based metrics require zero application code changes; user-defined custom metrics require writing to the Monitoring API (or via Ops Agent/OpenTelemetry).
Uptime checks test external reachability and can themselves trigger alerts, distinct from internal metric-threshold monitoring.
Dashboards can be prebuilt (automatic) or custom (Console/API/Terraform), queried with MQL or PromQL.