A team wants to define an SLO for their service based on availability. Over a 30-day window, the service handled 1,000,000 requests, of which 999,500 succeeded. What is the achieved availability, and what is the error budget consumed if the SLO is 99.95%?
Correct calculation: availability equals SLO, so all budget used.
Why this answer
Availability = successful / total = 999,500 / 1,000,000 = 99.95%. SLO target is also 99.95%, so the allowed error budget is 0.05% of requests = 500 failures. Actual failures = 500, so error budget consumed = 500/500 = 100%.
A company is running a MySQL database on Cloud SQL and needs to optimize for high random read/write performance. Which storage type should they choose?
A.SSD persistent disk
B.Local SSD
C.Balanced persistent disk
D.HDD persistent disk
AnswerA
SSD persistent disk offers high IOPS and low latency, ideal for database storage in Cloud SQL.
Why this answer
SSD persistent disk provides consistent low-latency performance for random read/write operations, which is critical for MySQL databases on Cloud SQL. It offers higher IOPS and throughput compared to HDD or balanced persistent disks, making it the optimal choice for high random read/write workloads.
Exam trap
The trap here is that candidates may confuse Local SSD's high performance with persistence, not realizing it is ephemeral and cannot be used for Cloud SQL's managed database service, which requires durable storage.
How to eliminate wrong answers
Option B (Local SSD) is wrong because it is ephemeral and data is lost if the instance stops or fails, making it unsuitable for persistent database storage on Cloud SQL. Option C (Balanced persistent disk) is wrong because it offers lower IOPS and higher latency than SSD persistent disk, which is not ideal for high random read/write performance. Option D (HDD persistent disk) is wrong because it is designed for sequential read/write workloads and has significantly lower IOPS and higher latency, making it unsuitable for random access patterns.
A team uses Skaffold for local development and wants to integrate it into their CI/CD pipeline on Cloud Build for continuous deployment to GKE. What is the recommended approach?
A.Use Cloud Build's built-in kubectl deployer
B.Run 'skaffold dev' in the Cloud Build step
C.Convert skaffold.yaml to a Helm chart
D.Use 'skaffold run' in a Cloud Build step
AnswerD
'skaffold run' builds and deploys once, suitable for CI/CD.
Why this answer
Skaffold can be run as a step in cloudbuild.yaml. It handles building, tagging, and deploying based on skaffold.yaml configuration. Using 'skaffold run' in a Cloud Build step is the standard integration.
A team is reviewing IAM permissions on a Cloud Storage bucket. The exhibit shows the bucket's IAM policy. A developer is using the service account sa-1 and reports that they cannot delete objects in the bucket. What is the likely reason?
A.The etag value must be updated before any delete operation.
B.The service account sa-1 does not have the storage.objects.delete permission.
C.A condition is attached to the objectViewer role that prevents deletion.
D.The policy only allows deletion by the service account sa-2.
AnswerB
objectViewer only grants read access.
Why this answer
The IAM policy shown in the exhibit grants the `objectViewer` role to service account `sa-1`, which includes the `storage.objects.get` and `storage.objects.list` permissions but does not include `storage.objects.delete`. Without the `storage.objects.delete` permission, the developer cannot delete objects in the bucket, even if they can view them. The correct answer is B because the service account lacks the necessary delete permission.
Exam trap
Google Cloud often tests the distinction between viewing and deleting objects, where candidates mistakenly assume that having read access (objectViewer) also allows deletion, or that a condition or etag is the blocking factor, rather than recognizing the missing delete permission.
How to eliminate wrong answers
Option A is wrong because the `etag` field in an IAM policy is used for optimistic concurrency control during policy updates, not for object deletion operations; object deletion does not require updating the etag. Option C is wrong because the exhibit shows no conditions attached to the `objectViewer` role; even if a condition existed, it would restrict access further, but the core issue is the lack of the delete permission. Option D is wrong because the policy does not explicitly restrict deletion to `sa-2`; it only grants `storage.objectAdmin` to `sa-2`, which includes delete permission, but this does not prevent `sa-1` from deleting if it had the permission.
You need to send alert notifications to a Slack channel. Which TWO components are required?
Select 2 answers
A.A notification channel of type 'slack' in Cloud Monitoring
B.A Slack webhook URL
C.A Cloud Pub/Sub topic
D.An email notification channel
E.A Cloud Function to transform the alert
AnswersA, B
Correct. The Slack notification channel must be created with the webhook URL.
Why this answer
To send alerts to Slack, you need a Slack app with a webhook URL, and a Cloud Monitoring notification channel of type 'slack' configured with that webhook URL. Pub/Sub is not required for Slack directly; Slack channels are configured via webhooks. Email notification channel type is incorrect; Slack is a separate type.
A Cloud Function could be used as an intermediary but is not required.
A logistics company uses BigQuery to track shipments. The `shipments` table has columns `id`, `status`, `created_date`, and `delivery_date`. They need a query that returns the number of shipments that were delivered within 5 days of creation for each month of 2024. Which SQL construct is most appropriate?
A.SELECT EXTRACT(MONTH FROM created_date) AS month, COUNT(*) FROM shipments WHERE TIMESTAMP_DIFF(delivery_date, created_date, HOUR) <= 120 AND EXTRACT(YEAR FROM created_date) = 2024 GROUP BY month
B.SELECT EXTRACT(MONTH FROM created_date) AS month, COUNTIF(DATETIME_DIFF(delivery_date, created_date, DAY) <= 5) FROM shipments WHERE EXTRACT(YEAR FROM created_date) = 2024 GROUP BY month
C.SELECT EXTRACT(MONTH FROM created_date) AS month, COUNT(*) FROM shipments WHERE DATETIME_DIFF(delivery_date, created_date, DAY) <= 5 AND EXTRACT(YEAR FROM created_date) = 2024 GROUP BY month
D.SELECT EXTRACT(MONTH FROM created_date) AS month, COUNT(*) FROM shipments WHERE DATE_DIFF(delivery_date, created_date, DAY) <= 5 AND EXTRACT(YEAR FROM created_date) = 2024 GROUP BY month
AnswerC
Correct function and clear intent.
Why this answer
Option C is correct because it uses `DATETIME_DIFF` with `DAY` precision to accurately compute the difference between `delivery_date` and `created_date` in days, and filters for shipments delivered within 5 days (i.e., <= 5 days). The `WHERE` clause also restricts to the year 2024, and the `GROUP BY month` with `EXTRACT(MONTH FROM created_date)` correctly aggregates counts per month. This matches the requirement precisely.
Exam trap
Google Cloud often tests the distinction between `DATE_DIFF`, `DATETIME_DIFF`, and `TIMESTAMP_DIFF`, and candidates mistakenly choose `DATE_DIFF` without considering the actual data types of the columns, or they use `TIMESTAMP_DIFF` with hours thinking it is equivalent, but fail to account for timezone and daylight saving effects.
How to eliminate wrong answers
Option A is wrong because it uses `TIMESTAMP_DIFF` with `HOUR` precision and checks `<= 120` hours, which is equivalent to 5 days but introduces potential edge-case errors due to daylight saving time shifts or timezone differences, and it is less readable and less precise for day-level logic. Option B is wrong because it uses `COUNTIF` with `DATETIME_DIFF` inside the SELECT clause, but `COUNTIF` is not a valid aggregate function in standard BigQuery SQL; the correct function is `COUNTIF` only in the context of a `COUNT` with a filter expression, but here it would cause a syntax error. Option D is wrong because it uses `DATE_DIFF` with `DAY` precision, but `DATE_DIFF` expects `DATE` type arguments, and if `delivery_date` or `created_date` are `DATETIME` or `TIMESTAMP` types, this will cause a type mismatch error or implicit conversion issues.
A developer needs to authenticate to Artifact Registry from a CI/CD pipeline that runs on Compute Engine. The pipeline does not have access to user credentials. Which authentication method should they use?
A.Configure Workload Identity on the Compute Engine VM
B.Create a service account key and store it in Cloud Storage
C.Use a personal access token in the pipeline
D.Use gcloud auth login with a user account
AnswerA
Workload Identity allows the VM to authenticate as a service without keys.
Why this answer
Workload Identity allows a Compute Engine VM to act as a service account without needing to manage keys. The VM's service account can be granted permissions to access Artifact Registry.
A retail company uses BigQuery to store sales data. The 'sales' table has 10 billion rows and is partitioned by transaction_date (daily). The BI dashboard runs a query that aggregates sales by product_category for the last 30 days. The query is slow and expensive. Which improvement is most effective?
A.Cluster the table on product_category
B.Change partitioning to monthly
C.Denormalize the product_category into the sales table
D.Use a materialized view with aggregation on product_category
AnswerA
Clustering on product_category organizes data within each partition so that queries filtering/aggregating on that column scan fewer blocks.
Why this answer
Option A is correct because clustering the table on product_category organizes the data within each daily partition by that column, allowing BigQuery to use block-level pruning to skip irrelevant blocks when filtering or aggregating by product_category. This directly reduces the amount of data scanned for the 30-day aggregation query, improving both performance and cost.
Exam trap
Google Cloud often tests the distinction between partitioning (which limits data by time range) and clustering (which organizes data within partitions for column-based pruning), and candidates mistakenly choose partitioning changes or materialized views without understanding that clustering directly addresses the slow aggregation on a non-time column.
How to eliminate wrong answers
Option B is wrong because changing partitioning from daily to monthly would increase the partition size, forcing the query to scan more data per partition (the entire month) rather than only the last 30 days, which would actually worsen performance and cost. Option C is wrong because denormalizing product_category into the sales table is already the current schema; the issue is not about normalization but about data organization for efficient pruning. Option D is wrong because a materialized view with aggregation on product_category would still require scanning all partitions unless the view is also partitioned and clustered; moreover, materialized views in BigQuery are best for pre-aggregating high-frequency queries but do not inherently reduce scan costs if the underlying table is not properly clustered.
A team manages infrastructure across multiple Google Cloud projects using Terraform. They want to centralize state file management in a GCS bucket and ensure that each project's state is isolated. Which backend configuration best achieves this?
A.Use a single bucket with a separate prefix for each project; configure the backend for each project with its own prefix.
B.Use a separate bucket for each project.
C.Use local state files and commit them to Git.
D.Store all state files in the same bucket under the same prefix and use workspaces.
AnswerA
This isolates state files by project using prefixes.
Why this answer
Terraform backend configuration allows specifying a GCS bucket and prefix. Using a separate prefix per project (e.g., `project-a/terraform.tfstate`) isolates state files. Workspaces are not needed; the prefix approach is simpler.
An organization wants to enforce that all Compute Engine VMs are created with Shielded VM features enabled to protect against rootkits and boot-level malware. Which Google Cloud mechanism should be used?
A.Organization policies
B.Resource labels
C.Service accounts
D.IAM roles
AnswerA
Organization policies can enforce constraints like requiring Shielded VMs across the organization.
Why this answer
Organization policies allow you to define constraints that apply to all resources under an organization. The `compute.requireShieldedVm` constraint enforces that VMs must have Shielded VM enabled. IAM roles and service accounts control access but not resource properties.
An SRE team is creating a postmortem after a service outage. They want to ensure the process is blameless and focuses on systemic improvements. Which practice is central to a blameless postmortem?
A.Determining the financial cost of the outage
B.Escalating the issue to senior management
C.Assigning action items with owners and due dates to prevent recurrence
D.Identifying the individual who caused the incident for performance review
AnswerC
Action items drive improvements; blameless culture ensures people feel safe contributing to solutions.
Why this answer
A blameless postmortem focuses on identifying contributing factors and systemic issues rather than assigning blame to individuals. The 5 Whys technique helps drill down to root causes.
A team is migrating to GCP and wants to use Cloud Deployment Manager for infrastructure. They have existing Terraform modules. What is the best approach?
A.Use Deployment Manager only for new resources and Terraform for existing.
B.Convert Terraform modules to Deployment Manager templates manually.
C.Run Terraform as a subprocess within Deployment Manager.
D.Use Terraform with a GCS backend; avoid Deployment Manager.
AnswerD
Terraform is the preferred tool; no need to switch.
Why this answer
Option D is correct because the team already has existing Terraform modules, and using Terraform with a GCS backend allows them to continue leveraging their investment in Terraform without rewriting or bridging tools. Cloud Deployment Manager is a native Google Cloud IaC tool, but it does not natively import or execute Terraform configurations; forcing a migration or hybrid approach introduces unnecessary complexity and risk. The best practice is to standardize on one IaC tool, and since Terraform is already in use, using it with a GCS backend for state management is the most efficient and reliable path.
Exam trap
The trap here is that candidates assume Cloud Deployment Manager is the 'native' GCP tool and must be used, but the question tests whether you recognize that existing Terraform modules should be preserved and that forcing a migration or hybrid approach is anti-pattern.
How to eliminate wrong answers
Option A is wrong because maintaining two separate IaC tools (Deployment Manager for new resources and Terraform for existing) creates fragmentation, increases the risk of configuration drift, and adds operational overhead with no clear benefit. Option B is wrong because manually converting Terraform modules to Deployment Manager templates is time-consuming, error-prone, and negates the value of existing tested modules; it also introduces a manual translation step that can introduce bugs. Option C is wrong because running Terraform as a subprocess within Deployment Manager is not a supported integration pattern, adds unnecessary complexity, and defeats the purpose of using a single declarative tool; Deployment Manager cannot natively execute Terraform or manage its state.
A data engineer creates a clustered table in BigQuery with clustering order: country, city, product_id. The BI team frequently runs a query that filters on city and product_id but rarely on country. What is the most likely performance issue?
A.BigQuery allows only one clustering column per table.
B.The query does not filter on the first clustering column (country), so block pruning is minimal.
C.The table should be partitioned by country instead of clustered.
D.The query filters on too many clustering columns, causing overhead.
AnswerB
Clustering is optimized when filters include the leftmost clustering column.
Why this answer
BigQuery clustered tables use block pruning to skip reading blocks that don't match the query's filter. Pruning is most effective when the filter includes the first clustering column (country). Without it, BigQuery must scan more blocks, leading to higher query costs and slower performance.
Exam trap
Google Cloud often tests the misconception that any filter on clustering columns is equally effective, but the key is that pruning requires the first column in the clustering order to be filtered for maximum benefit.
How to eliminate wrong answers
Option A is wrong because BigQuery allows up to four clustering columns per table, not just one. Option C is wrong because partitioning by country would not help if the query rarely filters on country; partitioning is most beneficial for queries that filter on the partition column. Option D is wrong because filtering on multiple clustering columns does not cause overhead; it actually improves pruning, but the missing first column is the issue.
Which Google Cloud service can be used to automate repetitive operational tasks such as restarting a VM or clearing a cache, as part of toil reduction?
A.Compute Engine
B.Cloud Run
C.Cloud Build
D.Cloud Functions
AnswerD
Cloud Functions can automate tasks like VM restarts, cache clearing, etc.
Why this answer
Cloud Functions is a serverless execution environment that can be triggered by events or schedules to automate tasks. It is well-suited for automating simple operational tasks.
A BI dashboard query is slow and high cost. The query does multiple joins on large tables and uses window functions. The data engineer suggests using materialized views. However, the query uses non-deterministic functions. What is the limitation?
A.Materialized views cannot include non-deterministic functions
B.Materialized views cannot be updated automatically
C.Materialized views cannot be created with joins
D.Materialized views only support simple aggregation
AnswerA
Materialized views require deterministic expressions to maintain consistency between base table changes.
Why this answer
Materialized views store the result set of a query physically, like a table. If the query includes non-deterministic functions (e.g., NOW(), RAND(), CURRENT_TIMESTAMP), the stored result would become stale immediately because the function's output changes each time it is evaluated. Most SQL databases (e.g., PostgreSQL, Oracle, Snowflake) explicitly forbid non-deterministic functions in materialized view definitions to prevent this logical inconsistency.
Exam trap
Google Cloud often tests the misconception that materialized views are 'static' and cannot be refreshed, or that they only support simple aggregations, when the real limitation is the prohibition of non-deterministic functions to ensure data consistency.
How to eliminate wrong answers
Option B is wrong because materialized views can be updated automatically via refresh mechanisms (e.g., ON COMMIT, scheduled refreshes), though they are not always updated in real-time. Option C is wrong because materialized views commonly support joins; in fact, they are often used to pre-join large tables for performance. Option D is wrong because materialized views can include complex aggregations, window functions, and multiple joins—not just simple aggregation.
A BI query uses COUNT(column) to count non-null values and COUNT(*) to count all rows. The analyst expects both counts to be equal, but COUNT(column) returns fewer rows. What is the most likely explanation?
A.The query has a WHERE clause that filters some rows.
B.COUNT(*) is faster, so it's not accurate.
C.COUNT(*) counts duplicate rows, while COUNT(column) does not.
D.The column contains NULL values, which are not counted by COUNT(column).
AnswerD
COUNT(column) only counts non-null values.
Why this answer
COUNT(column) ignores NULL values in the specified column, while COUNT(*) counts every row in the result set regardless of NULLs. If the column contains any NULLs, COUNT(column) will return a lower number. This is a fundamental SQL behavior defined in the ANSI SQL standard and is consistent across all major BI platforms (e.g., Tableau, Power BI, Looker) that generate SQL queries.
Exam trap
Google Cloud often tests the subtle distinction between COUNT(*) and COUNT(column) by embedding NULL values in the column, tempting candidates to incorrectly attribute the difference to duplicates or filtering.
How to eliminate wrong answers
Option A is wrong because a WHERE clause would filter rows before aggregation, affecting both COUNT(column) and COUNT(*) equally, so it cannot cause a discrepancy between the two counts. Option B is wrong because COUNT(*) is not inherently faster or less accurate; both functions return precise counts based on the same data set, and performance differences are irrelevant to accuracy. Option C is wrong because both COUNT(*) and COUNT(column) count duplicate rows; COUNT(column) counts non-null occurrences of the column, including duplicates, so duplicates do not cause a difference.
An engineer configures Cloud Deploy to promote a container to production after manual approval. The deployment strategy must gradually shift traffic from the current version to the new version while monitoring error rates. Which deployment strategy should they select in the delivery pipeline?
A.Blue/green
B.Rollback
C.Canary
D.Standard
AnswerC
Canary deploys a small percentage first, then increases based on metrics and approval.
Why this answer
Canary deployment is the correct choice because it gradually shifts traffic from the current version to the new version while allowing monitoring of error rates. In Cloud Deploy, a canary strategy uses a sequence of phases (e.g., 10%, 50%, 100%) to incrementally route traffic, enabling real-time observability and automated rollback if error thresholds are breached.
Exam trap
Cisco often tests the distinction between deployment strategies by making candidates confuse canary (gradual traffic shifting with monitoring) with blue/green (instantaneous full traffic switch), so the trap here is assuming blue/green supports gradual traffic shifting when it actually flips all traffic at once.
How to eliminate wrong answers
Option A is wrong because blue/green deployment switches all traffic at once between two environments (blue and green), not gradually, and does not inherently support phased traffic shifting with error rate monitoring. Option B is wrong because rollback is not a deployment strategy but a recovery action to revert to a previous version after a failure, not a method for gradual traffic shifting. Option D is wrong because standard deployment (also known as rolling update) replaces instances incrementally but does not provide fine-grained traffic control or canary-style phased routing with error rate monitoring.
A company is adopting GitOps for managing their Kubernetes infrastructure with Config Sync. They want to ensure that any changes to the cluster's desired state are automatically applied from a Git repository. Which branching strategy is MOST suitable for this workflow?
A.One branch per cluster, with manual merge from development to production branches.
B.Trunk-based development where all changes are merged into the main branch frequently, and Config Sync watches the main branch.
C.Gitflow with separate develop and release branches, merging to main only for production releases.
D.Feature branching with long-lived branches per environment (dev, staging, prod).
AnswerB
Trunk-based development ensures that main branch is always the single source of truth, which is ideal for GitOps.
Why this answer
Trunk-based development with short-lived feature branches and direct commits to main (or a single release branch) is the simplest and most aligned with GitOps principles where main branch represents the desired state.
Which three of the following are valid considerations when designing secondary indexes in Cloud Spanner? (Choose three.)
Select 3 answers
A.Secondary indexes maintain strong consistency with the base table
B.Secondary indexes are automatically used for queries that filter on primary key columns
C.Secondary indexes require a unique constraint
D.Secondary indexes can be created on child tables without including the parent key
E.Secondary indexes can be created with a STORING clause to include non-key columns
AnswersA, D, E
All indexes in Spanner are strongly consistent.
Why this answer
Option A is correct because Cloud Spanner secondary indexes are fully synchronous with the base table, meaning they are updated atomically in the same transaction as the table write. This ensures that reads using the secondary index always return strongly consistent data, without any eventual consistency window.
Exam trap
Cisco often tests the misconception that secondary indexes are automatically used for any query filter, when in fact the optimizer only uses them when the filter columns match the index key, and primary key filters bypass secondary indexes entirely.
During a postmortem for a service outage, the team identifies that the root cause was a configuration change that disabled TLS on a critical internal service. The change was made by an automated deployment pipeline. Which tool or practice should be implemented to prevent this in the future?
A.Use Cloud Audit Logs to detect configuration changes after the fact
B.Implement canary deployments with automated rollback based on SLI metrics
C.Add a manual approval gate before every deployment
D.Disable automated deployments and require all changes to be made manually
AnswerB
This would catch the degradation (e.g., TLS errors) and rollback automatically.
Why this answer
Preventing misconfigurations requires automated validation in the deployment pipeline. A canary analysis or progressive delivery with automated checks can catch such issues. Cloud Deploy supports canary deployments with verification using Cloud Monitoring.
Additionally, using Binary Authorization or Config Connector can enforce policies. But the best practice is to implement automated canary analysis that checks SLI metrics before full rollout.
A company is designing a data model for a BI dashboard that requires real-time updates and historical analysis. Which THREE practices should be followed?
Select 3 answers
A.Use clustering on frequently filtered columns.
B.Use streaming inserts for real-time data.
C.Create a separate table for each day's data.
D.Use the default BigQuery table expiration setting.
E.Use partitioning by ingestion time for continuous data.
AnswersA, B, E
Clustering orders data within partitions, improving filter performance.
Why this answer
Option A is correct because clustering on frequently filtered columns in BigQuery organizes data into blocks based on the values of those columns, allowing queries with filters on those columns to skip irrelevant blocks entirely. This reduces the amount of data scanned, improving query performance and lowering costs, which is critical for a BI dashboard that needs real-time updates and fast historical analysis.
Exam trap
Google Cloud often tests the misconception that creating separate tables for daily data is a good practice for time-series data, when in fact BigQuery's partitioning and clustering features are designed to handle such data more efficiently and with less administrative overhead.
Which THREE factors should you consider when configuring Cloud SQL for MySQL query caching to optimize performance?
Select 3 answers
A.High write workloads can lead to frequent cache invalidation, reducing its effectiveness.
B.The query cache can become fragmented and require periodic defragmentation.
C.Query cache uses disk storage for cached results.
D.The query cache is deprecated and removed in MySQL 8.0+, so it should not be relied upon for new deployments.
E.Prepared statements always bypass the query cache.
AnswersA, B, D
Every table modification invalidates cached queries for that table, making cache less useful for write-heavy workloads.
Why this answer
Option A is correct because in Cloud SQL for MySQL, high write workloads cause frequent updates to tables, which invalidates the query cache entries for those tables. This means the cache must be repopulated often, reducing the hit rate and potentially adding overhead from cache maintenance, making it less effective for performance optimization.
Exam trap
Google Cloud often tests the misconception that the query cache uses disk storage, when in fact it uses memory, and that prepared statements always bypass the cache, which is not universally true across all MySQL configurations.
Drag a concept onto its matching description — or click a concept then click the description.
Concepts
Matches
Column-based ordering to improve query performance
Dividing tables into segments for cost and performance
Guaranteed query capacity
In-memory analysis for sub-second query response
Automated data ingestion from various sources
Why these pairings
These features optimize cost, performance, and management in BigQuery. Partitioning reduces scan costs, Clustering improves query performance, Materialized Views accelerate complex queries, and Slots provide resource control.
Your Bigtable cluster is experiencing high CPU utilization and write latency during a daily batch job that writes 500 GB of data. The job uses bulk mutations with 1000 rows per request. What is the most effective way to reduce CPU usage?
A.Disable write-ahead logs
B.Increase the number of rows per mutation to 10,000
C.Increase the number of nodes temporarily
D.Create a new cluster in a different zone
AnswerB
Fewer RPCs reduce CPU overhead.
Why this answer
Option B is correct because larger mutations reduce overhead per row. Option A is wrong because increasing nodes would help but is not as efficient as optimizing the write pattern. Option C is wrong because increasing cluster size doesn't reduce CPU per request.
Option D is wrong because write-ahead logs are internal; tuning them doesn't reduce CPU for writes.
A social media application uses Memorystore for Redis to cache user profiles and session data. Recently, the application experienced intermittent errors and high latency. You observe that the Redis CPU utilization is consistently above 90% and the cache hit ratio is 85%. The instance type is a Standard tier M2 (30 GB) with a maxmemory setting of 25 GB. The eviction policy is allkeys-lru. The number of keys is 10 million with an average value size of 2 KB. You suspect memory pressure is causing CPU spikes. What should you do to reduce CPU utilization and improve performance?
A.Reduce the maxmemory setting to force more aggressive eviction and free up memory.
B.Change the eviction policy to volatile-lru to prefer evicting keys with TTL.
C.Upgrade the Memorystore instance to a larger size (e.g., M5 with 60 GB) to provide more CPU and memory resources.
D.Implement Redis monitoring with Cloud Monitoring and set alerts to notify when CPU exceeds 80%.
AnswerC
A larger instance has more CPU cores and memory, reducing pressure.
Why this answer
Option C is correct because upgrading to a larger instance (e.g., M5 with 60 GB) directly addresses both the high CPU utilization and memory pressure. The M2 instance is CPU-bound with sustained >90% usage, and the 85% cache hit ratio indicates that evictions are already occurring under the allkeys-lru policy, causing CPU spikes from eviction overhead and key lookups. A larger instance provides more CPU cores and memory, reducing eviction frequency and allowing the cache to serve more requests without thrashing.
Exam trap
Cisco often tests the misconception that tuning eviction policies or reducing memory limits can solve CPU pressure, when in fact the root cause is resource exhaustion that requires vertical scaling.
How to eliminate wrong answers
Option A is wrong because reducing maxmemory would force even more aggressive eviction, increasing CPU overhead from eviction processing and further degrading cache hit ratio, worsening the problem. Option B is wrong because changing to volatile-lru would only evict keys with TTLs, but the question does not indicate that keys have TTLs; if most keys lack TTLs, volatile-lru would evict nothing, leaving memory pressure unchanged and CPU spikes unresolved. Option D is wrong because monitoring and alerts only provide visibility into the problem; they do not reduce CPU utilization or improve performance, which requires a resource scaling action.