Professional-Cloud-DevOps-Engineer Google Cloud Certified - Professional Cloud DevOps Engineer Exam Questions and Answers

The most effective ways to measure application reliability from a user perspective without making any engineering changes are to create new synthetic clients to simulate a user journey using the application, and to use current and historic Request Logs to trace customer interaction with the application. These methods can help you monitor the availability, latency, and errors of your application from an end-user perspective .

https://cloud.google.com/architecture/continuous-delivery-toolchain-spinnaker-cloud

https://spinnaker.io/guides/user/pipeline/triggers/pubsub/

 The most efficient way to build an automated pipeline that deploys the application when the image is updated is to use Cloud Pub/Sub to trigger a Spinnaker pipeline. This way, you can leverage the built-in integration between GCR and Cloud Pub/Sub, and use Spinnaker as a continuous delivery platform for deploying your application .

https://cloud.google.com/security-key-management

The correct answer is D. Review the design of the product with the product development team to provide feedback early in the design phase.

According to the Google Cloud DevOps best practices, a Site Reliability Engineer (SRE) should collaborate with the product development team from the beginning of the product lifecycle, not just after the product is deployed or tested. This way, the SRE can provide operational input on the product design, such as scalability, reliability, security, and cost efficiency. The SRE can also help define service level objectives (SLOs) and service level indicators (SLIs) for the product, as well as monitoring and alerting strategies. By collaborating early and often, the SRE and the product development team can ensure that the product meets the operational requirements and expectations of the customers.

Comprehensive and Detailed Explanation From General GKE and GitOps Knowledge:

The requirements are:

Enforce constraint templates (implying a policy agent like OPA Gatekeeper) on GKE.

Store policy parameters in a GitHub repository.

Automatically apply changes from the GitHub repository to the clusters.

This is a classic GitOps scenario.

A. Set up a GitHub action to trigger Cloud Build when there is a parameter change. In Cloud Build, run a gcloud CLI command to apply the change.This is a plausible CI/CD approach. GitHub Actions can trigger Cloud Build, which can then use kubectl or gcloud to apply configurations. However, this is a push-based imperative approach. GitOps tools offer a more declarative, pull-based model specifically designed for syncing Kubernetes configurations.  

B. When there is a change in GitHub, use a webhook to send a request to Cloud Service Mesh, and apply the change.Cloud Service Mesh (based on Istio) is primarily for managing traffic, security, and observability for microservices. It's not designed for applying general Kubernetes policy configurations like Gatekeeper constraints from a Git repository.  

C. Configure Config Sync with the GitHub repository. When there is a change in the repository, use Config Sync to apply the change.Config Sync is a Google Cloud product specifically designed for GitOps with GKE (and other Kubernetes clusters). It synchronizes configurations (including CustomResourceDefinitions for constraint templates and the constraints themselves) from a Git repository (like GitHub) to your clusters. It continuously monitors the repository and automatically applies any committed changes to the clusters, ensuring they remain in the desired state. This perfectly matches the requirements.  

D. Configure Config Connector with the GitHub repository. When there is a change in the repository, use Config Connector to apply the change.Config Connector allows you to manage Google Cloud resources (like Pub/Sub topics, Spanner instances, etc.) using Kubernetes-style declarative configurations and kubectl. While it uses Kubernetes tooling, its primary purpose is managing Google Cloud resources, not syncing general Kubernetes configurations like Gatekeeper constraints from Git. Config Sync is the tool for syncing arbitrary Kubernetes manifests from Git to a cluster.  

Config Sync is the Google Cloud tool built for the exact purpose described: maintaining consistency between Kubernetes cluster configurations and a Git repository using a GitOps model.

Reference (Based on Google Cloud GKE and Config Sync documentation):

Config Sync Overview: https://cloud.google.com/anthos-config-management/docs/config-sync-overview or https://cloud.google.com/kubernetes-engine/docs/add-on/config-sync/overview (if referring to it as a GKE add-on)."Config Sync is a GitOps tool that helps you keep your Google Kubernetes Engine (GKE) Enterprise edition clusters synchronized with configs stored in a Git repository."  

It supports syncing various Kubernetes objects, including CustomResources, which are used by OPA Gatekeeper for defining constraints and constraint templates.

It automatically pulls changes from the Git repository and applies them, which meets the "automatically applied when changes occur" requirement.

A change advisory board (CAB) is a traditional way of approving changes to a service, but it can slow down the software delivery performance and introduce bottlenecks. A better way to improve the speed and quality of changes is to use a peer-review based process for individual changes that is enforced at code check-in time and supported by automated tests. This way, developers can get fast feedback on the impact of their changes and catch any errors or bugs before they reach production. Additionally, the team’s development platform should enable developers to get fast feedback on the impact of their changes, such as using Cloud Code, Cloud Build, or Cloud Debugger.

Comprehensive and Detailed Explanation From General CI/CD Practices:

The issue is a runtime failure: the container fails to start due to a missing environment variable. This means the application expects an environment variable that wasn't provided when the container was run. The goal is to prevent this within the CI/CD workflow before it reaches deployment.

A. Run integration tests in the CI pipeline: Integration tests typically involve deploying the application (or a component of it) to a test environment and checking if its parts work together correctly. As part of this, the application would attempt to start up with its configured environment. An integration test suite could include a basic "smoke test" that simply verifies the application starts successfully. If a required environment variable is missing, the application would fail to start during this integration test phase in the CI pipeline, catching the error before a production deployment. Many integration test setups will try to mimic the target deployment environment including its configuration mechanisms (like environment variables).  

B. Implement static code analysis in the CI pipeline: Static code analysis tools check the code for potential bugs, style issues, and security vulnerabilities without actually running it. While useful, they are unlikely to catch a missing environment variable configuration, as this is an issue with the deployment configuration or runtime environment, not typically a static property of the code itself (unless the code hardcodes an expectation that could be flagged, but that's less direct).  

C. Use a canary deployment strategy: Canary deployments are a strategy for releasing software to production by first deploying to a small subset of users/servers. This helps limit the blast radius if an issue occurs in production. While a good practice for deployments, it doesn't prevent the issue from occurring in the first place; it just limits its impact once it does occur. The question asks to prevent recurrence within the CI/CD workflow (i.e., earlier).  

D. Enable Cloud Audit Logs for the deployment: Cloud Audit Logs record administrative actions and accesses within Google Cloud. While the deployment logs already indicated the failure, audit logs provide information about who did what and when regarding the deployment configuration or execution. They are useful for post-mortem analysis of the deployment process itself but don't directly prevent the application from failing due to a misconfiguration like a missing environment variable during the build and test stages.  

The most effective way to catch such an issue before a production deployment attempt is to have a test stage in the CI pipeline that attempts to run the application in an environment configured similarly to production, including expected environment variables. Integration tests (or even simpler smoke tests that check for successful startup) would achieve this.

Reference (Based on CI/CD best practices):

Continuous Integration (CI) principles emphasize automated testing at various levels (unit, integration, end-to-end) to catch issues early.  

A common CI pipeline stage is to build the application, then deploy it to a test/staging environment and run integration tests. If the application fails to start in this test environment due to a missing environment variable, the pipeline would fail, preventing a flawed release from proceeding further.

"Integration tests verify that different parts of your application work together correctly. This can include interactions with databases, external services, and ensuring the application starts and operates as expected with its runtime configuration."  

Catching configuration errors like missing environment variables is a key benefit of running integration or smoke tests in a CI environment that mirrors production.

Comprehensive and Detailed Explanation:

To follow GitOps best practices and Google Cloud’s recommended repository structure for Terraform (IaC), Config Sync, and application code, we should use a shared repository for Terraform and Config Sync while keeping application repositories separate.

Cloud Infrastructure (Terraform) repository is shared → This allows infrastructure teams to manage all environments in a single repository with different directories per environment (dev, QA, production). This is the standard approach to structuring Terraform repositories.

GKE Enterprise Infrastructure (Config Sync) repository is shared → Using Kustomize overlays per environment (instead of separate repositories) aligns with Config Sync’s best practices and makes managing configurations easier.

Application repositories are separated, using different branches for features → This allows application teams to follow the Git branching model (feature branches, main branch, release branches, etc.) without affecting infrastructure.

????Official Reference:

Config Sync Best Practices

Terraform Structure Best Practices

GitOps Best Practices

https://cloud.google.com/blog/topics/retail/preparing-for-peak-holiday-season-while-wfh

The best option for sharing a Cloud Monitoring custom dashboard with a partner team is to provide the partner team with the dashboard URL to enable the partner team to create a copy of the dashboard. A Cloud Monitoring custom dashboard is a dashboard that allows you to create and customize charts and widgets to display metrics, logs, and traces from your Google Cloud resources and applications. You can share a custom dashboard with a partner team by providing them with the dashboard URL, which is a link that allows them to view the dashboard in their browser. The partner team can then create a copy of the dashboard in their own project by using the Copy Dashboard option. This way, they can access and modify the dashboard without affecting the original one.

The best option for deploying a containerized web application to Google Cloud with the given acceptance criteria is to use Google Kubernetes Engine (GKE) with Anthos Service Mesh. GKE is a managed service for running Kubernetes clusters on Google Cloud, and Anthos Service Mesh is a service mesh that provides observability, traffic management, and security features for microservices. With Anthos Service Mesh, you can use traffic splitting to direct traffic from Android devices to an Android-specific microservice by configuring the user-agent header in the virtual service. You can also use traffic splitting to direct arbitrary percentage-based traffic to different versions of any microservice for continuous testing. For example, you can use a canary release strategy to direct 10% of user traffic to a new version of a microservice and monitor its performance and reliability.

The Standard Tier network service offers lower network costs than the Premium Tier. This is the correct option to reduce the network cost for the application3.

The best deployment model for releasing a new version of your application in GKE with the ability to instantly roll back to the previous version is to perform a blue/green deployment and test your new application after the deployment is complete. A blue/green deployment is a deployment strategy that involves creating two identical environments, one running the current version of the application (blue) and one running the new version of the application (green). The traffic is switched from blue to green after testing the new version, and if any issues are discovered, the traffic can be switched back to blue instantly. This way, you can minimize downtime and risk during deployment.

 The best option for mitigating the incident impact on users and enabling the developers to troubleshoot the issue is to change the selector on the Service app-svc to app: my-app, version: blue. A Service is a resource that defines how to access a set of Pods. A selector is a field that specifies which Pods are selected by the Service. By changing the selector on the Service app-svc to app: my-app, version: blue, you can ensure that the Service only routes traffic to the Pods that have both labels app: my-app and version: blue. These Pods belong to the Deployment app-blue, which uses the previous version of the application. This way, you can mitigate the incident impact on users by switching back to the working version of the application. You can also enable the developers to troubleshoot the issue with the new version of the application in the Deployment app-green without affecting users.

Comprehensive and Detailed Explanation:

In Google’s Site Reliability Engineering (SRE) practices, an error budget defines the acceptable level of failure before new feature deployments should pause. If a service exceeds its error budget, the correct approach is to:

Notify the product team that the error budget is depleted.

Negotiate a launch freeze or decide if the team can tolerate slightly degraded performance.

????Why not other options?

A (Ensure all tests pass and proceed)❌→ Testing cannot guarantee stability when the error budget is already depleted.

C (Request additional error budget)❌→ Error budgets are not arbitrary; increasing them would defeat their purpose.

D (Reallocate SLOs from other areas)❌→ Error budgets should not be mixed across different SLOs, as this breaks reliability guarantees.

????Official Reference:

Google SRE: Error Budget Policy

Google Cloud SRE Principles

https://cloud.google.com/compute/quotas#understanding_quotas

https://cloud.google.com/compute/quotas

The best option for automating scaling by only running enough Pods and nodes for the load is to configure the Horizontal Pod Autoscaler and enable the cluster autoscaler. The Horizontal Pod Autoscaler is a feature that automatically adjusts the number of Pods in a deployment or replica set based on observed CPU utilization or custom metrics. The cluster autoscaler is a feature that automatically adjusts the size of a node pool based on the demand for node capacity. By using both features together, you can ensure that your application runs enough Pods to handle the load, and that your cluster runs enough nodes to host the Pods. This way, you can optimize your resource utilization and cost efficiency.

https://cloud.google.com/billing/docs/how-to/export-data-bigquery

https://cloud.google.com/monitoring/support/notification-options#creating_channels

To configure SMS notifications, do the following:

In the SMS section, click Add new and follow the instructions. Click Save. When you set up your alerting policy, select the SMS notification type and choose a verified phone number from the list.

https://cloud.google.com/architecture/customizing-stackdriver-logs-fluentd

Besides the list of default logs that the Logging agent streams by default, you can customize the Logging agent to send additional logs to Logging or to adjust agent settings by adding input configurations. The configuration definitions in these sections apply to the fluent-plugin-google-cloud output plugin only and specify how logs are transformed and ingested into Cloud Logging.https://cloud.google.com/logging/docs/agent/logging/configuration#configure

To securely connect Cloud Build to an AlloyDB cluster using a private IP address and adhere to Google-recommended security practices, you need to address two main aspects:

Network Connectivity:Ensuring Cloud Build can reach the private IP of the AlloyDB cluster.

Authentication/Credential Management:Securely authenticating Cloud Build to the AlloyDB cluster.

Let's break down why Option B is the most suitable:

Cloud Build Private Pool:AlloyDB is accessed via a private IP in your VPC. Cloud Build's default build environment runs on Google-managed infrastructure outside your VPC and cannot directly access private IP addresses. To enable this, you must use aCloud Build private pool. A private pool can be configured with VPC peering to your default VPC, allowing build steps running within that pool to access resources like your AlloyDB cluster via their private IPs. Option B correctly includes "execute the schema migration script in a private pool."  

Service Account with Permissions (IAM Database Authentication):AlloyDB supports IAM database authentication. This is a Google-recommended security practice because it allows you to manage database access using Google Cloud's Identity and Access Management (IAM) rather than relying on traditional database passwords.  

You would create a dedicated service account for Cloud Build (or use the private pool's service account).

This service account would be granted the necessary IAM roles to connect to the AlloyDB instance (e.g., roles/alloydb.client) and a database-level IAM role for login (e.g., roles/alloydb.user or roles/alloydb.admin depending on the permissions needed for schema migration).  

Cloud Build would then be configured to use this service account. The "permission to access the database" in Option B refers to these IAM permissions. This method avoids managing and distributing database passwords.

Analyzing the options:

A. Set up a Cloud Build private pool to access the database through a static external IP address...

While using a private pool is correct for network access, routing this through a staticexternalIP for a resource that has aprivateIP is generally not the first-choice secure pattern if direct private access is feasible. It adds complexity and a potential external exposure point, even if firewalled. The aim is to keep traffic within the private network as much as possible.

B. Create a service account that has permission to access the database. Configure Cloud Build to use this service account and execute the schema migration script in a private pool.

This option correctly combines the use of aprivate pool(for private IP network access) with aservice account having permissions(strongly implying IAM database authentication for AlloyDB, which is a best practice). This is a secure and robust approach.

C. Add the database username and encrypted password to the application configuration file...

Storing credentials, even if "encrypted" (the method and key management for encryption are unspecified and problematic), in application configuration files checked into source control or packaged with the application is a significant security risk and not a recommended practice.

D. Add the database username and password to Secret Manager. When running the schema migration script, retrieve the username and password from Secret Manager.

UsingSecret Managerto store database usernames and passwords is a Google-recommended practiceifyou are using password-based authentication. However, this optionalonedoes not solve the network connectivity issue for Cloud Build to reach the private IP of AlloyDB. You would still need a private pool. While D is good for secret management, B offers a more comprehensive solution that includes both the network aspect and implies a more modern authentication method (IAM database auth). If the question forced a choice between only doing secure credential storage (D) or doing IAM auth + private networking (B), B is more complete for the overall task.  

Conclusion:Option B is the most aligned with Google-recommended security practices as it addresses both the necessary private network connectivity via a Cloud Build private pool and promotes the use of IAM-based database authentication for AlloyDB, which is generally preferred over managing passwords.

References (General Concepts):

Cloud Build Private Pools for VPC Access:Google Cloud documentation for Cloud Build explicitly details using private pools to connect to resources in a VPC network.

See:https://www.google.com/search?q=https://cloud.google.com/build/docs/private-pools/accessing-private-resources-with-private-pools

AlloyDB IAM Database Authentication:Google Cloud documentation for AlloyDB highlights IAM database authentication as a secure method.

See:https://www.google.com/search?q=https://cloud.google.com/alloydb/docs/iam-authentication

Secret Manager:If password authentication were the only option, Secret Manager would be the recommended way to store those credentials.

See:https://cloud.google.com/secret-manager

Option B synergizes the benefits of private networking and modern IAM-based authentication for a comprehensive secure solution.

The most probable cause of the database timeout is an increased number of connections to the Cloud SQL instance. This could happen if the application does not close connections properly or if it creates too many connections at once. You can check the number of connections to the Cloud SQL instance using Cloud Monitoring or Cloud SQL Admin API .

The best option for ensuring that the warehouse system accurately reflects product inventory at the time orders are placed and minimizing the impact on customers is to increase the number of Pod replicas. Increasing the number of Pod replicas will increase the scalability and availability of your microservice, which will allow it to handle more Pub/Sub messages and update stock information faster. This way, you can reduce the backlog of undelivered messages and oldest unacknowledged message age, which are causing delays in updating product inventory. You can use Horizontal Pod Autoscaler or Cloud Monitoring metrics-based autoscaling to automatically adjust the number of Pod replicas based on load or custom metrics.

https://cloud.google.com/build/docs/securing-builds/use-encrypted-credentials

 The best option for optimizing your cloud spend by ensuring that only a single instance of your infrastructure stack exists at a time is to confirm that the pipeline is storing and retrieving the terraform.tfstate file from Cloud Storage with the Terraform gcs backend. The terraform.tfstate file is a file that Terraform uses to store the current state of your infrastructure. The Terraform gcs backend is a backend type that allows you to store the terraform.tfstate file in a Cloud Storage bucket. By using the Terraform gcs backend, you can ensure that your pipeline has access to the latest state of your infrastructure and avoid creating multiple copies of the entire infrastructure stack.

The most cost-effective network tier and load balancing configuration for your frontend tier is to use Premium Tier with a regional load balancer. Premium Tier is a network tier that provides high-performance and low-latency network connectivity across Google’s global network. A regional load balancer is a load balancer that distributes traffic within a single region. Since your application is deployed entirely within the europe-west2 region and only serves users based in the United Kingdom, you can use Premium Tier with a regional load balancer to optimize the network performance and cost.

The best option for preparing to handle the predicted growth is to verify the maximum node pool size, enable a Horizontal Pod Autoscaler, and then perform a load test to verify your expected resource needs. The maximum node pool size is a parameter that specifies the maximum number of nodes that can be added to a node pool by the cluster autoscaler. You should verify that the maximum node pool size is sufficient to accommodate your expected growth rate and avoid hitting any quota limits. The Horizontal Pod Autoscaler is a feature that automatically adjusts the number of Pods in a deployment or replica set based on observed CPU utilization or custom metrics. You should enable a Horizontal Pod Autoscaler for your application to ensure that it runs enough Pods to handle the load. A load test is a test that simulates high user traffic and measures the performance and reliability of your application. You should perform a load test to verify your expected resource needs and identify any bottlenecks or issues.

The best option for configuring Cloud Monitoring dashboards to only display metrics from the projects within one folder is to create new scoping projects for each folder. A scoping project is a project that defines which resources are monitored by Cloud Monitoring. You can create new scoping projects for each folder by using the gcloud monitoring register-project command. This way, you can associate each scoping project with a folder and only monitor the resources within that folder. You can then configure Cloud Monitoring dashboards to use the scoping projects as data sources and only display metrics from the projects within one folder.

The best option for investigating the issue with your application’s performance in Google Cloud is to configure Cloud Trace in your application. Cloud Trace is a service that allows you to collect and analyze latency data from your application. You can use Cloud Trace to trace requests across different components of your application, such as downstream dependencies, and identify where they take longer to complete. You can also use Cloud Trace to compare latency data across different versions of your application, and detect any performance degradation or improvement. By using Cloud Trace, you can diagnose and troubleshoot performance issues with your application in Google Cloud.

https://sre.google/workbook/implementing-slos/

In the SRE principles book, it's recommended treating the SLI as the ratio of two numbers: the number of good events divided by the total number of events. For example: Number of successful HTTP requests / total HTTP requests (success rate)

https://devops.com/when-it-disaster-strikes-part-3-conducting-a-blameless-post-mortem/

Comprehensive and Detailed Explanation:

When using Managed Service for Prometheus, metrics may not appear in Cloud Monitoring if PodMonitoring is misconfigured. The most likely issue is that the PodMonitoring configuration does not reference a valid port.

PodMonitoring is required to collect metrics from workloads in GKE.

If the port is incorrect or missing, metrics won’t be scraped.

????Why not other options?

A (Check quota limits)❌→ If quotas were exceeded, you’d see explicit errors, but the question states no errors were encountered.

B (Grafana installation check)❌→ Grafana is not required for Prometheus metric collection.

C (monitoring.servicesViewer IAM role issue)❌→ This role allows viewing metrics, but does not affect metric collection.

????Official Reference:

Managed Service for Prometheus - PodMonitoring

GKE Monitoring Troubleshooting

The correct answer is A. Communicate your intent to the incident team. Perform a load analysis to determine if the remaining nodes can handle the increase in traffic offloaded from the removed node, and scale appropriately. When any new nodes report healthy, drain traffic from the unhealthy node, and remove the unhealthy node from service.

This answer follows the Google-recommended practices for incident management, as described in the Chapter 9 - Incident Response, Google SRE Book1. According to this source, some of the best practices are:

Maintain a clear line of command. Designate clearly defined roles. Keep a working record of debugging and mitigation as you go. Declare incidents early and often.

Communicate your intent before taking any action that might affect the service or the incident response. This helps to avoid confusion, duplication of work, or unintended consequences.

Perform a load analysis before removing a node from the load balancer pool, as this might affect the capacity and performance of the service. Scale the pool as necessary to handle the expected load.

Drain traffic from the unhealthy node before removing it from service, as this helps to avoid dropping requests or causing errors for users.

Answer A follows these best practices by communicating the intent to the incident team, performing a load analysis and scaling the pool, and draining traffic from the unhealthy node before removing it.

Answer B does not follow the best practice of performing a load analysis before adding or removing nodes, as this might cause overloading or underutilization of resources.

Answer C does not follow the best practice of communicating the intent before taking any action, as this might cause confusion or conflict with other responders.

Answer D does not follow the best practice of draining traffic from the unhealthy node before removing it, as this might cause errors for users.

"A Project can host many Projects and appear in many Projects, but it can only be used as the scoping project once. We recommend that you create a new Project for the purpose of having multiple Projects in the same scope."

https://cloud.google.com/binary-authorization/docs/overview

The best options for reducing toil in the pipeline and minimizing the amount of time it takes to complete an end-to-end deployment are to create a trigger to notify the required team to complete the next step when manual intervention is required and to automate promotion approvals from the development environment to the test environment. A trigger is a resource that initiates a deployment when an event occurs, such as a code change, a schedule, or a manual request. You can create a trigger to notify the required team to complete the next step when manual intervention is required by using Cloud Build or Cloud Functions. This way, you can reduce the waiting time and human errors in the pipeline. A promotion approval is a process that allows you to approve or reject a deployment from one environment to another, such as from development to test. You can automate promotion approvals from the development environment to the test environment by using Google Cloud Deploy or Cloud Build. This way, you can speed up the deployment process and avoid manual steps.

The best option for managing all charts uniformly, with native access control and VPC Service Controls is to store public and private charts in OCI format by using Artifact Registry. Artifact Registry is a service that allows you to store and manage container images and other artifacts in Google Cloud. Artifact Registry supports OCI format, which is an open standard for storing container images and other artifacts such as Helm charts. You can use Artifact Registry to store public and private charts in OCI format and manage them uniformly. You can also use Artifact Registry’s native access control features, such as IAM policies and VPC Service Controls, to secure your charts and control who can access them.

https://cloud.google.com/storage/docs/best-practices

https://cloud.google.com/build/docs/speeding-up-builds#caching_directories_with_google_cloud_storage

Caching directories with Google Cloud Storage To increase the speed of a build, reuse the results from a previous build. You can copy the results of a previous build to a Google Cloud Storage bucket, use the results for faster calculation, and then copy the new results back to the bucket. Use this method when your build takes a long time and produces a small number of files that does not take time to copy to and from Google Cloud Storage.

   upvoted 2 times

Comprehensive and Detailed Explanation:

Google Cloud Trace is specifically designed to analyze request latency and identify performance bottlenecks across services. Since the issue is related to slow performance after a new release, the best approach is to use Cloud Trace to:

Visualize request latency across services

Pinpoint slow dependencies affecting response time

Analyze performance trends over time

????Why not other options?

B (Error Reporting)❌→ Focuses on uncaught exceptions and crashes, not latency issues.

C (Cloud Profiler)❌→ Helps with CPU and memory analysis, not request tracing.

D (Prometheus for Cloud Monitoring)❌→ Useful for metrics collection, but not ideal for debugging specific request latency issues.

????Official Reference:

Google Cloud Trace Overview

"After making a change in the Cloud Build YAML configuration, you notice that no new artifacts are being built by the pipeline"- means something wrong on the recent change not with the image registry.